WRITE_RAW_ENCODER(ceph_mds_lease);
WRITE_RAW_ENCODER(ceph_mds_reply_head);
WRITE_RAW_ENCODER(ceph_mds_reply_inode);
+
WRITE_RAW_ENCODER(ceph_osd_request_head);
+WRITE_RAW_ENCODER(ceph_osd_reply_head);
// ----------------------
// some basic types
}
void encode_payload() {
- ::_encode(inst, payload);
- ::_encode(sb, payload);
+ ::encode(inst, payload);
+ ::encode(sb, payload);
}
void decode_payload() {
- int off = 0;
- ::_decode(inst, payload, off);
- ::_decode(sb, payload, off);
+ bufferlist::iterator p = payload.begin();
+ ::decode(inst, p);
+ ::decode(sb, p);
}
};
epoch_t get_epoch() { return epoch; }
void decode_payload() {
- int off = 0;
- ::_decode(fsid, payload, off);
- ::_decode(from, payload, off);
- ::_decode(failed, payload, off);
- ::_decode(epoch, payload, off);
+ bufferlist::iterator p = payload.begin();
+ ::decode(fsid, p);
+ ::decode(from, p);
+ ::decode(failed, p);
+ ::decode(epoch, p);
}
void encode_payload() {
- ::_encode(fsid, payload);
- ::_encode(from, payload);
- ::_encode(failed, payload);
- ::_encode(epoch, payload);
+ ::encode(fsid, payload);
+ ::encode(from, payload);
+ ::encode(failed, payload);
+ ::encode(epoch, payload);
}
const char *get_type_name() { return "osd_failure"; }
}
void encode_payload() {
- ::_encode(fsid, payload);
- ::_encode(start, payload);
+ ::encode(fsid, payload);
+ ::encode(start, payload);
}
void decode_payload() {
- int off = 0;
- ::_decode(fsid, payload, off);
- ::_decode(start, payload, off);
+ bufferlist::iterator p = payload.begin();
+ ::decode(fsid, p);
+ ::decode(start, p);
}
};
// marshalling
void decode_payload() {
- int off = 0;
- ::_decode(fsid, payload, off);
- ::_decode(incremental_maps, payload, off);
- ::_decode(maps, payload, off);
+ bufferlist::iterator p = payload.begin();
+ ::decode(fsid, p);
+ ::decode(incremental_maps, p);
+ ::decode(maps, p);
}
void encode_payload() {
- ::_encode(fsid, payload);
- ::_encode(incremental_maps, payload);
- ::_encode(maps, payload);
+ ::encode(fsid, payload);
+ ::encode(incremental_maps, payload);
+ ::encode(maps, payload);
}
const char *get_type_name() { return "omap"; }
// marshalling
virtual void decode_payload() {
- int off = 0;
- ::_decode(head, payload, off);
+ bufferlist::iterator p = payload.begin();
+ ::decode(head, p);
}
virtual void encode_payload() {
- ::_encode(head, payload);
+ ::encode(head, payload);
env.data_off = get_offset();
}
// marshalling
virtual void decode_payload() {
- int off = 0;
- ::_decode(head, payload, off);
+ bufferlist::iterator p = payload.begin();
+ ::decode(head, p);
}
virtual void encode_payload() {
- ::_encode(head, payload);
+ ::encode(head, payload);
env.data_off = get_offset();
}
epoch_t created; // epoch pg created
pg_t parent; // split from parent (if != pg_t())
int split_bits;
+
+ void encode(bufferlist &bl) const {
+ ::encode(created, bl);
+ ::encode(parent, bl);
+ ::encode(split_bits, bl);
+ }
+ void decode(bufferlist::iterator &bl) {
+ ::decode(created, bl);
+ ::decode(parent, bl);
+ ::decode(split_bits, bl);
+ }
};
+ WRITE_CLASS_ENCODERS(create_rec)
+
map<pg_t,create_rec> mkpg;
MOSDPGCreate() {}
const char *get_type_name() { return "pg_create"; }
void encode_payload() {
- ::_encode(epoch, payload);
- ::_encode(mkpg, payload);
+ ::encode(epoch, payload);
+ ::encode(mkpg, payload);
}
void decode_payload() {
- int off = 0;
- ::_decode(epoch, payload, off);
- ::_decode(mkpg, payload, off);
+ bufferlist::iterator p = payload.begin();
+ ::decode(epoch, p);
+ ::decode(mkpg, p);
}
};
+WRITE_CLASS_ENCODERS(MOSDPGCreate::create_rec)
+
#endif
}
void encode_payload() {
- ::_encode(epoch, payload);
- ::_encode(pg_info, payload);
+ ::encode(epoch, payload);
+ ::encode(pg_info, payload);
}
void decode_payload() {
- int off = 0;
- ::_decode(epoch, payload, off);
- ::_decode(pg_info, payload, off);
+ bufferlist::iterator p = payload.begin();
+ ::decode(epoch, p);
+ ::decode(pg_info, p);
}
};
const char *get_type_name() { return "PGnot"; }
void encode_payload() {
- payload.append((char*)&epoch, sizeof(epoch));
- _encode(pg_list, payload);
+ ::encode(epoch, payload);
+ ::encode(pg_list, payload);
}
void decode_payload() {
- int off = 0;
- payload.copy(off, sizeof(epoch), (char*)&epoch);
- off += sizeof(epoch);
- _decode(pg_list, payload, off);
+ bufferlist::iterator p = payload.begin();
+ ::decode(epoch, p);
+ ::decode(pg_list, p);
}
};
char *get_type_name() { return "PGPeer"; }
void encode_payload() {
- payload.append((char*)&map_version, sizeof(map_version));
- payload.append((char*)&complete, sizeof(complete));
- _encode(pg_list, payload);
+ ::encode(map_version, payload);
+ ::encode(complete, payload);
+ ::encode(pg_list, payload);
}
void decode_payload() {
- int off = 0;
- payload.copy(off, sizeof(map_version), (char*)&map_version);
- off += sizeof(map_version);
- payload.copy(off, sizeof(complete), (char*)&complete);
- off += sizeof(complete);
- _decode(pg_list, payload, off);
+ bufferlist::iterator p = payload.begin();
+ ::decode(map_version, p);
+ ::decode(complete, p);
+ ::decode(pg_list, p);
}
};
char *get_type_name() { return "PGPeer"; }
void encode_payload() {
- payload.append((char*)&map_version, sizeof(map_version));
- _encode(pg_dne, payload);
-
- int n = pg_state.size();
- payload.append((char*)&n, sizeof(n));
- for (map<pg_t, PGReplicaInfo >::iterator it = pg_state.begin();
- it != pg_state.end();
- it++) {
- payload.append((char*)&it->first, sizeof(it->first));
- it->second._encode(payload);
- }
+ ::encode(map_version, payload);
+ ::encode(pg_dne, payload);
+ ::encode(pg_state, payload);
}
void decode_payload() {
- int off = 0;
- payload.copy(off, sizeof(map_version), (char*)&map_version);
- off += sizeof(map_version);
- _decode(pg_dne, payload, off);
-
- int n;
- payload.copy(off, sizeof(n), (char*)&n);
- off += sizeof(n);
- for (int i=0; i<n; i++) {
- pg_t pgid;
- payload.copy(off, sizeof(pgid), (char*)&pgid);
- off += sizeof(pgid);
- pg_state[pgid]._decode(payload, off);
- }
+ bufferlist::iterator p = payload.begin();
+ ::decode(map_version, payload);
+ ::decode(pg_dne, payload);
+ ::decode(pg_state, payload);
}
};
char *get_type_name() { return "PGPR"; }
void encode_payload() {
- payload.append((char*)&map_version, sizeof(map_version));
- _encode(pg_list, payload);
+ ::encode(map_version, payload);
+ ::encode(pg_list, payload);
}
void decode_payload() {
- int off = 0;
- payload.copy(off, sizeof(map_version), (char*)&map_version);
- off += sizeof(map_version);
- _decode(pg_list, payload, off);
+ bufferlist::iterator p = payload.begin();
+ ::decode(map_version, p);
+ ::decode(pg_list, p);
}
};
const char *get_type_name() { return "PGq"; }
void encode_payload() {
- ::_encode(epoch, payload);
- ::_encode(pg_list, payload);
+ ::encode(epoch, payload);
+ ::encode(pg_list, payload);
}
void decode_payload() {
- int off = 0;
- ::_decode(epoch, payload, off);
- ::_decode(pg_list, payload, off);
+ bufferlist::iterator p = payload.begin();
+ ::decode(epoch, p);
+ ::decode(pg_list, p);
}
};
const char *get_type_name() { return "PGrm"; }
void encode_payload() {
- payload.append((char*)&epoch, sizeof(epoch));
- _encode(pg_list, payload);
+ ::encode(epoch, payload);
+ ::encode(pg_list, payload);
}
void decode_payload() {
- int off = 0;
- payload.copy(off, sizeof(epoch), (char*)&epoch);
- off += sizeof(epoch);
- _decode(pg_list, payload, off);
+ bufferlist::iterator p = payload.begin();
+ ::decode(epoch, p);
+ ::decode(pg_list, p);
}
};
Message(MSG_OSD_PG_SUMMARY) {
this->epoch = mv;
this->pgid = pgid;
- summary._encode(sumbl);
+ summary.encode(sumbl);
}
pg_t get_pgid() { return pgid; }
MOSDPing() {}
void decode_payload() {
- int off = 0;
- ::_decode(map_epoch, payload, off);
- ::_decode(ack, payload, off);
- ::_decode(peer_stat, payload, off);
+ bufferlist::iterator p = payload.begin();
+ ::decode(map_epoch, p);
+ ::decode(ack, p);
+ ::decode(peer_stat, p);
}
void encode_payload() {
- ::_encode(map_epoch, payload);
- ::_encode(ack, payload);
- ::_encode(peer_stat, payload);
+ ::encode(map_epoch, payload);
+ ::encode(ack, payload);
+ ::encode(peer_stat, payload);
}
const char *get_type_name() { return "osd_ping"; }
class MOSDSubOp : public Message {
public:
private:
- struct st_ {
- epoch_t map_epoch;
+ epoch_t map_epoch;
+
+ // metadata from original request
+ osd_reqid_t reqid;
+
+ // subop
+ pg_t pgid;
+ pobject_t poid;
+ int32_t op;
+ off_t offset, length;
+
+ // subop metadata
+ tid_t rep_tid;
+ eversion_t version;
+ uint32_t inc_lock;
+
+ // piggybacked osd/og state
+ eversion_t pg_trim_to; // primary->replica: trim to here
+ osd_peer_stat_t peer_stat;
- // metadata from original request
- osd_reqid_t reqid;
+ map<string,bufferptr> attrset;
- // subop
- pg_t pgid;
- pobject_t poid;
- int32_t op;
- off_t offset, length;
+public:
+ virtual void decode_payload() {
+ bufferlist::iterator p = payload.begin();
+ ::decode(map_epoch, p);
+ ::decode(reqid, p);
+ ::decode(pgid, p);
+ ::decode(poid, p);
+ ::decode(op, p);
+ ::decode(offset, p);
+ ::decode(length, p);
+ ::decode(rep_tid, p);
+ ::decode(version, p);
+ ::decode(inc_lock, p);
+ ::decode(pg_trim_to, p);
+ ::decode(peer_stat, p);
+ ::decode(attrset, p);
+ }
- // subop metadata
- tid_t rep_tid;
- eversion_t version;
- uint32_t inc_lock;
+ virtual void encode_payload() {
+ ::encode(map_epoch, payload);
+ ::encode(reqid, payload);
+ ::encode(pgid, payload);
+ ::encode(poid, payload);
+ ::encode(op, payload);
+ ::encode(offset, payload);
+ ::encode(length, payload);
+ ::encode(rep_tid, payload);
+ ::encode(version, payload);
+ ::encode(inc_lock, payload);
+ ::encode(pg_trim_to, payload);
+ ::encode(peer_stat, payload);
+ ::encode(attrset, payload);
+ env.data_off = offset;
+ }
- // piggybacked osd/og state
- eversion_t pg_trim_to; // primary->replica: trim to here
- osd_peer_stat_t peer_stat;
- } st;
- map<string,bufferptr> attrset;
+ const epoch_t get_map_epoch() { return map_epoch; }
-public:
- const epoch_t get_map_epoch() { return st.map_epoch; }
-
- const osd_reqid_t& get_reqid() { return st.reqid; }
+ const osd_reqid_t& get_reqid() { return reqid; }
bool wants_reply() {
- if (st.op < 100) return true;
+ if (op < 100) return true;
return false; // no reply needed for primary-lock, -unlock.
}
- const pg_t get_pg() { return st.pgid; }
- const pobject_t get_poid() { return st.poid; }
- const int get_op() { return st.op; }
- bool is_read() { return st.op < 10; }
- const off_t get_length() { return st.length; }
- const off_t get_offset() { return st.offset; }
+ const pg_t get_pg() { return pgid; }
+ const pobject_t get_poid() { return poid; }
+ const int get_op() { return op; }
+ bool is_read() { return op < 10; }
+ const off_t get_length() { return length; }
+ const off_t get_offset() { return offset; }
- const tid_t get_rep_tid() { return st.rep_tid; }
- const eversion_t get_version() { return st.version; }
- const eversion_t get_pg_trim_to() { return st.pg_trim_to; }
- void set_pg_trim_to(eversion_t v) { st.pg_trim_to = v; }
+ const tid_t get_rep_tid() { return rep_tid; }
+ const eversion_t get_version() { return version; }
+ const eversion_t get_pg_trim_to() { return pg_trim_to; }
+ void set_pg_trim_to(eversion_t v) { pg_trim_to = v; }
- unsigned get_inc_lock() { return st.inc_lock; }
- void set_inc_lock(unsigned i) { st.inc_lock = i; }
+ unsigned get_inc_lock() { return inc_lock; }
+ void set_inc_lock(unsigned i) { inc_lock = i; }
map<string,bufferptr>& get_attrset() { return attrset; }
void set_attrset(map<string,bufferptr> &as) { attrset.swap(as); }
- void set_peer_stat(const osd_peer_stat_t& stat) { st.peer_stat = stat; }
- const osd_peer_stat_t& get_peer_stat() { return st.peer_stat; }
+ void set_peer_stat(const osd_peer_stat_t& stat) { peer_stat = stat; }
+ const osd_peer_stat_t& get_peer_stat() { return peer_stat; }
MOSDSubOp(osd_reqid_t r, pg_t p, pobject_t po, int o, off_t of, off_t le,
epoch_t mape, tid_t rtid, unsigned il, eversion_t v) :
- Message(MSG_OSD_SUBOP) {
- memset(&st, 0, sizeof(st));
- st.reqid = r;
-
- st.pgid = p;
- st.poid = po;
- st.op = o;
- st.offset = of;
- st.length = le;
- st.map_epoch = mape;
- st.rep_tid = rtid;
- st.inc_lock = il;
- st.version = v;
+ Message(MSG_OSD_SUBOP),
+ map_epoch(mape),
+ reqid(r),
+ pgid(p),
+ poid(po),
+ op(o),
+ offset(of),
+ length(le),
+ rep_tid(rtid),
+ version(v),
+ inc_lock(il)
+ {
+ memset(&peer_stat, 0, sizeof(peer_stat));
}
MOSDSubOp() {}
- // marshalling
- virtual void decode_payload() {
- int off = 0;
- ::_decode(st, payload, off);
- ::_decode(attrset, payload, off);
- }
-
- virtual void encode_payload() {
- ::_encode(st, payload);
- ::_encode(attrset, payload);
- env.data_off = st.offset;
- }
-
const char *get_type_name() { return "osd_sub_op"; }
void print(ostream& out) {
- out << "osd_sub_op(" << st.reqid
- << " " << MOSDOp::get_opname(st.op)
- << " " << st.poid
- << " v" << st.version;
- if (st.length) out << " " << st.offset << "~" << st.length;
+ out << "osd_sub_op(" << reqid
+ << " " << MOSDOp::get_opname(op)
+ << " " << poid
+ << " v" << version;
+ if (length) out << " " << offset << "~" << length;
out << ")";
}
};
*/
class MOSDSubOpReply : public Message {
- struct st_t {
- epoch_t map_epoch;
-
- // subop metadata
- osd_reqid_t reqid;
- pg_t pgid;
- tid_t rep_tid;
- int32_t op;
- pobject_t poid;
- off_t length, offset;
-
- // result
- bool commit;
- int32_t result;
-
- // piggybacked osd state
- eversion_t pg_complete_thru;
- osd_peer_stat_t peer_stat;
- } st;
+ epoch_t map_epoch;
+
+ // subop metadata
+ osd_reqid_t reqid;
+ pg_t pgid;
+ tid_t rep_tid;
+ int32_t op;
+ pobject_t poid;
+ off_t length, offset;
+
+ // result
+ bool commit;
+ int32_t result;
+
+ // piggybacked osd state
+ eversion_t pg_complete_thru;
+ osd_peer_stat_t peer_stat;
map<string,bufferptr> attrset;
public:
- epoch_t get_map_epoch() { return st.map_epoch; }
+ virtual void decode_payload() {
+ bufferlist::iterator p = payload.begin();
+ ::decode(map_epoch, p);
+ ::decode(reqid, p);
+ ::decode(pgid, p);
+ ::decode(rep_tid, p);
+ ::decode(op, p);
+ ::decode(poid, p);
+ ::decode(length, p);
+ ::decode(offset, p);
+ ::decode(commit, p);
+ ::decode(result, p);
+ ::decode(pg_complete_thru, p);
+ ::decode(peer_stat, p);
+ ::decode(attrset, p);
+ }
+ virtual void encode_payload() {
+ ::encode(map_epoch, payload);
+ ::encode(reqid, payload);
+ ::encode(pgid, payload);
+ ::encode(rep_tid, payload);
+ ::encode(op, payload);
+ ::encode(poid, payload);
+ ::encode(length, payload);
+ ::encode(offset, payload);
+ ::encode(commit, payload);
+ ::encode(result, payload);
+ ::encode(pg_complete_thru, payload);
+ ::encode(peer_stat, payload);
+ ::encode(attrset, payload);
+ env.data_off = offset;
+ }
- pg_t get_pg() { return st.pgid; }
- tid_t get_rep_tid() { return st.rep_tid; }
- int get_op() { return st.op; }
- pobject_t get_poid() { return st.poid; }
- const off_t get_length() { return st.length; }
- const off_t get_offset() { return st.offset; }
+ epoch_t get_map_epoch() { return map_epoch; }
- bool get_commit() { return st.commit; }
- int get_result() { return st.result; }
+ pg_t get_pg() { return pgid; }
+ tid_t get_rep_tid() { return rep_tid; }
+ int get_op() { return op; }
+ pobject_t get_poid() { return poid; }
+ const off_t get_length() { return length; }
+ const off_t get_offset() { return offset; }
- void set_pg_complete_thru(eversion_t v) { st.pg_complete_thru = v; }
- eversion_t get_pg_complete_thru() { return st.pg_complete_thru; }
+ bool get_commit() { return commit; }
+ int get_result() { return result; }
- void set_peer_stat(const osd_peer_stat_t& stat) { st.peer_stat = stat; }
- const osd_peer_stat_t& get_peer_stat() { return st.peer_stat; }
+ void set_pg_complete_thru(eversion_t v) { pg_complete_thru = v; }
+ eversion_t get_pg_complete_thru() { return pg_complete_thru; }
+
+ void set_peer_stat(const osd_peer_stat_t& stat) { peer_stat = stat; }
+ const osd_peer_stat_t& get_peer_stat() { return peer_stat; }
void set_attrset(map<string,bufferptr> &as) { attrset = as; }
map<string,bufferptr>& get_attrset() { return attrset; }
public:
- MOSDSubOpReply(MOSDSubOp *req, int result, epoch_t e, bool commit) :
- Message(MSG_OSD_SUBOPREPLY) {
- st.map_epoch = e;
- st.reqid = req->get_reqid();
- st.pgid = req->get_pg();
- st.rep_tid = req->get_rep_tid();
- st.op = req->get_op();
- st.poid = req->get_poid();
- st.commit = commit;
- st.result = result;
- st.length = req->get_length();
- st.offset = req->get_offset();
+ MOSDSubOpReply(MOSDSubOp *req, int result_, epoch_t e, bool commit_) :
+ Message(MSG_OSD_SUBOPREPLY),
+ map_epoch(e),
+ reqid(req->get_reqid()),
+ pgid(req->get_pg()),
+ rep_tid(req->get_rep_tid()),
+ op(req->get_op()),
+ poid(req->get_poid()),
+ length(req->get_length()),
+ offset(req->get_offset()),
+ commit(commit_),
+ result(result_) {
+ memset(&peer_stat, 0, sizeof(peer_stat));
}
MOSDSubOpReply() {}
-
- // marshalling
- virtual void decode_payload() {
- int off = 0;
- ::_decode(st, payload, off);
- ::_decode(attrset, payload, off);
- }
- virtual void encode_payload() {
- ::_encode(st, payload);
- ::_encode(attrset, payload);
- env.data_off = st.offset;
- }
-
const char *get_type_name() { return "osd_op_reply"; }
void print(ostream& out) {
- out << "osd_sub_op_reply(" << st.reqid
- << " " << MOSDOp::get_opname(st.op)
- << " " << st.poid;
- if (st.length) out << " " << st.offset << "~" << st.length;
- if (st.op >= 10) {
- if (st.commit)
+ out << "osd_sub_op_reply(" << reqid
+ << " " << MOSDOp::get_opname(op)
+ << " " << poid;
+ if (length) out << " " << offset << "~" << length;
+ if (op >= 10) {
+ if (commit)
out << " commit";
else
out << " ack";
}
- out << " = " << st.result;
+ out << " = " << result;
out << ")";
}
WRITE_CLASS_ENCODERS(pg_stat_t)
typedef struct ceph_osd_peer_stat osd_peer_stat_t;
+WRITE_RAW_ENCODER(osd_peer_stat_t)
inline ostream& operator<<(ostream& out, const osd_peer_stat_t &stat) {
return out << "stat(" << stat.stamp
epoch_t current_epoch; // most recent epoch
epoch_t oldest_map, newest_map; // oldest/newest maps we have.
double weight;
+
OSDSuperblock(int w=0) :
magic(MAGIC), whoami(w),
current_epoch(0), oldest_map(0), newest_map(0), weight(0) {
memset(&fsid, 0, sizeof(fsid));
}
+
+ void encode(bufferlist &bl) const {
+ ::encode(magic, bl);
+ ::encode(fsid, bl);
+ ::encode(whoami, bl);
+ ::encode(current_epoch, bl);
+ ::encode(oldest_map, bl);
+ ::encode(newest_map, bl);
+ ::encode(weight, bl);
+ }
+ void decode(bufferlist::iterator &bl) {
+ ::decode(magic, bl);
+ ::decode(fsid, bl);
+ ::decode(whoami, bl);
+ ::decode(current_epoch, bl);
+ ::decode(oldest_map, bl);
+ ::decode(newest_map, bl);
+ ::decode(weight, bl);
+ }
};
+WRITE_CLASS_ENCODERS(OSDSuperblock)
inline ostream& operator<<(ostream& out, OSDSuperblock& sb)
{
projects / ceph.git / commitdiff