Merge remote-tracking branch 'gh/wip-stats' into next

Reviewed-by: Samuel Just <sam.just@inktank.com>

3 files changed, 79 insertions, 24 deletions

diff --git a/src/mon/PGMap.cc b/src/mon/PGMap.cc
index ebdf582ff23..8b37376ba7a 100644
--- a/src/mon/PGMap.cc
+++ b/src/mon/PGMap.cc
@@ -728,23 +728,29 @@ void PGMap::recovery_summary(Formatter *f, ostream *out) const
     }
     first = false;
   }
-  if (pg_sum_delta.stats.sum.num_objects_recovered ||
-      pg_sum_delta.stats.sum.num_bytes_recovered ||
-      pg_sum_delta.stats.sum.num_keys_recovered) {
-    uint64_t objps = pg_sum_delta.stats.sum.num_objects_recovered / (double)stamp_delta;
-    uint64_t bps = pg_sum_delta.stats.sum.num_bytes_recovered / (double)stamp_delta;
-    uint64_t kps = pg_sum_delta.stats.sum.num_keys_recovered / (double)stamp_delta;
+
+  // make non-negative; we can get negative values if osds send
+  // uncommitted stats and then "go backward" or if they are just
+  // buggy/wrong.
+  pool_stat_t pos_delta = pg_sum_delta;
+  pos_delta.floor(0);
+  if (pos_delta.stats.sum.num_objects_recovered ||
+      pos_delta.stats.sum.num_bytes_recovered ||
+      pos_delta.stats.sum.num_keys_recovered) {
+    int64_t objps = pos_delta.stats.sum.num_objects_recovered / (double)stamp_delta;
+    int64_t bps = pos_delta.stats.sum.num_bytes_recovered / (double)stamp_delta;
+    int64_t kps = pos_delta.stats.sum.num_keys_recovered / (double)stamp_delta;
     if (f) {
-      f->dump_unsigned("recovering_objects_per_sec", objps);
-      f->dump_unsigned("recovering_bytes_per_sec", bps);
-      f->dump_unsigned("recovering_keys_per_sec", kps);
+      f->dump_int("recovering_objects_per_sec", objps);
+      f->dump_int("recovering_bytes_per_sec", bps);
+      f->dump_int("recovering_keys_per_sec", kps);
     } else {
       if (!first)
 	*out << "; ";
       *out << " recovering "
 	   << si_t(objps) << " o/s, "
 	   << si_t(bps) << "B/s";
-      if (pg_sum_delta.stats.sum.num_keys_recovered)
+      if (pos_delta.stats.sum.num_keys_recovered)
 	*out << ", " << si_t(kps) << " key/s";
     }
   }
@@ -815,29 +821,34 @@ void PGMap::print_summary(Formatter *f, ostream *out) const
 	 << kb_t(osd_sum.kb) << " avail";
   }
 
