diff options
| -rw-r--r-- | include/applets.h | 1 | ||||
| -rw-r--r-- | include/rtc_.h | 73 | ||||
| -rw-r--r-- | include/usage.h | 23 | ||||
| -rw-r--r-- | libbb/Kbuild | 2 | ||||
| -rw-r--r-- | libbb/rtc.c | 86 | ||||
| -rw-r--r-- | util-linux/Config.in | 6 | ||||
| -rw-r--r-- | util-linux/Kbuild | 1 | ||||
| -rw-r--r-- | util-linux/hwclock.c | 115 | ||||
| -rw-r--r-- | util-linux/rtcwake.c | 209 |
9 files changed, 417 insertions, 99 deletions
diff --git a/include/applets.h b/include/applets.h index b14c20528..90b6e703d 100644 --- a/include/applets.h +++ b/include/applets.h @@ -293,6 +293,7 @@ USE_RMMOD(APPLET(rmmod, _BB_DIR_SBIN, _BB_SUID_NEVER)) USE_ROUTE(APPLET(route, _BB_DIR_SBIN, _BB_SUID_NEVER)) USE_RPM(APPLET(rpm, _BB_DIR_BIN, _BB_SUID_NEVER)) USE_RPM2CPIO(APPLET(rpm2cpio, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_RTCWAKE(APPLET(rtcwake, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) USE_RUN_PARTS(APPLET_ODDNAME(run-parts, run_parts, _BB_DIR_BIN, _BB_SUID_NEVER, run_parts)) USE_RUNCON(APPLET(runcon, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) USE_RUNLEVEL(APPLET(runlevel, _BB_DIR_SBIN, _BB_SUID_NEVER)) diff --git a/include/rtc_.h b/include/rtc_.h new file mode 100644 index 000000000..50b60dd29 --- /dev/null +++ b/include/rtc_.h @@ -0,0 +1,73 @@ +/* + * Common defines/structures/etc... for applets that need to work with the RTC. + * + * Licensed under the GPL-2 or later. + */ + +#ifndef _BB_RTC_H_ +#define _BB_RTC_H_ + +#include "libbb.h" + +extern int rtc_adjtime_is_utc(void); +extern int rtc_xopen(const char *default_rtc, int flags); +extern time_t rtc_read_time(int fd, int utc); + + + +/* + * Everything below this point has been copied from linux/rtc.h + * to eliminate the kernel header dependency + */ + +struct linux_rtc_time { + int tm_sec; + int tm_min; + int tm_hour; + int tm_mday; + int tm_mon; + int tm_year; + int tm_wday; + int tm_yday; + int tm_isdst; +}; + +struct linux_rtc_wkalrm { + unsigned char enabled; /* 0 = alarm disabled, 1 = alarm enabled */ + unsigned char pending; /* 0 = alarm not pending, 1 = alarm pending */ + struct linux_rtc_time time; /* time the alarm is set to */ +}; + +/* + * ioctl calls that are permitted to the /dev/rtc interface, if + * any of the RTC drivers are enabled. + */ + +#define RTC_AIE_ON _IO('p', 0x01) /* Alarm int. enable on */ +#define RTC_AIE_OFF _IO('p', 0x02) /* ... off */ +#define RTC_UIE_ON _IO('p', 0x03) /* Update int. enable on */ +#define RTC_UIE_OFF _IO('p', 0x04) /* ... off */ +#define RTC_PIE_ON _IO('p', 0x05) /* Periodic int. enable on */ +#define RTC_PIE_OFF _IO('p', 0x06) /* ... off */ +#define RTC_WIE_ON _IO('p', 0x0f) /* Watchdog int. enable on */ +#define RTC_WIE_OFF _IO('p', 0x10) /* ... off */ + +#define RTC_ALM_SET _IOW('p', 0x07, struct linux_rtc_time) /* Set alarm time */ +#define RTC_ALM_READ _IOR('p', 0x08, struct linux_rtc_time) /* Read alarm time */ +#define RTC_RD_TIME _IOR('p', 0x09, struct linux_rtc_time) /* Read RTC time */ +#define RTC_SET_TIME _IOW('p', 0x0a, struct linux_rtc_time) /* Set RTC time */ +#define RTC_IRQP_READ _IOR('p', 0x0b, unsigned long) /* Read IRQ rate */ +#define RTC_IRQP_SET _IOW('p', 0x0c, unsigned long) /* Set IRQ rate */ +#define RTC_EPOCH_READ _IOR('p', 0x0d, unsigned long) /* Read epoch */ +#define RTC_EPOCH_SET _IOW('p', 0x0e, unsigned long) /* Set epoch */ + +#define RTC_WKALM_SET _IOW('p', 0x0f, struct linux_rtc_wkalrm)/* Set wakeup alarm*/ +#define RTC_WKALM_RD _IOR('p', 0x10, struct linux_rtc_wkalrm)/* Get wakeup alarm*/ + +/* interrupt flags */ +#define RTC_IRQF 0x80 /* any of the following is active */ +#define RTC_PF 0x40 +#define RTC_AF 0x20 +#define RTC_UF 0x10 + +#endif diff --git a/include/usage.h b/include/usage.h index 51a92126c..71e1d125f 100644 --- a/include/usage.h +++ b/include/usage.h @@ -3070,6 +3070,29 @@ USE_FEATURE_BRCTL_FANCY("\n" \ #define rpm2cpio_full_usage \ "Output a cpio archive of the rpm file" +#define rtcwake_trivial_usage \ + "[-a | -l | -u] [-d DEV] [-m MODE] [-s SECS | -t TIME]" +#define rtcwake_full_usage \ + "enter a system sleep state until specified wakeup time\n\n" \ + USE_GETOPT_LONG( \ + " -a,--auto Read clock mode from adjtime\n" \ + " -l,--local Clock is set to local time\n" \ + " -u,--utc Clock is set to UTC time\n" \ + " -d,--device=DEV Specify the RTC device\n" \ + " -m,--mode=MODE Set the sleep state (default: standby)\n" \ + " -s,--seconds=SEC Set the timeout in SEC seconds from now\n" \ + " -t,--time=TIME Set the timeout to TIME seconds from epoch" \ + ) \ + SKIP_GETOPT_LONG( \ + " -a Read clock mode from adjtime\n" \ + " -l Clock is set to local time\n" \ + " -u Clock is set to UTC time\n" \ + " -d DEV Specify the RTC device\n" \ + " -m MODE Set the sleep state (default: standby)\n" \ + " -s SEC Set the timeout in SEC seconds from now\n" \ + " -t TIME Set the timeout to TIME seconds from epoch" \ + ) + #define runcon_trivial_usage \ "[-c] [-u USER] [-r ROLE] [-t TYPE] [-l RANGE] COMMAND [args]\n" \ " runcon CONTEXT COMMAND [args]" diff --git a/libbb/Kbuild b/libbb/Kbuild index c4aac95bb..2fb1b2420 100644 --- a/libbb/Kbuild +++ b/libbb/Kbuild @@ -115,6 +115,8 @@ lib-$(CONFIG_LOGIN) += correct_password.o lib-$(CONFIG_DF) += find_mount_point.o lib-$(CONFIG_MKFS_MINIX) += find_mount_point.o lib-$(CONFIG_SELINUX) += selinux_common.o +lib-$(CONFIG_HWCLOCK) += rtc.o +lib-$(CONFIG_RTCWAKE) += rtc.o # We shouldn't build xregcomp.c if we don't need it - this ensures we don't # require regex.h to be in the include dir even if we don't need it thereby diff --git a/libbb/rtc.c b/libbb/rtc.c new file mode 100644 index 000000000..4cbf32206 --- /dev/null +++ b/libbb/rtc.c @@ -0,0 +1,86 @@ +/* + * Common RTC functions + */ + +#include "libbb.h" +#include "rtc_.h" + +#if ENABLE_FEATURE_HWCLOCK_ADJTIME_FHS +# define ADJTIME_PATH "/var/lib/hwclock/adjtime" +#else +# define ADJTIME_PATH "/etc/adjtime" +#endif + +int rtc_adjtime_is_utc(void) +{ + int utc = 0; + FILE *f = fopen(ADJTIME_PATH, "r"); + + if (f) { + RESERVE_CONFIG_BUFFER(buffer, 128); + + while (fgets(buffer, sizeof(buffer), f)) { + int len = strlen(buffer); + + while (len && isspace(buffer[len - 1])) + len--; + + buffer[len] = 0; + + if (strncmp(buffer, "UTC", 3) == 0) { + utc = 1; + break; + } + } + fclose(f); + + RELEASE_CONFIG_BUFFER(buffer); + } + + return utc; +} + +int rtc_xopen(const char *default_rtc, int flags) +{ + int rtc; + + if (!default_rtc) { + rtc = open("/dev/rtc", flags); + if (rtc >= 0) + return rtc; + rtc = open("/dev/rtc0", flags); + if (rtc >= 0) + return rtc; + default_rtc = "/dev/misc/rtc"; + } + + return xopen(default_rtc, flags); +} + +time_t rtc_read_time(int fd, int utc) +{ + struct tm tm; + char *oldtz = 0; + time_t t = 0; + + memset(&tm, 0, sizeof(struct tm)); + xioctl(fd, RTC_RD_TIME, &tm); + tm.tm_isdst = -1; /* not known */ + + if (utc) { + oldtz = getenv("TZ"); + putenv((char*)"TZ=UTC0"); + tzset(); + } + + t = mktime(&tm); + + if (utc) { + unsetenv("TZ"); + if (oldtz) + putenv(oldtz - 3); + tzset(); + } + + return t; +} diff --git a/util-linux/Config.in b/util-linux/Config.in index e97f84062..d1688e8c9 100644 --- a/util-linux/Config.in +++ b/util-linux/Config.in @@ -458,6 +458,12 @@ config READPROFILE help This allows you to parse /proc/profile for basic profiling. +config RTCWAKE + bool "rtcwake" + default n + help + Enter a system sleep state until specified wakeup time. + config SETARCH bool "setarch" default n diff --git a/util-linux/Kbuild b/util-linux/Kbuild index cc1d0e05d..4a18ff21f 100644 --- a/util-linux/Kbuild +++ b/util-linux/Kbuild @@ -26,6 +26,7 @@ lib-$(CONFIG_MOUNT) +=mount.o lib-$(CONFIG_PIVOT_ROOT) +=pivot_root.o lib-$(CONFIG_RDATE) +=rdate.o lib-$(CONFIG_READPROFILE) +=readprofile.o +lib-$(CONFIG_RTCWAKE) +=rtcwake.o lib-$(CONFIG_SETARCH) +=setarch.o lib-$(CONFIG_SWAPONOFF) +=swaponoff.o lib-$(CONFIG_SWITCH_ROOT) +=switch_root.o diff --git a/util-linux/hwclock.c b/util-linux/hwclock.c index f91379bed..b581d2604 100644 --- a/util-linux/hwclock.c +++ b/util-linux/hwclock.c @@ -10,22 +10,7 @@ #include <sys/utsname.h> #include <getopt.h> #include "libbb.h" - -/* Copied from linux/rtc.h to eliminate the kernel dependency */ -struct linux_rtc_time { - int tm_sec; - int tm_min; - int tm_hour; - int tm_mday; - int tm_mon; - int tm_year; - int tm_wday; - int tm_yday; - int tm_isdst; -}; - -#define RTC_SET_TIME _IOW('p', 0x0a, struct linux_rtc_time) /* Set RTC time */ -#define RTC_RD_TIME _IOR('p', 0x09, struct linux_rtc_time) /* Read RTC time */ +#include "rtc_.h" #if ENABLE_FEATURE_HWCLOCK_LONG_OPTIONS # ifndef _GNU_SOURCE @@ -35,56 +20,22 @@ struct linux_rtc_time { static const char *rtcname; -static int xopen_rtc(int flags) -{ - int rtc; - - if (!rtcname) { - rtc = open("/dev/rtc", flags); - if (rtc >= 0) - return rtc; - rtc = open("/dev/rtc0", flags); - if (rtc >= 0) - return rtc; - rtcname = "/dev/misc/rtc"; - } - return xopen(rtcname, flags); -} - static time_t read_rtc(int utc) { - struct tm tm; - char *oldtz = 0; - time_t t = 0; - int rtc = xopen_rtc(O_RDONLY); + time_t ret; + int fd; - memset(&tm, 0, sizeof(struct tm)); - xioctl(rtc, RTC_RD_TIME, &tm); - tm.tm_isdst = -1; /* not known */ + fd = rtc_xopen(rtcname, O_RDONLY); + ret = rtc_read_time(fd, utc); + close(fd); - close(rtc); - - if (utc) { - oldtz = getenv("TZ"); - putenv((char*)"TZ=UTC0"); - tzset(); - } - - t = mktime(&tm); - - if (utc) { - unsetenv("TZ"); - if (oldtz) - putenv(oldtz - 3); - tzset(); - } - return t; + return ret; } static void write_rtc(time_t t, int utc) { struct tm tm; - int rtc = xopen_rtc(O_WRONLY); + int rtc = rtc_xopen(rtcname, O_WRONLY); tm = *(utc ? gmtime(&t) : localtime(&t)); tm.tm_isdst = 0; @@ -132,38 +83,6 @@ static void from_sys_clock(int utc) write_rtc(tv.tv_sec, utc); } -#if ENABLE_FEATURE_HWCLOCK_ADJTIME_FHS -# define ADJTIME_PATH "/var/lib/hwclock/adjtime" -#else -# define ADJTIME_PATH "/etc/adjtime" -#endif -static int check_utc(void) -{ - int utc = 0; - FILE *f = fopen(ADJTIME_PATH, "r"); - - if (f) { - RESERVE_CONFIG_BUFFER(buffer, 128); - - while (fgets(buffer, sizeof(buffer), f)) { - int len = strlen(buffer); - - while (len && isspace(buffer[len - 1])) - len--; - - buffer[len] = 0; - - if (strncmp(buffer, "UTC", 3) == 0) { - utc = 1; - break; - } - } - fclose(f); - RELEASE_CONFIG_BUFFER(buffer); - } - return utc; -} - #define HWCLOCK_OPT_LOCALTIME 0x01 #define HWCLOCK_OPT_UTC 0x02 #define HWCLOCK_OPT_SHOW 0x04 @@ -193,19 +112,17 @@ int hwclock_main(int argc, char **argv) /* If -u or -l wasn't given check if we are using utc */ if (opt & (HWCLOCK_OPT_UTC | HWCLOCK_OPT_LOCALTIME)) - utc = opt & HWCLOCK_OPT_UTC; + utc = (opt & HWCLOCK_OPT_UTC); else - utc = check_utc(); + utc = rtc_adjtime_is_utc(); - if (opt & HWCLOCK_OPT_HCTOSYS) { + if (opt & HWCLOCK_OPT_HCTOSYS) to_sys_clock(utc); - return 0; - } - if (opt & HWCLOCK_OPT_SYSTOHC) { + else if (opt & HWCLOCK_OPT_SYSTOHC) from_sys_clock(utc); - return 0; - } - /* default HWCLOCK_OPT_SHOW */ - show_clock(utc); + else + /* default HWCLOCK_OPT_SHOW */ + show_clock(utc); + return 0; } diff --git a/util-linux/rtcwake.c b/util-linux/rtcwake.c new file mode 100644 index 000000000..718f43d45 --- /dev/null +++ b/util-linux/rtcwake.c @@ -0,0 +1,209 @@ +/* + * rtcwake -- enter a system sleep state until specified wakeup time. + * + * This version was taken from util-linux and scrubbed down for busybox. + * + * 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 "libbb.h" +#include "rtc_.h" + +#define SYS_RTC_PATH "/sys/class/rtc/%s/device/power/wakeup" +#define SYS_POWER_PATH "/sys/power/state" +#define DEFAULT_MODE "suspend" + +static time_t rtc_time; + +static int may_wakeup(const char *rtcname) +{ + ssize_t ret; + char buf[128]; + + /* strip the '/dev/' from the rtcname here */ + if (!strncmp(rtcname, "/dev/", 5)) + rtcname += 5; + + snprintf(buf, sizeof(buf), SYS_RTC_PATH, rtcname); + ret = open_read_close(buf, buf, sizeof(buf)); + if (ret < 0) + return 0; + + /* wakeup events could be disabled or not supported */ + return strcmp(buf, "enabled\n") == 0; +} + +static void setup_alarm(int fd, time_t *wakeup) +{ + struct tm *tm; + struct linux_rtc_wkalrm wake; + + /* 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 running in utc mode this process's timezone is UTC, + * so we'll pass a UTC date to the RTC. + * + * Else mode is local so the time given to the RTC + * will instead use the local time zone. + */ + tm = localtime(wakeup); + + 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 by Linux */ + wake.time.tm_wday = -1; + wake.time.tm_yday = -1; + wake.time.tm_isdst = -1; + + /* many rtc alarms only support up to 24 hours from 'now', + * so use the "more than 24 hours" request only if we must + */ + if ((rtc_time + (24 * 60 * 60)) > *wakeup) { + xioctl(fd, RTC_ALM_SET, &wake.time); + xioctl(fd, RTC_AIE_ON, 0); + } else { + /* avoid an extra AIE_ON call */ + wake.enabled = 1; + xioctl(fd, RTC_WKALM_SET, &wake); + } +} + +static void suspend_system(const char *suspend) +{ + FILE *f = xfopen(SYS_POWER_PATH, "w"); + fprintf(f, "%s\n", suspend); + fflush(f); + /* this executes after wake from suspend */ + fclose(f); +} + +#define RTCWAKE_OPT_AUTO 0x01 +#define RTCWAKE_OPT_LOCAL 0x02 +#define RTCWAKE_OPT_UTC 0x04 +#define RTCWAKE_OPT_DEVICE 0x08 +#define RTCWAKE_OPT_SUSPEND_MODE 0x10 +#define RTCWAKE_OPT_SECONDS 0x20 +#define RTCWAKE_OPT_TIME 0x40 + +int rtcwake_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; +int rtcwake_main(int argc, char **argv) +{ + unsigned opt; + const char *rtcname = NULL; + const char *suspend; + const char *opt_seconds; + const char *opt_time; + + time_t sys_time; + time_t alarm_time = 0; + unsigned seconds = 0; + int utc = -1; + int fd; + +#if ENABLE_GETOPT_LONG + static const char rtcwake_longopts[] ALIGN1 = + "auto\0" No_argument "a" + "local\0" No_argument "l" + "utc\0" No_argument "u" + "device\0" Required_argument "d" + "mode\0" Required_argument "m" + "seconds\0" Required_argument "s" + "time\0" Required_argument "t" + ; + applet_long_options = rtcwake_longopts; + } +#endif + opt = getopt32(argv, "alud:m:s:t:", &rtcname, &suspend, &opt_seconds, &opt_time); + + /* this is the default + if (opt & RTCWAKE_OPT_AUTO) + utc = -1; + */ + if (opt & (RTCWAKE_OPT_UTC | RTCWAKE_OPT_LOCAL)) + utc = opt & RTCWAKE_OPT_UTC; + if (!(opt & RTCWAKE_OPT_SUSPEND_MODE)) + suspend = DEFAULT_MODE; + if (opt & RTCWAKE_OPT_SECONDS) + /* alarm time, seconds-to-sleep (relative) */ + seconds = xatoi(opt_seconds); + if (opt & RTCWAKE_OPT_TIME) + /* alarm time, time_t (absolute, seconds since 1/1 1970 UTC) */ + alarm_time = xatoi(opt_time); + + if (!alarm_time && !seconds) + bb_error_msg_and_die("must provide wake time"); + + if (utc == -1) + utc = rtc_adjtime_is_utc(); + + /* the rtcname is relative to /dev */ + xchdir("/dev"); + + if (strcmp(suspend, "on") != 0 && !may_wakeup(rtcname)) + bb_error_msg_and_die("%s not enabled for wakeup events", rtcname); + + /* this RTC must exist and (if we'll sleep) be wakeup-enabled */ + fd = rtc_xopen(rtcname, O_RDONLY); + + /* relative or absolute alarm time, normalized to time_t */ + sys_time = time(0); + if (sys_time == (time_t)-1) + bb_perror_msg_and_die("read system time"); + rtc_time = rtc_read_time(fd, utc); + + if (alarm_time) { + if (alarm_time < sys_time) + bb_error_msg_and_die("time doesn't go backward to %s", ctime(&alarm_time)); + alarm_time += sys_time - rtc_time; + } else + alarm_time = rtc_time + seconds + 1; + setup_alarm(fd, &alarm_time); + + sync(); + printf("wakeup from \"%s\" at %s", suspend, ctime(&alarm_time)); + fflush(stdout); + usleep(10 * 1000); + + if (!strcmp(suspend, "on")) + suspend_system(suspend); + else { + /* "fake" suspend ... we'll do the delay ourselves */ + unsigned long data; + + do { + ssize_t ret = safe_read(fd, &data, sizeof(data)); + if (ret < 0) { + bb_perror_msg("rtc read"); + break; + } + } while (!(data & RTC_AF)); + } + + xioctl(fd, RTC_AIE_OFF, 0); + + if (ENABLE_FEATURE_CLEAN_UP) + close(fd); + + return EXIT_SUCCESS; +} |