1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2013 Inktank Storage, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#ifndef ECBMSGTYPES_H
#define ECBMSGTYPES_H
#include "osd_types.h"
#include "include/buffer.h"
#include "os/ObjectStore.h"
#include "boost/tuple/tuple.hpp"
struct ECSubWrite {
pg_shard_t from;
ceph_tid_t tid;
osd_reqid_t reqid;
hobject_t soid;
pg_stat_t stats;
ObjectStore::Transaction t;
eversion_t at_version;
eversion_t trim_to;
eversion_t roll_forward_to;
std::vector<pg_log_entry_t> log_entries;
std::set<hobject_t> temp_added;
std::set<hobject_t> temp_removed;
std::optional<pg_hit_set_history_t> updated_hit_set_history;
bool backfill_or_async_recovery = false;
ECSubWrite() : tid(0) {}
ECSubWrite(
pg_shard_t from,
ceph_tid_t tid,
osd_reqid_t reqid,
hobject_t soid,
const pg_stat_t &stats,
const ObjectStore::Transaction &t,
eversion_t at_version,
eversion_t trim_to,
eversion_t roll_forward_to,
std::vector<pg_log_entry_t> log_entries,
std::optional<pg_hit_set_history_t> updated_hit_set_history,
const std::set<hobject_t> &temp_added,
const std::set<hobject_t> &temp_removed,
bool backfill_or_async_recovery)
: from(from), tid(tid), reqid(reqid),
soid(soid), stats(stats), t(t),
at_version(at_version),
trim_to(trim_to), roll_forward_to(roll_forward_to),
log_entries(log_entries),
temp_added(temp_added),
temp_removed(temp_removed),
updated_hit_set_history(updated_hit_set_history),
backfill_or_async_recovery(backfill_or_async_recovery)
{}
void claim(ECSubWrite &other) {
from = other.from;
tid = other.tid;
reqid = other.reqid;
soid = other.soid;
stats = other.stats;
t.swap(other.t);
at_version = other.at_version;
trim_to = other.trim_to;
roll_forward_to = other.roll_forward_to;
log_entries.swap(other.log_entries);
temp_added.swap(other.temp_added);
temp_removed.swap(other.temp_removed);
updated_hit_set_history = other.updated_hit_set_history;
backfill_or_async_recovery = other.backfill_or_async_recovery;
}
void encode(ceph::buffer::list &bl) const;
void decode(ceph::buffer::list::const_iterator &bl);
void dump(ceph::Formatter *f) const;
static void generate_test_instances(std::list<ECSubWrite*>& o);
private:
// no outside copying -- slow
ECSubWrite(ECSubWrite& other);
const ECSubWrite& operator=(const ECSubWrite& other);
};
WRITE_CLASS_ENCODER(ECSubWrite)
struct ECSubWriteReply {
pg_shard_t from;
ceph_tid_t tid;
eversion_t last_complete;
bool committed;
bool applied;
ECSubWriteReply() : tid(0), committed(false), applied(false) {}
void encode(ceph::buffer::list &bl) const;
void decode(ceph::buffer::list::const_iterator &bl);
void dump(ceph::Formatter *f) const;
static void generate_test_instances(std::list<ECSubWriteReply*>& o);
};
WRITE_CLASS_ENCODER(ECSubWriteReply)
struct ECSubRead {
pg_shard_t from;
ceph_tid_t tid;
std::map<hobject_t, std::list<boost::tuple<uint64_t, uint64_t, uint32_t> >> to_read;
std::set<hobject_t> attrs_to_read;
std::map<hobject_t, std::vector<std::pair<int, int>>> subchunks;
void encode(ceph::buffer::list &bl, uint64_t features) const;
void decode(ceph::buffer::list::const_iterator &bl);
void dump(ceph::Formatter *f) const;
static void generate_test_instances(std::list<ECSubRead*>& o);
};
WRITE_CLASS_ENCODER_FEATURES(ECSubRead)
struct ECSubReadReply {
pg_shard_t from;
ceph_tid_t tid;
std::map<hobject_t, std::list<std::pair<uint64_t, ceph::buffer::list> >> buffers_read;
std::map<hobject_t, std::map<std::string, ceph::buffer::list>> attrs_read;
std::map<hobject_t, int> errors;
void encode(ceph::buffer::list &bl) const;
void decode(ceph::buffer::list::const_iterator &bl);
void dump(ceph::Formatter *f) const;
static void generate_test_instances(std::list<ECSubReadReply*>& o);
};
WRITE_CLASS_ENCODER(ECSubReadReply)
std::ostream &operator<<(
std::ostream &lhs, const ECSubWrite &rhs);
std::ostream &operator<<(
std::ostream &lhs, const ECSubWriteReply &rhs);
std::ostream &operator<<(
std::ostream &lhs, const ECSubRead &rhs);
std::ostream &operator<<(
std::ostream &lhs, const ECSubReadReply &rhs);
#endif
|
