]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- |
2 | ||
3 | #include "OpRequest.h" | |
4 | #include "common/Formatter.h" | |
5 | #include <iostream> | |
6 | #include <vector> | |
7 | #include "common/debug.h" | |
8 | #include "common/config.h" | |
9 | #include "msg/Message.h" | |
10 | #include "messages/MOSDOp.h" | |
11 | #include "messages/MOSDSubOp.h" | |
12 | #include "messages/MOSDRepOp.h" | |
13 | #include "include/assert.h" | |
14 | #include "osd/osd_types.h" | |
15 | ||
16 | #ifdef WITH_LTTNG | |
17 | #define TRACEPOINT_DEFINE | |
18 | #define TRACEPOINT_PROBE_DYNAMIC_LINKAGE | |
19 | #include "tracing/oprequest.h" | |
20 | #undef TRACEPOINT_PROBE_DYNAMIC_LINKAGE | |
21 | #undef TRACEPOINT_DEFINE | |
22 | #else | |
23 | #define tracepoint(...) | |
24 | #endif | |
25 | ||
26 | OpRequest::OpRequest(Message *req, OpTracker *tracker) : | |
27 | TrackedOp(tracker, req->get_recv_stamp()), | |
28 | rmw_flags(0), request(req), | |
29 | hit_flag_points(0), latest_flag_point(0), | |
30 | hitset_inserted(false) { | |
31 | if (req->get_priority() < tracker->cct->_conf->osd_client_op_priority) { | |
32 | // don't warn as quickly for low priority ops | |
33 | warn_interval_multiplier = tracker->cct->_conf->osd_recovery_op_warn_multiple; | |
34 | } | |
35 | if (req->get_type() == CEPH_MSG_OSD_OP) { | |
36 | reqid = static_cast<MOSDOp*>(req)->get_reqid(); | |
37 | } else if (req->get_type() == MSG_OSD_SUBOP) { | |
38 | reqid = static_cast<MOSDSubOp*>(req)->reqid; | |
39 | } else if (req->get_type() == MSG_OSD_REPOP) { | |
40 | reqid = static_cast<MOSDRepOp*>(req)->reqid; | |
41 | } | |
c07f9fc5 | 42 | req_src_inst = req->get_source_inst(); |
7c673cae FG |
43 | mark_event("header_read", request->get_recv_stamp()); |
44 | mark_event("throttled", request->get_throttle_stamp()); | |
45 | mark_event("all_read", request->get_recv_complete_stamp()); | |
46 | mark_event("dispatched", request->get_dispatch_stamp()); | |
47 | } | |
48 | ||
49 | void OpRequest::_dump(Formatter *f) const | |
50 | { | |
51 | Message *m = request; | |
52 | f->dump_string("flag_point", state_string()); | |
53 | if (m->get_orig_source().is_client()) { | |
54 | f->open_object_section("client_info"); | |
55 | stringstream client_name, client_addr; | |
c07f9fc5 FG |
56 | client_name << req_src_inst.name; |
57 | client_addr << req_src_inst.addr; | |
7c673cae FG |
58 | f->dump_string("client", client_name.str()); |
59 | f->dump_string("client_addr", client_addr.str()); | |
60 | f->dump_unsigned("tid", m->get_tid()); | |
61 | f->close_section(); // client_info | |
62 | } | |
63 | { | |
64 | f->open_array_section("events"); | |
65 | Mutex::Locker l(lock); | |
66 | for (auto& i : events) { | |
67 | f->dump_object("event", i); | |
68 | } | |
69 | f->close_section(); | |
70 | } | |
71 | } | |
72 | ||
73 | void OpRequest::_dump_op_descriptor_unlocked(ostream& stream) const | |
74 | { | |
75 | get_req()->print(stream); | |
76 | } | |
77 | ||
78 | void OpRequest::_unregistered() { | |
79 | request->clear_data(); | |
80 | request->clear_payload(); | |
81 | request->release_message_throttle(); | |
82 | request->set_connection(nullptr); | |
83 | } | |
84 | ||
85 | bool OpRequest::check_rmw(int flag) { | |
86 | assert(rmw_flags != 0); | |
87 | return rmw_flags & flag; | |
88 | } | |
89 | bool OpRequest::may_read() { | |
90 | return need_read_cap() || check_rmw(CEPH_OSD_RMW_FLAG_CLASS_READ); | |
91 | } | |
92 | bool OpRequest::may_write() { | |
93 | return need_write_cap() || check_rmw(CEPH_OSD_RMW_FLAG_CLASS_WRITE); | |
94 | } | |
95 | bool OpRequest::may_cache() { return check_rmw(CEPH_OSD_RMW_FLAG_CACHE); } | |
96 | bool OpRequest::rwordered_forced() { | |
97 | return check_rmw(CEPH_OSD_RMW_FLAG_RWORDERED); | |
98 | } | |
99 | bool OpRequest::rwordered() { | |
100 | return may_write() || may_cache() || rwordered_forced(); | |
101 | } | |
102 | ||
103 | bool OpRequest::includes_pg_op() { return check_rmw(CEPH_OSD_RMW_FLAG_PGOP); } | |
104 | bool OpRequest::need_read_cap() { | |
105 | return check_rmw(CEPH_OSD_RMW_FLAG_READ); | |
106 | } | |
107 | bool OpRequest::need_write_cap() { | |
108 | return check_rmw(CEPH_OSD_RMW_FLAG_WRITE); | |
109 | } | |
110 | bool OpRequest::need_promote() { | |
111 | return check_rmw(CEPH_OSD_RMW_FLAG_FORCE_PROMOTE); | |
112 | } | |
113 | bool OpRequest::need_skip_handle_cache() { | |
114 | return check_rmw(CEPH_OSD_RMW_FLAG_SKIP_HANDLE_CACHE); | |
115 | } | |
116 | bool OpRequest::need_skip_promote() { | |
117 | return check_rmw(CEPH_OSD_RMW_FLAG_SKIP_PROMOTE); | |
118 | } | |
119 | ||
120 | void OpRequest::set_rmw_flags(int flags) { | |
121 | #ifdef WITH_LTTNG | |
122 | int old_rmw_flags = rmw_flags; | |
123 | #endif | |
124 | rmw_flags |= flags; | |
125 | tracepoint(oprequest, set_rmw_flags, reqid.name._type, | |
126 | reqid.name._num, reqid.tid, reqid.inc, | |
127 | flags, old_rmw_flags, rmw_flags); | |
128 | } | |
129 | ||
130 | void OpRequest::set_read() { set_rmw_flags(CEPH_OSD_RMW_FLAG_READ); } | |
131 | void OpRequest::set_write() { set_rmw_flags(CEPH_OSD_RMW_FLAG_WRITE); } | |
132 | void OpRequest::set_class_read() { set_rmw_flags(CEPH_OSD_RMW_FLAG_CLASS_READ); } | |
133 | void OpRequest::set_class_write() { set_rmw_flags(CEPH_OSD_RMW_FLAG_CLASS_WRITE); } | |
134 | void OpRequest::set_pg_op() { set_rmw_flags(CEPH_OSD_RMW_FLAG_PGOP); } | |
135 | void OpRequest::set_cache() { set_rmw_flags(CEPH_OSD_RMW_FLAG_CACHE); } | |
136 | void OpRequest::set_promote() { set_rmw_flags(CEPH_OSD_RMW_FLAG_FORCE_PROMOTE); } | |
137 | void OpRequest::set_skip_handle_cache() { set_rmw_flags(CEPH_OSD_RMW_FLAG_SKIP_HANDLE_CACHE); } | |
138 | void OpRequest::set_skip_promote() { set_rmw_flags(CEPH_OSD_RMW_FLAG_SKIP_PROMOTE); } | |
139 | void OpRequest::set_force_rwordered() { set_rmw_flags(CEPH_OSD_RMW_FLAG_RWORDERED); } | |
140 | ||
141 | void OpRequest::mark_flag_point(uint8_t flag, const char *s) { | |
142 | #ifdef WITH_LTTNG | |
143 | uint8_t old_flags = hit_flag_points; | |
144 | #endif | |
145 | mark_event(s); | |
146 | hit_flag_points |= flag; | |
147 | latest_flag_point = flag; | |
148 | tracepoint(oprequest, mark_flag_point, reqid.name._type, | |
149 | reqid.name._num, reqid.tid, reqid.inc, rmw_flags, | |
150 | flag, s, old_flags, hit_flag_points); | |
151 | } | |
152 | ||
153 | void OpRequest::mark_flag_point_string(uint8_t flag, const string& s) { | |
154 | #ifdef WITH_LTTNG | |
155 | uint8_t old_flags = hit_flag_points; | |
156 | #endif | |
157 | mark_event_string(s); | |
158 | hit_flag_points |= flag; | |
159 | latest_flag_point = flag; | |
160 | tracepoint(oprequest, mark_flag_point, reqid.name._type, | |
161 | reqid.name._num, reqid.tid, reqid.inc, rmw_flags, | |
162 | flag, s.c_str(), old_flags, hit_flag_points); | |
163 | } | |
164 | ||
c07f9fc5 FG |
165 | bool OpRequest::filter_out(const set<string>& filters) |
166 | { | |
167 | set<entity_addr_t> addrs; | |
168 | for (auto it = filters.begin(); it != filters.end(); it++) { | |
169 | entity_addr_t addr; | |
170 | if (addr.parse((*it).c_str())) { | |
171 | addrs.insert(addr); | |
172 | } | |
173 | } | |
174 | if (addrs.empty()) | |
175 | return true; | |
176 | ||
177 | entity_addr_t cmp_addr = req_src_inst.addr; | |
178 | if (addrs.count(cmp_addr)) { | |
179 | return true; | |
180 | } | |
181 | cmp_addr.set_nonce(0); | |
182 | if (addrs.count(cmp_addr)) { | |
183 | return true; | |
184 | } | |
185 | cmp_addr.set_port(0); | |
186 | if (addrs.count(cmp_addr)) { | |
187 | return true; | |
188 | } | |
189 | ||
190 | return false; | |
191 | } | |
192 | ||
7c673cae FG |
193 | ostream& operator<<(ostream& out, const OpRequest::ClassInfo& i) |
194 | { | |
195 | out << "class " << i.name << " rd " << i.read | |
196 | << " wr " << i.write << " wl " << i.whitelisted; | |
197 | return out; | |
198 | } |