← Back to branch summary

~ubuntu-branches/ubuntu/precise/ceph/precise-proposed

« back to all changes in this revision

Viewing changes to src/osd/osd_types.h

  • Committer: Bazaar Package Importer
  • Author(s): Laszlo Boszormenyi (GCS)
  • Date: 2011-09-24 16:51:57 UTC
  • mfrom: (1.1.5 upstream) (0.1.8 sid)
  • Revision ID: james.westby@ubuntu.com-20110924165157-x9zh5nxpipno2u33
Tags: 0.35-1
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/osd/osd_types.h
21
21
 
22
22
#include "msg/msg_types.h"
23
23
#include "include/types.h"
 
24
#include "include/utime.h"
24
25
#include "include/CompatSet.h"
25
26
#include "include/interval_set.h"
26
27
#include "common/Formatter.h"
88
89
 
89
90
// pg stuff
90
91
 
91
 
typedef uint16_t ps_t;
92
 
 
93
92
// object namespaces
94
93
#define CEPH_METADATA_NS       1
95
94
#define CEPH_DATA_NS           2
103
102
  CEPH_RBD_RULE,
104
103
};
105
104
 
106
 
//#define CEPH_POOL(poolset, size) (((poolset) << 8) + (size))
107
 
 
108
 
#define OSD_SUPERBLOCK_POBJECT sobject_t(object_t("osd_superblock"), 0)
 
105
#define OSD_SUPERBLOCK_POBJECT hobject_t(sobject_t(object_t("osd_superblock"), 0))
 
106
 
 
107
// placement seed (a hash value)
 
108
typedef uint32_t ps_t;
 
109
 
 
110
// old (v1) pg_t encoding (wrap old struct ceph_pg)
 
111
struct old_pg_t {
 
112
  ceph_pg v;
 
113
  void encode(bufferlist& bl) const {
 
114
    ::encode_raw(v, bl);
 
115
  }
 
116
  void decode(bufferlist::iterator& bl) {
 
117
    ::decode_raw(v, bl);
 
118
  }
 
119
};
 
120
WRITE_CLASS_ENCODER(old_pg_t)
109
121
 
110
122
// placement group id
111
123
struct pg_t {
112
 
  struct ceph_pg v;
 
124
  uint64_t m_pool;
 
125
  uint32_t m_seed;
 
126
  int32_t m_preferred;
113
127
 
114
 
  pg_t() { memset(&v, 0, sizeof(v)); }
115
 
  pg_t(const pg_t& o) { v = o.v; }
116
 
  pg_t(ps_t seed, int pool_, int pref) {
117
 
    v.ps = seed;
118
 
    v.pool = pool_;
119
 
    v.preferred = pref;   // hack: avoid negative.
 
128
  pg_t() : m_pool(0), m_seed(0), m_preferred(-1) {}
 
129
  pg_t(ps_t seed, uint64_t pool, int pref) {
 
130
    m_seed = seed;
 
131
    m_pool = pool;
 
132
    m_preferred = pref;
120
133
  }
 
134
 
121
135
  pg_t(const ceph_pg& cpg) {
122
 
    v = cpg;
123
 
  }
124
 
 
125
 
  ps_t ps() const { return v.ps; }
126
 
  int pool() const { return v.pool; }
127
 
  int preferred() const { return (__s16)v.preferred; }   // hack: avoid negative.
 
136
    m_pool = cpg.pool;
 
137
    m_seed = cpg.ps;
 
138
    m_preferred = (__s16)cpg.preferred;
 
139
  }
 
140
  old_pg_t get_old_pg() const {
 
141
    old_pg_t o;
 
142
    assert(m_pool < 0xffffffffull);
 
143
    o.v.pool = m_pool;
 
144
    o.v.ps = m_seed;
 
145
    o.v.preferred = (__s16)m_preferred;
 
146
    return o;
 
147
  }
 
148
  pg_t(const old_pg_t& opg) {
 
149
    *this = opg.v;
 
150
  }
 
151
 
 
152
  ps_t ps() const {
 
153
    return m_seed;
 
154
  }
 
155
  uint64_t pool() const {
 
156
    return m_pool;
 
157
  }
 
158
  int32_t preferred() const {
 
159
    return m_preferred;
 
160
  }
 
161
 
 
162
  void set_ps(ps_t p) {
 
163
    m_seed = p;
 
164
  }
 
165
  void set_pool(uint64_t p) {
 
166
    m_pool = p;
 
167
  }
 
168
  void set_preferred(int32_t osd) {
 
169
    m_preferred = osd;
 
170
  }
128
171
 
129
172
  int print(char *o, int maxlen) const;
130
173
  bool parse(const char *s);
131
 
} __attribute__ ((packed));
 
174
 
 
175
  void encode(bufferlist& bl) const {
 
176
    __u8 v = 1;
 
177
    ::encode(v, bl);
 
178
    ::encode(m_pool, bl);
 
179
    ::encode(m_seed, bl);
 
180
    ::encode(m_preferred, bl);
 
181
  }
 
182
  void decode(bufferlist::iterator& bl) {
 
183
    __u8 v;
 
184
    ::decode(v, bl);
 
185
    ::decode(m_pool, bl);
 
186
    ::decode(m_seed, bl);
 
187
    ::decode(m_preferred, bl);
 
188
  }
 
189
  void decode_old(bufferlist::iterator& bl) {
 
190
    old_pg_t opg;
 
191
    ::decode(opg, bl);
 
192
    *this = opg;
 
193
  }
 
194
};
 
195
WRITE_CLASS_ENCODER(pg_t)
132
196
 
