Merge lp:~charlesk/powerd/add-hardware-alarms into lp:powerd

[Charles Kerr]

Add hardware wakeup support.

Add hardware wakeup support. As discussed in #phablet, the u_hardware_alarm_*() API basically only allows one client, so powerd will be that one client and will act as a gatekeeper for hardware wakeups.

This adds a little new public API: two methods (requestWakeup() and clearWakeup()) and a broadcast signal (Wakeup).

Also added are wakeup and clear-wakeup commands in powerd-cli.

The wakeup.cpp implementation is fairly straightforward. One point that might be contentious is the new logging functions in log.h. I think they're pretty useful but don't mind removing them if they're too un-powerd-like.

See related MP for indicator-datetime to make use of this: <https://code.launchpad.net/~charlesk/indicator-datetime/add-powerd-alarm-support/+merge/231303>

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:142
http://jenkins.qa.ubuntu.com/job/powerd-ci/160/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/powerd-utopic-armhf-ci/12
        deb: http://jenkins.qa.ubuntu.com/job/powerd-utopic-armhf-ci/12/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/powerd-ci/160/rebuild

review: Approve (continuous-integration)

[Ricardo Salveti (rsalveti)]

Code looks fine, just one inline comment for the packaging. Will do some further tests and then approve with the proper feedback.

[lp:~charlesk/powerd/add-hardware-alarms]

143. By Charles Kerr on 2014-08-19

in debian/control, remove [armhf i386 amd64] arch restrictions for libubuntu-platform-hardware-api-*

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:143
http://jenkins.qa.ubuntu.com/job/powerd-ci/161/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/powerd-utopic-armhf-ci/13
        deb: http://jenkins.qa.ubuntu.com/job/powerd-utopic-armhf-ci/13/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/powerd-ci/161/rebuild

review: Approve (continuous-integration)

[Ricardo Salveti (rsalveti)]

Looks good, works as expected.

Would be nice for powerd-cli list to also show the current list of the pending wakeup events, but that can be done later on.

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-05-21 03:17:03 +0000
+++ CMakeLists.txt	2014-08-19 19:23:22 +0000
@@ -9,7 +9,7 @@
 endif()
 
 set(CMAKE_C_FLAGS "-Wall")
-set(CMAKE_CXX_FLAGS "-Wall")
+set(CMAKE_CXX_FLAGS "-Wall -std=c++11")
 set(CMAKE_C_FLAGS_DEBUG "-O0 -ggdb -g")
 set(CMAKE_CXX_FLAGS_DEBUG "-O0 -ggdb -g")
 set(CMAKE_C_FLAGS_RELEASE "-O3")
@@ -56,6 +56,7 @@
   src/spline.c
   src/stats.c
   src/util.c
+  src/wakeup.cpp
   src/${GDBUS_NAME}.c
 )
 
@@ -103,6 +104,7 @@
   ${GIO_LIBRARIES}
   ${GIO-UNIX_LIBRARIES}
   ${PHABLET_LIBRARIES}
+  "-lubuntu_platform_hardware_api"
   "-lubuntu_application_api"
   "-landroid-properties"
   "-lhardware"
 
=== modified file 'cli/powerd-cli.c'
--- cli/powerd-cli.c	2014-06-18 18:06:10 +0000
+++ cli/powerd-cli.c	2014-08-19 19:23:22 +0000
@@ -141,6 +141,55 @@
 }
 
 static gboolean
