Merge lp:~sforshee/powerd/stats into lp:powerd

[Seth Forshee]

Add support for collecting and reporting statistics about requests

Add support for collecting and reporting statistics about requests

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:98
http://jenkins.qa.ubuntu.com/job/powerd-ci/104/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/powerd-saucy-armhf-ci/58
        deb: http://jenkins.qa.ubuntu.com/job/powerd-saucy-armhf-ci/58/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[lp:~sforshee/powerd/stats]

99. By Seth Forshee on 2013-08-12

stats: Fix accounting and reporting of max_active_time

100. By Seth Forshee on 2013-08-12

powerd-cli: Reorder flag fields in display stats output

Printing out the "on time" and "on since" times for a given flag
side-by-side groups together fields which are likely to be used
together.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:99
http://jenkins.qa.ubuntu.com/job/powerd-ci/105/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/powerd-saucy-armhf-ci/59
        deb: http://jenkins.qa.ubuntu.com/job/powerd-saucy-armhf-ci/59/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Seth Forshee (sforshee)]

Sample output: http://pastebin.ubuntu.com/5977523/

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:100
http://jenkins.qa.ubuntu.com/job/powerd-ci/106/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/powerd-saucy-armhf-ci/60
        deb: http://jenkins.qa.ubuntu.com/job/powerd-saucy-armhf-ci/60/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Michael Frey (mfrey)]

tested. Works well.

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-07-23 14:42:07 +0000
+++ CMakeLists.txt	2013-08-12 14:34:58 +0000
@@ -46,6 +46,7 @@
   src/powerd-client.c
   src/powerd-object.c
   src/powerd-sensors.cpp
+  src/stats.c
   src/util.c
   src/${GDBUS_NAME}.c
 )

=== modified file 'cli/powerd-cli.c'
--- cli/powerd-cli.c	2013-08-02 12:48:24 +0000
+++ cli/powerd-cli.c	2013-08-12 14:34:58 +0000
@@ -22,6 +22,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
+#include <inttypes.h>
 #include <sys/types.h>
 #include <glib-object.h>
 #include <gio/gio.h>
@@ -57,6 +58,28 @@
     guint32 flags;
 };
 
+struct SysRequestStats {
+    const char *owner;
+    const char *name;
+    unsigned active_count;
+    guint64 active_time;
+    guint64 max_active_time;
+    guint64 active_since;
+};
+
+struct DispRequestStats {
+    const char *owner;
+    const char *name;
+    unsigned active_count;
+    guint64 active_time;
+    guint64 max_active_time;
+    guint64 active_since;
+    guint64 disp_on_time;
+    guint64 disp_on_since;
+    guint64 flag_on_time[POWERD_NUM_DISPLAY_FLAGS];
+    guint64 flag_on_since[POWERD_NUM_DISPLAY_FLAGS];
+};
+
 static GMainLoop *main_loop = NULL;
 static powerd_cookie_t main_cookie;
 static gboolean checkForDbusName(const char *dbusname, int count,
@@ -307,6 +330,171 @@
     }
 }
 
