common/TrackedOp: make Tracker can dynamic control.

After osd/mds initating, the optracker can't set. For dynamic
control, we can set optracker enable or disable at any time.

Signed-off-by: Jianpeng Ma <jianpeng.ma@intel.com>

diff --git a/src/common/TrackedOp.cc b/src/common/TrackedOp.cc
index 5975017920eac33e8319ded00520d0b6b4216270..de53c2aee68e5b49b941aed2181a47b05aac271c 100644 (file)
--- a/src/common/TrackedOp.cc
+++ b/src/common/TrackedOp.cc
@@ -117,8 +117,8 @@ void OpTracker::dump_ops_in_flight(Formatter *f)
 
 void OpTracker::register_inflight_op(xlist<TrackedOp*>::item *i)
 {
-  if (!tracking_enabled)
-    return;
+  // caller checks;
+  assert(tracking_enabled);
 
   uint64_t current_seq = seq.inc();
   uint32_t shard_index = current_seq % num_optracker_shards;
@@ -134,7 +134,7 @@ void OpTracker::register_inflight_op(xlist<TrackedOp*>::item *i)
 void OpTracker::unregister_inflight_op(TrackedOp *i)
 {
   // caller checks;
-  assert(tracking_enabled);
+  assert(i->is_tracked);
 
   uint32_t shard_index = i->seq % num_optracker_shards;
   ShardedTrackingData* sdata = sharded_in_flight_list[shard_index];
@@ -145,12 +145,18 @@ void OpTracker::unregister_inflight_op(TrackedOp *i)
     i->xitem.remove_myself();
   }
   i->_unregistered();
-  utime_t now = ceph_clock_now(cct);
-  history.insert(now, TrackedOpRef(i));
+
+  if (!tracking_enabled)
+    delete i;
+  else {
+    utime_t now = ceph_clock_now(cct);
+    history.insert(now, TrackedOpRef(i));
+  }
 }
 
 bool OpTracker::check_ops_in_flight(std::vector<string> &warning_vector)
 {
+  RWLock::RLocker l(lock);
   if (!tracking_enabled)
     return false;
 
@@ -275,7 +281,7 @@ void OpTracker::get_age_ms_histogram(pow2_hist_t *h)
 
 void OpTracker::mark_event(TrackedOp *op, const string &dest, utime_t time)
 {
-  if (!tracking_enabled)
+  if (!op->is_tracked)
     return;
   return _mark_event(op, dest, time);
 }
@@ -293,7 +299,7 @@ void OpTracker::_mark_event(TrackedOp *op, const string &evt,
 }
 
 void OpTracker::RemoveOnDelete::operator()(TrackedOp *op) {
-  if (!tracker->tracking_enabled) {
+  if (!op->is_tracked) {
     op->_unregistered();
     delete op;
     return;
@@ -305,7 +311,7 @@ void OpTracker::RemoveOnDelete::operator()(TrackedOp *op) {
 
 void TrackedOp::mark_event(const string &event)
 {
-  if (!tracker->tracking_enabled)
+  if (!is_tracked)
     return;
 
   utime_t now = ceph_clock_now(g_ceph_context);

diff --git a/src/common/TrackedOp.h b/src/common/TrackedOp.h
index 2f656cacb97e4187915b2a39e463840f007f2ddf..89b990a8b410ffbe51e50dfff950dcda7a1061e0 100644 (file)
--- a/src/common/TrackedOp.h
+++ b/src/common/TrackedOp.h
@@ -21,6 +21,7 @@
 #include "include/xlist.h"
 #include "msg/Message.h"
 #include "include/memory.h"
+#include "common/RWLock.h"
 
 class TrackedOp;
 typedef ceph::shared_ptr<TrackedOp> TrackedOpRef;
@@ -77,10 +78,12 @@ class OpTracker {
 public:
   bool tracking_enabled;
   CephContext *cct;
+  RWLock       lock;
   OpTracker(CephContext *cct_, bool tracking, uint32_t num_shards) : seq(0), 
                                      num_optracker_shards(num_shards),
                                     complaint_time(0), log_threshold(0),
-                                    tracking_enabled(tracking), cct(cct_) {
+                                    tracking_enabled(tracking), cct(cct_),
+                                    lock("OpTracker::lock") {
 
     for (uint32_t i = 0; i < num_optracker_shards; i++) {
       char lock_name[32] = {0};
@@ -97,6 +100,10 @@ public:
   void set_history_size_and_duration(uint32_t new_size, uint32_t new_duration) {
     history.set_size_and_duration(new_size, new_duration);
   }
+  void set_tracking(bool enable) {
+    RWLock::WLocker l(lock);
+    tracking_enabled = enable;
+  }
   void dump_ops_in_flight(Formatter *f);
   void dump_historic_ops(Formatter *f);
   void register_inflight_op(xlist<TrackedOp*>::item *i);
@@ -151,18 +158,22 @@ protected:
   uint64_t seq; /// a unique value set by the OpTracker
 
   uint32_t warn_interval_multiplier; // limits output of a given op warning
-
+  bool is_tracked; //whether in tracker
   TrackedOp(OpTracker *_tracker, const utime_t& initiated) :
     xitem(this),
     tracker(_tracker),
     initiated_at(initiated),
     lock("TrackedOp::lock"),
     seq(0),
-    warn_interval_multiplier(1)
+    warn_interval_multiplier(1),
+    is_tracked(false)
   {
-    tracker->register_inflight_op(&xitem);
-    if (tracker->tracking_enabled)
+    RWLock::RLocker l(tracker->lock);
+    if (tracker->tracking_enabled) {
+      tracker->register_inflight_op(&xitem);
       events.push_back(make_pair(initiated_at, "initiated"));
+      is_tracked = true;
+    }
   }
 
   /// output any type-specific data you want to get when dump() is called

diff --git a/src/mds/MDSRank.cc b/src/mds/MDSRank.cc
index 8c04b2f3fde15f828c2c4c8d19104f756e8f51e8..84f6c966f35b5f0312369d602ed3637b8bab09dc 100644 (file)
--- a/src/mds/MDSRank.cc
+++ b/src/mds/MDSRank.cc
@@ -1632,12 +1632,14 @@ bool MDSRankDispatcher::handle_asok_command(
 {
   if (command == "dump_ops_in_flight" ||
              command == "ops") {
+    RWLock::RLocker l(op_tracker.lock);
     if (!op_tracker.tracking_enabled) {
       ss << "op_tracker tracking is not enabled";
     } else {
       op_tracker.dump_ops_in_flight(f);
     }
   } else if (command == "dump_historic_ops") {
+    RWLock::RLocker l(op_tracker.lock);
     if (!op_tracker.tracking_enabled) {
       ss << "op_tracker tracking is not enabled";
     } else {

diff --git a/src/osd/OSD.cc b/src/osd/OSD.cc
index 0572410e3c51fa113baa045948c68d88be9401cc..998ebb039b850ea6a13c5985251f8d6c31b233a6 100644 (file)
--- a/src/osd/OSD.cc
+++ b/src/osd/OSD.cc
@@ -1659,12 +1659,14 @@ bool OSD::asok_command(string command, cmdmap_t& cmdmap, string format,
     store->flush_journal();
   } else if (command == "dump_ops_in_flight" ||
             command == "ops") {
+    RWLock::RLocker l(op_tracker.lock);
     if (!op_tracker.tracking_enabled) {
       ss << "op_tracker tracking is not enabled";
     } else {
       op_tracker.dump_ops_in_flight(f);
     }
   } else if (command == "dump_historic_ops") {
+    RWLock::RLocker l(op_tracker.lock);
     if (!op_tracker.tracking_enabled) {
       ss << "op_tracker tracking is not enabled";
     } else {