Collect some disk statistics.

metrics_daemon.h

 // 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.
 
 #ifndef METRICS_DAEMON_H_
 #define METRICS_DAEMON_H_
 
 #include <dbus/dbus.h>
 #include <glib.h>
 #include <map>
@@ skipping 12 matching lines @@
 }
 
 class MetricsDaemon {
 
  public:
   MetricsDaemon();
   ~MetricsDaemon();
 
   // Initializes.
   void Init(bool testing, MetricsLibraryInterface* metrics_lib);
+  void Init(bool testing, MetricsLibraryInterface* metrics_lib,

[petkov, 2011/02/14 19:28:33]

Again -- no overloading.

[Luigi Semenzato, 2011/02/14 23:24:17]

Sorry.  Caffeine underdose.

+            const char* diskstats_path);  // for testing
 
   // Does all the work. If |run_as_daemon| is true, daemonizes by
   // forking.
   void Run(bool run_as_daemon);
 
  private:
   friend class MetricsDaemonTest;
   FRIEND_TEST(MetricsDaemonTest, CheckSystemCrash);
   FRIEND_TEST(MetricsDaemonTest, ComputeEpochNoCurrent);
   FRIEND_TEST(MetricsDaemonTest, ComputeEpochNoLast);
   FRIEND_TEST(MetricsDaemonTest, GetHistogramPath);
   FRIEND_TEST(MetricsDaemonTest, IsNewEpoch);
   FRIEND_TEST(MetricsDaemonTest, LookupPowerState);
   FRIEND_TEST(MetricsDaemonTest, LookupScreenSaverState);
   FRIEND_TEST(MetricsDaemonTest, LookupSessionState);
   FRIEND_TEST(MetricsDaemonTest, MessageFilter);
   FRIEND_TEST(MetricsDaemonTest, PowerStateChanged);
   FRIEND_TEST(MetricsDaemonTest, ProcessKernelCrash);
   FRIEND_TEST(MetricsDaemonTest, ProcessUncleanShutdown);
   FRIEND_TEST(MetricsDaemonTest, ProcessUserCrash);
   FRIEND_TEST(MetricsDaemonTest, ReportCrashesDailyFrequency);
   FRIEND_TEST(MetricsDaemonTest, ReportDailyUse);
+  FRIEND_TEST(MetricsDaemonTest, ReportDiskStats);
   FRIEND_TEST(MetricsDaemonTest, ReportKernelCrashInterval);
   FRIEND_TEST(MetricsDaemonTest, ReportUncleanShutdownInterval);
   FRIEND_TEST(MetricsDaemonTest, ReportUserCrashInterval);
   FRIEND_TEST(MetricsDaemonTest, ScreenSaverStateChanged);
   FRIEND_TEST(MetricsDaemonTest, SendMetric);
   FRIEND_TEST(MetricsDaemonTest, SessionStateChanged);
   FRIEND_TEST(MetricsDaemonTest, SetUserActiveState);
   FRIEND_TEST(MetricsDaemonTest, SetUserActiveStateTimeJump);
 
   // The power states (see power_states.h).
   enum PowerState {
     kUnknownPowerState = -1, // Initial/unknown power state.
 #define STATE(name, capname) kPowerState ## capname,
 #include "power_states.h"
     kNumberPowerStates
   };
 
   // The user session states (see session_states.h).
   enum SessionState {
     kUnknownSessionState = -1, // Initial/unknown user session state.
 #define STATE(name, capname) kSessionState ## capname,
 #include "session_states.h"
     kNumberSessionStates
   };
 
+  // State for disk stats collector callback.
+  enum DiskStatsState {
+    kDiskStatsShort,    // short wait before short interval collection
+    kDiskStatsLong,     // final wait before new collection
+  };
+
   // Data record for aggregating daily usage.
   class UseRecord {
    public:
     UseRecord() : day_(0), seconds_(0) {}
     int day_;
     int seconds_;
   };
 
   typedef std::map<std::string, chromeos_metrics::FrequencyCounter*>
     FrequencyCounters;
@@ skipping 14 matching lines @@
   static const char kMetricKernelCrashesDailyName[];
   static const char kMetricKernelCrashesWeeklyName[];
   static const char kMetricKernelCrashIntervalName[];
   static const char kMetricsPath[];
   static const char kMetricUncleanShutdownIntervalName[];
   static const char kMetricUncleanShutdownsDailyName[];
   static const char kMetricUncleanShutdownsWeeklyName[];
   static const char kMetricUserCrashesDailyName[];
   static const char kMetricUserCrashesWeeklyName[];
   static const char kMetricUserCrashIntervalName[];
+  static const char kMetricReadSectorsLongName[];
+  static const char kMetricReadSectorsShortName[];
+  static const char kMetricWriteSectorsLongName[];
+  static const char kMetricWriteSectorsShortName[];
+  static const int kMetricDiskStatsShortInterval;
+  static const int kMetricDiskStatsLongInterval;
+  static const int kMetricSectorsIOMax;
+  static const int kMetricSectorsBuckets;
+  static const char kMetricsDiskStatsPath[];
 
   // D-Bus message match strings.
   static const char* kDBusMatches_[];
 
   // Array of power states.
   static const char* kPowerStates_[kNumberPowerStates];
 
   // Array of user session states.
   static const char* kSessionStates_[kNumberSessionStates];
 
@@ skipping 86 matching lines @@
 
   // Report daily use through UMA.
   static void ReportDailyUse(void* handle, int tag, int count);
 
   // Sends a regular (exponential) histogram sample to Chrome for
   // transport to UMA. See MetricsLibrary::SendToUMA in
   // metrics_library.h for a description of the arguments.
   void SendMetric(const std::string& name, int sample,
                   int min, int max, int nbuckets);
 
+  // Initializes disk stats reporting.
+  void DiskStatsReporterInit();
+
+  // Schedules a callback for the next disk stats collection.
+  void ScheduleDiskStatsCallback(int wait);
+
+  // Reads cumulative disk statistics from sysfs.
+  void DiskStatsReadStats(long int* read_sectors, long int* write_sectors);
+
+  // Reports disk statistics (static version for glib).  Arguments are a glib
+  // artifact.
+  static gboolean DiskStatsCallbackStatic(void* handle);
+
+  // Reports disk statistics.
+  void DiskStatsCallback();
+
   // Test mode.
   bool testing_;
 
   // The metrics library handle.
   MetricsLibraryInterface* metrics_lib_;
 
   // Timestamps last network state update.  This timestamp is used to
   // sample the time from the network going online to going offline so
   // TimeTicks ensures a monotonically increasing TimeDelta.
   base::TimeTicks network_state_last_;
@@ skipping 28 matching lines @@
 
   // Map of all frequency counters, to simplify flushing them.
   FrequencyCounters frequency_counters_;
 
   // Sleep period until the next daily usage aggregation performed by
   // the daily use monitor (see ScheduleUseMonitor).
   int usemon_interval_;
 
   // Scheduled daily use monitor source (see ScheduleUseMonitor).
   GSource* usemon_source_;
+
+  // Contains the most recent disk stats.
+  long int read_sectors_;
+  long int write_sectors_;
+
+  DiskStatsState diskstats_state_;
+  const char* diskstats_path_;
 };
 
 #endif  // METRICS_DAEMON_H_