Skip to content
Permalink
master
Switch branches/tags
Go to file
 
 
Cannot retrieve contributors at this time
/**
* @file mce-io.c
* Generic I/O functionality for the Mode Control Entity
* <p>
* Copyright © 2006-2011 Nokia Corporation and/or its subsidiary(-ies).
* Copyright (C) 2012-2019 Jolla Ltd.
* <p>
* @author David Weinehall <david.weinehall@nokia.com>
* @author Santtu Lakkala <ext-santtu.1.lakkala@nokia.com>
* @author Jukka Turunen <ext-jukka.t.turunen@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-io.h"
#include "mce.h"
#include "mce-log.h"
#include "mce-lib.h"
#include "mce-wakelock.h"
#ifdef ENABLE_WAKELOCKS
# include "libwakelock.h"
#endif
#include <sys/timerfd.h>
#include <unistd.h>
#include <inttypes.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <glib/gstdio.h>
#ifndef TFD_TIMER_CANCELON_SET
# define TFD_TIMER_CANCELON_SET (1<<1)
#endif
/* ========================================================================= *
* CONSTANTS
* ========================================================================= */
/** Suffix used for temporary files */
#define TMP_SUFFIX ".tmp"
/* ========================================================================= *
* TYPES
* ========================================================================= */
/** I/O monitor type */
typedef enum {
IOMON_UNSET = -1, /**< I/O monitor type unset */
IOMON_STRING = 0, /**< String I/O monitor */
IOMON_CHUNK = 1, /**< Chunk I/O monitor */
} iomon_type;
/** I/O monitor structure */
struct mce_io_mon_t {
gchar *path; /**< Monitored file */
iomon_type type; /**< Monitor type */
gulong chunk_size; /**< Read-chunk size */
gboolean seekable; /**< is the I/O channel seekable */
gboolean suspended; /**< Is the I/O monitor suspended? */
GIOChannel *iochan; /**< I/O channel */
guint iowatch_id; /**< GSource ID for input */
mce_io_mon_notify_cb nofity_cb; /**< Input handling callback */
mce_io_mon_delete_cb delete_cb; /**< Iomon delete callback */
error_policy_t error_policy; /**< Error policy */
gboolean rewind_policy; /**< Rewind policy */
void *user_data; /**< Attached user data block */
mce_io_mon_free_cb user_free_cb;/**< Callback for freeing user_data */
};
/* ========================================================================= *
* STATE_DATA
* ========================================================================= */
/** List of all file monitors */
static GSList *file_monitors = NULL;
/* ========================================================================= *
* PROTOTYPES
* ========================================================================= */
// SUSPEND_DETECTION
static void io_detect_resume (void);
static gboolean mce_io_resume_timer_cb (GIOChannel *chn, GIOCondition cnd, gpointer aptr);
static bool mce_io_prime_resume_timer (void);
void mce_io_init_resume_timer (void);
void mce_io_quit_resume_timer (void);
// GLIB_IO_HELPERS
const char *mce_io_condition_repr (GIOCondition cond);
const char *mce_io_status_name (GIOStatus io_status);
// IO_MONITOR
static mce_io_mon_t *mce_io_mon_create (const char *path, mce_io_mon_delete_cb delete_cb);
static void mce_io_mon_delete (mce_io_mon_t *self);
static void mce_io_mon_probe_seekable (mce_io_mon_t *self);
static gboolean mce_io_mon_read_chunks (GIOChannel *source, GIOCondition condition, gpointer data);
static gboolean mce_io_mon_read_string (GIOChannel *source, GIOCondition condition, gpointer data);
static gboolean mce_io_mon_input_cb (GIOChannel *source, GIOCondition condition, gpointer data);
static mce_io_mon_t *mce_io_mon_register (gint fd, const gchar *path, error_policy_t error_policy, gboolean rewind_policy, mce_io_mon_notify_cb callback, mce_io_mon_delete_cb delete_cb);
mce_io_mon_t *mce_io_mon_register_string (const gint fd, const gchar *const file, error_policy_t error_policy, gboolean rewind_policy, mce_io_mon_notify_cb callback, mce_io_mon_delete_cb delete_cb);
mce_io_mon_t *mce_io_mon_register_chunk (const gint fd, const gchar *const file, error_policy_t error_policy, gboolean rewind_policy, mce_io_mon_notify_cb callback, mce_io_mon_delete_cb delete_cb, gulong chunk_size);
void mce_io_mon_unregister (mce_io_mon_t *iomon);
void mce_io_mon_unregister_list (GSList *list);
void mce_io_mon_unregister_at_path (const char *path);
void mce_io_mon_suspend (mce_io_mon_t *iomon);
void mce_io_mon_resume (mce_io_mon_t *iomon);
const gchar *mce_io_mon_get_path (const mce_io_mon_t *iomon);
int mce_io_mon_get_fd (const mce_io_mon_t *iomon);
// MISC_UTILS
guint mce_io_add_watch (int fd, bool close_on_unref, GIOCondition cnd, GIOFunc io_cb, gpointer aptr);
gboolean mce_close_file (const gchar *const file, FILE **fp);
gboolean mce_read_chunk_from_file (const gchar *const file, void **data, gssize *len, int flags);
gboolean mce_read_string_from_file (const gchar *const file, gchar **string);
gboolean mce_read_number_string_from_file (const gchar *const file, gulong *number, FILE **fp, gboolean rewind_file, gboolean close_on_exit);
gboolean mce_write_string_to_file (const gchar *const file, const gchar *const string);
void mce_close_output (output_state_t *output);
gboolean mce_write_number_string_to_file (output_state_t *output, const gulong number);
gboolean mce_write_number_string_to_file_atomic (const gchar *const file, const gulong number);
gboolean mce_are_settings_locked (void);
gboolean mce_unlock_settings (void);
static gboolean mce_io_read_all (int fd, void *buff, size_t size, size_t *pdone);
static gboolean mce_io_write_all (int fd, const void *buff, size_t size, size_t *pdone);
void *mce_io_load_file (const char *path, size_t *psize);
void *mce_io_load_file_until_eof (const char *path, size_t *psize);
gboolean mce_io_save_file (const char *path, const void *data, size_t size, mode_t mode);
gboolean mce_io_save_to_existing_file (const char *path, const void *data, size_t size);
gboolean mce_io_save_file_atomic (const char *path, const void *data, size_t size, mode_t mode, gboolean keep_backup);
gboolean mce_io_update_file_atomic (const char *path, const void *data, size_t size, mode_t mode, gboolean keep_backup);
/* ========================================================================= *
* SUSPEND_DETECTION
* ========================================================================= */
/** Detect suspend/resume cycle from CLOCK_MONOTONIC vs CLOCK_BOOTTIME
*/
static void io_detect_resume(void)
{
static int64_t prev = 0;
int64_t boot = mce_lib_get_boot_tick();
int64_t mono = mce_lib_get_mono_tick();
int64_t diff = boot - mono;
int64_t skip = diff - prev;
// small jitter can be due to scheduling too
if( skip < 100 )
goto EXIT;
prev = diff;
// no logging from the 1st time skip
if( prev == skip )
goto EXIT;
mce_log(LL_DEVEL, "time skip: assume %"PRId64".%03"PRId64"s suspend",
skip / 1000, skip % 1000);
// notify in case some timers need re-evaluating
datapipe_exec_full(&resume_detected_event_pipe, &prev);
EXIT:
return;
}
/** Timerfd we use for detecting resume
*/
static int mce_io_resume_timer_fd = -1;
/** Glib io watch for mce_io_resume_timer_fd
*/
static guint mce_io_resume_timer_id = 0;
/** Virtual wakelock used for protecting resume timer wakeups
*/
static const char mce_io_resume_timer_wakelock[] = "mce_io_resume_timer";
/** Glib io callback for mce_io_resume_timer_fd
*/
static gboolean
mce_io_resume_timer_cb(GIOChannel *chn, GIOCondition cnd, gpointer aptr)
{
(void)chn;
(void)aptr;
/* Deny suspending while handling timer wakeup */
mce_wakelock_obtain(mce_io_resume_timer_wakelock, -1);
gboolean result = G_SOURCE_REMOVE;
if( mce_io_resume_timer_fd == -1 || mce_io_resume_timer_id == 0 ) {
mce_log(LL_WARN, "stray resume timer wakeup");
goto EXIT;
}
if( cnd & ~G_IO_IN ) {
mce_log(LL_CRIT, "unexpected resume timer wakeup: %s",
mce_io_condition_repr(cnd));
goto EXIT;
}
/* Read trigger count. Expected result is ECANCELED */
uint64_t cnt = 0;
int res = read(mce_io_resume_timer_fd, &cnt, sizeof cnt);
if( res == -1 ) {
if( errno == EAGAIN || errno == EINTR ) {
/* Silentry ignore temporary errors */
}
else if( errno == ECANCELED ) {
/* The expected error */
mce_log(LL_DEBUG, "resume timer wakeup");
io_detect_resume();
if( !mce_io_prime_resume_timer() )
goto EXIT;
}
else {
/* Some unexpected error */
mce_log(LL_CRIT, "can't read resume timer: %m");
goto EXIT;
}
}
else {
/* Silentry ignore timer actually triggering */
if( !mce_io_prime_resume_timer() )
goto EXIT;
}
result = G_SOURCE_CONTINUE;
EXIT:
if( result != G_SOURCE_CONTINUE && mce_io_resume_timer_id ) {
mce_log(LL_CRIT, "disabling resume timer");
mce_io_resume_timer_id = 0;
mce_io_quit_resume_timer();
}
mce_wakelock_release(mce_io_resume_timer_wakelock);
return result;
}
/** Program resume timer fd
*/
static bool
mce_io_prime_resume_timer(void)
{
bool ack = false;
if( mce_io_resume_timer_fd == -1 )
goto EXIT;
/* Use dummy interval as we are basically only interested in
* getting ECANCELED when CLOCK_REALTIME is adjusted due to
* device resuming from suspend.
*/
struct itimerspec its = { };
int flags = TFD_TIMER_ABSTIME | TFD_TIMER_CANCELON_SET;
if( timerfd_settime(mce_io_resume_timer_fd, flags, &its, 0) == -1 ) {
mce_log(LL_WARN, "can't program resume timer: %m");
goto EXIT;
}
ack = true;
EXIT:
return ack;
}
/** Create resume timer fd
*/
void
mce_io_init_resume_timer(void)
{
bool ack = false;
/* Create realtime clock timerfd */
int clockid = CLOCK_REALTIME;
int flags = O_NONBLOCK | O_CLOEXEC;
mce_io_resume_timer_fd = timerfd_create(clockid, flags);
if( mce_io_resume_timer_fd == -1 ) {
mce_log(LL_WARN, "timerfd_create: %m");
goto EXIT;
}
/* Program dummy wakeup time */
if( !mce_io_prime_resume_timer() )
goto EXIT;
/* Add io watch for the timerfd */
mce_io_resume_timer_id = mce_io_add_watch(mce_io_resume_timer_fd,
false,
G_IO_IN,
mce_io_resume_timer_cb,
0);
if( !mce_io_resume_timer_id )
goto EXIT;
ack = true;
EXIT:
if( !ack ) {
mce_io_quit_resume_timer();
mce_log(LL_WARN, "detect resume via timerfd not in use");
}
}
/** Delete resume timer fd
*/
void
mce_io_quit_resume_timer(void)
{
if( mce_io_resume_timer_id ) {
g_source_remove(mce_io_resume_timer_id),
mce_io_resume_timer_id = 0;
}
if( mce_io_resume_timer_fd != -1 ) {
close(mce_io_resume_timer_fd),
mce_io_resume_timer_fd = -1;
}
}
/* ========================================================================= *
* GLIB_IO_HELPERS
* ========================================================================= */
/**
* Get glib io condition as human readable string
*
* @param cond Bitmap of glib io conditions
*
* @return Names of bits set, separated with " | "
*/
const char *mce_io_condition_repr(GIOCondition cond)
{
static const struct
{
GIOCondition bit;
const char *name;
} lut[] =
{
{ .bit = G_IO_IN, .name = "IN" },
{ .bit = G_IO_OUT, .name = "OUT" },
{ .bit = G_IO_PRI, .name = "PRI" },
{ .bit = G_IO_ERR, .name = "ERR" },
{ .bit = G_IO_HUP, .name = "HUP" },
{ .bit = G_IO_NVAL, .name = "NVAL" },
// sentinel
{ .bit = 0, .name = 0 }
};
static char buf[64];
char *end = buf + sizeof buf - 1;
char *pos = buf;
auto void add(const char *s);
auto void add(const char *s)
{
while( pos < end && *s ) *pos++ = *s++;
}
for( size_t i = 0; lut[i].bit; ++i ) {
if( cond & lut[i].bit ) {
cond ^= lut[i].bit;
if( pos > buf ) add("|");
add(lut[i].name);
}
}
*pos = 0;
if( cond ) {
if( pos > buf ) add("|");
snprintf(pos, end - pos, "0x%x", cond);
}
return buf;
}
/**
* Get glib io status as human readable string
*
* @param io_status as returned from g_io_channel_read_chars()
*
* @return Name of the status enum, without the common prefix
*/
const char *mce_io_status_name(GIOStatus io_status)
{
const char *status_name = "UNKNOWN";
switch (io_status) {
case G_IO_STATUS_NORMAL: status_name = "NORMAL"; break;
case G_IO_STATUS_ERROR: status_name = "ERROR"; break;
case G_IO_STATUS_EOF: status_name = "EOF"; break;
case G_IO_STATUS_AGAIN: status_name = "AGAIN"; break;
default: break; // ... just to keep static analysis happy
}
return status_name;
}
/* ========================================================================= *
* IO_MONITOR
* ========================================================================= */
/** Create I/O monitor object
*
* Allocates I/O monitor object and does all initialization that
* does not need monitoring type information.
*
* Specifically the io watch is not activated from within this
* function, it needs to be done separately.
*
* @param path File path
* @param delete_cb I/O monitor object delete notification callback
*
* @return I/O monitor object
*/
static mce_io_mon_t *mce_io_mon_create(const char *path, mce_io_mon_delete_cb delete_cb)
{
mce_io_mon_t *self = 0;
if( !path ) {
mce_log(LL_ERR, "path == NULL!");
goto EXIT;
}
if( !delete_cb ) {
mce_log(LL_ERR, "delete_cb == NULL!");
goto EXIT;
}
if( !(self = g_slice_new(mce_io_mon_t)) )
goto EXIT;
memset(self, 0, sizeof *self);
/* Fill in sane default values */
self->path = g_strdup(path);
self->type = IOMON_UNSET;
self->chunk_size = 0;
self->seekable = FALSE;
self->suspended = TRUE;
self->iochan = 0;
self->iowatch_id = 0;
self->nofity_cb = 0;
self->delete_cb = delete_cb;
self->error_policy = MCE_IO_ERROR_POLICY_WARN;
self->rewind_policy = FALSE;
self->user_data = 0;
self->user_free_cb = 0;
mce_log(LL_DEBUG, "adding monitor for: %s", self->path);
EXIT:
return self;
}
/** Delete I/O monitor object
*
* Calls delete notification callback to allow upper level
* logic to perform cleanup.
*
* Then removes io watch, closes io channel and releases
* all dynamic resources associated with the I/O monitor object.
*
* @param self I/O monitor object
*/
static void mce_io_mon_delete(mce_io_mon_t *self)
{
if( !self )
goto EXIT;
mce_log(LL_NOTICE, "removing monitor for: %s", self->path);
/* Call the about to delete callback */
if( self->delete_cb ) {
self->delete_cb(self);
}
/* Free attached user data */
if( self->user_data && self->user_free_cb )
self->user_free_cb(self->user_data);
/* Unlink from monitor list */
if( !g_slist_find(file_monitors, self) ) {
mce_log(LL_WARN, "Trying to unregister non-registered"
" file monitor");
}
else {
file_monitors = g_slist_remove(file_monitors, self);
}
/* Remove I/O watch */
mce_io_mon_suspend(self);
/* Close the I/O channel */
if( self->iochan ) {
GError *error = NULL;
GIOStatus iostatus = g_io_channel_shutdown(self->iochan,
TRUE, &error);
if( iostatus != G_IO_STATUS_NORMAL ) {
loglevel_t loglevel = LL_ERR;
/* If we get ENODEV, only log a debug message,
* since this happens for hotpluggable
* /dev/input files
*/
if( (error->code == G_IO_CHANNEL_ERROR_FAILED) &&
(errno == ENODEV) )
loglevel = LL_DEBUG;
mce_log(loglevel, "Cannot close `%s'; %s",
self->path, error->message);
}
g_clear_error(&error);
g_io_channel_unref(self->iochan);
self->iochan = 0;
}
/* Forget file path */
g_free(self->path), self->path = 0;
/* Reset to something that is likely to generate segfaults
* if it ends up used after freeing ... */
memset(self, 0xff, sizeof *self);
g_slice_free(mce_io_mon_t, self);
EXIT:
return;
}
/**
* Check if the monitored io channel is truly seekable
*
* Glib seems to be making guesses based on file type and
* gets it massively wrong for the files MCE needs to read.
*/
static void mce_io_mon_probe_seekable(mce_io_mon_t *self)
{
gboolean glib = FALSE, kernel = FALSE;
/* glib assumes ... */
if (g_io_channel_get_flags(self->iochan) & G_IO_FLAG_IS_SEEKABLE) {
glib = TRUE;
}
/* ... kernel knows */
if (lseek64(g_io_channel_unix_get_fd(self->iochan), 0, SEEK_CUR) != -1) {
kernel = TRUE;
}
/* report the difference */
if (kernel != glib) {
mce_log(LL_DEBUG, "%s: is %sseekable, while glib thinks it is %sseekable",
self->path, kernel ? "" : "NOT ", glib ? "" : "NOT ");
}
self->seekable = kernel;
}
/** Process input for chunked io monitor
*
* For use from mce_io_mon_input_cb() only.
*
* @param source The source of the activity
* @param condition The I/O condition
* @param data The iomon structure
*
* @return TRUE on success, FALSE on failure
*/
static gboolean mce_io_mon_read_chunks(GIOChannel *source,
GIOCondition condition,
gpointer data)
{
gboolean status = FALSE;
mce_io_mon_t *iomon = data;
gchar *buffer = NULL;
gsize bytes_want = 4096;
gsize bytes_have = 0;
gsize chunks_have = 0;
gsize chunks_done = 0;
GError *error = NULL;
GIOStatus io_status = G_IO_STATUS_NORMAL;
#ifdef ENABLE_WAKELOCKS
/* Since the locks on kernel side are released once all
* events are read, we must obtain the userspace lock
* before reading the available data */
wakelock_lock("mce_input_handler", -1);
#endif
/* We get input from evdev nodes at resume, handle that 1st */
io_detect_resume();
// paranoia mode: upper levels should take care of these
if( !(condition & G_IO_IN) )
goto EXIT;
if( !iomon )
goto EXIT;
/* Seek to the beginning of the file before reading if needed */
if( iomon->rewind_policy ) {
g_io_channel_seek_position(source, 0, G_SEEK_SET, &error);
if( error ) {
mce_log(LL_ERR, "%s: seek error: %s",
iomon->path, error->message);
g_clear_error(&error);
}
}
/* Adjust read size to multiples of small sized chunks,
* or size of one larger chunk */
if( iomon->chunk_size < bytes_want )
bytes_want -= bytes_want % iomon->chunk_size;
else
bytes_want = iomon->chunk_size;
/* Allocate read buffer */
buffer = g_malloc(bytes_want);
io_status = g_io_channel_read_chars(source, buffer,
bytes_want, &bytes_have, &error);
/* If the read was interrupted, ignore */
if( io_status == G_IO_STATUS_AGAIN ) {
status = TRUE;
goto EXIT;
}
if( error ) {
mce_log(LL_ERR, "Error when reading from %s: %s",
iomon->path, error->message);
g_clear_error(&error);
goto EXIT;
}
if( bytes_have % iomon->chunk_size ) {
mce_log(LL_WARN, "Incomplete chunks read from: %s",
iomon->path);
}
/* Process the data, and optionally ignore some of it */
chunks_have = bytes_have / iomon->chunk_size;
if( !chunks_have ) {
mce_log(LL_ERR, "Empty read from %s", iomon->path);
}
else {
gchar *chunk = buffer;
for( ; chunks_done < chunks_have ; chunk += iomon->chunk_size ) {
++chunks_done;
if( !iomon->nofity_cb(iomon, chunk, iomon->chunk_size) ) {
continue;
}
/* Ignore rest of the data already read */
if( !iomon->seekable )
break;
/* Try to seek to end of the file */
g_io_channel_seek_position(iomon->iochan, 0,
G_SEEK_END, &error);
if( error ) {
mce_log(LL_ERR, "Error when reading from %s: %s",
iomon->path, error->message);
g_clear_error(&error);
}
break;
}
}
mce_log(LL_INFO, "%s: status=%s, data=%ld/%ld=%ld+%ld, skipped=%ld",
iomon->path, mce_io_status_name(io_status),
(long)bytes_have, (long)iomon->chunk_size, (long)chunks_have,
(long)(bytes_have % iomon->chunk_size), (long)(chunks_have - chunks_done));
status = TRUE;
EXIT:
g_clear_error(&error);
g_free(buffer);
#ifdef ENABLE_WAKELOCKS
/* Release the lock after we're done with processing it */
wakelock_unlock("mce_input_handler");
#endif
return status;
}
/** Process input for string io monitor
*
* For use from mce_io_mon_input_cb() only.
*
* @param source The source of the activity
* @param condition The I/O condition
* @param data The iomon structure
*
* @return TRUE on success, FALSE on failure
*/
static gboolean mce_io_mon_read_string(GIOChannel *source,
GIOCondition condition,
gpointer data)
{
gboolean status = FALSE;
mce_io_mon_t *iomon = data;
gchar *str = NULL;
gsize bytes_read = 0;
GError *error = NULL;
// paranoia mode: upper levels should take care of these
if( !(condition & G_IO_IN) )
goto EXIT;
if( !iomon )
goto EXIT;
/* Seek to the beginning of the file before reading if needed */
if( iomon->rewind_policy ) {
g_io_channel_seek_position(source, 0, G_SEEK_SET, &error);
if( error ) {
mce_log(LL_ERR, "%s: seek error: %s",
iomon->path, error->message);
g_clear_error(&error);
}
}
g_io_channel_read_line(source, &str, &bytes_read, NULL, &error);
if( error ) {
mce_log(LL_ERR, "Error when reading from %s: %s",
iomon->path, error->message);
goto EXIT;
}
if( !bytes_read || !str || !*str )
mce_log(LL_ERR, "Empty read from %s",iomon->path);
else
iomon->nofity_cb(iomon, str, bytes_read);
status = TRUE;
EXIT:
g_free(str);
g_clear_error(&error);
return status;
}
/** Callback for I/O watch
*
* Handles error conditions first; then does input monitor
* type specific input processing.
*
* The I/O monitor will be disabled and deleted on errors.
* Additionally the whole process can be terminated if
* error policy requires it.
*
* @param source Unused
* @param condition The GIOCondition for the error
* @param data The iomon structure
*
* @return TRUE to keep iomon active, FALSE to disable it;
* may also exit depending on error policy for iomon
*/
static gboolean mce_io_mon_input_cb(GIOChannel *source,
GIOCondition condition,
gpointer data)
{
(void)source; // unused
mce_io_mon_t *iomon = data;
gboolean keep_going = TRUE;
gboolean terminate = FALSE;
loglevel_t loglevel = LL_DEBUG;
// sanity checks
if( !iomon ) {
mce_log(LL_ERR, "iomon == NULL!");
keep_going = FALSE;
goto EXIT;
}
// error conditions
if( condition & (G_IO_ERR | G_IO_HUP | G_IO_NVAL) ) {
mce_log(LL_ERR, "iomon '%s' got %s", iomon->path,
mce_io_condition_repr(condition));
keep_going = FALSE;
goto EXIT;
}
// input processing
if( condition & G_IO_IN ) {
switch (iomon->type) {
case IOMON_STRING:
if( !mce_io_mon_read_string(source, condition, data) ) {
mce_log(LL_WARN, "mce_io_mon_read_string failed");
}
break;
case IOMON_CHUNK:
if( !mce_io_mon_read_chunks(source, condition, data) ) {
mce_log(LL_WARN, "mce_io_mon_read_chunks failed");
}
break;
default:
case IOMON_UNSET:
mce_log(LL_WARN, "unknown iomon type");
keep_going = FALSE;
break;
}
}
EXIT:
// cancel io monitor
if( !keep_going && iomon ) {
/* Mark error watch as removed */
iomon->iowatch_id = 0;
/* Adjust actions based on error policy */
switch (iomon->error_policy) {
case MCE_IO_ERROR_POLICY_EXIT:
terminate = TRUE;
loglevel = LL_CRIT;
break;
case MCE_IO_ERROR_POLICY_WARN:
loglevel = LL_WARN;
break;
default:
case MCE_IO_ERROR_POLICY_IGNORE:
loglevel = LL_DEBUG;
break;
}
/* Write log */
mce_log(loglevel, "disabling io monitor for: %s", iomon->path);
/* Remove IO monitor */
mce_io_mon_unregister(iomon);
}
// terminate process
if( terminate ) {
mce_log(LL_CRIT, "terminating due to error policy");
mce_quit_mainloop();
}
return keep_going;
}
/* ========================================================================= *
* I/O MONITOR API
* ========================================================================= */
/**
* Register an I/O monitor; reads and returns data
*
* @param fd File Descriptor; this takes priority over file; -1 if not used
* @param file Path to the file
* @param error_policy MCE_IO_ERROR_POLICY_EXIT to exit on error,
* MCE_IO_ERROR_POLICY_WARN to warn about errors
* but ignore them,
* MCE_IO_ERROR_POLICY_IGNORE to silently ignore errors
* @param callback Function to call with result
* @return An I/O monitor pointer on success, NULL on failure
*/
static mce_io_mon_t *mce_io_mon_register(gint fd,
const gchar *path,
error_policy_t error_policy,
gboolean rewind_policy,
mce_io_mon_notify_cb callback,
mce_io_mon_delete_cb delete_cb)
{
bool success = false;
mce_io_mon_t *iomon = 0;
GError *error = NULL;
/* Sanity checks */
if( !path ) {
mce_log(LL_ERR, "path == NULL!");
goto EXIT;
}
if( !callback ) {
mce_log(LL_ERR, "callback == NULL!");
goto EXIT;
}
/* Silently ignore non-existing files */
if( fd == -1 && access(path, F_OK) == -1 )
goto EXIT;
/* Allocate monitor object */
if( !(iomon = mce_io_mon_create(path, delete_cb)) )
goto EXIT;
/* Add to monitor list */
file_monitors = g_slist_prepend(file_monitors, iomon);
/* Set custom props */
iomon->nofity_cb = callback;
iomon->error_policy = error_policy;
/* Set up io channel */
if( fd != -1 )
iomon->iochan = g_io_channel_unix_new(fd);
else
iomon->iochan = g_io_channel_new_file(path, "r", &error);
if( !iomon->iochan ) {
mce_log(LL_ERR, "Failed to open `%s'; %s", path,
error ? error->message : "unknown error");
goto EXIT;
}
/* Transfer fd ownership to io channel */
g_io_channel_set_close_on_unref(iomon->iochan, TRUE), fd = -1;
/* Glib seekability is broken, probe via syscall */
mce_io_mon_probe_seekable(iomon);
/* Set rewind policy */
if( iomon->seekable ) {
iomon->rewind_policy = rewind_policy;
} else if( rewind_policy ) {
mce_log(LL_ERR, "Attempting to set rewind policy to TRUE "
"on non-seekable I/O channel `%s'", path);
}
success = true;
EXIT:
if( fd != -1 )
close(fd);
if( !success )
mce_io_mon_delete(iomon), iomon = 0;
g_clear_error(&error);
return iomon;
}
/** Unregister an I/O monitor
*
* @param io_monitor A pointer to the I/O monitor to unregister
*/
void mce_io_mon_unregister(mce_io_mon_t *iomon)
{
mce_io_mon_delete(iomon);
}
/** Remove all touch device I/O monitors in a list
*
* @param list A list of I/O monitors
*/
void mce_io_mon_unregister_list(GSList *list)
{
GSList *now, *zen;
for( now = list; now; now = zen ) {
zen = now->next;
mce_io_mon_unregister(now->data);
}
}
/** Unregister I/O monitors for the given path
*
* @param path Path to file for which all monitors should be unregistered
*/
void mce_io_mon_unregister_at_path(const char *path)
{
GSList *now, *zen;
if( !path )
goto EXIT;
for( now = file_monitors; now; now = zen ) {
zen = now->next;
mce_io_mon_t *self = now->data;
if( !self->path || strcmp(self->path, path) )
continue;
mce_io_mon_unregister(self);
}
EXIT:
return;
}
/**
* Suspend an I/O monitor
*
* @param io_monitor A pointer to the I/O monitor to suspend
*/
void mce_io_mon_suspend(mce_io_mon_t *iomon)
{
if( !iomon ) {
mce_log(LL_ERR, "iomon == NULL!");
goto EXIT;
}
/* Remove I/O watches */
if( iomon->iowatch_id ) {
g_source_remove(iomon->iowatch_id),
iomon->iowatch_id = 0;
}
iomon->suspended = TRUE;
EXIT:
return;
}
/**
* Resume an I/O monitor
*
* @param io_monitor A pointer to the I/O monitor to resume
*/
void mce_io_mon_resume(mce_io_mon_t *iomon)
{
if( !iomon ) {
mce_log(LL_ERR, "iomon == NULL!");
goto EXIT;
}
if( !iomon->suspended )
goto EXIT;
/* Seek to the end of the file if the file is seekable,
* and rewind policy is not requested
*/
if( iomon->seekable && !iomon->rewind_policy ) {
GError *error = NULL;
g_io_channel_seek_position(iomon->iochan, 0,
G_SEEK_END, &error);
if( error ) {
mce_log(LL_ERR, "%s: seek error: %s",
iomon->path, error->message);
}
g_clear_error(&error);
}
/* Set up input monitor */
if( iomon->iowatch_id )
g_source_remove(iomon->iowatch_id);
iomon->iowatch_id =
g_io_add_watch(iomon->iochan,
G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
mce_io_mon_input_cb, iomon);
/* Mark as not-suspended */
iomon->suspended = FALSE;
EXIT:
return;
}
/**
* Register an I/O monitor; reads and returns a string
*
* @param fd File Descriptor; this takes priority over file; -1 if not used
* @param file Path to the file
* @param error_policy MCE_IO_ERROR_POLICY_EXIT to exit on error,
* MCE_IO_ERROR_POLICY_WARN to warn about errors
* but ignore them,
* MCE_IO_ERROR_POLICY_IGNORE to silently ignore errors
* @param rewind_policy TRUE to seek to the beginning,
* FALSE to stay at current position
* @param callback Function to call with result
* @return An I/O monitor cookie on success, NULL on failure
*/
mce_io_mon_t *mce_io_mon_register_string(const gint fd,
const gchar *const file,
error_policy_t error_policy,
gboolean rewind_policy,
mce_io_mon_notify_cb callback,
mce_io_mon_delete_cb delete_cb)
{
mce_io_mon_t *iomon = NULL;
iomon = mce_io_mon_register(fd, file,
error_policy, rewind_policy,
callback, delete_cb);
if (iomon == NULL)
goto EXIT;
/* Set the I/O monitor type and call resume to add an I/O watch */
iomon->type = IOMON_STRING;
mce_io_mon_resume(iomon);
EXIT:
return iomon;
}
/**
* Register an I/O monitor; reads and returns a chunk of specified size
*
* @param fd File Descriptor; this takes priority over file; -1 if not used
* @param file Path to the file
* @param error_policy MCE_IO_ERROR_POLICY_EXIT to exit on error,
* MCE_IO_ERROR_POLICY_WARN to warn about errors
* but ignore them,
* MCE_IO_ERROR_POLICY_IGNORE to silently ignore errors
* @param rewind_policy TRUE to seek to the beginning,
* FALSE to stay at current position
* @param callback Function to call with result
* @param chunk_size The number of bytes to read in each chunk
* @return An I/O monitor cookie on success, NULL on failure
*/
mce_io_mon_t *mce_io_mon_register_chunk(const gint fd,
const gchar *const file,
error_policy_t error_policy,
gboolean rewind_policy,
mce_io_mon_notify_cb callback,
mce_io_mon_delete_cb delete_cb,
gulong chunk_size)
{
mce_io_mon_t *iomon = NULL;
GError *error = NULL;
iomon = mce_io_mon_register(fd, file,
error_policy, rewind_policy,
callback, delete_cb);
if( !iomon )
goto EXIT;
/* We only read this file in binary form */
g_io_channel_set_encoding(iomon->iochan, NULL, &error);
g_clear_error(&error);
/* No buffering since we're using this for reading data from
* device drivers and need to keep the i/o state in sync
* between kernel and user space for the automatic suspend
* prevention via wakelocks to work
*/
g_io_channel_set_buffered(iomon->iochan, FALSE);
/* Don't block */
g_io_channel_set_flags(iomon->iochan, G_IO_FLAG_NONBLOCK, &error);
g_clear_error(&error);
/* Set the I/O monitor type and call resume to add an I/O watch */
iomon->type = IOMON_CHUNK;
iomon->chunk_size = chunk_size;
mce_io_mon_resume(iomon);
EXIT:
return iomon;
}
/**
* Return the name of the monitored file
*
* @param io_monitor An opaque pointer to the I/O monitor structure
* @return The name of the monitored file
*/
const gchar *mce_io_mon_get_path(const mce_io_mon_t *iomon)
{
const gchar *path = 0;
if( iomon )
path = iomon->path;
return path;
}
/**
* Return the file descriptor of the monitored file;
* if the file being monitored was opened from a path
* rather than a file descriptor, -1 is returned
*
* @param io_monitor An opaque pointer to the I/O monitor structure
* @return The file descriptor of the monitored file
*/
int mce_io_mon_get_fd(const mce_io_mon_t *iomon)
{
int fd = -1;
if( iomon && iomon->iochan )
fd = g_io_channel_unix_get_fd(iomon->iochan);
return fd;
}
/** Attach user data block to io monitor
*
* If non-null free_cb callback is given, the user_data block will
* be released using it when io-monitor itself is deleted.
*
* Note: The delete notification callback is called before the
* user data is released, i.e. user data is still available
* at that point.
*
* @param io_monitor An opaque pointer to the I/O monitor structure
* @param user_data Data block to attach to io monitor, or NULL
* @param free_cb Free function to release data block or NULL
*/
void mce_io_mon_set_user_data(mce_io_mon_t *iomon,
void *user_data,
mce_io_mon_free_cb free_cb)
{
if( !iomon )
goto EXIT;
/* Clear already existing user data */
if( iomon->user_data && iomon->user_free_cb )
iomon->user_free_cb(iomon->user_data);
/* Set user data */
iomon->user_data = user_data;
iomon->user_free_cb = free_cb;
EXIT:
return;
}
/** Get user data block attached to io monitor
*
* @param io_monitor An opaque pointer to the I/O monitor structure
*
* @return user data block, or NULL if not set
*/
void *mce_io_mon_get_user_data(const mce_io_mon_t *iomon)
{
return iomon ? iomon->user_data : 0;
}
/* ========================================================================= *
* MISC_UTILS
* ========================================================================= */
/** Helper for creating I/O watch for file descriptor
*
* @param fd File descriptor for which to add glib io watch
* @param close_on_unref True to transfer fd owhership to io watch
* @param cnd Condition bitmask
* @param io_cb Callback function
* @param aptr User data to pass to the callback
*
* @return wath id on success, or 0 on failure
*/
guint
mce_io_add_watch(int fd, bool close_on_unref,
GIOCondition cnd, GIOFunc io_cb, gpointer aptr)
{
guint wid = 0;
GIOChannel *chn = 0;
if( !(chn = g_io_channel_unix_new(fd)) )
goto cleanup;
g_io_channel_set_close_on_unref(chn, close_on_unref);
cnd |= G_IO_ERR | G_IO_HUP | G_IO_NVAL;
if( !(wid = g_io_add_watch(chn, cnd, io_cb, aptr)) )
goto cleanup;
cleanup:
if( chn != 0 ) g_io_channel_unref(chn);
return wid;
}
/**
* Helper function for closing files that checks for NULL,
* prints proper error messages and NULLs the file pointer after close
*
* @param file The name of the file to close; only used by error messages
* @param fp A pointer to the file pointer to close
* @return TRUE on success, FALSE on failure
*/
gboolean mce_close_file(const gchar *const file, FILE **fp)
{
gboolean status = FALSE;
if (fp == NULL) {
mce_log(LL_CRIT,
"fp == NULL!");
goto EXIT;
}
if (*fp == NULL) {
status = TRUE;
goto EXIT;
}
if (fclose(*fp) == EOF) {
mce_log(LL_ERR,
"Failed to close `%s'; %s",
file ? file : "<unset>",
g_strerror(errno));
status = FALSE;
/* Ignore error */
errno = 0;
goto EXIT;
}
*fp = NULL;
status = TRUE;
EXIT:
return status;
}
/**
* Read a chunk from a file
*
* @param file Path to the file, or NULL to use an already open fd instead
* @param[out] data A newly allocated buffer with the first chunk from the file
* @param[in,out] len [in] The length of the buffer to read
* [out] The number of bytes read
* @param flags Additional flags to pass to open();
* by default O_RDONLY is always passed -- this is mainly
* to allow passing O_NONBLOCK
* @return TRUE on success, FALSE on failure
*/
gboolean mce_read_chunk_from_file(const gchar *const file, void **data,
gssize *len, int flags)
{
gboolean status = FALSE;
gint again_count = 0;
gssize result = -1;
gint fd;
if (file == NULL) {
mce_log(LL_CRIT, "file == NULL!");
goto EXIT;
}
if (len == NULL) {
mce_log(LL_CRIT, "len == NULL!");
goto EXIT;
}
if (*len <= 0) {
mce_log(LL_CRIT, "*len <= 0!");
goto EXIT;
}
/* If we cannot open the file, abort */
if ((fd = open(file, O_RDONLY | flags)) == -1) {
mce_log(LL_ERR,
"Cannot open `%s' for reading; %s",
file, g_strerror(errno));
/* Ignore error */
errno = 0;
goto EXIT;
}
if ((*data = g_try_malloc(*len)) == NULL) {
mce_log(LL_CRIT,
"Failed to allocate memory (%zd bytes)!",
*len);
goto EXIT2;
}
while (again_count++ < 10) {
/* Clear errors from earlier iterations */
errno = 0;
result = read(fd, *data, *len);
if ((result == -1) &&
((errno == EAGAIN) || (errno == EWOULDBLOCK))) {
continue;
} else {
break;
}
}
if (result == -1) {
mce_log(LL_ERR,
"Failed to read from `%s'; %s",
file, g_strerror(errno));
/* Ignore error */
errno = 0;
goto EXIT2;
}
status = TRUE;
EXIT2:
if (close(fd) == -1) {
mce_log(LL_ERR,
"Failed to close `%s'; %s",
file, g_strerror(errno));
errno = 0;
}
/* Ignore error */
errno = 0;
*len = result;
EXIT:
return status;
}
/**
* Read a string from a file
*
* @param file Path to the file
* @param[out] string A newly allocated string with the first line of the file
* @return TRUE on success, FALSE on failure
*/
gboolean mce_read_string_from_file(const gchar *const file, gchar **string)
{
GError *error = NULL;
gboolean status = FALSE;
if (file == NULL) {
mce_log(LL_CRIT, "file == NULL!");
goto EXIT;
}
if (g_file_get_contents(file, string, NULL, &error) == FALSE) {
mce_log(LL_ERR,
"Cannot open `%s' for reading; %s",
file, error->message);
goto EXIT;
}
status = TRUE;
EXIT:
/* Reset errno,
* to avoid false positives down the line
*/
errno = 0;
g_clear_error(&error);
return status;
}
/**
* Read a number representation of a string from a file
*
* @param file Path to the file, or NULL to user an already open FILE * instead
* @param[out] number A number representation of the first line of the file
* @param fp A pointer to a FILE *; set the FILE * to NULL to use the file
* path instead
* @param rewind_file TRUE to seek to the beginning of the file,
* FALSE to read from the current position;
* only affects already open files
* @param close_on_exit TRUE to close the file on exit,
* FALSE to leave the file open
* @return TRUE on success, FALSE on failure
*/
gboolean mce_read_number_string_from_file(const gchar *const file,
gulong *number, FILE **fp,
gboolean rewind_file,
gboolean close_on_exit)
{
gboolean status = FALSE;
gint again_count = 0;
FILE *new_fp = NULL;
gint retval;
if ((file == NULL) && ((fp == NULL) || (*fp == NULL))) {
mce_log(LL_CRIT,
"(file == NULL) && ((fp == NULL) || (*fp == NULL))!");
goto EXIT;
}
if ((fp == NULL) && (close_on_exit == FALSE)) {
mce_log(LL_CRIT,
"(fp == NULL) && (close_on_exit == FALSE)!");
goto EXIT;
}
/* If we cannot open the file, abort */
if ((fp == NULL) || (*fp == NULL)) {
if ((new_fp = fopen(file, "r")) == NULL) {
mce_log(LL_ERR,
"Cannot open `%s' for reading; %s",
file, g_strerror(errno));
/* Ignore error */
errno = 0;
goto EXIT;
}
} else {
new_fp = *fp;
}
/* Rewind file if we already have one */
if ((fp != NULL) && (*fp != NULL) && (rewind_file == TRUE)) {
if (fseek(*fp, 0L, SEEK_SET) == -1) {
mce_log(LL_ERR,
"Failed to rewind `%s'; %s",
file, g_strerror(errno));
/* Ignore error */
errno = 0;
goto EXIT2;
}
}
if ((fp != NULL) && (*fp == NULL))
*fp = new_fp;
while (again_count++ < 10) {
/* Clear errors from earlier iterations */
clearerr(new_fp);
errno = 0;
retval = fscanf(new_fp, "%lu", number);
if ((retval == EOF) &&
(ferror(new_fp) != 0) && (errno == EAGAIN)) {
continue;
} else {
break;
}
}
/* Was the read successful? */
if ((retval == EOF) && (ferror(new_fp) != 0)) {
mce_log(LL_ERR,
"Failed to read from `%s'; %s",
file, g_strerror(errno));
clearerr(new_fp);
/* Ignore error */
errno = 0;
goto EXIT2;
}
if (retval != 1) {
mce_log(LL_ERR,
"Could not match any values when reading from `%s'",
file);
goto EXIT2;
}
status = TRUE;
EXIT2:
/* XXX: improve close policy? */
if ((status == FALSE) || (close_on_exit == TRUE)) {
mce_close_file(file, &new_fp);
if (fp != NULL)
*fp = NULL;
}
/* Ignore error */
errno = 0;
EXIT:
return status;
}
/**
* Write a string to a file
*
* @param file Path to the file
* @param string The string to write
* @return TRUE on success, FALSE on failure
*/
gboolean mce_write_string_to_file(const gchar *const file,
const gchar *const string)
{
gboolean status = FALSE;
FILE *fp = NULL;
gint retval;
if (file == NULL) {
mce_log(LL_CRIT, "file == NULL!");
goto EXIT;
}
if (string == NULL) {
mce_log(LL_CRIT, "string == NULL!");
goto EXIT;
}
if ((fp = fopen(file, "w")) == NULL) {
mce_log(LL_ERR,
"Cannot open `%s' for %s; %s",
file,
"writing",
g_strerror(errno));
/* Ignore error */
errno = 0;
goto EXIT;
}
retval = fprintf(fp, "%s", string);
/* Was the write successful? */
if (retval < 0) {
mce_log(LL_ERR,
"Failed to write to `%s'; %s",
file, g_strerror(errno));
/* Ignore error */
errno = 0;
goto EXIT2;
}
status = TRUE;
EXIT2:
mce_close_file(file, &fp);
EXIT:
return status;
}
/**
* Cleanup function for output file control structures
*
* Closes file stream associated with output if it is open
*
* It is explicitly permitted to call this function:
* 1) with NULL output parameter
* 2) without open stream in ouput
* 3) more than one times
*
* @param output control structure for writing to a file
*/
void mce_close_output(output_state_t *output)
{
if( output && output->file ) {
if( fclose(output->file) == EOF ) {
mce_log(LL_WARN,"%s: can't close %s: %m", output->context, output->path);
}
output->file = 0;
}
}
/**
* Write a string representation of a number to a file
*
* Note: this variant uses in-place rewrites when truncating.
* It should thus not be used in cases where atomicity is expected.
* For atomic replace, use mce_write_number_string_to_file_atomic()
*
* @param output control structure for writing to a file
* @param number The number to write
*
* @return TRUE on success, FALSE on failure
*/
gboolean mce_write_number_string_to_file(output_state_t *output, const gulong number)
{
gboolean status = FALSE; // assume failure
if( !output ) {
mce_log(LL_CRIT, "NULL output passed, terminating");
mce_abort();
}
if( !output->context ) {
mce_log(LL_CRIT, "output->context missing, terminating");
mce_abort();
}
if( !output->path ) {
if( !output->invalid_config_reported ) {
output->invalid_config_reported = TRUE;
mce_log(LL_ERR, "%s: output->path not configured", output->context);
}
goto EXIT;
}
if( !output->file ) {
output->file = fopen(output->path, output->truncate_file ? "w" : "a");
if( !output->file ) {
mce_log(LL_ERR,"%s: can't open %s: %m", output->context, output->path);
goto EXIT;
}
}
else if( output->truncate_file )
{
rewind(output->file);
if( ftruncate(fileno(output->file), 0) == -1 ) {
mce_log(LL_WARN,"%s: can't truncate %s: %m", output->context, output->path);
}
}
// from now on assume success
status = TRUE;
if( fprintf(output->file, "%lu", number) < 0 ) {
mce_log(LL_WARN,"%s: can't write %s: %m", output->context, output->path);
status = FALSE;
}
if( fflush(output->file) == EOF ) {
mce_log(output->reported_errno != errno ? LL_WARN : LL_DEBUG,
"%s: can't flush %s: %m", output->context, output->path);
output->reported_errno = errno;
status = FALSE;
}
else {
output->reported_errno = 0;
}
EXIT:
if( output->close_on_exit && output->file ) {
if( fclose(output->file) == EOF ) {
mce_log(LL_WARN,"%s: can't close %s: %m", output->context, output->path);
}
output->file = 0;
}
return status;
}
/**
* Write a string representation of a number to a file
* in an atomic manner
*
* @param file Path to the file to write to
* @param number The number to write
* @return TRUE on success, FALSE on failure
*/
gboolean mce_write_number_string_to_file_atomic(const gchar *const file,
const gulong number)
{
gboolean status = FALSE;
gchar *tmpname = NULL;
FILE *fp = NULL;
gint retval;
int fd;
if (file == NULL) {
mce_log(LL_CRIT,
"file == NULL");
goto EXIT;
}
if ((tmpname = g_strconcat(file, TMP_SUFFIX, NULL)) == NULL) {
mce_log(LL_ERR,
"Failed to allocate memory for `%s%s'",
file, TMP_SUFFIX);
goto EXIT;
}
/* If we cannot open the file, abort */
if ((fp = fopen(tmpname, "w")) == NULL) {
mce_log(LL_ERR,
"Cannot open `%s' for writing; %s",
tmpname, g_strerror(errno));
/* Ignore error */
errno = 0;
goto EXIT;
}
retval = fprintf(fp, "%lu", number);
/* Was the write successful? */
if (retval < 0) {
mce_log(LL_ERR,
"Failed to write to `%s'; %s",
tmpname, g_strerror(errno));
/* Ignore error */
errno = 0;
goto EXIT2;
}
if ((fd = fileno(fp)) == -1) {
mce_log(LL_ERR,
"Failed to convert *fp to fd; %s",
g_strerror(errno));
/* Ignore error */
errno = 0;
goto EXIT2;
}
/* Ensure that the data makes it to disk */
if (fsync(fd) == -1) {
mce_log(LL_ERR,
"Failed to fsync `%s'; %s",
tmpname, g_strerror(errno));
/* Ignore error */
errno = 0;
goto EXIT2;
}
status = TRUE;
EXIT2:
/* Close the temporary file */
if (mce_close_file(tmpname, &fp) == FALSE) {
status = FALSE;
goto EXIT;
}
/* And if everything has been successful so far,
* rename the temporary file over the old file
*/
if (status == TRUE) {
if (rename(tmpname, file) == -1) {
mce_log(LL_ERR,
"Failed to rename `%s' to `%s'; %s",
tmpname, file, g_strerror(errno));
status = FALSE;
/* Ignore error */
errno = 0;
goto EXIT;
}
}
EXIT:
g_free(tmpname);
return status;
}
/**
* Test whether there's a settings lock due to pending
* backup/restore or device clear/factory reset operation
*
* @return TRUE if the settings lock file is in place,
* FALSE if the settings lock file is not in place
*/
gboolean mce_are_settings_locked(void)
{
gboolean status = (g_access(MCE_SETTINGS_LOCK_FILE_PATH, F_OK) == 0);
errno = 0;
return status;
}
/**
* Remove the settings lock file
*
* @return TRUE on success, FALSE on failure
*/
gboolean mce_unlock_settings(void)
{
gboolean status = (g_unlink(MCE_SETTINGS_LOCK_FILE_PATH) == 0);
errno = 0;
return status;
}
/** Helper for dealing with partially successful reads
*
* @param fd file descriptor to read from
* @param buff address where to read to
* @param size number of bytes to read
* @param pdone where to store actual read count, or NULL
*
* @return TRUE if all bytes could be read, otherwise FALSE
*/
static
gboolean mce_io_read_all(int fd, void *buff, size_t size, size_t *pdone)
{
size_t done = 0;
char *data = buff;
while( done < size ) {
ssize_t rc = TEMP_FAILURE_RETRY(read(fd, data+done, size));
if( rc < 0 )
break;
if( rc == 0 ) {
// clear errno if returning prematurely due to eof
errno = 0;
break;
}
done += (size_t)rc;
}
if( pdone )
*pdone = done;
return (done == size);
}
/** Helper for dealing with partially successful writes
*
* @param fd file descriptor to write to
* @param buff address where to write from
* @param size number of bytes to write
* @param pdone where to store actual write count, or NULL
*
* @return TRUE if all bytes could be written, otherwise FALSE
*/
static
gboolean mce_io_write_all(int fd, const void *buff, size_t size, size_t *pdone)
{
size_t done = 0;
const char *data = buff;
while( done < size ) {
ssize_t rc = TEMP_FAILURE_RETRY(write(fd, data+done, size));
if( rc < 0 )
break;
done += (size_t)rc;
}
if( pdone )
*pdone = done;
return (done == size);
}
/** Load contents of a file
*
* @param path file to read from
* @param psize where to store size of the loaded file, or NULL if not needed
*
* @return Zero terminated contents of the file, or NULL in case of errors
*/
void *mce_io_load_file(const char *path, size_t *psize)
{
void *res = 0;
char *data = 0;
size_t size = 0;
int fd = -1;
struct stat st;
if( (fd = TEMP_FAILURE_RETRY(open(path, O_RDONLY))) == -1 ) {
if( errno != ENOENT )
mce_log(LL_WARN, "open(%s): %m", path);
goto EXIT;
}
if( fstat(fd, &st) == -1 ) {
mce_log(LL_WARN, "stat(%s): %m", path);
goto EXIT;
}
size = st.st_size;
data = g_malloc(size + 1);
if( !mce_io_read_all(fd, data, size, 0) ) {
mce_log(LL_WARN, "read(%s): %m", path);
goto EXIT;
}
data[size] = 0;
res = data, data = 0;
EXIT:
g_free(data);
if( fd != -1 && TEMP_FAILURE_RETRY(close(fd)) == -1 )
mce_log(LL_WARN, "close(%s): %m", path);
if( psize )
*psize = res ? size : 0;
return res;
}
/** Load contents of a file, ignoring the reported file size
*
* @param path file to read from
* @param psize where to store size of the loaded file, or NULL if not needed
*
* @return Zero terminated contents of the file, or NULL in case of errors
*/
void *mce_io_load_file_until_eof(const char *path, size_t *psize)
{
void *res = 0;
char *data = 0;
size_t used = 0;
size_t size = 0;
int fd = -1;
ssize_t rc;
if( (fd = TEMP_FAILURE_RETRY(open(path, O_RDONLY))) == -1 ) {
if( errno != ENOENT )
mce_log(LL_WARN, "open(%s): %m", path);
goto EXIT;
}
size = 1024;
data = g_malloc(size);
for( ;; ) {
rc = TEMP_FAILURE_RETRY(read(fd, data + used, size - used));;
if( rc == 0 )
break;
if( rc == -1 ) {
mce_log(LL_WARN, "read(%s): %m", path);
goto EXIT;
}
used += (size_t)rc;
if( size - used < 512 ) {
size = size * 2;
data = g_realloc(data, size);
}
}
data = g_realloc(data, used + 1);
data[used] = 0;
res = data, data = 0;
EXIT:
g_free(data);
if( fd != -1 && TEMP_FAILURE_RETRY(close(fd)) == -1 )
mce_log(LL_WARN, "close(%s): %m", path);
if( psize )
*psize = res ? used : 0;
return res;
}
/** Write datablock to a file
*
* @param path file to write to
* @param data start of the data to write
* @param size length of the data to write
* @param mode protection bits to apply
*
* @return TRUE on success, FALSE on errors
*/
gboolean mce_io_save_file(const char *path,
const void *data, size_t size,
mode_t mode)
{
gboolean res = FALSE;
int fd = -1;
if( mode <= 0 )
mode = 0664;
fd = TEMP_FAILURE_RETRY(open(path, O_WRONLY|O_CREAT|O_TRUNC, 0600));
if( fd == -1 ) {
mce_log(LL_WARN, "open(%s): %m", path);
goto EXIT;
}
if( !mce_io_write_all(fd, data, size, 0) ) {
mce_log(LL_WARN, "write(%s): %m", path);
goto EXIT;
}
if( fchmod(fd, mode) == -1 ) {
mce_log(LL_WARN, "chmod(%s, %03o): %m", path, (int)mode);
goto EXIT;
}
res = TRUE;
EXIT:
if( fd != -1 && TEMP_FAILURE_RETRY(close(fd)) == -1 )
mce_log(LL_WARN, "close(%s): %m", path);
return res;
}
/** Write datablock to an existing file
*
* @param path file to write to
* @param data start of the data to write
* @param size length of the data to write
*
* @return TRUE on success, FALSE on errors
*/
gboolean mce_io_save_to_existing_file(const char *path,
const void *data, size_t size)
{
gboolean res = FALSE;
int fd = -1;
fd = TEMP_FAILURE_RETRY(open(path, O_WRONLY|O_TRUNC));
if( fd == -1 ) {
mce_log(LL_WARN, "open(%s): %m", path);
goto EXIT;
}
if( !mce_io_write_all(fd, data, size, 0) ) {
mce_log(LL_WARN, "write(%s): %m", path);
goto EXIT;
}
res = TRUE;
EXIT:
if( fd != -1 && TEMP_FAILURE_RETRY(close(fd)) == -1 )
mce_log(LL_WARN, "close(%s): %m", path);
return res;
}
/** Atomically replace a file contents
*
* First writes to a temp file, then duplicates the original as
* a backup and atomically replaces the original with freshly
* written data.
*
* @param path file to write to
* @param data start of the data to write
* @param size length of the data to write
* @param mode protection bits to apply
* @param keep_backup whether to keep backup file on successful update
*
* @return TRUE on success, FALSE on errors
*/
gboolean mce_io_save_file_atomic(const char *path,
const void *data, size_t size,
mode_t mode, gboolean keep_backup)
{
gboolean res = FALSE;
gchar *temp = g_strdup_printf("%s.tmp", path);
gchar *back = g_strdup_printf("%s.bak", path);
if( !mce_io_save_file(temp, data, size, mode) )
goto EXIT;
if( unlink(back) == -1 && errno != ENOENT ) {
mce_log(LL_WARN, "unlink(%s): %m", back);
goto EXIT;
}
if( link(path, back) == -1 && errno != ENOENT ) {
mce_log(LL_WARN, "link(%s, %s): %m", path, back);
goto EXIT;
}
if( rename(temp, path) == -1 ) {
mce_log(LL_WARN, "rename(%s, %s): %m", temp, path);
goto EXIT;
}
if( !keep_backup && unlink(back) == -1 && errno != ENOENT ) {
mce_log(LL_WARN, "unlink(%s): %m", back);
goto EXIT;
}
res = TRUE;
EXIT:
if( temp && unlink(temp) == -1 && errno != ENOENT )
mce_log(LL_WARN, "unlink(%s): %m", temp);
g_free(back);
g_free(temp);
return res;
}
/** Atomically replace a file if existing file content differs from wanted
*
* The purpose of this function is to avoid unnecessary writes when
* writing to filesystem is slow or otherwise undesired (flash wear out).
*
* @param path file to write to
* @param data start of the data to write
* @param size length of the data to write
* @param mode protection bits to apply
* @param keep_backup whether to keep backup file on successful update
*
* @return TRUE on success, FALSE on errors
*/
gboolean mce_io_update_file_atomic(const char *path,
const void *data, size_t size,
mode_t mode, gboolean keep_backup)
{
gboolean res = FALSE;
size_t old_size = 0;
void *old_data = 0;
/* Skip write if the content would not change */
if( (old_data = mce_io_load_file(path, &old_size)) ) {
if( old_size == size && !memcmp(old_data, data, size) ) {
res = TRUE;
goto EXIT;
}
}
res = mce_io_save_file_atomic(path, data, size, mode, keep_backup);
EXIT:
g_free(old_data);
return res;
}