From: Sage Weil <sage@newdream.net>
Date: Thu, 8 May 2008 23:29:46 +0000 (-0700)
Subject: fixed osd message encoding
X-Git-Tag: v0.3~239^2~16
X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=b8f5dcbf6d296bf70e260fc80b7e0ad9a46ca9d9;p=ceph.git

fixed osd message encoding
---

diff --git a/src/include/types.h b/src/include/types.h
index f83b78b69840..128fe26da097 100644
--- a/src/include/types.h
+++ b/src/include/types.h
@@ -117,7 +117,9 @@ WRITE_RAW_ENCODER(ceph_mds_file_caps);
 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
diff --git a/src/messages/MOSDBoot.h b/src/messages/MOSDBoot.h
index 9b4f8b00defe..8e22755dfc4a 100644
--- a/src/messages/MOSDBoot.h
+++ b/src/messages/MOSDBoot.h
@@ -38,13 +38,13 @@ class MOSDBoot : public Message {
   }
   
   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);
   }
 };
 
diff --git a/src/messages/MOSDFailure.h b/src/messages/MOSDFailure.h
index f5ca4a0d218f..264abbf957f2 100644
--- a/src/messages/MOSDFailure.h
+++ b/src/messages/MOSDFailure.h
@@ -36,17 +36,17 @@ class MOSDFailure : public Message {
   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"; }
diff --git a/src/messages/MOSDGetMap.h b/src/messages/MOSDGetMap.h
index 8a955d76969f..15b6b9fff635 100644
--- a/src/messages/MOSDGetMap.h
+++ b/src/messages/MOSDGetMap.h
@@ -38,13 +38,13 @@ class MOSDGetMap : public Message {
   }
   
   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);
   }
 };
 
diff --git a/src/messages/MOSDMap.h b/src/messages/MOSDMap.h
index b03d93d174c4..44574ae85881 100644
--- a/src/messages/MOSDMap.h
+++ b/src/messages/MOSDMap.h
@@ -56,15 +56,15 @@ class MOSDMap : public Message {
 
   // 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"; }
diff --git a/src/messages/MOSDOp.h b/src/messages/MOSDOp.h
index 76df969b8670..13e43f18d97a 100644
--- a/src/messages/MOSDOp.h
+++ b/src/messages/MOSDOp.h
@@ -139,12 +139,12 @@ public:
 
   // 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();
   }
 
diff --git a/src/messages/MOSDOpReply.h b/src/messages/MOSDOpReply.h
index 1e8c7564790a..3216bede1d74 100644
--- a/src/messages/MOSDOpReply.h
+++ b/src/messages/MOSDOpReply.h
@@ -76,11 +76,11 @@ public:
 
   // 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();
   }
 
diff --git a/src/messages/MOSDPGCreate.h b/src/messages/MOSDPGCreate.h
index ba1ee668b8c0..8d7d5c4f03ac 100644
--- a/src/messages/MOSDPGCreate.h
+++ b/src/messages/MOSDPGCreate.h
@@ -28,7 +28,20 @@ struct MOSDPGCreate : public Message {
     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() {}
@@ -39,14 +52,16 @@ struct MOSDPGCreate : public Message {
   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
diff --git a/src/messages/MOSDPGInfo.h b/src/messages/MOSDPGInfo.h
index 55d59d27f9f2..2e030851ec79 100644
--- a/src/messages/MOSDPGInfo.h
+++ b/src/messages/MOSDPGInfo.h
@@ -37,13 +37,13 @@ public:
   }
 
   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);
   }
 };
 
diff --git a/src/messages/MOSDPGNotify.h b/src/messages/MOSDPGNotify.h
index 52394393c9e4..1294390d6f4e 100644
--- a/src/messages/MOSDPGNotify.h
+++ b/src/messages/MOSDPGNotify.h
@@ -41,14 +41,13 @@ class MOSDPGNotify : public Message {
   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);
   }
 };
 
