ofp-util: Work on decoding OF1.1 flow_mods.
[openvswitch] / vswitchd / system-stats.c
index 11b2fbedbeb700af8d83588628942a4ba1ffdac1..e0937a3931b5570326e5fcd2e9bb99e55faa689c 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (c) 2010 Nicira Networks
+/* Copyright (c) 2010, 2012 Nicira, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,6 +15,8 @@
 
 #include <config.h>
 
+#include "system-stats.h"
+
 #include <assert.h>
 #include <ctype.h>
 #include <dirent.h>
@@ -22,7 +24,6 @@
 #if HAVE_MNTENT_H
 #include <mntent.h>
 #endif
-#include <signal.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include "daemon.h"
 #include "dirs.h"
 #include "dynamic-string.h"
+#include "json.h"
+#include "ofpbuf.h"
+#include "poll-loop.h"
 #include "shash.h"
-#include "system-stats.h"
+#include "smap.h"
 #include "timeval.h"
 #include "vlog.h"
+#include "worker.h"
 
-VLOG_DEFINE_THIS_MODULE(system_stats)
+VLOG_DEFINE_THIS_MODULE(system_stats);
 
 /* #ifdefs make it a pain to maintain code: you have to try to build both ways.
  * Thus, this file tries to compile as much of the code as possible regardless
@@ -53,24 +58,23 @@ VLOG_DEFINE_THIS_MODULE(system_stats)
 #endif
 
 static void
-get_cpu_cores(struct shash *stats)
+get_cpu_cores(struct smap *stats)
 {
     long int n_cores = sysconf(_SC_NPROCESSORS_ONLN);
     if (n_cores > 0) {
-        shash_add(stats, "cpu", xasprintf("%ld", n_cores));
+        smap_add_format(stats, "cpu", "%ld", n_cores);
     }
 }
 
 static void
-get_load_average(struct shash *stats OVS_UNUSED)
+get_load_average(struct smap *stats OVS_UNUSED)
 {
 #if HAVE_GETLOADAVG
     double loadavg[3];
 
     if (getloadavg(loadavg, 3) == 3) {
-        shash_add(stats, "load_average",
-                  xasprintf("%.2f,%.2f,%.2f",
-                            loadavg[0], loadavg[1], loadavg[2]));
+        smap_add_format(stats, "load_average", "%.2f,%.2f,%.2f",
+                        loadavg[0], loadavg[1], loadavg[2]);
     }
 #endif
 }
@@ -91,12 +95,16 @@ get_page_size(void)
 }
 
 static void
-get_memory_stats(struct shash *stats)
+get_memory_stats(struct smap *stats)
 {
     if (!LINUX) {
         unsigned int pagesize = get_page_size();
         long int phys_pages = sysconf(_SC_PHYS_PAGES);
+#ifdef _SC_AVPHYS_PAGES
         long int avphys_pages = sysconf(_SC_AVPHYS_PAGES);
+#else
+        long int avphys_pages = 0;
+#endif
         int mem_total, mem_used;
 
         if (pagesize <= 0 || phys_pages <= 0 || avphys_pages <= 0) {
@@ -105,7 +113,7 @@ get_memory_stats(struct shash *stats)
 
         mem_total = phys_pages * (pagesize / 1024);
         mem_used = (phys_pages - avphys_pages) * (pagesize / 1024);
-        shash_add(stats, "memory", xasprintf("%d,%d", mem_total, mem_used));
+        smap_add_format(stats, "memory", "%d,%d", mem_total, mem_used);
     } else {
         static const char file_name[] = "/proc/meminfo";
         int mem_used, mem_cache, swap_used;
@@ -149,9 +157,8 @@ get_memory_stats(struct shash *stats)
         mem_used = mem_total - mem_free;
         mem_cache = buffers + cached;
         swap_used = swap_total - swap_free;
-        shash_add(stats, "memory",
-                  xasprintf("%d,%d,%d,%d,%d", mem_total, mem_used, mem_cache,
-                            swap_total, swap_used));
+        smap_add_format(stats, "memory", "%d,%d,%d,%d,%d",
+                        mem_total, mem_used, mem_cache, swap_total, swap_used);
     }
 }
 
@@ -382,22 +389,22 @@ get_process_info(pid_t pid, struct process_info *pinfo)
 }
 
 static void
-get_process_stats(struct shash *stats)
+get_process_stats(struct smap *stats)
 {
     struct dirent *de;
     DIR *dir;
 
-    dir = opendir(ovs_rundir);
+    dir = opendir(ovs_rundir());
     if (!dir) {
-        VLOG_ERR_ONCE("%s: open failed (%s)", ovs_rundir, strerror(errno));
+        VLOG_ERR_ONCE("%s: open failed (%s)", ovs_rundir(), strerror(errno));
         return;
     }
 
     while ((de = readdir(dir)) != NULL) {
         struct process_info pinfo;
-        char *key, *value;
         char *file_name;
         char *extension;
+        char *key;
         pid_t pid;
 
 #ifdef _DIRENT_HAVE_D_TYPE
@@ -411,36 +418,32 @@ get_process_stats(struct shash *stats)
             continue;
         }
 
-        file_name = xasprintf("%s/%s", ovs_rundir, de->d_name);
+        file_name = xasprintf("%s/%s", ovs_rundir(), de->d_name);
         pid = read_pidfile(file_name);
         free(file_name);
-        if (pid < 0 || kill(pid, 0)) {
+        if (pid < 0) {
             continue;
         }
 
         key = xasprintf("process_%.*s",
                         (int) (extension - de->d_name), de->d_name);
-        if (shash_find(stats, key)) {
-            free(key);
-            continue;
-        }
-
-        if (LINUX && get_process_info(pid, &pinfo)) {
-            value = xasprintf("%lu,%lu,%lld,%d,%lld,%lld",
-                              pinfo.vsz, pinfo.rss, pinfo.cputime,
-                              pinfo.crashes, pinfo.booted, pinfo.uptime);
-        } else {
-            value = xstrdup("");
+        if (!smap_get(stats, key)) {
+            if (LINUX && get_process_info(pid, &pinfo)) {
+                smap_add_format(stats, key, "%lu,%lu,%lld,%d,%lld,%lld",
+                                pinfo.vsz, pinfo.rss, pinfo.cputime,
+                                pinfo.crashes, pinfo.booted, pinfo.uptime);
+            } else {
+                smap_add(stats, key, "");
+            }
         }
-
-        shash_add_nocopy(stats, key, value);
+        free(key);
     }
 
     closedir(dir);
 }
 
 static void
-get_filesys_stats(struct shash *stats OVS_UNUSED)
+get_filesys_stats(struct smap *stats OVS_UNUSED)
 {
 #if HAVE_SETMNTENT && HAVE_STATVFS
     static const char file_name[] = "/etc/mtab";
@@ -486,18 +489,160 @@ get_filesys_stats(struct shash *stats OVS_UNUSED)
     endmntent(stream);
 
     if (s.length) {
-        shash_add(stats, "file_systems", ds_steal_cstr(&s));
+        smap_add(stats, "file_systems", ds_cstr(&s));
     }
     ds_destroy(&s);
 #endif  /* HAVE_SETMNTENT && HAVE_STATVFS */
 }
