]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
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) 2004-2006 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 | ||
15 | ||
16 | #ifndef CEPH_MOSDSUBOPREPLY_H | |
17 | #define CEPH_MOSDSUBOPREPLY_H | |
18 | ||
19 | #include "MOSDFastDispatchOp.h" | |
20 | ||
21 | #include "MOSDSubOp.h" | |
22 | #include "os/ObjectStore.h" | |
23 | ||
24 | /* | |
25 | * OSD op reply | |
26 | * | |
27 | * oid - object id | |
28 | * op - OSD_OP_DELETE, etc. | |
29 | * | |
30 | */ | |
31 | ||
32 | class MOSDSubOpReply : public MOSDFastDispatchOp { | |
33 | static const int HEAD_VERSION = 2; | |
34 | static const int COMPAT_VERSION = 1; | |
35 | public: | |
d2e6a577 | 36 | epoch_t map_epoch = 0; |
7c673cae FG |
37 | |
38 | // subop metadata | |
39 | osd_reqid_t reqid; | |
40 | pg_shard_t from; | |
41 | spg_t pgid; | |
42 | hobject_t poid; | |
43 | ||
44 | vector<OSDOp> ops; | |
45 | ||
46 | // result | |
d2e6a577 FG |
47 | __u8 ack_type = 0; |
48 | int32_t result = 0; | |
7c673cae FG |
49 | |
50 | // piggybacked osd state | |
51 | eversion_t last_complete_ondisk; | |
52 | osd_peer_stat_t peer_stat; | |
53 | ||
54 | map<string,bufferptr> attrset; | |
55 | ||
56 | epoch_t get_map_epoch() const override { | |
57 | return map_epoch; | |
58 | } | |
59 | spg_t get_spg() const override { | |
60 | return pgid; | |
61 | } | |
62 | ||
63 | void decode_payload() override { | |
64 | bufferlist::iterator p = payload.begin(); | |
65 | ::decode(map_epoch, p); | |
66 | ::decode(reqid, p); | |
67 | ::decode(pgid.pgid, p); | |
68 | ::decode(poid, p); | |
69 | ||
70 | unsigned num_ops; | |
71 | ::decode(num_ops, p); | |
72 | ops.resize(num_ops); | |
73 | for (unsigned i = 0; i < num_ops; i++) { | |
74 | ::decode(ops[i].op, p); | |
75 | } | |
76 | ::decode(ack_type, p); | |
77 | ::decode(result, p); | |
78 | ::decode(last_complete_ondisk, p); | |
79 | ::decode(peer_stat, p); | |
80 | ::decode(attrset, p); | |
81 | ||
82 | if (!poid.is_max() && poid.pool == -1) | |
83 | poid.pool = pgid.pool(); | |
84 | ||
85 | if (header.version >= 2) { | |
86 | ::decode(from, p); | |
87 | ::decode(pgid.shard, p); | |
88 | } else { | |
89 | from = pg_shard_t( | |
90 | get_source().num(), | |
91 | shard_id_t::NO_SHARD); | |
92 | pgid.shard = shard_id_t::NO_SHARD; | |
93 | } | |
94 | } | |
95 | ||
96 | void finish_decode() { } | |
97 | ||
98 | void encode_payload(uint64_t features) override { | |
99 | ::encode(map_epoch, payload); | |
100 | ::encode(reqid, payload); | |
101 | ::encode(pgid.pgid, payload); | |
102 | ::encode(poid, payload); | |
103 | __u32 num_ops = ops.size(); | |
104 | ::encode(num_ops, payload); | |
105 | for (unsigned i = 0; i < ops.size(); i++) { | |
106 | ::encode(ops[i].op, payload); | |
107 | } | |
108 | ::encode(ack_type, payload); | |
109 | ::encode(result, payload); | |
110 | ::encode(last_complete_ondisk, payload); | |
111 | ::encode(peer_stat, payload); | |
112 | ::encode(attrset, payload); | |
113 | ::encode(from, payload); | |
114 | ::encode(pgid.shard, payload); | |
115 | } | |
116 | ||
117 | epoch_t get_map_epoch() { return map_epoch; } | |
118 | ||
119 | spg_t get_pg() const { return pgid; } | |
120 | const hobject_t& get_poid() const { return poid; } | |
121 | ||
122 | int get_ack_type() { return ack_type; } | |
123 | bool is_ondisk() { return ack_type & CEPH_OSD_FLAG_ONDISK; } | |
124 | bool is_onnvram() { return ack_type & CEPH_OSD_FLAG_ONNVRAM; } | |
125 | ||
126 | int get_result() { return result; } | |
127 | ||
128 | void set_last_complete_ondisk(eversion_t v) { last_complete_ondisk = v; } | |
129 | eversion_t get_last_complete_ondisk() { return last_complete_ondisk; } | |
130 | ||
131 | void set_peer_stat(const osd_peer_stat_t& stat) { peer_stat = stat; } | |
132 | const osd_peer_stat_t& get_peer_stat() { return peer_stat; } | |
133 | ||
134 | void set_attrset(map<string,bufferptr> &as) { attrset = as; } | |
135 | map<string,bufferptr>& get_attrset() { return attrset; } | |
136 | ||
137 | public: | |
138 | MOSDSubOpReply( | |
139 | const MOSDSubOp *req, pg_shard_t from, int result_, epoch_t e, int at) | |
140 | : MOSDFastDispatchOp(MSG_OSD_SUBOPREPLY, HEAD_VERSION, COMPAT_VERSION), | |
141 | map_epoch(e), | |
142 | reqid(req->reqid), | |
143 | from(from), | |
144 | pgid(req->pgid.pgid, req->from.shard), | |
145 | poid(req->poid), | |
146 | ops(req->ops), | |
147 | ack_type(at), | |
148 | result(result_) { | |
149 | memset(&peer_stat, 0, sizeof(peer_stat)); | |
150 | set_tid(req->get_tid()); | |
151 | } | |
152 | MOSDSubOpReply() | |
153 | : MOSDFastDispatchOp(MSG_OSD_SUBOPREPLY, HEAD_VERSION, COMPAT_VERSION) {} | |
154 | private: | |
155 | ~MOSDSubOpReply() override {} | |
156 | ||
157 | public: | |
158 | const char *get_type_name() const override { return "osd_subop_reply"; } | |
159 | ||
160 | void print(ostream& out) const override { | |
161 | out << "osd_sub_op_reply(" << reqid | |
162 | << " " << pgid | |
163 | << " " << poid << " " << ops; | |
164 | if (ack_type & CEPH_OSD_FLAG_ONDISK) | |
165 | out << " ondisk"; | |
166 | if (ack_type & CEPH_OSD_FLAG_ONNVRAM) | |
167 | out << " onnvram"; | |
168 | if (ack_type & CEPH_OSD_FLAG_ACK) | |
169 | out << " ack"; | |
170 | out << ", result = " << result; | |
171 | out << ")"; | |
172 | } | |
173 | ||
174 | }; | |
175 | ||
176 | ||
177 | #endif |