+static GArray *
+getSysRequestStats(void)
+{
+    GVariant *ret, *item;
+    GVariantIter *iter;
+    GArray *retarray;
+    GError *error;
+
+    retarray =  g_array_new(FALSE, FALSE, sizeof(struct SysRequestStats));
+
+    error = NULL;
+    ret = g_dbus_proxy_call_sync(powerd_proxy,
+            "getSysRequestStats",
+            NULL,
+            G_DBUS_CALL_FLAGS_NONE,
+            -1,
+            NULL,
+            &error);
+    if (ret == NULL) {
+        cli_warn("getSysRequestStats failed: %s", error->message);
+        g_error_free(error);
+    } else {
+        g_variant_get(ret, "(a(ssuttt))", &iter);
+        while ((item = g_variant_iter_next_value (iter))) {
+            struct SysRequestStats stats;
+            g_variant_get_child(item, 0, "s", &stats.owner);
+            g_variant_get_child(item, 1, "s", &stats.name);
+            g_variant_get_child(item, 2, "u", &stats.active_count);
+            g_variant_get_child(item, 3, "t", &stats.active_time);
+            g_variant_get_child(item, 4, "t", &stats.max_active_time);
+            g_variant_get_child(item, 5, "t", &stats.active_since);
+            g_array_append_val(retarray, stats);
+            g_variant_unref(item);
+        }
+        g_variant_unref(ret);
+    }
+    return retarray;
+}
+
+static void
+printSysRequestStats(GArray *stats)
+{
+    int i;
+    struct SysRequestStats *stat;
+    printf("System Request Statistics:\n");
+    if (stats->len == 0) {
+        printf("  None\n");
+    } else {
+        printf("  %-16.16s %-20.20s %-8.8s %-16.16s %-16.16s %-16.16s\n",
+               "", "", "Active", "", "Max Active", "");
+        printf("  %-16.16s %-20.20s %-8.8s %-16.16s %-16.16s %-16.16s\n",
+               "Owner", "Name", "Count", "Active Time", "Time", "Active Since");
+        for (i = 0; i < stats->len; i++) {
+            stat = &g_array_index(stats, struct SysRequestStats, i);
+            printf("  %-16.16s %-20.20s %-8u %-16.6f %-16.6f %-16.6f\n",
+                   stat->owner, stat->name, stat->active_count,
+                   (double)stat->active_time / 1000000.0f,
+                   (double)stat->max_active_time / 1000000.0f,
+                   (double)stat->active_since / 1000000.0f);
+        }
+    }
+}
+
+static GArray *
+getDispRequestStats(void)
+{
+    GVariant *ret, *item;
+    GVariantIter *iter;
+    GArray *retarray;
+    GError *error;
+
+    retarray =  g_array_new(FALSE, FALSE, sizeof(struct DispRequestStats));
+
+    error = NULL;
+    ret = g_dbus_proxy_call_sync(powerd_proxy,
+            "getDispRequestStats",
+            NULL,
+            G_DBUS_CALL_FLAGS_NONE,
+            -1,
+            NULL,
+            &error);
+    if (ret == NULL) {
+        cli_warn("getDispRequestStats failed: %s", error->message);
+        g_error_free(error);
+    } else {
+        g_variant_get(ret, "(a(ssutttttatat))", &iter);
+        while ((item = g_variant_iter_next_value (iter))) {
+            struct DispRequestStats stats;
+            GVariantIter *array_iter;
+            guint64 val;
+            int i;
+
+            g_variant_get_child(item, 0, "s", &stats.owner);
+            g_variant_get_child(item, 1, "s", &stats.name);
+            g_variant_get_child(item, 2, "u", &stats.active_count);
+            g_variant_get_child(item, 3, "t", &stats.active_time);
+            g_variant_get_child(item, 4, "t", &stats.max_active_time);
+            g_variant_get_child(item, 5, "t", &stats.active_since);
+            g_variant_get_child(item, 6, "t", &stats.disp_on_time);
+            g_variant_get_child(item, 7, "t", &stats.disp_on_since);
+
+            g_variant_get_child(item, 8, "at", &array_iter);
+            i = 0;
+            while (g_variant_iter_loop(array_iter, "t", &val)) {
+                if (i >= POWERD_NUM_DISPLAY_FLAGS)
+                    break;
+                stats.flag_on_time[i++] = val;
+            }
+            g_variant_iter_free(array_iter);
+
+            g_variant_get_child(item, 9, "at", &array_iter);
+            i = 0;
+            while (g_variant_iter_loop(array_iter, "t", &val)) {
+                if (i >= POWERD_NUM_DISPLAY_FLAGS)
+                    break;
+                stats.flag_on_since[i++] = val;
+            }
+            g_variant_iter_free(array_iter);
+
+            g_array_append_val(retarray, stats);
+            g_variant_unref(item);
+        }
+        g_variant_unref(ret);
+    }
+    return retarray;
+}
+
+static void
+printDispRequestStats(GArray *stats)
+{
+    int i, j;
+    struct DispRequestStats *stat;
+    printf("Display Request Statistics:\n");
+    if (stats->len == 0) {
+        printf("  None\n");
+    } else {
+        printf("  %-16.16s %-20.20s %-8.8s %-16.16s %-16.16s %-16.16s %-16.16s %-16.16s",
+               "", "", "Active", "", "Max Active", "", "Display On",
+               "Display On");
+        for (i = 0; i < POWERD_NUM_DISPLAY_FLAGS; i++)
+            printf(" Flag %-2d          Flag %-2d         ", i, i);
+        printf("\n  %-16.16s %-20.20s %-8.8s %-16.16s %-16.16s %-16.16s %-16.16s %-16.16s",
+               "Owner", "Name", "Count", "Active Time", "Time", "Active Since",
+               "Time", "Since");
+        for (i = 0; i < POWERD_NUM_DISPLAY_FLAGS; i++)
+            printf(" On Time          On Since        ");
+        printf("\n");
+        for (i = 0; i < stats->len; i++) {
+            stat = &g_array_index(stats, struct DispRequestStats, i);
+            printf("  %-16.16s %-20.20s %-8u %-16.6f %-16.6f %-16.6f %-16.6f %-16.6f",
+                   stat->owner, stat->name, stat->active_count,
+                   (double)stat->active_time / 1000000.0f,
+                   (double)stat->max_active_time / 1000000.0f,
+                   (double)stat->active_since / 1000000.0f,
+                   (double)stat->disp_on_time / 1000000.0f,
+                   (double)stat->disp_on_since / 1000000.0f);
+            for (j = 0; j < POWERD_NUM_DISPLAY_FLAGS; j++) {
+                printf(" %-16.6f", (double)stat->flag_on_time[j] / 1000000.0f);
+                printf(" %-16.6f", (double)stat->flag_on_since[j] / 1000000.0f);
+            }
+            printf("\n");
+        }
+    }
+}
+
 gboolean
 clearSysState(powerd_cookie_t cookie)
 {
@@ -601,7 +789,7 @@
     do_test(updateDisplayState(pdr, cookie) == TRUE);
 
     pdr.state = -1;
-    do_test(updateDisplayState(pdr, cookie) == TRUE);
+    do_test(updateDisplayState(pdr, cookie) == FALSE);
 
     do_test(clearDisplayState(cookie) == TRUE);
 
@@ -730,6 +918,7 @@
     printf("list - list outstanding requests\n");
     printf("listen - listen for signals from powerd. This runs a\n"\
            "\tgmainloop and must be manually killed.\n");
+    printf("stats - print request statistics\n");
     printf("test - runs tests\n");
 }
 