-  if (pg_sum_delta.stats.sum.num_rd ||
-      pg_sum_delta.stats.sum.num_wr) {
+  // make non-negative; we can get negative values if osds send
+  // uncommitted stats and then "go backward" or if they are just
+  // buggy/wrong.
+  pool_stat_t pos_delta = pg_sum_delta;
+  pos_delta.floor(0);
+  if (pos_delta.stats.sum.num_rd ||
+      pos_delta.stats.sum.num_wr) {
     if (!f)
       *out << "; ";
-    if (pg_sum_delta.stats.sum.num_rd) {
-      uint64_t rd = (pg_sum_delta.stats.sum.num_rd_kb << 10) / (double)stamp_delta;
+    if (pos_delta.stats.sum.num_rd) {
+      int64_t rd = (pos_delta.stats.sum.num_rd_kb << 10) / (double)stamp_delta;
       if (f) {
-	f->dump_unsigned("read_bytes_sec", rd);
+	f->dump_int("read_bytes_sec", rd);
       } else {
 	*out << si_t(rd) << "B/s rd, ";
       }
     }
-    if (pg_sum_delta.stats.sum.num_wr) {
-      uint64_t wr = (pg_sum_delta.stats.sum.num_wr_kb << 10) / (double)stamp_delta;
+    if (pos_delta.stats.sum.num_wr) {
+      int64_t wr = (pos_delta.stats.sum.num_wr_kb << 10) / (double)stamp_delta;
       if (f) {
-	f->dump_unsigned("write_bytes_sec", wr);
+	f->dump_int("write_bytes_sec", wr);
       } else {
 	*out << si_t(wr) << "B/s wr, ";
       }
     }
-    uint64_t iops = (pg_sum_delta.stats.sum.num_rd + pg_sum_delta.stats.sum.num_wr) / (double)stamp_delta;
+    int64_t iops = (pos_delta.stats.sum.num_rd + pos_delta.stats.sum.num_wr) / (double)stamp_delta;
     if (f) {
-      f->dump_unsigned("op_per_sec", iops);
+      f->dump_int("op_per_sec", iops);
     } else {
       *out << si_t(iops) << "op/s";
     }
diff --git a/src/osd/osd_types.cc b/src/osd/osd_types.cc
index fa3b7ecc45d..02c1ef7b69d 100644
--- a/src/osd/osd_types.cc
+++ b/src/osd/osd_types.cc
@@ -1351,8 +1351,8 @@ void pg_stat_t::generate_test_instances(list<pg_stat_t*>& o)
 void pool_stat_t::dump(Formatter *f) const
 {
   stats.dump(f);
-  f->dump_unsigned("log_size", log_size);
-  f->dump_unsigned("ondisk_log_size", ondisk_log_size);
+  f->dump_int("log_size", log_size);
+  f->dump_int("ondisk_log_size", ondisk_log_size);
 }
 
 void pool_stat_t::encode(bufferlist &bl, uint64_t features) const
diff --git a/src/osd/osd_types.h b/src/osd/osd_types.h
index ff6d70fa69a..3a6db4d8315 100644
--- a/src/osd/osd_types.h
+++ b/src/osd/osd_types.h
@@ -888,6 +888,28 @@ struct object_stat_sum_t {
       num_keys_recovered(0)
   {}
 
+  void floor(int64_t f) {
+#define FLOOR(x) if (x < f) x = f
+    FLOOR(num_bytes);
+    FLOOR(num_objects);
+    FLOOR(num_object_clones);
+    FLOOR(num_object_copies);
+    FLOOR(num_objects_missing_on_primary);
+    FLOOR(num_objects_degraded);
+    FLOOR(num_objects_unfound);
+    FLOOR(num_rd);
+    FLOOR(num_rd_kb);
+    FLOOR(num_wr);
+    FLOOR(num_wr_kb);
+    FLOOR(num_scrub_errors);
+    FLOOR(num_shallow_scrub_errors);
+    FLOOR(num_deep_scrub_errors);
+    FLOOR(num_objects_recovered);
+    FLOOR(num_bytes_recovered);
+    FLOOR(num_keys_recovered);
+#undef FLOOR
+  }
+
   void clear() {
     memset(this, 0, sizeof(*this));
   }
@@ -940,6 +962,12 @@ struct object_stat_collection_t {
     cat_sum.clear();
   }
 
+  void floor(int64_t f) {
+    sum.floor(f);
+    for (map<string,object_stat_sum_t>::iterator p = cat_sum.begin(); p != cat_sum.end(); ++p)
+      p->second.floor(f);
+  }
+
   void add(const object_stat_sum_t& o, const string& cat) {
     sum.add(o);
     if (cat.length())
@@ -1031,6 +1059,14 @@ struct pg_stat_t {
     return make_pair(reported_epoch, reported_seq);
   }
 
+  void floor(int64_t f) {
+    stats.floor(f);
+    if (log_size < f)
+      log_size = f;
+    if (ondisk_log_size < f)
+      ondisk_log_size = f;
+  }
+
   void add(const pg_stat_t& o) {
     stats.add(o.stats);
     log_size += o.log_size;
@@ -1054,12 +1090,20 @@ WRITE_CLASS_ENCODER(pg_stat_t)
  */
 struct pool_stat_t {
   object_stat_collection_t stats;
-  uint64_t log_size;
-  uint64_t ondisk_log_size;    // >= active_log_size
+  int64_t log_size;
+  int64_t ondisk_log_size;    // >= active_log_size
 
   pool_stat_t() : log_size(0), ondisk_log_size(0)
   { }
 
+  void floor(int64_t f) {
+    stats.floor(f);
+    if (log_size < f)
+      log_size = f;
+    if (ondisk_log_size < f)
+      ondisk_log_size = f;
+  }
+
   void add(const pg_stat_t& o) {
     stats.add(o.stats);
     log_size += o.log_size;