+requestWakeup(const char *name,
+              uint64_t wakeup_time,
+              powerd_cookie_t setme_cookie)
+{
+    GVariant *ret;
+    GError *error;
+    gboolean success;
+
+    g_return_val_if_fail (setme_cookie != NULL, FALSE);
+
+    error = NULL;
+    ret = g_dbus_proxy_call_sync(powerd_proxy,
+                                 "requestWakeup",
+                                 g_variant_new("(st)", name, wakeup_time),
+                                 G_DBUS_CALL_FLAGS_NONE,
+                                 -1, /* use default timeout */
+                                 NULL, /* cancellable */
+                                 &error);
+
+    if (ret == NULL) {
+        cli_warn("%s failed: %s", G_STRFUNC, error->message);
+        success = FALSE;
+    }
+    else if (!g_variant_is_of_type(ret, G_VARIANT_TYPE("(s)"))) {
+        char * s = g_variant_print(ret, TRUE);
+        cli_warn("Unexpected response: %s", s);
+        g_free(s);
+        success = FALSE;
+    }
+    else {
+        const char* s = NULL;
+        g_variant_get(ret, "(&s)", &s);
+        if (strlen(s) != sizeof(powerd_cookie_t) - 1) {
+            cli_warn("Returned cookie has incorrect size");
+            success = FALSE;
+        }
+        else {
+            memcpy(setme_cookie, s, sizeof(powerd_cookie_t));
+            cli_debug("Got cookie: %s", setme_cookie);
+            success = TRUE;
+        }
+    }
+
+    g_clear_error(&error);
+    g_clear_pointer(&ret, g_variant_unref);
+    return success;
+}
+
+static gboolean
 requestDisplayState(int *cookie)
 {
     GVariant *ret = NULL;
@@ -286,6 +335,35 @@
     }
 }
 
+static gboolean
+clearWakeup(const char* cookie_str)
+{
+    GVariant *ret;
+    GError *error;
+    gboolean success;
+
+    error = NULL;
+    ret = g_dbus_proxy_call_sync(powerd_proxy,
+                                 "clearWakeup",
+                                 g_variant_new("(s)", cookie_str),
+                                 G_DBUS_CALL_FLAGS_NONE,
+                                 -1, /* default timeout */
+                                 NULL, /* cancellable */
+                                 &error);
+
+    if (ret == NULL) {
+        cli_warn("%s failed: %s", G_STRFUNC, error->message);
+        success = FALSE;
+    } else {
+        cli_debug("%s success", G_STRFUNC);
+        success = TRUE;
+    }
+
+    g_clear_error(&error);
+    g_clear_pointer(&ret, g_variant_unref);
+    return success;
+}
+
 gboolean
 clearSysState(powerd_cookie_t cookie)
 {
@@ -618,6 +696,8 @@
     printf("listen\t- listen for signals from powerd. This runs a\n"\
            "\t  gmainloop and must be manually killed.\n");
     printf("stats\t- print request statistics.\n");
+    printf("wakeup <n>\t- request a hardware wakeup n seconds from now.\n");
+    printf("clear-wakeup <cookie>\t- clear a hardware wakeup request given a cookie.\n");
     printf("test\t- runs tests.\n");
 }
 
@@ -646,6 +726,8 @@
        (strcmp(argv[1],"stats")) &&
        (strcmp(argv[1],"active")) &&
        (strcmp(argv[1],"active-nc")) &&
+       (strcmp(argv[1],"wakeup")) &&
+       (strcmp(argv[1],"clear-wakeup")) &&
        (strcmp(argv[1],"test")) &&
        (strcmp(argv[1],"dbusnametest")) &&
        (strcmp(argv[1],"listen")) &&
@@ -751,6 +833,9 @@
                 if (!strcmp(argv[1],"clear-sys")) {
                     clearSysState(argv[2]);
                 }
+                else if (!g_strcmp0(argv[1], "clear-wakeup")) {
+                    clearWakeup(argv[2]);
+                }
                 else {
                     // Note: We should never get here due to earlier checks
                     fprintf(stderr,"Invalid option %s\n",argv[1]);
@@ -844,6 +929,20 @@
             exit(-1);
         }
         setUserBrightness((int)brightness);
+    } else if (!g_strcmp0(argv[1], "wakeup")) {
+        int n_seconds;
+        powerd_cookie_t cookie;
+        if (argc != 3) {
+            usage(argv[0]);
+            exit(-1);
+        }
+        n_seconds = atoi(argv[2]);
+        if (n_seconds < 1) {
+            fprintf(stderr, "Invalid number of seconds %s\n", argv[2]);
+            usage(argv[0]);
+            exit(-1);
+        }
+        requestWakeup(argv[0], time(NULL)+n_seconds, cookie);
     }
     return 0;
 }
 
