Collect some disk statistics.

metrics_daemon.cc

 // Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "metrics_daemon.h"
 
+#include <fcntl.h>
 #include <string.h>
 
 #include <base/file_util.h>
 #include <base/logging.h>
 #include <dbus/dbus-glib-lowlevel.h>
 
 #include "counter.h"
 
 using base::Time;
 using base::TimeDelta;
@@ skipping 60 matching lines @@
 const char MetricsDaemon::kMetricUncleanShutdownsWeeklyName[] =
     "Logging.UncleanShutdownsWeekly";
 const char MetricsDaemon::kMetricUserCrashesDailyName[] =
     "Logging.UserCrashesDaily";
 const char MetricsDaemon::kMetricUserCrashesWeeklyName[] =
     "Logging.UserCrashesWeekly";
 const char MetricsDaemon::kMetricCrashFrequencyMin = 1;
 const char MetricsDaemon::kMetricCrashFrequencyMax = 100;
 const char MetricsDaemon::kMetricCrashFrequencyBuckets = 50;
 
+// disk stats metrics
+
+// The {Read,Write}Sectors numbers are in sectors/second.
+// A sector is usually 512 bytes.
+
+const char MetricsDaemon::kMetricReadSectorsLongName[] =
+    "Filesystem.ReadSectorsLong";
+const char MetricsDaemon::kMetricWriteSectorsLongName[] =
+    "Filesystem.WriteSectorsLong";
+const char MetricsDaemon::kMetricReadSectorsShortName[] =
+    "Filesystem.ReadSectorsShort";
+const char MetricsDaemon::kMetricWriteSectorsShortName[] =
+    "Filesystem.WriteSectorsShort";
+
+const int MetricsDaemon::kMetricDiskStatsShortInterval = 1;  // seconds
+const int MetricsDaemon::kMetricDiskStatsLongInterval = 30;  // seconds
+
+// Assume a max rate of 250Mb/s for reads (worse for writes) and 512 byte
+// sectors.
+const int MetricsDaemon::kMetricSectorsIOMax = 500000;  // sectors/second
+const int MetricsDaemon::kMetricSectorsBuckets = 50;    // buckets
+
 // persistent metrics path
 const char MetricsDaemon::kMetricsPath[] = "/var/log/metrics";
 
 
 // static
 const char* MetricsDaemon::kDBusMatches_[] = {
   "type='signal',"
   "interface='" DBUS_IFACE_CRASH_REPORTER "',"
   "path='/',"
   "member='UserCrash'",
@@ skipping 14 matching lines @@
 #define STATE(name, capname) #name,
 #include "power_states.h"
 };
 
 // static
 const char* MetricsDaemon::kSessionStates_[] = {
 #define STATE(name, capname) #name,
 #include "session_states.h"
 };
 
 MetricsDaemon::MetricsDaemon()

[petkov, 2011/02/14 23:39:16]

initialize diskstats_path_ to NULL here.

[Luigi Semenzato, 2011/02/15 17:45:47]

Thanks.

     : power_state_(kUnknownPowerState),
       session_state_(kUnknownSessionState),
       user_active_(false),
       usemon_interval_(0),
       usemon_source_(NULL) {}
 
 MetricsDaemon::~MetricsDaemon() {
   DeleteFrequencyCounters();
 }
 
@@ skipping 51 matching lines @@
   time_t cycle_duration = strstr(histogram_name, "Weekly") != NULL ?
       chromeos_metrics::kSecondsPerWeek :
       chromeos_metrics::kSecondsPerDay;
   new_counter->Init(
       static_cast<chromeos_metrics::TaggedCounterInterface*>(
           reporter.release()),
       cycle_duration);
   frequency_counters_[histogram_name] = new_counter.release();
 }
 