diff --git a/src/messages/MOSDPGPeer.h b/src/messages/MOSDPGPeer.h
index dd3164cdc112..978f540c2335 100644
--- a/src/messages/MOSDPGPeer.h
+++ b/src/messages/MOSDPGPeer.h
@@ -41,17 +41,15 @@ class MOSDPGPeer : public Message {
   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);
   }
 };
 
diff --git a/src/messages/MOSDPGPeerAck.h b/src/messages/MOSDPGPeerAck.h
index dc4fac1a9436..88b6ddf434c6 100644
--- a/src/messages/MOSDPGPeerAck.h
+++ b/src/messages/MOSDPGPeerAck.h
@@ -37,33 +37,15 @@ class MOSDPGPeerAck : public Message {
   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);
   }
 };
 
diff --git a/src/messages/MOSDPGPeerRequest.h b/src/messages/MOSDPGPeerRequest.h
index fab654237f4d..e6626c549ceb 100644
--- a/src/messages/MOSDPGPeerRequest.h
+++ b/src/messages/MOSDPGPeerRequest.h
@@ -37,14 +37,13 @@ class MOSDPGPeerRequest : public Message {
   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);
   }
 };
 
diff --git a/src/messages/MOSDPGQuery.h b/src/messages/MOSDPGQuery.h
index c8e1c94a49a9..870f41eae88e 100644
--- a/src/messages/MOSDPGQuery.h
+++ b/src/messages/MOSDPGQuery.h
@@ -38,13 +38,13 @@ class MOSDPGQuery : public Message {
   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);
   }
 };
 
diff --git a/src/messages/MOSDPGRemove.h b/src/messages/MOSDPGRemove.h
index 18afb41a427e..6903213e9260 100644
--- a/src/messages/MOSDPGRemove.h
+++ b/src/messages/MOSDPGRemove.h
@@ -37,14 +37,13 @@ class MOSDPGRemove : public Message {
   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);
   }
 
 };
diff --git a/src/messages/MOSDPGSummary.h b/src/messages/MOSDPGSummary.h
index 0dcebffaf74d..df2dae5d6e65 100644
--- a/src/messages/MOSDPGSummary.h
+++ b/src/messages/MOSDPGSummary.h
@@ -33,7 +33,7 @@ public:
     Message(MSG_OSD_PG_SUMMARY) {
     this->epoch = mv;
     this->pgid = pgid;
-    summary._encode(sumbl);
+    summary.encode(sumbl);
   }
 
   pg_t get_pgid() { return pgid; }
diff --git a/src/messages/MOSDPing.h b/src/messages/MOSDPing.h
index 84689676b142..2bff616fb35d 100644
--- a/src/messages/MOSDPing.h
+++ b/src/messages/MOSDPing.h
@@ -32,15 +32,15 @@ class MOSDPing : public Message {
   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"; }
diff --git a/src/messages/MOSDSubOp.h b/src/messages/MOSDSubOp.h
index c52374c71721..2155022a0b7e 100644
--- a/src/messages/MOSDSubOp.h
+++ b/src/messages/MOSDSubOp.h
@@ -26,100 +26,120 @@
 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 << ")";
   }
 };
diff --git a/src/messages/MOSDSubOpReply.h b/src/messages/MOSDSubOpReply.h
index f44827992491..30b5c1ca5f08 100644
--- a/src/messages/MOSDSubOpReply.h
+++ b/src/messages/MOSDSubOpReply.h
@@ -30,93 +30,112 @@
  */
 
 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 << ")";
   }
 
diff --git a/src/osd/osd_types.h b/src/osd/osd_types.h
index ee3a5f28636b..9e525ca33c0f 100644
--- a/src/osd/osd_types.h
+++ b/src/osd/osd_types.h
@@ -323,6 +323,7 @@ struct pg_stat_t {
 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
@@ -371,12 +372,33 @@ public:
   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)
 {