ceph/src/messages/MOSDSubOpReply.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) 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:
  36   epoch_t map_epoch;
  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
  47   __u8 ack_type;
  48   int32_t result;
  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