ceph/src/osd/OpRequest.h

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3 /*
   4  * Ceph - scalable distributed file system
   5  *
   6  * Copyright (C) 2012 New Dream Network/Sage Weil <sage@newdream.net>
   7  *
   8  * This is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License version 2.1, as published by the Free Software
  11  * Foundation.  See file COPYING.
  12  */
  13
  14 #ifndef OPREQUEST_H_
  15 #define OPREQUEST_H_
  16
  17 #include "osd/osd_op_util.h"
  18 #include "osd/osd_types.h"
  19 #include "common/TrackedOp.h"
  20 #include "common/tracer.h"
  21 /**
  22  * The OpRequest takes in a Message* and takes over a single reference
  23  * to it, which it puts() when destroyed.
  24  */
  25 struct OpRequest : public TrackedOp {
  26   friend class OpTracker;
  27
  28 private:
  29   OpInfo op_info;
  30
  31 public:
  32   int maybe_init_op_info(const OSDMap &osdmap);
  33
  34   auto get_flags() const { return op_info.get_flags(); }
  35   bool op_info_needs_init() const { return op_info.get_flags() == 0; }
  36   bool check_rmw(int flag) const { return op_info.check_rmw(flag); }
  37   bool may_read() const { return op_info.may_read(); }
  38   bool may_write() const { return op_info.may_write(); }
  39   bool may_cache() const { return op_info.may_cache(); }
  40   bool rwordered_forced() const { return op_info.rwordered_forced(); }
  41   bool rwordered() const { return op_info.rwordered(); }
  42   bool includes_pg_op() const { return op_info.includes_pg_op(); }
  43   bool need_read_cap() const { return op_info.need_read_cap(); }
  44   bool need_write_cap() const { return op_info.need_write_cap(); }
  45   bool need_promote() const { return op_info.need_promote(); }
  46   bool need_skip_handle_cache() const { return op_info.need_skip_handle_cache(); }
  47   bool need_skip_promote() const { return op_info.need_skip_promote(); }
  48   bool allows_returnvec() const { return op_info.allows_returnvec(); }
  49
  50   std::vector<OpInfo::ClassInfo> classes() const {
  51     return op_info.get_classes();
  52   }
  53
  54   void _dump(ceph::Formatter *f) const override;
  55
  56   bool has_feature(uint64_t f) const {
  57     return request->get_connection()->has_feature(f);
  58   }
  59
  60 private:
  61   Message *request; /// the logical request we are tracking
  62   osd_reqid_t reqid;
  63   entity_inst_t req_src_inst;
  64   uint8_t hit_flag_points;
  65   uint8_t latest_flag_point;
  66   utime_t dequeued_time;
  67   static const uint8_t flag_queued_for_pg=1 << 0;
  68   static const uint8_t flag_reached_pg =  1 << 1;
  69   static const uint8_t flag_delayed =     1 << 2;
  70   static const uint8_t flag_started =     1 << 3;
  71   static const uint8_t flag_sub_op_sent = 1 << 4;
  72   static const uint8_t flag_commit_sent = 1 << 5;
  73
  74   OpRequest(Message *req, OpTracker *tracker);
  75
  76 protected:
  77   void _dump_op_descriptor_unlocked(std::ostream& stream) const override;
  78   void _unregistered() override;
  79   bool filter_out(const std::set<std::string>& filters) override;
  80
  81 public:
  82   ~OpRequest() override {
  83     request->put();
  84   }
  85
  86   bool check_send_map = true; ///< true until we check if sender needs a map
  87   epoch_t sent_epoch = 0;     ///< client's map epoch
  88   epoch_t min_epoch = 0;      ///< min epoch needed to handle this msg
  89
  90   bool hitset_inserted;
  91   jspan osd_parent_span;
  92
  93   template<class T>
  94   const T* get_req() const { return static_cast<const T*>(request); }
  95
  96   const Message *get_req() const { return request; }
  97   Message *get_nonconst_req() { return request; }
  98
  99   entity_name_t get_source() {
 100     if (request) {
 101       return request->get_source();
 102     } else {
 103       return entity_name_t();
 104     }
 105   }
 106   uint8_t state_flag() const {
 107     return latest_flag_point;
 108   }
 109
 110   std::string_view state_string() const override {
 111     switch(latest_flag_point) {
 112     case flag_queued_for_pg: return "queued for pg";
 113     case flag_reached_pg: return "reached pg";
 114     case flag_delayed: return "delayed";
 115     case flag_started: return "started";
 116     case flag_sub_op_sent: return "waiting for sub ops";
 117     case flag_commit_sent: return "commit sent; apply or cleanup";
 118     default: break;
 119     }
 120     return "no flag points reached";
 121   }
 122
 123   static std::string get_state_string(uint8_t flag) {
 124     std::string flag_point;
 125
 126     switch(flag) {
 127       case flag_queued_for_pg:
 128         flag_point = "queued for pg";
 129         break;
 130       case flag_reached_pg:
 131         flag_point = "reached pg";
 132         break;
 133       case flag_delayed:
 134         flag_point = "delayed";
 135         break;
 136       case flag_started:
 137         flag_point = "started";
 138         break;
 139       case flag_sub_op_sent:
 140         flag_point = "waiting for sub ops";
 141         break;
 142       case flag_commit_sent:
 143         flag_point = "commit sent; apply or cleanup";
 144         break;
 145     }
 146     return flag_point;
 147   }
 148
 149   void mark_queued_for_pg() {
 150     mark_flag_point(flag_queued_for_pg, "queued_for_pg");
 151   }
 152   void mark_reached_pg() {
 153     mark_flag_point(flag_reached_pg, "reached_pg");
 154   }
 155   void mark_delayed(const std::string& s) {
 156     mark_flag_point_string(flag_delayed, s);
 157   }
 158   void mark_started() {
 159     mark_flag_point(flag_started, "started");
 160   }
 161   void mark_sub_op_sent(const std::string& s) {
 162     mark_flag_point_string(flag_sub_op_sent, s);
 163   }
 164   void mark_commit_sent() {
 165     mark_flag_point(flag_commit_sent, "commit_sent");
 166   }
 167
 168   utime_t get_dequeued_time() const {
 169     return dequeued_time;
 170   }
 171   void set_dequeued_time(utime_t deq_time) {
 172     dequeued_time = deq_time;
 173   }
 174
 175   osd_reqid_t get_reqid() const {
 176     return reqid;
 177   }
 178
 179   typedef boost::intrusive_ptr<OpRequest> Ref;
 180
 181 private:
 182   void mark_flag_point(uint8_t flag, const char *s);
 183   void mark_flag_point_string(uint8_t flag, const std::string& s);
 184 };
 185
 186 typedef OpRequest::Ref OpRequestRef;
 187
 188 #endif /* OPREQUEST_H_ */