This way all callers do not need to specify it.
Exhaustively tested by running test-log under valgrind ;)
#define log_struct_errno(level, error, ...) \
log_struct_internal(LOG_REALM_PLUS_LEVEL(LOG_REALM, level), \
error, __FILE__, __LINE__, __func__, __VA_ARGS__)
+ error, __FILE__, __LINE__, __func__, __VA_ARGS__, NULL)
#define log_struct(level, ...) log_struct_errno(level, 0, __VA_ARGS__)
#define log_struct_iovec_errno(level, error, iovec, n_iovec) \
case KEY_POWER2:
log_struct(LOG_INFO,
LOG_MESSAGE("Power key pressed."),
- "MESSAGE_ID=" SD_MESSAGE_POWER_KEY_STR,
- NULL);
+ "MESSAGE_ID=" SD_MESSAGE_POWER_KEY_STR);
manager_handle_action(b->manager, INHIBIT_HANDLE_POWER_KEY, b->manager->handle_power_key, b->manager->power_key_ignore_inhibited, true);
break;
case KEY_SLEEP:
log_struct(LOG_INFO,
LOG_MESSAGE("Suspend key pressed."),
- "MESSAGE_ID=" SD_MESSAGE_SUSPEND_KEY_STR,
- NULL);
+ "MESSAGE_ID=" SD_MESSAGE_SUSPEND_KEY_STR);
manager_handle_action(b->manager, INHIBIT_HANDLE_SUSPEND_KEY, b->manager->handle_suspend_key, b->manager->suspend_key_ignore_inhibited, true);
break;
case KEY_SUSPEND:
log_struct(LOG_INFO,
LOG_MESSAGE("Hibernate key pressed."),
- "MESSAGE_ID=" SD_MESSAGE_HIBERNATE_KEY_STR,
- NULL);
+ "MESSAGE_ID=" SD_MESSAGE_HIBERNATE_KEY_STR);
manager_handle_action(b->manager, INHIBIT_HANDLE_HIBERNATE_KEY, b->manager->handle_hibernate_key, b->manager->hibernate_key_ignore_inhibited, true);
break;
if (ev.code == SW_LID) {
log_struct(LOG_INFO,
LOG_MESSAGE("Lid closed."),
- "MESSAGE_ID=" SD_MESSAGE_LID_CLOSED_STR,
- NULL);
+ "MESSAGE_ID=" SD_MESSAGE_LID_CLOSED_STR);
b->lid_closed = true;
button_lid_switch_handle_action(b->manager, true);
} else if (ev.code == SW_DOCK) {
log_struct(LOG_INFO,
LOG_MESSAGE("System docked."),
- "MESSAGE_ID=" SD_MESSAGE_SYSTEM_DOCKED_STR,
- NULL);
+ "MESSAGE_ID=" SD_MESSAGE_SYSTEM_DOCKED_STR);
b->docked = true;
}
if (ev.code == SW_LID) {
log_struct(LOG_INFO,
LOG_MESSAGE("Lid opened."),
- "MESSAGE_ID=" SD_MESSAGE_LID_OPENED_STR,
- NULL);
+ "MESSAGE_ID=" SD_MESSAGE_LID_OPENED_STR);
b->lid_closed = false;
b->check_event_source = sd_event_source_unref(b->check_event_source);
} else if (ev.code == SW_DOCK) {
log_struct(LOG_INFO,
LOG_MESSAGE("System undocked."),
- "MESSAGE_ID=" SD_MESSAGE_SYSTEM_UNDOCKED_STR,
- NULL);
+ "MESSAGE_ID=" SD_MESSAGE_SYSTEM_UNDOCKED_STR);
b->docked = false;
}
return log_struct(LOG_NOTICE,
"MESSAGE_ID=" SD_MESSAGE_SHUTDOWN_STR,
p,
- q,
- NULL);
+ q);
}
#endif // 0
log_struct(LOG_INFO,
"MESSAGE_ID=" SD_MESSAGE_SEAT_START_STR,
"SEAT_ID=%s", s->id,
- LOG_MESSAGE("New seat %s.", s->id),
- NULL);
+ LOG_MESSAGE("New seat %s.", s->id));
/* Initialize VT magic stuff */
#if 0 /// elogind does not support autospawning vts
log_struct(LOG_INFO,
"MESSAGE_ID=" SD_MESSAGE_SEAT_STOP_STR,
"SEAT_ID=%s", s->id,
- LOG_MESSAGE("Removed seat %s.", s->id),
- NULL);
+ LOG_MESSAGE("Removed seat %s.", s->id));
seat_stop_sessions(s, force);
"SESSION_ID=%s", s->id,
"USER_ID=%s", s->user->name,
"LEADER="PID_FMT, s->leader,
- LOG_MESSAGE("New session %s of user %s.", s->id, s->user->name),
- NULL);
+ LOG_MESSAGE("New session %s of user %s.", s->id, s->user->name));
if (!dual_timestamp_is_set(&s->timestamp))
dual_timestamp_get(&s->timestamp);
"LEADER="PID_FMT, s->leader,
LOG_MESSAGE("Removed session %s.", s->id),
NULL);
+ LOG_MESSAGE("Removed session %s.", s->id));
s->timer_event_source = sd_event_source_unref(s->timer_event_source);
Copyright 2012 Lennart Poettering
Copyright 2013 Zbigniew Jędrzejewski-Szmek
+ Copyright 2010-2017 Canonical
Copyright 2018 Dell Inc.
***/
//#include <errno.h>
//#include <getopt.h>
+//#include <linux/fiemap.h>
//#include <stdio.h>
#include "sd-messages.h"
static char* arg_verb = NULL;
+static int write_hibernate_location_info(void) {
+ _cleanup_free_ char *device = NULL, *type = NULL;
+ _cleanup_free_ struct fiemap *fiemap = NULL;
+ char offset_str[DECIMAL_STR_MAX(uint64_t)];
+ char device_str[DECIMAL_STR_MAX(uint64_t)];
+ _cleanup_close_ int fd = -1;
+ struct stat stb;
+ uint64_t offset;
+ int r;
+
+ r = find_hibernate_location(&device, &type, NULL, NULL);
+ if (r < 0)
+ return log_debug_errno(r, "Unable to find hibernation location: %m");
+
+ /* if it's a swap partition, we just write the disk to /sys/power/resume */
+ if (streq(type, "partition"))
+ return write_string_file("/sys/power/resume", device, 0);
+ else if (!streq(type, "file"))
+ return log_debug_errno(EINVAL, "Invalid hibernate type %s: %m",
+ type);
+
+ /* Only available in 4.17+ */
+ if (access("/sys/power/resume_offset", F_OK) < 0) {
+ if (errno == ENOENT)
+ return 0;
+ return log_debug_errno(errno, "/sys/power/resume_offset unavailable: %m");
+ }
+
+ r = access("/sys/power/resume_offset", W_OK);
+ if (r < 0)
+ return log_debug_errno(errno, "/sys/power/resume_offset not writeable: %m");
+
+ fd = open(device, O_RDONLY | O_CLOEXEC | O_NONBLOCK);
+ if (fd < 0)
+ return log_debug_errno(errno, "Unable to open '%s': %m", device);
+ r = fstat(fd, &stb);
+ if (r < 0)
+ return log_debug_errno(errno, "Unable to stat %s: %m", device);
+ r = read_fiemap(fd, &fiemap);
+ if (r < 0)
+ return log_debug_errno(r, "Unable to read extent map for '%s': %m",
+ device);
+ if (fiemap->fm_mapped_extents == 0) {
+ log_debug("No extents found in '%s'", device);
+ return -EINVAL;
+ }
+ offset = fiemap->fm_extents[0].fe_physical / page_size();
+ xsprintf(offset_str, "%" PRIu64, offset);
+ r = write_string_file("/sys/power/resume_offset", offset_str, 0);
+ if (r < 0)
+ return log_debug_errno(r, "Failed to write offset '%s': %m",
+ offset_str);
+
+ xsprintf(device_str, "%lx", (unsigned long)stb.st_dev);
+ r = write_string_file("/sys/power/resume", device_str, 0);
+ if (r < 0)
+ return log_debug_errno(r, "Failed to write device '%s': %m",
+ device_str);
+ return 0;
+}
+
static int write_mode(char **modes) {
int r = 0;
char **mode;
r = k;
}
- if (r < 0)
- log_error_errno(r, "Failed to write mode to /sys/power/disk: %m");
-
return r;
}
fclose(*f);
*f = fopen("/sys/power/state", "we");
if (!*f)
- return log_error_errno(errno, "Failed to open /sys/power/state: %m");
+ return -errno;
}
return r;
return log_error_errno(errno, "Failed to open /sys/power/state: %m");
/* Configure the hibernation mode */
- r = write_mode(modes);
- if (r < 0)
- return r;
+ if (!strv_isempty(modes)) {
+ r = write_hibernate_location_info();
+ if (r < 0)
+ return log_error_errno(r, "Failed to write hibernation disk offset: %m");
+ r = write_mode(modes);
+ if (r < 0)
+ return log_error_errno(r, "Failed to write mode to /sys/power/disk: %m");;
+ }
execute_directories(dirs, DEFAULT_TIMEOUT_USEC, NULL, NULL, arguments);
log_struct(LOG_INFO,
"MESSAGE_ID=" SD_MESSAGE_SLEEP_START_STR,
LOG_MESSAGE("Suspending system..."),
- "SLEEP=%s", arg_verb,
- NULL);
+ "SLEEP=%s", arg_verb);
r = write_state(&f, states);
if (r < 0)
- return r;
+ return log_error_errno(r, "Failed to write /sys/power/state: %m");
log_struct(LOG_INFO,
"MESSAGE_ID=" SD_MESSAGE_SLEEP_STOP_STR,
LOG_MESSAGE("System resumed."),
- "SLEEP=%s", arg_verb,
- NULL);
+ "SLEEP=%s", arg_verb);
arguments[1] = (char*) "post";
execute_directories(dirs, DEFAULT_TIMEOUT_USEC, NULL, NULL, arguments);
static void test_log_console(void) {
log_struct(LOG_INFO,
"MESSAGE=Waldo PID="PID_FMT, getpid_cached(),
- "SERVICE=piepapo",
- NULL);
+ "SERVICE=piepapo");
}
static void test_log_journal(void) {
log_struct(LOG_INFO,
"MESSAGE=Foobar PID="PID_FMT, getpid_cached(),
- "SERVICE=foobar",
- NULL);
+ "SERVICE=foobar");
log_struct(LOG_INFO,
"MESSAGE=Foobar PID="PID_FMT, getpid_cached(),
"FORMAT_STR_TEST=1=%i A=%c 2=%hi 3=%li 4=%lli 1=%p foo=%s 2.5=%g 3.5=%g 4.5=%Lg",
(int) 1, 'A', (short) 2, (long int) 3, (long long int) 4, (void*) 1, "foo", (float) 2.5f, (double) 3.5, (long double) 4.5,
- "SUFFIX=GOT IT",
- NULL);
+ "SUFFIX=GOT IT");
}
static void test_long_lines(void) {