Skip to content
Permalink
master
Switch branches/tags
Go to file
 
 
Cannot retrieve contributors at this time
/**
* @file libwakelock.c
* Mode Control Entity - wakelock management
* <p>
* Copyright (C) 2012-2019 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/>.
*/
/* NOTE: Only async-signal-safe functions can be called from this
* module since we might need to use the functionality while
* handling non-recoverable signals!
*/
#include "libwakelock.h"
#include <stdarg.h>
#include <stdbool.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
/** Whether to write debug logging to stderr
*
* If not enabled, no diagnostics of any kind gets written.
*/
#ifndef LWL_ENABLE_LOGGING
# define LWL_ENABLE_LOGGING 01
#endif
/** Prefix used for log messages
*/
#define LWL_LOG_PFIX "LWL: "
/** Number to string helper
*
* @param buf work space
* @param len size of work space
* @param num number to convert
* @return pointer to ascii representation of num
*/
static char *lwl_number(char *buf, size_t len, long long num)
{
char *pos = buf + len;
int sgn = (num < 0);
unsigned long long val = sgn ? -num : num;
auto void emit(int c) {
if( pos > buf ) *--pos = c;
}
/* terminate at end of work space */
emit(0);
/* work backwards from least signigicant digits */
do { emit('0' + val % 10); } while( val /= 10 );
/* apply minus sign if needed */
if( sgn ) emit('-');
/* return pointer to 1st digit (not start of buffer) */
return pos;
}
/** String concatenation helper
*
* @param buf work space
* @param len size of work space
* @param str first string to copy
* @param ... NULL terminated list of more strings to copy
* @return pointer to the start of the buffer
*/
static char *lwl_concat(char *buf, size_t len, const char *str, ...)
{
char *pos = buf;
char *end = buf + len - 1;
va_list va;
auto void emit(const char *s) {
while( pos < end && *s ) *pos++ = *s++;
}
va_start(va, str);
while( str )
emit(str), str = va_arg(va, const char *);
va_end(va);
*pos = 0;
return buf;
}
#if LWL_ENABLE_LOGGING
/** Flag for enabling wakelock debug logging */
static int lwl_debug_enabled = 0;
/** Logging functionality that can be configured out at compile time
*/
static void lwl_debug_(const char *m, ...)
{
char buf[256];
char *pos = buf;
char *end = buf + sizeof buf - 1;
va_list va;
auto void emit(const char *s)
{
while( pos < end && *s ) *pos++ = *s++;
}
emit("LWL: ");
va_start(va, m);
while( m )
{
emit(m), m = va_arg(va, const char *);
}
va_end(va);
if( write(STDERR_FILENO, buf, pos - buf) < 0 )
{
// do not care
}
}
# define lwl_debug(MSG, MORE...) \
do {\
if( lwl_debug_enabled ) lwl_debug_(MSG, ##MORE); \
} while( 0 )
#else
# define lwl_debug(MSG, MORE...) do { } while( 0 )
#endif
/** Flag that gets set once the process is about to exit */
static int lwl_shutting_down = 0;
/** Sysfs entry for acquiring wakelocks */
static const char lwl_lock_path[] = "/sys/power/wake_lock";
/** Sysfs entry for releasing wakelocks */
static const char lwl_unlock_path[] = "/sys/power/wake_unlock";
/** Sysfs entry for allow/block early suspend */
static const char lwl_state_path[] = "/sys/power/state";
/** Sysfs entry for allow/block autosleep */
static const char lwl_autosleep_path[] = "/sys/power/autosleep";
/** Helper for writing to sysfs files
*/
static void lwl_write_file(const char *path, const char *data)
{
int file;
lwl_debug(path, " << ", data, NULL);
if( (file = TEMP_FAILURE_RETRY(open(path, O_WRONLY))) == -1 ) {
lwl_debug(path, ": open: ", strerror(errno), "\n", NULL);
} else {
int size = strlen(data);
errno = 0;
if( TEMP_FAILURE_RETRY(write(file, data, size)) != size ) {
lwl_debug(path, ": write: ", strerror(errno),
"\n", NULL);
}
TEMP_FAILURE_RETRY(close(file));
}
}
/** Structure for holding static text + size */
typedef struct
{
const char *text;
size_t size;
} suspend_data_t;
/** Early suspend disable string */
static const suspend_data_t data_on = { .text = "on", .size = 2 };
/** Autosleep disable string */
static const suspend_data_t data_off = { .text = "off", .size = 3 };
/** Early suspend / autosleep enable string */
static const suspend_data_t data_mem = { .text = "mem", .size = 3 };
/** Write text to a sysfs file
*
* @param path file to write
* @param data text to write
* @param size lenght of text
*
* @return true if write was successful, false otherwise
*/
static bool
lwl_write_text(const char *path, const char *data, int size)
{
bool res = false;
int fd = -1;
if( !path || !data || size <= 0 )
goto cleanup;
lwl_debug(path, " << ", data, "\n", NULL);
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;
}
/** Write fixed string to a sysfs file
*
* @param path file to write
* @param data text of known size to write
*
* @return true if write was successful, false otherwise
*/
static bool
lwl_write_data(const char *path, const suspend_data_t *data)
{
return lwl_write_text(path, data->text, data->size);
}
/** Helper for checking if/what kind of suspend model is supported
*/
suspend_type_t lwl_probe(void)
{
static suspend_type_t suspend_type = SUSPEND_TYPE_UNKN;
if( suspend_type != SUSPEND_TYPE_UNKN )
goto EXIT;
if( access(lwl_lock_path, W_OK) || access(lwl_unlock_path, W_OK) ) {
/* No suspend without wakelock controls */
suspend_type = SUSPEND_TYPE_NONE;
}
else if( lwl_write_data(lwl_state_path, &data_on) ) {
/* No error from disabling early suspend */
suspend_type = SUSPEND_TYPE_EARLY;
}
else if( lwl_write_data(lwl_autosleep_path, &data_off) ) {
/* No error from disabling autosleep */
suspend_type = SUSPEND_TYPE_AUTO;
}
else {
suspend_type = SUSPEND_TYPE_NONE;
}
EXIT:
return suspend_type;
}
/** Use sysfs interface to create and enable a wakelock.
*
* @param name The name of the wakelock to obtain
* @param ns Time in nanoseconds before the wakelock gets released
* automatically, or negative value for no timeout.
*/
void wakelock_lock(const char *name, long long ns)
{
if( lwl_shutting_down )
goto EXIT;
if( lwl_probe() > SUSPEND_TYPE_NONE ) {
char tmp[64];
char num[64];
if( ns < 0 ) {
lwl_concat(tmp, sizeof tmp, name, "\n", NULL);
} else {
lwl_concat(tmp, sizeof tmp, name, " ",
lwl_number(num, sizeof num, ns),
"\n", NULL);
}
lwl_write_file(lwl_lock_path, tmp);
}
EXIT:
return;
}
/** Use sysfs interface to disable a wakelock.
*
* @param name The name of the wakelock to release
*
* Note: This will not delete the wakelocks.
*/
void wakelock_unlock(const char *name)
{
if( lwl_probe() > SUSPEND_TYPE_NONE ) {
char tmp[64];
lwl_concat(tmp, sizeof tmp, name, "\n", NULL);
lwl_write_file(lwl_unlock_path, tmp);
}
}
/** Use sysfs interface to allow automatic entry to suspend
*
* After this call the device will enter suspend mode once all
* the wakelocks have been released.
*
* Android kernels will enter early suspend (i.e. display is
* turned off etc) even if there still are active wakelocks.
*/
void wakelock_allow_suspend(void)
{
if( lwl_shutting_down )
goto EXIT;
switch( lwl_probe() ) {
case SUSPEND_TYPE_EARLY:
lwl_write_data(lwl_state_path, &data_mem);
break;
case SUSPEND_TYPE_AUTO:
lwl_write_data(lwl_autosleep_path, &data_mem);
break;
default:
break;
}
EXIT:
return;
}
/** Use sysfs interface to block automatic entry to suspend
*
* The device will not enter suspend mode with or without
* active wakelocks.
*/
void wakelock_block_suspend(void)
{
switch( lwl_probe() ) {
case SUSPEND_TYPE_EARLY:
lwl_write_data(lwl_state_path, &data_on);
break;
case SUSPEND_TYPE_AUTO:
lwl_write_data(lwl_autosleep_path, &data_off);
break;
default:
break;
}
}
/** Block automatic suspend without possibility to unblock it again
*
* For use on exit path. We want to do clean exit from mainloop and
* that might that code that re-enables autosuspend gets triggered
* while we're on exit path.
*
* By calling this function when initiating daemon shutdown we are
* protected against this.
*/
void wakelock_block_suspend_until_exit(void)
{
lwl_shutting_down = 1;
wakelock_block_suspend();
}
/** Enable wakelock debug logging (if support compiled in)
*/
void lwl_enable_logging(void)
{
lwl_debug_enabled = 1;
}