=== modified file 'data/com.canonical.powerd.xml'
--- data/com.canonical.powerd.xml	2014-05-13 22:05:20 +0000
+++ data/com.canonical.powerd.xml	2014-08-19 19:23:22 +0000
@@ -14,6 +14,16 @@
       <arg type="s" name="cookie" direction="in" />
     </method>
 
+    <method name="requestWakeup">
+      <arg type="s" name="name" direction="in" />
+      <arg type="t" name="time" direction="in" />
+      <arg type="s" name="cookie" direction="out" />
+    </method>
+
+    <method name="clearWakeup">
+      <arg type="s" name="cookie" direction="in" />
+    </method>
+
     <method name="registerClient">
         <arg type="s" name="name" direction="in" />
     </method>
@@ -55,5 +65,8 @@
       <arg type="i" name="sysState" direction="out" />
     </signal>
 
+    <signal name="Wakeup">
+    </signal>
+
   </interface>
 </node>
 
=== modified file 'debian/control'
--- debian/control	2014-06-13 15:56:20 +0000
+++ debian/control	2014-08-19 19:23:22 +0000
@@ -10,6 +10,8 @@
                python:any,
                libandroid-properties-dev,
                libubuntu-application-api-dev,
+               libubuntu-platform-hardware-api-headers,
+               libubuntu-platform-hardware-api-dev,
                libupower-glib-dev,
                uuid-dev,
                libhardware-dev (>= 0.1.0+git20131207+e452e83-0ubuntu12),
 
=== modified file 'src/log.h'
--- src/log.h	2013-07-10 21:28:20 +0000
+++ src/log.h	2014-08-19 19:23:22 +0000
@@ -39,6 +39,29 @@
         __attribute__ ((format (printf, 2, 3)));
 void powerd_log_init(void);
 