@@ -756,6 +945,7 @@
     }
 
     if ((strcmp(argv[1],"list")) &&
+       (strcmp(argv[1],"stats")) &&
        (strcmp(argv[1],"active")) &&
        (strcmp(argv[1],"active-nc")) &&
        (strcmp(argv[1],"test")) &&
@@ -807,6 +997,15 @@
         printDisplayRequests(requests);
         g_array_free(requests, TRUE);
     }
+    else if (!strcmp(argv[1], "stats")) {
+        requests = getSysRequestStats();
+        printSysRequestStats(requests);
+        g_array_free(requests, TRUE);
+
+        requests = getDispRequestStats();
+        printDispRequestStats(requests);
+        g_array_free(requests, TRUE);
+    }
     else if (!strcmp(argv[1],"active-nc")) {
         requestSysState("active-nc", POWERD_SYS_STATE_ACTIVE,&cookie);
         printf("Power State requested, cookie is %s\n", cookie);

=== modified file 'data/com.canonical.powerd.xml'
--- data/com.canonical.powerd.xml	2013-07-29 16:05:34 +0000
+++ data/com.canonical.powerd.xml	2013-08-12 14:34:58 +0000
@@ -52,6 +52,14 @@
       <arg type="a(ssiu)" name="requestList" direction="out" />
     </method>
 
+    <method name="getSysRequestStats">
+      <arg type="a(ssuttt)" name="requestStats" direction="out" />
+    </method>
+
+    <method name="getDispRequestStats">
+      <arg type="a(ssutttttatat)" name="requestStats" direction="out" />
+    </method>
+
     <!-- Signals -->
     <signal name="SysPowerStateChange">
       <arg type="i" name="sysState" direction="out" />

=== modified file 'src/display-request.c'
--- src/display-request.c	2013-07-29 16:05:34 +0000
+++ src/display-request.c	2013-08-12 14:34:58 +0000
@@ -116,6 +116,8 @@
     powerd_dbus_name_watch_add(request->owner);
     __add_request(&request->req);
     update_internal_state();
+    powerd_account_add_display_req(request->owner, request->name,
+                                   &request->req);
 }
 
 static gboolean update_request(struct powerd_display_request *new_req)
@@ -135,6 +137,7 @@
     ireq->req.flags = new_req->flags;
 
     update_internal_state();
+    powerd_account_update_display_req(ireq->owner, ireq->name, &ireq->req);
     return TRUE;
 }
 