+\f
+#define SYSTEM_STATS_INTERVAL (5 * 1000) /* In milliseconds. */
+
+/* Whether the client wants us to report system stats. */
+static bool enabled;
+
+static enum {
+    S_DISABLED,                 /* Not enabled, nothing going on. */
+    S_WAITING,                  /* Sleeping for SYSTEM_STATS_INTERVAL ms. */
+    S_REQUEST_SENT,             /* Sent a request to worker. */
+    S_REPLY_RECEIVED            /* Received a reply from worker. */
+} state;
+
+/* In S_WAITING state: the next time to wake up.
+ * In other states: not meaningful. */
+static long long int next_refresh;
+
+/* In S_REPLY_RECEIVED: the stats that have just been received.
+ * In other states: not meaningful. */
+static struct smap *received_stats;
+
+static worker_request_func system_stats_request_cb;
+static worker_reply_func system_stats_reply_cb;
+
+/* Enables or disables system stats collection, according to 'new_enable'.
+ *
+ * Even if system stats are disabled, the caller should still periodically call
+ * system_stats_run(). */
+void
+system_stats_enable(bool new_enable)
+{
+    if (new_enable != enabled) {
+        if (new_enable) {
+            if (state == S_DISABLED) {
+                state = S_WAITING;
+                next_refresh = time_msec();
+            }
+        } else {
+            if (state == S_WAITING) {
+                state = S_DISABLED;
+            }
+        }
+        enabled = new_enable;
+    }
+}
+
+/* Tries to obtain a new snapshot of system stats every SYSTEM_STATS_INTERVAL
+ * milliseconds.
+ *
+ * When a new snapshot is available (which only occurs if system stats are
+ * enabled), returns it as an smap owned by the caller.  The caller must use
+ * both smap_destroy() and free() to complete free the returned data.
+ *
+ * When no new snapshot is available, returns NULL. */
+struct smap *
+system_stats_run(void)
+{
+    switch (state) {
+    case S_DISABLED:
+        break;
+
+    case S_WAITING:
+        if (time_msec() >= next_refresh) {
+            worker_request(NULL, 0, NULL, 0, system_stats_request_cb,
+                           system_stats_reply_cb, NULL);
+            state = S_REQUEST_SENT;
+        }
+        break;
+
+    case S_REQUEST_SENT:
+        break;
+
+    case S_REPLY_RECEIVED:
+        if (enabled) {
+            state = S_WAITING;
+            next_refresh = time_msec() + SYSTEM_STATS_INTERVAL;
+            return received_stats;
+        } else {
+            smap_destroy(received_stats);
+            free(received_stats);
+            state = S_DISABLED;
+        }
+        break;
+    }
+
+    return NULL;
+}
 