-void MetricsDaemon::Init(bool testing, MetricsLibraryInterface* metrics_lib) {
+void MetricsDaemon::Init(bool testing, MetricsLibraryInterface* metrics_lib,
+                         const char* diskstats_path) {
   testing_ = testing;
   DCHECK(metrics_lib != NULL);
   metrics_lib_ = metrics_lib;
   chromeos_metrics::TaggedCounterReporter::
       SetMetricsLibraryInterface(metrics_lib);
 
   static const char kDailyUseRecordFile[] = "/var/log/metrics/daily-usage";
   daily_use_.reset(new chromeos_metrics::TaggedCounter());
   daily_use_->Init(kDailyUseRecordFile, &ReportDailyUse, this);
 
   ConfigureCrashIntervalReporter(kMetricKernelCrashIntervalName,
                                  &kernel_crash_interval_);
   ConfigureCrashIntervalReporter(kMetricUncleanShutdownIntervalName,
                                  &unclean_shutdown_interval_);
   ConfigureCrashIntervalReporter(kMetricUserCrashIntervalName,
                                  &user_crash_interval_);
 
   DeleteFrequencyCounters();
   ConfigureCrashFrequencyReporter(kMetricAnyCrashesDailyName);
   ConfigureCrashFrequencyReporter(kMetricAnyCrashesWeeklyName);
   ConfigureCrashFrequencyReporter(kMetricKernelCrashesDailyName);
   ConfigureCrashFrequencyReporter(kMetricKernelCrashesWeeklyName);
   ConfigureCrashFrequencyReporter(kMetricUncleanShutdownsDailyName);
   ConfigureCrashFrequencyReporter(kMetricUncleanShutdownsWeeklyName);
   ConfigureCrashFrequencyReporter(kMetricUserCrashesDailyName);
   ConfigureCrashFrequencyReporter(kMetricUserCrashesWeeklyName);
 
+  diskstats_path_ = diskstats_path;
+  DiskStatsReporterInit();
+
   // Don't setup D-Bus and GLib in test mode.
   if (testing)
     return;
 
   g_thread_init(NULL);
   g_type_init();
   dbus_g_thread_init();
 
   DBusError error;
   dbus_error_init(&error);
@@ skipping 256 matching lines @@
   // If there's a use monitor scheduled already, destroys it.
   if (usemon_source_ == NULL)
     return;
 
   DLOG(INFO) << "destroying use monitor";
   g_source_destroy(usemon_source_);
   usemon_source_ = NULL;
   usemon_interval_ = 0;
 }
 
+void MetricsDaemon::DiskStatsReporterInit() {
+  DiskStatsReadStats(&read_sectors_, &write_sectors_);
+  // The first time around just run the long stat, so we don't delay boot.
+  diskstats_state_ = kDiskStatsLong;
+  ScheduleDiskStatsCallback(kMetricDiskStatsLongInterval);
+}
+
+void MetricsDaemon::ScheduleDiskStatsCallback(int wait) {
+  if (testing_) {
+    return;
+  }
+  g_timeout_add_seconds(wait, DiskStatsCallbackStatic, this);
+}
+
+void MetricsDaemon::DiskStatsReadStats(long int* read_sectors,
+                                       long int* write_sectors) {
+  int nchars;
+  int nitems;
+  char line[200];
+  int file = HANDLE_EINTR(open(diskstats_path_, O_RDONLY));
+  if (file < 0) {
+    PLOG(WARNING) << "cannot open " << diskstats_path_;
+    return;
+  }
+  nchars = HANDLE_EINTR(read(file, line, sizeof(line)));
+  if (nchars < 0) {
+    PLOG(WARNING) << "cannot read from " << diskstats_path_;
+  } else {
+    LOG_IF(WARNING, nchars == sizeof(line)) << "line too long in "
+                                            << diskstats_path_;
+    line[nchars] = '\0';
+    nitems = sscanf(line, "%*d %*d %ld %*d %*d %*d %ld",
+                    read_sectors, write_sectors);
+    LOG_IF(WARNING, nitems != 2) << "found " << nitems << " items in "
+                                 << diskstats_path_ << ", expected 2";
+  }
+  HANDLE_EINTR(close(file));
+}
+
+// static
+gboolean MetricsDaemon::DiskStatsCallbackStatic(void* handle) {
+  (static_cast<MetricsDaemon*>(handle))->DiskStatsCallback();
+  return false;  // one-time callback
+}
+
+void MetricsDaemon::DiskStatsCallback() {
+  long int read_sectors_now, write_sectors_now;
+  DiskStatsReadStats(&read_sectors_now, &write_sectors_now);
+
+  switch (diskstats_state_) {
+    case kDiskStatsShort:
+      SendMetric(kMetricReadSectorsShortName,
+                 (int) (read_sectors_now - read_sectors_) /
+                 kMetricDiskStatsShortInterval,
+                 0,

[petkov, 2011/02/14 23:39:16]

did you double check that it's OK for this to be 0 rather than 1?

[Luigi Semenzato, 2011/02/15 17:45:47]

No, it should be 1.  Fixing.

+                 kMetricSectorsIOMax,
+                 kMetricSectorsBuckets);
+      SendMetric(kMetricWriteSectorsShortName,
+                 (int) (write_sectors_now - write_sectors_) /
+                 kMetricDiskStatsShortInterval,
+                 0,
+                 kMetricSectorsIOMax,
+                 kMetricSectorsBuckets);
+      // Schedule long callback.
+      diskstats_state_ = kDiskStatsLong;
+      ScheduleDiskStatsCallback(kMetricDiskStatsLongInterval -
+                                kMetricDiskStatsShortInterval);
+      break;
+    case kDiskStatsLong:
+      SendMetric(kMetricReadSectorsLongName,
+                 (int) (read_sectors_now - read_sectors_) /
+                 kMetricDiskStatsLongInterval,
+                 1,
+                 kMetricSectorsIOMax,
+                 kMetricSectorsBuckets);
+      SendMetric(kMetricWriteSectorsLongName,
+                 (int) (write_sectors_now - write_sectors_) /
+                 kMetricDiskStatsLongInterval,
+                 1,
+                 kMetricSectorsIOMax,
+                 kMetricSectorsBuckets);
+      // Reset sector counters
+      read_sectors_ = read_sectors_now;
+      write_sectors_ = write_sectors_now;
+      // Schedule short callback.
+      diskstats_state_ = kDiskStatsShort;
+      ScheduleDiskStatsCallback(kMetricDiskStatsShortInterval);
+      break;
+    default:
+      LOG(FATAL) << "Invalid disk stats state";
+  }
+}
+
 // static
 void MetricsDaemon::ReportDailyUse(void* handle, int tag, int count) {
   if (count <= 0)
     return;
 
   MetricsDaemon* daemon = static_cast<MetricsDaemon*>(handle);
   int minutes = (count + kSecondsPerMinute / 2) / kSecondsPerMinute;
   daemon->SendMetric(kMetricDailyUseTimeName, minutes,
                      kMetricDailyUseTimeMin,
                      kMetricDailyUseTimeMax,
                      kMetricDailyUseTimeBuckets);
 }
 
 void MetricsDaemon::SendMetric(const string& name, int sample,
                                int min, int max, int nbuckets) {
   DLOG(INFO) << "received metric: " << name << " " << sample << " "
              << min << " " << max << " " << nbuckets;
   metrics_lib_->SendToUMA(name, sample, min, max, nbuckets);
 }