diff options
Diffstat (limited to 'util-linux')
| -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 |
4 files changed, 232 insertions, 99 deletions
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; +} |