@@ -154,11 +157,12 @@
     ireq = g_hash_table_lookup(display_request_hash, cookie);
     if (ireq) {
         req = ireq->req;
-        /* We need to remove it from our watch hash before we remove it
-         * from the state hash or the ireq->owner memory will be freed
-         * before we try to use it.
+        /* We need to remove it from our watch hash and do accounting
+         * before we remove it from the state hash or the ireq->owner
+         * memory will be freed before we try to use it.
          */
         powerd_dbus_name_watch_remove(ireq->owner);
+        powerd_account_clear_display_req(ireq->owner, ireq->name);
         found = g_hash_table_remove(display_request_hash, cookie);
         if (!found)
             powerd_warn("Display request found on lookup but not on remove");
@@ -172,25 +176,11 @@
     return found;
 }
 
-static int add_request_worker(gpointer data)
-{
-    struct display_request_internal *req = data;
-    add_request(req);
-    return 0;
-}
-
-/*
- * @request need not refer to persistent memory, as the data from
- * the struct will be copied into internally-managed storage.
- */
-static int __powerd_add_display_request(struct powerd_display_request *request,
-                                        const char *name, const char *owner)
-{
-    struct display_request_internal *hash_req;
-
+static gboolean request_valid(struct powerd_display_request *request)
+{
     if ((unsigned)request->state >= POWERD_NUM_DISPLAY_STATES) {
         powerd_warn("Invalid display state requested: %d", request->state);
-        return -EINVAL;
+        return FALSE;
     }
 
     /*
@@ -199,8 +189,30 @@
      */
     if (request->flags & (-1U << POWERD_NUM_DISPLAY_FLAGS)) {
         powerd_warn("Invalid display flags requested: 0x%08x", request->flags);
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static int add_request_worker(gpointer data)
+{
+    struct display_request_internal *req = data;
+    add_request(req);
+    return 0;
+}
+
+/*
+ * @request need not refer to persistent memory, as the data from
+ * the struct will be copied into internally-managed storage.
+ */
+static int __powerd_add_display_request(struct powerd_display_request *request,
+                                        const char *name, const char *owner)
+{
+    struct display_request_internal *hash_req;
+
+    if (!request_valid(request))
         return -EINVAL;
-    }
 
     uuid_generate(request->cookie);
     hash_req = g_new(struct display_request_internal, 1);
@@ -235,6 +247,9 @@
 {
     gboolean found;
 
+    if (!request_valid(request))
+        return -EINVAL;
+
     found = powerd_run_mainloop_sync(update_request_worker, request);
     return found ? 0 : -EINVAL;
 }
@@ -434,6 +449,7 @@
     while (g_hash_table_iter_next(&iter, &key, &value)) {
         struct display_request_internal *ireq = value;
         if (!strcmp(owner, ireq->owner)) {
+            powerd_account_clear_display_req(ireq->owner, ireq->name);
             __remove_request(&ireq->req);
             powerd_dbus_name_watch_remove(ireq->owner);
             g_hash_table_iter_remove(&iter);

=== modified file 'src/power-request.c'
--- src/power-request.c	2013-08-05 08:47:30 +0000
+++ src/power-request.c	2013-08-12 14:34:58 +0000
@@ -210,6 +210,7 @@
     g_hash_table_insert(state_request_hash, sr->cookie, sr);
     state_request_count[sr->state - 1] += 1;
     powerd_dbus_name_watch_add(sr->owner);
+    powerd_account_request_sys_state(sr->owner, sr->name);
     return 0;
 }
 
@@ -278,6 +279,7 @@
 {
     powerd_dbus_name_watch_remove(req->owner);
     state_request_count[req->state - 1] -= 1;
+    powerd_account_clear_sys_state(req->owner, req->name);
 }
 
 /* Must only be called from main loop */

=== modified file 'src/powerd-internal.h'
--- src/powerd-internal.h	2013-07-29 16:05:34 +0000
+++ src/powerd-internal.h	2013-08-12 14:34:58 +0000
@@ -161,6 +161,22 @@
 int powerd_client_init(void);
 void powerd_client_deinit(void);
 
+/* Statistics functions */
+void powerd_account_request_sys_state(const char *dbus_name, const char *name);
+void powerd_account_clear_sys_state(const char *dbus_name, const char *name);
+void powerd_account_add_display_req(const char *dbus_name, const char *name,
+                                    const struct powerd_display_request *req);
+void powerd_account_update_display_req(const char *dbus_name,
+                                       const char *name,
+                                       const struct powerd_display_request *req);
+void powerd_account_clear_display_req(const char *dbus_name, const char *name);
+int powerd_stats_init(void);
+void powerd_stats_deinit(void);
+gboolean handle_get_sys_request_stats(PowerdSource *obj,
+                                      GDBusMethodInvocation *invocation);
+gboolean handle_get_disp_request_stats(PowerdSource *obj,
+                                       GDBusMethodInvocation *invocation);
+
 /* Utility functions */
 int powerd_run_mainloop_sync(int (*func)(gpointer), gpointer data);
 guint powerd_uuid_hash(gconstpointer key);

=== modified file 'src/powerd-object.c'
--- src/powerd-object.c	2013-07-24 14:39:08 +0000
+++ src/powerd-object.c	2013-08-12 14:34:58 +0000
@@ -177,6 +177,10 @@
         G_CALLBACK(handle_ack_state_change), powerd_source);
     g_signal_connect(G_OBJECT(powerd_source->priv->skel), "handle-list-display-requests",
         G_CALLBACK(handle_list_display_requests), powerd_source);
+    g_signal_connect(G_OBJECT(powerd_source->priv->skel), "handle-get-sys-request-stats",
+        G_CALLBACK(handle_get_sys_request_stats), powerd_source);
+    g_signal_connect(G_OBJECT(powerd_source->priv->skel), "handle-get-disp-request-stats",
+        G_CALLBACK(handle_get_disp_request_stats), powerd_source);
 
     powerd_dbus_init_complete();
 }

=== modified file 'src/powerd.cpp'
--- src/powerd.cpp	2013-07-29 16:05:34 +0000
+++ src/powerd.cpp	2013-08-12 14:34:58 +0000
@@ -472,6 +472,7 @@
     powerd_debug("Auto-dim Timeout is %d seconds\n", dim_timeout);
 
     libsuspend_init(0);
+    powerd_stats_init();
     powerd_client_init();
     power_request_init();
     display_request_init();
@@ -512,5 +513,6 @@
     display_request_deinit();
     power_request_deinit();
     powerd_client_deinit();
+    powerd_stats_deinit();
     return g_exit_code;
 }

=== added file 'src/stats.c'
--- src/stats.c	1970-01-01 00:00:00 +0000
+++ src/stats.c	2013-08-12 14:34:58 +0000
@@ -0,0 +1,508 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * 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 <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <time.h>
+
+#include <glib.h>
+#include <gio/gio.h>
+
+#include "powerd-internal.h"
+#include "powerd-dbus.h"
+#include "log.h"
+
+#define USECS_PER_SEC 1000000
+#define NSECS_PER_USEC 1000
+
+struct client_stats {
+    const char *dbus_name;
+    GSList *sys_stats;
+    GSList *disp_stats;
+};
+
+struct sys_request_stats {
+    const char *name;
+    unsigned active_count;
+    guint64 active_time;
+    guint64 max_active_time;
+    guint64 active_since;
+};
+
+struct disp_request_stats {
+    const char *name;
+    unsigned active_count;
+    guint64 active_time;
+    guint64 max_active_time;
+    guint64 active_since;
+    guint64 disp_on_time;
+    guint64 disp_on_since;
+    guint64 flag_on_time[POWERD_NUM_DISPLAY_FLAGS];
+    guint64 flag_on_since[POWERD_NUM_DISPLAY_FLAGS];
+    struct powerd_display_request last_req;
+};
+
+GHashTable *stats_hash;
+
+static guint64 get_usecs(void)
+{
+    struct timespec ts;
+
+    if (clock_gettime(CLOCK_MONOTONIC, &ts)) {
+        powerd_error("Could not get monotonic time: %s", strerror(errno));
+        return 0;
+    }
+    return (guint64)ts.tv_sec * USECS_PER_SEC +
+           (ts.tv_nsec + NSECS_PER_USEC / 2) / NSECS_PER_USEC;
+}
+
+static struct client_stats *alloc_client(const char *dbus_name)
+{
+    struct client_stats *client = calloc(1, sizeof(*client));
+    if (!client) {
+        powerd_error("Error allocating client for statistics");
+        return NULL;
+    }
+
+    client->dbus_name = strdup(dbus_name);
+    if (!client->dbus_name) {
+        powerd_error("Error duplicating client dbus name for statistics");
+        free(client);
+        return NULL;
+    }
+
+    return client;
+}
+
+static struct sys_request_stats *alloc_sys_stats(const char *name)
+{
+    struct sys_request_stats *stats = calloc(1, sizeof(*stats));
+    if (!stats) {
+        powerd_error("Error allocating memory for system request statistics");
+        return NULL;
+    }
+
+    stats->name = strdup(name);
+    if (!stats->name) {
+        powerd_error("Error duplicating request name for statistics");
+        free(stats);
+        return NULL;
+    }
+
+    return stats;
+}
+
+static struct disp_request_stats *alloc_disp_stats(const char *name)
+{
+    struct disp_request_stats *stats = calloc(1, sizeof(*stats));
+    if (!stats) {
+        powerd_error("Error allocating memory for display request statistics");
+        return NULL;
+    }
+
+    stats->name = strdup(name);
+    if (!stats->name) {
+        powerd_error("Error duplicating request name for statistics");
+        free(stats);
+        return NULL;
+    }
+
+    return stats;
+}
+
+static gint sys_stats_comp(gconstpointer a, gconstpointer b)
+{
+    const struct sys_request_stats *stats = a;
+    const char *name = b;
+    return strcmp(stats->name, name);
+}
+
+static gint disp_stats_comp(gconstpointer a, gconstpointer b)
+{
+    const struct disp_request_stats *stats = a;
+    const char *name = b;
+    return strcmp(stats->name, name);
+}
+
+static struct client_stats *lookup_client(const char *dbus_name,
+                                          gboolean alloc)
+{
+    struct client_stats *client;
+
+    if (!stats_hash)
+        return NULL;
+
+    client = g_hash_table_lookup(stats_hash, dbus_name);
+    if (!client && alloc) {
+        client = alloc_client(dbus_name);
+        if (client)
+            g_hash_table_insert(stats_hash, (gpointer)client->dbus_name,
+                                client);
+    }
+    return client;
+}
+
+void powerd_account_request_sys_state(const char *dbus_name, const char *name)
+{
+    struct client_stats *client;
+    struct sys_request_stats *stats;
+    GSList *item;
+
+    client = lookup_client(dbus_name, TRUE);
+    if (!client)
+        return;
+
+    item = g_slist_find_custom(client->sys_stats, name, sys_stats_comp);
+    if (item) {
+        stats = item->data;
+    } else {
+        stats = alloc_sys_stats(name);
+        if (!stats)
+            return;
+        client->sys_stats = g_slist_prepend(client->sys_stats, stats);
+    }
+
+    stats->active_count++;
+    stats->active_since = get_usecs();
+}
+
+void powerd_account_clear_sys_state(const char *dbus_name, const char *name)
+{
+    struct client_stats *client;
+    struct sys_request_stats *stats;
+    GSList *item;
+    guint64 duration;
+
+    if (!stats_hash)
+        return;
+
+    client = lookup_client(dbus_name, FALSE);
+    if (!client)
+        return;
+    item = g_slist_find_custom(client->sys_stats, name, sys_stats_comp);
+    if (!item)
+        return;
+    stats = item->data;
+
+    duration = get_usecs() - stats->active_since;
+    stats->active_since = 0;
+    stats->active_time += duration;
+    if (duration > stats->max_active_time)
+        stats->max_active_time = duration;
+}
+
+static void aggregate_disp_stats(struct disp_request_stats *stats,
+                                 const struct powerd_display_request *new)
+{
+    guint64 us;
+    int i;
+
+    us = get_usecs();
+    if (new->state != stats->last_req.state) {
+        if (new->state == POWERD_DISPLAY_STATE_ON) {
+            stats->disp_on_since = us;
+        } else {
+            stats->disp_on_time += us - stats->disp_on_since;
+            stats->disp_on_since = 0;
+        }
+    }
+    for (i = 0; i < POWERD_NUM_DISPLAY_FLAGS; i++) {
+        guint32 mask = 1 << i;
+        if ((new->flags & mask) != (stats->last_req.flags & mask)) {
+            if (new->flags & mask) {
+                stats->flag_on_since[i] = us;
+            } else {
+                stats->flag_on_time[i] += us - stats->flag_on_since[i];
+                stats->flag_on_since[i] = 0;
+            }
+        }
+    }
+}
+
+void powerd_account_add_display_req(const char *dbus_name, const char *name,
+                                    const struct powerd_display_request *req)
+{
+    struct client_stats *client;
+    struct disp_request_stats *stats;
+    GSList *item;
+    guint64 us;
+    int i;
+
+    if (!stats_hash)
+        return;
+
+    client = lookup_client(dbus_name, TRUE);
+    if (!client)
+        return;
+
+    item = g_slist_find_custom(client->disp_stats, name, disp_stats_comp);
+    if (item) {
+        stats = item->data;
+    } else {
+        stats = alloc_disp_stats(name);
+        if (!stats)
+            return;
+        client->disp_stats = g_slist_prepend(client->disp_stats, stats);
+    }
+
+    us = get_usecs();
+    stats->active_count++;
+    stats->active_since = us;
+    if (req->state == POWERD_DISPLAY_STATE_ON)
+        stats->disp_on_since = us;
+    for (i = 0; i < POWERD_NUM_DISPLAY_FLAGS; i++) {
+        if (req->flags & (1 << i))
+            stats->flag_on_since[i] = us;
+    }
+    stats->last_req = *req;
+}
+
+void powerd_account_update_display_req(const char *dbus_name,
+                                       const char *name,
+                                       const struct powerd_display_request *req)
+{
+    struct client_stats *client;
+    struct disp_request_stats *stats;
+    GSList *item;
+
+    client = lookup_client(dbus_name, FALSE);
+    if (!client)
+        return;
+
+    item = g_slist_find_custom(client->disp_stats, name, disp_stats_comp);
+    if (!item)
+        return;
+    stats = item->data;
+
+    aggregate_disp_stats(stats, req);
+    stats->last_req = *req;
+}
+
+void powerd_account_clear_display_req(const char *dbus_name, const char *name)
+{
+    struct client_stats *client;
+    struct disp_request_stats *stats;
+    GSList *item;
+    struct powerd_display_request req;
+    guint64 duration;
+
+    client = lookup_client(dbus_name, FALSE);
+    if (!client)
+        return;
+
+    item = g_slist_find_custom(client->disp_stats, name, disp_stats_comp);
+    if (!item)
+        return;
+    stats = item->data;
+
+    memset(&req, 0, sizeof(req));
+    aggregate_disp_stats(stats, &req);
+
+    duration = get_usecs() - stats->active_since;
+    stats->active_time += duration;
+    stats->active_since = 0;
+    if (duration > stats->max_active_time)
+        stats->max_active_time = duration;
+
+    stats->last_req = req;
+}
+
+static void sys_stats_list_destroy(gpointer data)
+{
+    struct sys_request_stats *stats = data;
+    free((void *)stats->name);
+    free(stats);
+}
+
+static void disp_stats_list_destroy(gpointer data)
+{
+    struct disp_request_stats *stats = data;
+    free((void *)stats->name);
+    free(stats);
+}
+
+static void stats_hash_destroy(gpointer data)
+{
+    struct client_stats *client = data;
+    g_slist_free_full(client->sys_stats, sys_stats_list_destroy);
+    g_slist_free_full(client->disp_stats, disp_stats_list_destroy);
+    free((void *)client->dbus_name);
+    free(client);
+}
+
+int powerd_stats_init(void)
+{
+    stats_hash = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
+                                       stats_hash_destroy);
+    if (!stats_hash) {
+        powerd_warn("Unable to allocate stats hash table");
+        return -ENOMEM;
+    }
+    return 0;
+}
+
+void powerd_stats_deinit(void)
+{
+    if (stats_hash)
+        g_hash_table_destroy(stats_hash);
+}
+
+/* Dbus interface support */
+
+static int build_sys_request_list(GVariantBuilder *builder,
+                                  struct client_stats *client)
+{
+    const char *dbus_name = client->dbus_name;
+    GSList *cur;
+    guint64 us;
+    int count = 0;
+
+    us = get_usecs();
+    for (cur = client->sys_stats; cur; cur = g_slist_next(cur)) {
+        struct sys_request_stats *stats = cur->data;
+        guint64 active_time, max_active_time;
+       
+        /*
+         * Aggregate currently held requests into active_time, and
+         * consider whether this is greater than the current
+         * max_active_time.
+         */
+        active_time = stats->active_time;
+        max_active_time = stats->max_active_time;
+        if (stats->active_since != 0) {
+            guint64 duration = us - stats->active_since;
+            active_time += duration;
+            if (duration > max_active_time)
+                max_active_time = duration;
+        }
+        g_variant_builder_add(builder, "(ssuttt)", dbus_name, stats->name,
+                              stats->active_count, active_time,
+                              max_active_time, stats->active_since);
+        count++;
+    }
+    return count;
+}
+
+gboolean handle_get_sys_request_stats(PowerdSource *obj,
+                                      GDBusMethodInvocation *invocation)
+{
+    GVariantBuilder *builder;
+    GVariant *list, *tuple;
+    GHashTableIter iter;
+    gpointer key, value;
+    int count = 0;
+
+    builder = g_variant_builder_new(G_VARIANT_TYPE("a(ssuttt)"));
+    if (stats_hash) {
+        g_hash_table_iter_init(&iter, stats_hash);
+        while (g_hash_table_iter_next(&iter, &key, &value))
+            count += build_sys_request_list(builder, value);
+    }
+
+    if (count == 0) {
+        g_variant_builder_clear(builder);
+        list = g_variant_new_array(G_VARIANT_TYPE("a(ssuttt)"), NULL, 0);
+    } else {
+        list = g_variant_builder_end(builder);
+    }
+    tuple = g_variant_new_tuple(&list, 1);
+    g_dbus_method_invocation_return_value(invocation, tuple);
+    g_variant_builder_unref(builder);
+
+    return TRUE;
+}
+
+static int build_disp_request_list(GVariantBuilder *builder,
+                                   struct client_stats *client)
+{
+    const char *dbus_name = client->dbus_name;
+    GSList *cur;
+    guint64 us;
+    int count = 0;
+
+    us = get_usecs();
+    for (cur = client->disp_stats; cur; cur = g_slist_next(cur)) {
+        struct disp_request_stats *stats = cur->data;
+        guint64 active_time, max_active_time;
+        guint64 disp_on_time;
+        GVariantBuilder *fot_builder, *fos_builder;
+        int i;
+       
+        active_time = stats->active_time;
+        max_active_time = stats->max_active_time;
+        if (stats->active_since != 0) {
+            guint64 duration = us - stats->active_since;
+            active_time += duration;
+            if (duration > max_active_time)
+                max_active_time = duration;
+        }
+
+        disp_on_time = stats->disp_on_time;
+        if (stats->disp_on_since != 0)
+            disp_on_time += us - stats->disp_on_since;
+
+        fot_builder = g_variant_builder_new(G_VARIANT_TYPE("at"));
+        fos_builder = g_variant_builder_new(G_VARIANT_TYPE("at"));
+        for (i = 0; i < POWERD_NUM_DISPLAY_FLAGS; i++) {
+            guint64 flag_on_time = stats->flag_on_time[i];
+            if (stats->flag_on_since[i] != 0)
+                flag_on_time += us - stats->flag_on_since[i];
+            g_variant_builder_add(fot_builder, "t", flag_on_time);
+            g_variant_builder_add(fos_builder, "t", stats->flag_on_since[i]);
+        }
+        g_variant_builder_add(builder, "(ssutttttatat)", dbus_name,
+                              stats->name, stats->active_count, active_time,
+                              max_active_time, stats->active_since,
+                              disp_on_time, stats->disp_on_since,
+                              fot_builder, fos_builder);
+        g_variant_builder_unref(fot_builder);
+        g_variant_builder_unref(fos_builder);
+        count++;
+    }
+    return count;
+}
+
+gboolean handle_get_disp_request_stats(PowerdSource *obj,
+                                       GDBusMethodInvocation *invocation)
+{
+    GVariantBuilder *builder;
+    GVariant *list, *tuple;
+    GHashTableIter iter;
+    gpointer key, value;
+    int count = 0;
+
+    builder = g_variant_builder_new(G_VARIANT_TYPE("a(ssutttttatat)"));
+    if (stats_hash) {
+        g_hash_table_iter_init(&iter, stats_hash);
+        while (g_hash_table_iter_next(&iter, &key, &value))
+            count += build_disp_request_list(builder, value);
+    }
+
+    if (count == 0) {
+        g_variant_builder_clear(builder);
+        list = g_variant_new_array(G_VARIANT_TYPE("a(ssutttttatat)"), NULL, 0);
+    } else {
+        list = g_variant_builder_end(builder);
+    }
+    tuple = g_variant_new_tuple(&list, 1);
+    g_dbus_method_invocation_return_value(invocation, tuple);
+    g_variant_builder_unref(builder);
+
+    return TRUE;
+}