+#define powerd_warn_if_fail(expr) \
+  do { \
+    if (!(expr)) \
+        powerd_warn("%s", #expr); \
+  } while (0)
+
+#define powerd_return_if_fail(expr) \
+  do { \
+    if (!(expr)) { \
+        powerd_warn("%s: assertion '%s' failed", __func__,  #expr); \
+        return; \
+    } \
+  } while (0)
+
+#define powerd_return_val_if_fail(expr,val) \
+  do { \
+    if (!(expr)) { \
+        powerd_warn("%s: assertion '%s' failed", __func__,  #expr); \
+        return val; \
+    } \
+  } while (0)
+
+
 #ifdef __cplusplus
 }
 #endif
 
=== modified file 'src/powerd-internal.h'
--- src/powerd-internal.h	2014-07-02 16:24:51 +0000
+++ src/powerd-internal.h	2014-08-19 19:23:22 +0000
@@ -19,8 +19,8 @@
 #ifndef __POWERD_INTERNAL_H__
 #define __POWERD_INTERNAL_H__
 
+#include <time.h> /* time_t */
 #include <uuid/uuid.h>
-#include <glib.h>
 #include <gio/gio.h>
 
 #include "powerd-object.h"
@@ -107,6 +107,7 @@
 enum SysPowerStates current_system_power_state(void);
 const gchar * state_to_string(int state);
 void powerd_sys_state_signal_emit(enum SysPowerStates state);
+void powerd_wakeup_signal_emit(void);
 void clear_sys_state_by_owner(const char *owner);
 gboolean powerd_suspend_active(void);
 
@@ -164,6 +165,12 @@
 int powerd_ps_init(void);
 void powerd_ps_deinit(void);
 
+/* Hardware alarm functions */
+void wakeup_init(void);
+void wakeup_deinit(void);
+int wakeup_request(const char *name, time_t time, powerd_cookie_t setme_cookie);
+int wakeup_clear(const powerd_cookie_t cookie);
+
 /* Client functions */
 int powerd_client_register(const char *dbus_name, const char *name);
 void powerd_client_unregister(const char *dbus_name);
 
=== modified file 'src/powerd-object.c'
--- src/powerd-object.c	2014-07-02 16:24:51 +0000
+++ src/powerd-object.c	2014-08-19 19:23:22 +0000
@@ -19,6 +19,7 @@
 #include <glib.h>
 #include <glib-object.h>
 #include <gio/gio.h>
+#include <inttypes.h>
 #include <string.h>
 #include <stdio.h>
 #include <errno.h>
@@ -135,11 +136,69 @@
     return TRUE;
 }
 
+static gboolean
+handle_request_wakeup(PowerdSource *obj,
+                      GDBusMethodInvocation *invocation,
+                      const char *name,
+                      uint64_t wakeup_time)
+{
+    int err;
+    powerd_cookie_t cookie;
+
+    powerd_debug("handle_requestWakeup from %s - %s, %zu",
+                 g_dbus_method_invocation_get_sender(invocation),
+                 name,
+                 (size_t)wakeup_time);
+
+    if ((err = wakeup_request(name, wakeup_time, cookie)))
+    {
+        g_dbus_method_invocation_return_error_literal(invocation,
+                                                      G_DBUS_ERROR,
+                                                      G_DBUS_ERROR_FAILED,
+                                                      strerror(err));
+    }
+    else
+    {
+        g_dbus_method_invocation_return_value(invocation,
+                                              g_variant_new("(s)", cookie));
+    }
+
+    return TRUE;
+}
+
+static gboolean
+handle_clear_wakeup(PowerdSource *obj,
+                    GDBusMethodInvocation *invocation,
+                    const char* cookie)
+{
+    int err;
+
+    powerd_debug("handle_clearWakeup from %s, cookie: %s",
+                 g_dbus_method_invocation_get_sender(invocation),
+                 cookie);
+  
+    if ((err = wakeup_clear(cookie)))
+    {
+        g_dbus_method_invocation_return_error_literal(invocation,
+                                                      G_DBUS_ERROR,
+                                                      G_DBUS_ERROR_FAILED,
+                                                      strerror(err));
+    }
+    else
+    {
+        g_dbus_method_invocation_return_value(invocation, NULL);
+    }
+
+    return TRUE;
+}
+
+
 void
 powerd_bus_acquired_cb (GDBusConnection *connection,
                         const gchar     *name,
                         gpointer         user_data)
 {
+    GObject * oskel;
     GError *error = NULL;
 
     powerd_debug("Bus acquired (guid %s)", g_dbus_connection_get_guid (connection));
@@ -156,28 +215,35 @@
         powerd_exit(-1);
     }
 
-    g_signal_connect(G_OBJECT(powerd_source->priv->skel), "handle-request-sys-state",
+    oskel = G_OBJECT(powerd_source->priv->skel);
+
+    g_signal_connect(oskel, "handle-request-sys-state",
         G_CALLBACK(handle_request_sys_state), powerd_source);
-    g_signal_connect(G_OBJECT(powerd_source->priv->skel), "handle-clear-sys-state",
+    g_signal_connect(oskel, "handle-clear-sys-state",
         G_CALLBACK(handle_clear_sys_state), powerd_source);
-    g_signal_connect(G_OBJECT(powerd_source->priv->skel), "handle-list-sys-requests",
+    g_signal_connect(oskel, "handle-list-sys-requests",
         G_CALLBACK(handle_list_sys_requests), powerd_source);
 
-    g_signal_connect(G_OBJECT(powerd_source->priv->skel), "handle-register-client",
+    g_signal_connect(oskel, "handle-register-client",
         G_CALLBACK(handle_register_client), powerd_source);
-    g_signal_connect(G_OBJECT(powerd_source->priv->skel), "handle-unregister-client",
+    g_signal_connect(oskel, "handle-unregister-client",
         G_CALLBACK(handle_unregister_client), powerd_source);
-    g_signal_connect(G_OBJECT(powerd_source->priv->skel), "handle-ack-state-change",
+    g_signal_connect(oskel, "handle-ack-state-change",
         G_CALLBACK(handle_ack_state_change), powerd_source);
-    g_signal_connect(G_OBJECT(powerd_source->priv->skel), "handle-get-sys-request-stats",
+    g_signal_connect(oskel, "handle-get-sys-request-stats",
         G_CALLBACK(handle_get_sys_request_stats), powerd_source);
-    g_signal_connect(G_OBJECT(powerd_source->priv->skel), "handle-user-autobrightness-enable",
+    g_signal_connect(oskel, "handle-user-autobrightness-enable",
         G_CALLBACK(handle_user_autobrightness_enable), powerd_source);
-    g_signal_connect(G_OBJECT(powerd_source->priv->skel), "handle-get-brightness-params",
+    g_signal_connect(oskel, "handle-get-brightness-params",
         G_CALLBACK(handle_get_brightness_params), powerd_source);
-    g_signal_connect(G_OBJECT(powerd_source->priv->skel), "handle-set-user-brightness",
+    g_signal_connect(oskel, "handle-set-user-brightness",
         G_CALLBACK(handle_set_user_brightness), powerd_source);
 
+    g_signal_connect(oskel, "handle-request-wakeup",
+        G_CALLBACK(handle_request_wakeup), powerd_source);
+    g_signal_connect(oskel, "handle-clear-wakeup",
+        G_CALLBACK(handle_clear_wakeup), powerd_source);
+
     powerd_dbus_init_complete();
 }
 
@@ -224,6 +290,31 @@
 }
 
 void
+powerd_wakeup_signal_emit (void)
+{
+    GError *error = NULL;
+
+    /* Make sure dbus has been set up */
+    if (!powerd_source)
+        return;
+
+    powerd_debug("Emitting wakeup signal");
+
+    g_dbus_connection_emit_signal(
+            POWERD_SOURCE_GET_PRIVATE(powerd_source)->system_bus,
+            NULL, /* destination */
+            "/com/canonical/powerd",
+            "com.canonical.powerd",
+            "Wakeup",
+            NULL,
+            &error);
+    if (error) {
+        powerd_warn("Unable to emit wakeup signal: %s", error->message);
+        g_error_free(error);
+    }
+}
+
+void
 ofono_manager_proxy_connect_cb(GObject *source_object,
                GAsyncResult *res,
                gpointer user_data)
 
=== modified file 'src/powerd.cpp'
--- src/powerd.cpp	2014-08-12 07:23:07 +0000
+++ src/powerd.cpp	2014-08-19 19:23:22 +0000
@@ -577,6 +577,7 @@
     powerd_autobrightness_init();
     powerd_sensors_init();
     powerd_ps_init();
+    wakeup_init();
 
     main_loop = g_main_loop_new (NULL, FALSE);
     signal(SIGTERM, sigterm_quit);
@@ -598,6 +599,7 @@
     g_bus_unown_name(name_id);
     g_main_loop_unref(main_loop);
 
+    wakeup_deinit();
     powerd_ps_deinit();
     dbus_name_watch_deinit();
     powerd_autobrightness_deinit();
 
=== added file 'src/wakeup.cpp'
--- src/wakeup.cpp	1970-01-01 00:00:00 +0000
+++ src/wakeup.cpp	2014-08-19 19:23:22 +0000
@@ -0,0 +1,188 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * Authors:
+ * Charles Kerr: [e-mail]
+ *
+ * This file is part of powerd.
+ *
+ * powerd is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * powerd 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <ctime>
+#include <map>
+#include <memory> // std::unique_ptr
+#include <string>
+#include <thread>
+
+#include <glib.h>
+
+#include <ubuntu/hardware/alarm.h>
+
+#include "powerd-internal.h"
+#include "log.h"
+
+namespace
+{
+
+struct Request
+{
+    std::string name;
+    time_t time;
+};
+
+std::map<std::string,Request> requests;
+
+UHardwareAlarm hardware_alarm = nullptr;
+
+// NB: only the main thread accesses 'worker'
+std::unique_ptr<std::thread> worker;
+
+void start_worker_thread();
+
+void set_wakeup_time(time_t wakeup_time, const std::string& name)
+{
+    powerd_return_if_fail(hardware_alarm != nullptr);
+    powerd_return_if_fail(wakeup_time >= time(nullptr));
+
+    struct tm tm;
+    char buf[32];
+    localtime_r(&wakeup_time, &tm);
+    strftime(buf, sizeof(buf), "%F %T", &tm);
+    powerd_debug("setting hardware wakeup time to %s for %s", buf, name.c_str());
+
+    struct timespec sleep_interval;
+    sleep_interval.tv_sec = wakeup_time;
+    sleep_interval.tv_nsec = 0;
+    u_hardware_alarm_set_relative_to_with_behavior(
+        hardware_alarm,
+        U_HARDWARE_ALARM_TIME_REFERENCE_RTC,
+        U_HARDWARE_ALARM_SLEEP_BEHAVIOR_WAKEUP_DEVICE,
+        &sleep_interval);
+}
+
+void reset_alarm_clock()
+{
+    // find request that will occur next
+    const time_t now = time(nullptr);
+    const Request* next = nullptr;
+    size_t n_left = 0;
+    for (const auto& it : requests) {
+        if (now < it.second.time) {
+            ++n_left;
+            if (!next || (it.second.time < next->time))
+                next = &it.second;
+        }
+    }
+
+    if (next != nullptr)
+    {
+        powerd_debug("%s found %zu remaining wakeup requests", G_STRFUNC, n_left); 
+        set_wakeup_time(next->time, next->name);
+        if (!worker)
+            start_worker_thread();
+    }
+    else if (worker) // no pending requests...
+    {
+        powerd_debug("shortening wakeup_time so worker thread will finish soon");
+        set_wakeup_time(time(nullptr)+1, G_STRFUNC);
+    }
+}
+
+gboolean on_worker_thread_finished(gpointer /*unused*/)
+{
+    // tell the world that we woke up
+    powerd_wakeup_signal_emit();
+
+    // worker thread is done, so clean up our 'worker' variable
+    powerd_debug("worker thread is finished working; calling join()");
+    worker->join();
+    worker.reset();
+    powerd_debug("worker thread is destroyed.");
+
+    reset_alarm_clock();
+
+    return G_SOURCE_REMOVE;
+}
+
+void threadfunc(UHardwareAlarm hw_alarm)
+{
+    // wait for the next alarm
+    powerd_debug("calling wait_for_next_alarm");
+    UHardwareAlarmWaitResult wait_result;
+    auto rc = u_hardware_alarm_wait_for_next_alarm(hw_alarm, &wait_result);
+    powerd_debug("worker thread finished waiting for hw alarm");
+    powerd_warn_if_fail(rc == U_STATUS_SUCCESS);
+    u_hardware_alarm_unref(hw_alarm);
+
+    // kick back to the main loop
+    g_idle_add(on_worker_thread_finished, nullptr);
+}
+
+void start_worker_thread()
+{
+    powerd_return_if_fail(hardware_alarm != nullptr);
+
+    powerd_debug("starting hardware alarm worker thread");
+    u_hardware_alarm_ref(hardware_alarm);
+    worker.reset(new std::thread(threadfunc, hardware_alarm));
+}
+
+} // private impl in unnamed namespace
+
+void
+wakeup_init(void)
+{
+    hardware_alarm = u_hardware_alarm_create();
+}
+
+void
+wakeup_deinit(void)
+{
+    requests.clear();
+    reset_alarm_clock();
+    g_clear_pointer(&hardware_alarm, u_hardware_alarm_unref);
+}
+
+int
+wakeup_request(const char* name, time_t wakeup_time, powerd_cookie_t cookie)
+{
+    powerd_return_val_if_fail(hardware_alarm, ENOTSUP);
+    powerd_return_val_if_fail(wakeup_time > time(nullptr), EINVAL);
+    powerd_return_val_if_fail(cookie != NULL, EINVAL);
+
+    // generate a new uuid string
+    uuid_t tmp;
+    uuid_generate(tmp);
+    uuid_unparse(tmp, cookie);
+
+    requests[cookie] = { name, wakeup_time };
+
+    reset_alarm_clock();
+    return 0;
+}
+
+int
+wakeup_clear(const powerd_cookie_t cookie)
+{
+    powerd_return_val_if_fail(hardware_alarm, ENOTSUP);
+    auto it = requests.find(cookie);
+    powerd_return_val_if_fail(it != requests.end(), EINVAL);
+
+    requests.erase(it);
+
+    reset_alarm_clock();
+    return 0;
+}
+