Adding upstream version 2.38.1.upstream/2.38.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 688 insertions, 0 deletions

diff --git a/sys-utils/rtcwake.c b/sys-utils/rtcwake.c
new file mode 100644
index 0000000..65f916b
--- /dev/null
+++ b/sys-utils/rtcwake.c
@@ -0,0 +1,688 @@
+/*
+ * rtcwake -- enter a system sleep state until specified wakeup time.
+ *
+ * This uses cross-platform Linux interfaces to enter a system sleep state,
+ * and leave it no later than a specified time.  It uses any RTC framework
+ * driver that supports standard driver model wakeup flags.
+ *
+ * This is normally used like the old "apmsleep" utility, to wake from a
+ * suspend state like ACPI S1 (standby) or S3 (suspend-to-RAM).  Most
+ * platforms can implement those without analogues of BIOS, APM, or ACPI.
+ *
+ * On some systems, this can also be used like "nvram-wakeup", waking
+ * from states like ACPI S4 (suspend to disk).  Not all systems have
+ * persistent media that are appropriate for such suspend modes.
+ *
+ * The best way to set the system's RTC is so that it holds the current
+ * time in UTC.  Use the "-l" flag to tell this program that the system
+ * RTC uses a local timezone instead (maybe you dual-boot MS-Windows).
+ * That flag should not be needed on systems with adjtime support.
+ */
+
+#include <errno.h>
+#include <fcntl.h>
+#include <getopt.h>
+#include <linux/rtc.h>
+#include <poll.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <termios.h>
+#include <time.h>
+#include <unistd.h>
+
+#include "c.h"
+#include "closestream.h"
+#include "env.h"
+#include "nls.h"
+#include "optutils.h"
+#include "pathnames.h"
+#include "strutils.h"
+#include "strv.h"
+#include "timeutils.h"
+#include "xalloc.h"
+
+#ifndef RTC_AF
+# define RTC_AF		0x20	/* Alarm interrupt */
+#endif
+
+#define ADJTIME_ZONE_BUFSIZ		8
+#define SYS_WAKEUP_PATH_TEMPLATE	"/sys/class/rtc/%s/device/power/wakeup"
+#define SYS_POWER_STATE_PATH		"/sys/power/state"
+#define DEFAULT_RTC_DEVICE		"/dev/rtc0"
+
+enum rtc_modes {	/* manual page --mode option explains these. */
+	OFF_MODE = 0,
+	NO_MODE,
+	ON_MODE,
+	DISABLE_MODE,
+	SHOW_MODE,
+
+	SYSFS_MODE	/* keep it last */
+
+};
+
+static const char *rtcwake_mode_string[] = {
+	[OFF_MODE] = "off",
+	[NO_MODE] = "no",
+	[ON_MODE] = "on",
+	[DISABLE_MODE] = "disable",
+	[SHOW_MODE] = "show"
+};
+
+enum clock_modes {
+	CM_AUTO,
+	CM_UTC,
+	CM_LOCAL
+};
+
+struct rtcwake_control {
+	char *mode_str;			/* name of the requested mode */
+	char **possible_modes;		/* modes listed in /sys/power/state */
+	char *adjfile;			/* adjtime file path */
+	enum clock_modes clock_mode;	/* hwclock timezone */
+	time_t sys_time;		/* system time */
+	time_t rtc_time;		/* hardware time */
+	unsigned int verbose:1,		/* verbose messaging */
+		     dryrun:1;		/* do not set alarm, suspend system, etc */
+};
+
+static void __attribute__((__noreturn__)) usage(void)
+{
+	FILE *out = stdout;
+	fputs(USAGE_HEADER, out);
+	fprintf(out,
+	      _(" %s [options]\n"), program_invocation_short_name);
+
+	fputs(USAGE_SEPARATOR, out);
+	fputs(_("Enter a system sleep state until a specified wakeup time.\n"), out);
+
+	fputs(USAGE_OPTIONS, out);
+	fputs(_(" -a, --auto               reads the clock mode from adjust file (default)\n"), out);
+	fprintf(out,
+	      _(" -A, --adjfile <file>     specifies the path to the adjust file\n"
+		"                            the default is %s\n"), _PATH_ADJTIME);
+	fputs(_("     --date <timestamp>   date time of timestamp to wake\n"), out);
+	fputs(_(" -d, --device <device>    select rtc device (rtc0|rtc1|...)\n"), out);
+	fputs(_(" -n, --dry-run            does everything, but suspend\n"), out);
+	fputs(_(" -l, --local              RTC uses local timezone\n"), out);
+	fputs(_("     --list-modes         list available modes\n"), out);
+	fputs(_(" -m, --mode <mode>        standby|mem|... sleep mode\n"), out);
+	fputs(_(" -s, --seconds <seconds>  seconds to sleep\n"), out);
+	fputs(_(" -t, --time <time_t>      time to wake\n"), out);
+	fputs(_(" -u, --utc                RTC uses UTC\n"), out);
+	fputs(_(" -v, --verbose            verbose messages\n"), out);
+
+	fputs(USAGE_SEPARATOR, out);
+	printf(USAGE_HELP_OPTIONS(26));
+	printf(USAGE_MAN_TAIL("rtcwake(8)"));
+	exit(EXIT_SUCCESS);
+}
+
+static int is_wakeup_enabled(const char *devname)
+{
+	char	buf[128], *s;
+	FILE	*f;
+	size_t	skip = 0;
+
+	if (startswith(devname, "/dev/"))
+		skip = 5;
+	snprintf(buf, sizeof buf, SYS_WAKEUP_PATH_TEMPLATE, devname + skip);
+	f = fopen(buf, "r");
+	if (!f) {
+		warn(_("cannot open %s"), buf);
+		return 0;
+	}
+
+	s = fgets(buf, sizeof buf, f);
+	fclose(f);
+	if (!s)
+		return 0;
+	s = strchr(buf, '\n');
+	if (!s)
+		return 0;
+	*s = 0;
+	/* wakeup events could be disabled or not supported */
+	return strcmp(buf, "enabled") == 0;
+}
+
+static int get_basetimes(struct rtcwake_control *ctl, int fd)
+{
+	struct tm tm = { 0 };
+	struct rtc_time	rtc;
+
+	/* This process works in RTC time, except when working
+	 * with the system clock (which always uses UTC).
+	 */
+	if (ctl->clock_mode == CM_UTC)
+		xsetenv("TZ", "UTC", 1);
+	tzset();
+	/* Read rtc and system clocks "at the same time", or as
+	 * precisely (+/- a second) as we can read them.
+	 */
+	if (ioctl(fd, RTC_RD_TIME, &rtc) < 0) {
+		warn(_("read rtc time failed"));
+		return -1;
+	}
+
+	ctl->sys_time = time(NULL);
+	if (ctl->sys_time == (time_t)-1) {
+		warn(_("read system time failed"));
+		return -1;
+	}
+	/* Convert rtc_time to normal arithmetic-friendly form,
+	 * updating tm.tm_wday as used by asctime().
+	 */
+	tm.tm_sec = rtc.tm_sec;
+	tm.tm_min = rtc.tm_min;
+	tm.tm_hour = rtc.tm_hour;
+	tm.tm_mday = rtc.tm_mday;
+	tm.tm_mon = rtc.tm_mon;
+	tm.tm_year = rtc.tm_year;
+	tm.tm_isdst = -1;  /* assume the system knows better than the RTC */
+
+	ctl->rtc_time = mktime(&tm);
+	if (ctl->rtc_time == (time_t)-1) {
+		warn(_("convert rtc time failed"));
+		return -1;
+	}
+
+	if (ctl->verbose) {
+		/* Unless the system uses UTC, either delta or tzone
+		 * reflects a seconds offset from UTC.  The value can
+		 * help sort out problems like bugs in your C library. */
+		char s[64];
+		printf("\tdelta   = %"PRId64"\n", (int64_t) ctl->sys_time - ctl->rtc_time);
+		printf("\ttzone   = %ld\n", timezone);
+		printf("\ttzname  = %s\n", tzname[daylight]);
+		gmtime_r(&ctl->sys_time, &tm);
+		printf("\tsystime = %"PRId64", (UTC) %s",
+				(int64_t) ctl->sys_time, asctime_r(&tm, s));
+		gmtime_r(&ctl->rtc_time, &tm);
+		printf("\trtctime = %"PRId64", (UTC) %s",
+				(int64_t) ctl->rtc_time, asctime_r(&tm, s));
+	}
+	return 0;
+}
+
+static int setup_alarm(struct rtcwake_control *ctl, int fd, time_t *wakeup)
+{
+	struct tm		tm;
+	struct rtc_wkalrm	wake = { 0 };
+
+	/* The wakeup time is in POSIX time (more or less UTC).  Ideally
+	 * RTCs use that same time; but PCs can't do that if they need to
+	 * boot MS-Windows.  Messy...
+	 *
+	 * When clock_mode == CM_UTC this process's timezone is UTC, so
+	 * we'll pass a UTC date to the RTC.
+	 *
+	 * Else clock_mode == CM_LOCAL so the time given to the RTC will
+	 * instead use the local time zone. */
+	localtime_r(wakeup, &tm);
+	wake.time.tm_sec = tm.tm_sec;
+	wake.time.tm_min = tm.tm_min;
+	wake.time.tm_hour = tm.tm_hour;
+	wake.time.tm_mday = tm.tm_mday;
+	wake.time.tm_mon = tm.tm_mon;
+	wake.time.tm_year = tm.tm_year;
+	/* wday, yday, and isdst fields are unused */
+	wake.time.tm_wday = -1;
+	wake.time.tm_yday = -1;
+	wake.time.tm_isdst = -1;
+	wake.enabled = 1;
+
+	if (!ctl->dryrun && ioctl(fd, RTC_WKALM_SET, &wake) < 0) {
+		warn(_("set rtc wake alarm failed"));
+		return -1;
+	}
+	return 0;
+}
+
+static char **get_sys_power_states(struct rtcwake_control *ctl)
+{
+	int fd = -1;
+
+	if (!ctl->possible_modes) {
+		char buf[256] = { 0 };
+		ssize_t ss;
+
+		fd = open(SYS_POWER_STATE_PATH, O_RDONLY);
+		if (fd < 0)
+			goto nothing;
+		ss = read(fd, &buf, sizeof(buf) - 1);
+		if (ss <= 0)
+			goto nothing;
+		buf[ss] = '\0';
+		ctl->possible_modes = strv_split(buf, " \n");
+		close(fd);
+	}
+	return ctl->possible_modes;
+nothing:
+	if (fd >= 0)
+		close(fd);
+	return NULL;
+}
+
+static void wait_stdin(struct rtcwake_control *ctl)
+{
+	struct pollfd fd[] = {
+		{.fd = STDIN_FILENO, .events = POLLIN}
+	};
+	int tries = 0;
+
+	while (tries < 8 && poll(fd, 1, 10) == 1) {
+		if (ctl->verbose)
+			warnx(_("discarding stdin"));
+		xusleep(250000);
+		tcflush(STDIN_FILENO, TCIFLUSH);
+		tries++;
+	}
+}
+
+static void suspend_system(struct rtcwake_control *ctl)
+{
+	FILE	*f = fopen(SYS_POWER_STATE_PATH, "w");
+
+	if (!f) {
+		warn(_("cannot open %s"), SYS_POWER_STATE_PATH);
+		return;
+	}
+
+	if (!ctl->dryrun) {
+		if (isatty(STDIN_FILENO))
+			wait_stdin(ctl);
+		fprintf(f, "%s\n", ctl->mode_str);
+		fflush(f);
+	}
+	/* this executes after wake from suspend */
+	if (close_stream(f))
+		errx(EXIT_FAILURE, _("write error"));
+}
+
+static int read_clock_mode(struct rtcwake_control *ctl)
+{
+	FILE *fp;
+	char linebuf[ADJTIME_ZONE_BUFSIZ];
+
+	fp = fopen(ctl->adjfile, "r");
+	if (!fp)
+		return -1;
+	/* skip two lines */
+	if (skip_fline(fp) || skip_fline(fp)) {
+		fclose(fp);
+		return -1;
+	}
+	/* read third line */
+	if (!fgets(linebuf, sizeof linebuf, fp)) {
+		fclose(fp);
+		return -1;
+	}
+
+	if (strncmp(linebuf, "UTC", 3) == 0)
+		ctl->clock_mode = CM_UTC;
+	else if (strncmp(linebuf, "LOCAL", 5) == 0)
+		ctl->clock_mode = CM_LOCAL;
+	else if (ctl->verbose)
+		warnx(_("unexpected third line in: %s: %s"), ctl->adjfile, linebuf);
+
+	fclose(fp);
+	return 0;
+}
+
+static int print_alarm(struct rtcwake_control *ctl, int fd)
+{
+	struct rtc_wkalrm wake;
+	struct tm tm = { 0 };
+	time_t alarm;
+	char s[CTIME_BUFSIZ];
+
+	if (ioctl(fd, RTC_WKALM_RD, &wake) < 0) {
+		warn(_("read rtc alarm failed"));
+		return -1;
+	}
+
+	if (wake.enabled != 1 || wake.time.tm_year == -1) {
+		printf(_("alarm: off\n"));
+		return 0;
+	}
+	tm.tm_sec = wake.time.tm_sec;
+	tm.tm_min = wake.time.tm_min;
+	tm.tm_hour = wake.time.tm_hour;
+	tm.tm_mday = wake.time.tm_mday;
+	tm.tm_mon = wake.time.tm_mon;
+	tm.tm_year = wake.time.tm_year;
+	tm.tm_isdst = -1;  /* assume the system knows better than the RTC */
+
+	alarm = mktime(&tm);
+	if (alarm == (time_t)-1) {
+		warn(_("convert time failed"));
+		return -1;
+	}
+	/* 0 if both UTC, or expresses diff if RTC in local time */
+	alarm += ctl->sys_time - ctl->rtc_time;
+	ctime_r(&alarm, s);
+	printf(_("alarm: on  %s"), s);
+
+	return 0;
+}
+
+static int get_rtc_mode(struct rtcwake_control *ctl, const char *s)
+{
+	size_t i;
+	char **modes = get_sys_power_states(ctl), **m;
+
+	STRV_FOREACH(m, modes) {
+		if (strcmp(s, *m) == 0)
+			return SYSFS_MODE;
+	}
+
+	for (i = 0; i < ARRAY_SIZE(rtcwake_mode_string); i++)
+		if (!strcmp(s, rtcwake_mode_string[i]))
+			return i;
+
+	return -EINVAL;
+}
+
+static int open_dev_rtc(const char *devname)
+{
+	int fd;
+	char *devpath = NULL;
+
+	if (startswith(devname, "/dev"))
+		devpath = xstrdup(devname);
+	else
+		xasprintf(&devpath, "/dev/%s", devname);
+	fd = open(devpath, O_RDONLY | O_CLOEXEC);
+	if (fd < 0)
+		err(EXIT_FAILURE, _("%s: unable to find device"), devpath);
+	free(devpath);
+	return fd;
+}
+
+static void list_modes(struct rtcwake_control *ctl)
+{
+	size_t i;
+	char **modes = get_sys_power_states(ctl), **m;
+
+	if (!modes)
+		errx(EXIT_FAILURE, _("could not read: %s"), SYS_POWER_STATE_PATH);
+
+	STRV_FOREACH(m, modes)
+		printf("%s ", *m);
+
+	for (i = 0; i < ARRAY_SIZE(rtcwake_mode_string); i++)
+		printf("%s ", rtcwake_mode_string[i]);
+	putchar('\n');
+}
+
+int main(int argc, char **argv)
+{
+	struct rtcwake_control ctl = {
+		.mode_str = "suspend",		/* default mode */
+		.adjfile = _PATH_ADJTIME,
+		.clock_mode = CM_AUTO
+	};
+	char *devname = DEFAULT_RTC_DEVICE;
+	int suspend = SYSFS_MODE;
+	int rc = EXIT_SUCCESS;
+	int t;
+	int fd;
+	time_t alarm = 0, seconds = 0;
+	enum {
+		OPT_DATE = CHAR_MAX + 1,
+		OPT_LIST
+	};
+	static const struct option long_options[] = {
+		{ "adjfile",	required_argument,	NULL, 'A'      },
+		{ "auto",	no_argument,		NULL, 'a'      },
+		{ "dry-run",	no_argument,		NULL, 'n'      },
+		{ "local",	no_argument,		NULL, 'l'      },
+		{ "utc",	no_argument,		NULL, 'u'      },
+		{ "verbose",	no_argument,		NULL, 'v'      },
+		{ "version",	no_argument,		NULL, 'V'      },
+		{ "help",	no_argument,		NULL, 'h'      },
+		{ "mode",	required_argument,	NULL, 'm'      },
+		{ "device",	required_argument,	NULL, 'd'      },
+		{ "seconds",	required_argument,	NULL, 's'      },
+		{ "time",	required_argument,	NULL, 't'      },
+		{ "date",	required_argument,	NULL, OPT_DATE },
+		{ "list-modes",	no_argument,		NULL, OPT_LIST },
+		{ NULL, 0, NULL, 0 }
+	};
+	static const ul_excl_t excl[] = {
+		{ 'a', 'l', 'u' },
+		{ 's', 't', OPT_DATE },
+		{ 0 },
+	};
+	int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
+
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+	close_stdout_atexit();
+
+	while ((t = getopt_long(argc, argv, "A:ahd:lm:ns:t:uVv",
+					long_options, NULL)) != EOF) {
+		err_exclusive_options(t, long_options, excl, excl_st);
+		switch (t) {
+		case 'A':
+			/* for better compatibility with hwclock */
+			ctl.adjfile = optarg;
+			break;
+		case 'a':
+			ctl.clock_mode = CM_AUTO;
+			break;
+		case 'd':
+			devname = optarg;
+			break;
+		case 'l':
+			ctl.clock_mode = CM_LOCAL;
+			break;
+
+		case OPT_LIST:
+			list_modes(&ctl);
+			return EXIT_SUCCESS;
+
+		case 'm':
+			if ((suspend = get_rtc_mode(&ctl, optarg)) < 0)
+				errx(EXIT_FAILURE, _("unrecognized suspend state '%s'"), optarg);
+			ctl.mode_str = optarg;
+			break;
+		case 'n':
+			ctl.dryrun = 1;
+			break;
+		case 's':
+			/* alarm time, seconds-to-sleep (relative) */
+			seconds = strtotime_or_err(optarg, _("invalid seconds argument"));
+			break;
+		case 't':
+			/* alarm time, time_t (absolute, seconds since epoch) */
+			alarm = strtotime_or_err(optarg, _("invalid time argument"));
+			break;
+		case OPT_DATE:
+		{	/* alarm time, see timestamp format from manual */
+			usec_t p;
+			if (parse_timestamp(optarg, &p) < 0)
+				errx(EXIT_FAILURE, _("invalid time value \"%s\""), optarg);
+			alarm = (time_t) (p / 1000000);
+			break;
+		}
+		case 'u':
+			ctl.clock_mode = CM_UTC;
+			break;
+		case 'v':
+			ctl.verbose = 1;
+			break;
+
+		case 'V':
+			print_version(EXIT_SUCCESS);
+		case 'h':
+			usage();
+		default:
+			errtryhelp(EXIT_FAILURE);
+		}
+	}
+
+	if (ctl.clock_mode == CM_AUTO && read_clock_mode(&ctl) < 0) {
+		printf(_("%s: assuming RTC uses UTC ...\n"),  program_invocation_short_name);
+		ctl.clock_mode = CM_UTC;
+	}
+
+	if (ctl.verbose)
+		printf("%s",  ctl.clock_mode == CM_UTC ? _("Using UTC time.\n") :
+				_("Using local time.\n"));
+
+	if (!alarm && !seconds && suspend != DISABLE_MODE && suspend != SHOW_MODE)
+		errx(EXIT_FAILURE, _("must provide wake time (see --seconds, --time and --date options)"));
+
+	/* device must exist and (if we'll sleep) be wakeup-enabled */
+	fd = open_dev_rtc(devname);
+
+	if (suspend != ON_MODE && suspend != NO_MODE && !is_wakeup_enabled(devname))
+		errx(EXIT_FAILURE, _("%s not enabled for wakeup events"), devname);
+
+	/* relative or absolute alarm time, normalized to time_t */
+	if (get_basetimes(&ctl, fd) < 0)
+		exit(EXIT_FAILURE);
+
+	if (ctl.verbose)
+		printf(_("alarm %"PRId64", sys_time %"PRId64", "
+			 "rtc_time %"PRId64", seconds %"PRIu64"\n"),
+				(int64_t) alarm, (int64_t) ctl.sys_time,
+				(int64_t) ctl.rtc_time,
+				(int64_t) seconds);
+
+	if (suspend != DISABLE_MODE && suspend != SHOW_MODE) {
+		/* perform alarm setup when the show or disable modes are not set */
+		if (alarm) {
+			if (alarm < ctl.sys_time) {
+				char s[CTIME_BUFSIZ];
+
+				ctime_r(&alarm, s);
+				errx(EXIT_FAILURE, _("time doesn't go backward to %s"), s);
+			}
+			alarm -= ctl.sys_time - ctl.rtc_time;
+		} else
+			alarm = ctl.rtc_time + seconds + 1;
+
+		if (setup_alarm(&ctl, fd, &alarm) < 0)
+			exit(EXIT_FAILURE);
+
+		if (suspend == NO_MODE || suspend == ON_MODE) {
+			char s[CTIME_BUFSIZ];
+
+			ctime_r(&alarm, s);
+			printf(_("%s: wakeup using %s at %s"),
+				program_invocation_short_name, devname, s);
+		} else {
+			char s[CTIME_BUFSIZ];
+
+			ctime_r(&alarm, s);
+			printf(_("%s: wakeup from \"%s\" using %s at %s"),
+				program_invocation_short_name, ctl.mode_str, devname, s);
+		}
+		fflush(stdout);
+		xusleep(10 * 1000);
+	}
+
+	switch (suspend) {
+	case NO_MODE:
+		if (ctl.verbose)
+			printf(_("suspend mode: no; leaving\n"));
+		ctl.dryrun = 1;	/* to skip disabling alarm at the end */
+		break;
+	case OFF_MODE:
+	{
+		char *arg[5];
+		int i = 0;
+
+		if (!access(_PATH_SHUTDOWN, X_OK)) {
+			arg[i++] = _PATH_SHUTDOWN;
+			arg[i++] = "-h";
+			arg[i++] = "-P";
+			arg[i++] = "now";
+			arg[i]   = NULL;
+		} else if (!access(_PATH_POWEROFF, X_OK)) {
+			arg[i++] = _PATH_POWEROFF;
+			arg[i]   = NULL;
+		} else {
+			arg[i] 	 = NULL;
+		}
+
+		if (arg[0]) {
+			if (ctl.verbose)
+				printf(_("suspend mode: off; executing %s\n"),
+						arg[0]);
+			if (!ctl.dryrun) {
+				execv(arg[0], arg);
+				warn(_("failed to execute %s"), arg[0]);
+				rc = EX_EXEC_ENOENT;
+			}
+		} else {
+			/* Failed to find shutdown command */
+			warn(_("failed to find shutdown command"));
+			rc = EX_EXEC_ENOENT;
+		}
+		break;
+	}
+	case ON_MODE:
+	{
+		unsigned long data;
+
+		if (ctl.verbose)
+			printf(_("suspend mode: on; reading rtc\n"));
+		if (!ctl.dryrun) {
+			do {
+				t = read(fd, &data, sizeof data);
+				if (t < 0) {
+					warn(_("rtc read failed"));
+					break;
+				}
+				if (ctl.verbose)
+					printf("... %s: %03lx\n", devname, data);
+			} while (!(data & RTC_AF));
+		}
+		break;
+	}
+	case DISABLE_MODE:
+		/* just break, alarm gets disabled in the end */
+		if (ctl.verbose)
+			printf(_("suspend mode: disable; disabling alarm\n"));
+		break;
+	case SHOW_MODE:
+		if (ctl.verbose)
+			printf(_("suspend mode: show; printing alarm info\n"));
+		if (print_alarm(&ctl, fd))
+			rc = EXIT_FAILURE;
+		ctl.dryrun = 1;	/* don't really disable alarm in the end, just show */
+		break;
+	default:
+		if (ctl.verbose)
+			printf(_("suspend mode: %s; suspending system\n"), ctl.mode_str);
+		sync();
+		suspend_system(&ctl);
+	}
+
+	if (!ctl.dryrun) {
+		struct rtc_wkalrm wake;
+
+		if (ioctl(fd, RTC_WKALM_RD, &wake) < 0) {
+			warn(_("read rtc alarm failed"));
+			rc = EXIT_FAILURE;
+		} else {
+			wake.enabled = 0;
+			if (ioctl(fd, RTC_WKALM_SET, &wake) < 0) {
+				warn(_("disable rtc alarm interrupt failed"));
+				rc = EXIT_FAILURE;
+			}
+		}
+	}
+
+	close(fd);
+	return rc;
+}