133
197
inline bool operator<(const pg_t& l, const pg_t& r) {
134
198
  return l.pool() < r.pool() ||
161
225
                              (l.preferred() == r.preferred() && (l.ps() >= r.ps()))));
162
226
}
163
227
 
164
 
 
165
 
inline void encode(pg_t pgid, bufferlist& bl) {
166
 
  encode_raw(pgid.v, bl);
167
 
}
168
 
inline void decode(pg_t &pgid, bufferlist::iterator& p) { 
169
 
  decode_raw(pgid.v, p); 
170
 
}
171
 
 
172
228
ostream& operator<<(ostream& out, const pg_t &pg);
173
229
 
174
230
namespace __gnu_cxx {
177
233
    size_t operator()( const pg_t& x ) const
178
234
    {
179
235
      static hash<uint32_t> H;
180
 
      return H(x.pool() ^ x.ps() ^ x.preferred());
 
236
      return H((x.pool() & 0xffffffff) ^ (x.pool() >> 32) ^ x.ps() ^ x.preferred());
181
237
    }
182
238
  };
183
239
}
210
266
    return str.c_str();
211
267
  }
212
268
 
 
269
  int operator<(const coll_t &rhs) const {
 
270
    return str < rhs.str;
 
271
  }
 
272
 
213
273
  bool is_pg(pg_t& pgid, snapid_t& snap) const;
214
274
  void encode(bufferlist& bl) const;
215
275
  void decode(bufferlist::iterator& bl);
516
576
  bool is_rep()   const { return get_type() == CEPH_PG_TYPE_REP; }
517
577
  bool is_raid4() const { return get_type() == CEPH_PG_TYPE_RAID4; }
518
578
 
519
 
  int get_pg_num() const { return v.pg_num; }
520
 
  int get_pgp_num() const { return v.pgp_num; }
521
 
  int get_lpg_num() const { return v.lpg_num; }
522
 
  int get_lpgp_num() const { return v.lpgp_num; }
 
579
  unsigned get_pg_num() const { return v.pg_num; }
 
580
  unsigned get_pgp_num() const { return v.pgp_num; }
 
581
  unsigned get_lpg_num() const { return v.lpg_num; }
 
582
  unsigned get_lpgp_num() const { return v.lpgp_num; }
523
583
 
524
 
  int get_pg_num_mask() const { return pg_num_mask; }
525
 
  int get_pgp_num_mask() const { return pgp_num_mask; }
526
 
  int get_lpg_num_mask() const { return lpg_num_mask; }
527
 
  int get_lpgp_num_mask() const { return lpgp_num_mask; }
 
584
  unsigned get_pg_num_mask() const { return pg_num_mask; }
 
585
  unsigned get_pgp_num_mask() const { return pgp_num_mask; }
 
586
  unsigned get_lpg_num_mask() const { return lpg_num_mask; }
 
587
  unsigned get_lpgp_num_mask() const { return lpgp_num_mask; }
528
588
 
529
589
  int calc_bits_of(int t);
530
590
  void calc_pg_masks();
790
850
  }
791
851
 
792
852
  void encode(bufferlist &bl) const {
793
 
    __u8 v = 5;
 
853
    __u8 v = 6;
794
854
    ::encode(v, bl);
795
855
 
796
856
    ::encode(version, bl);
812
872
  void decode(bufferlist::iterator &bl) {
813
873
    __u8 v;
814
874
    ::decode(v, bl);
815
 
    if (v > 5)
 
875
    if (v > 6)
816
876
      throw buffer::malformed_input("unknown pg_stat_t encoding version > 4");
817
877
 
818
878
    ::decode(version, bl);
821
881
    ::decode(log_start, bl);
822
882
    ::decode(ondisk_log_start, bl);
823
883
    ::decode(created, bl);
824
 
    ::decode(parent, bl);
 
884
    if (v < 6) {
 
885
      old_pg_t opgid;
 
886
      ::decode(opgid, bl);
 
887
      parent = opgid;
 
888
    } else {
 
889
      ::decode(parent, bl);
 
890
    }
825
891
    ::decode(parent_split_bits, bl);
826
892
    ::decode(last_scrub, bl);
827
893
    ::decode(last_scrub_stamp, bl);
1102
1168
 
1103
1169
 
1104
1170
struct object_info_t {
1105
 
  sobject_t soid;
 
1171
  hobject_t soid;
1106
1172
  object_locator_t oloc;
1107
1173
  string category;
1108
1174
 
1124
1190
 
1125
1191
  void copy_user_bits(const object_info_t& other);
1126
1192
 
 
1193
  static ps_t legacy_object_locator_to_ps(const object_t &oid, 
 
1194
                                          const object_locator_t &loc);
 
1195
 
1127
1196
  void encode(bufferlist& bl) const;
1128
1197
  void decode(bufferlist::iterator& bl);
1129
1198
  void decode(bufferlist& bl) {
1131
1200
    decode(p);
1132
1201
  }
1133
1202
 
1134
 
  object_info_t(const sobject_t& s, const object_locator_t& o)
 
1203
  object_info_t(const hobject_t& s, const object_locator_t& o)
1135
1204
    : soid(s), oloc(o), size(0),
1136
1205
      lost(false), truncate_seq(0), truncate_size(0) {}
1137
1206
 
1174
1243
  };
1175
1244
  WRITE_CLASS_ENCODER(object)
1176
1245
 
1177
 
  map<sobject_t,object> objects;
 
1246
  map<hobject_t,object> objects;
1178
1247
  map<string,bufferptr> attrs;
1179
1248
  bufferlist logbl;
1180
1249
  eversion_t valid_through;