+/* Causes poll_block() to wake up when system_stats_run() needs to be
+ * called. */
 void
-get_system_stats(struct shash *stats)
+system_stats_wait(void)
 {
-    get_cpu_cores(stats);
-    get_load_average(stats);
-    get_memory_stats(stats);
-    get_process_stats(stats);
-    get_filesys_stats(stats);
+    switch (state) {
+    case S_DISABLED:
+        break;
+
+    case S_WAITING:
+        poll_timer_wait_until(next_refresh);
+        break;
+
+    case S_REQUEST_SENT:
+        /* Someone else should be calling worker_wait() to wake up when the
+         * reply arrives, otherwise there's a bug. */
+        break;
+
+    case S_REPLY_RECEIVED:
+        poll_immediate_wake();
+        break;
+    }
+}
+
+static void
+system_stats_request_cb(struct ofpbuf *request OVS_UNUSED,
+                        const int fds[] OVS_UNUSED, size_t n_fds OVS_UNUSED)
+{
+    struct smap stats;
+    struct json *json;
+    char *s;
+
+    smap_init(&stats);
+    get_cpu_cores(&stats);
+    get_load_average(&stats);
+    get_memory_stats(&stats);
+    get_process_stats(&stats);
+    get_filesys_stats(&stats);
+
+    json = smap_to_json(&stats);
+    s = json_to_string(json, 0);
+    worker_reply(s, strlen(s) + 1, NULL, 0);
+
+    free(s);
+    json_destroy(json);
+    smap_destroy(&stats);
+}
+
+static void
+system_stats_reply_cb(struct ofpbuf *reply,
+                      const int fds[] OVS_UNUSED, size_t n_fds OVS_UNUSED,
+                      void *aux OVS_UNUSED)
+{
+    struct json *json = json_from_string(reply->data);
+
+    received_stats = xmalloc(sizeof *received_stats);
+    smap_init(received_stats);
+    smap_from_json(received_stats, json);
+
+    assert(state == S_REQUEST_SENT);
+    state = S_REPLY_RECEIVED;
+
+    json_destroy(json);
 }