#define CEPH_MCLIENTCAPS_H
#include "msg/Message.h"
+#include "mds/mdstypes.h"
#include "include/ceph_features.h"
-#define CLIENT_CAPS_SYNC (0x1)
+class MClientCaps final : public SafeMessage {
+private:
-class MClientCaps : public Message {
- static const int HEAD_VERSION = 11;
- static const int COMPAT_VERSION = 1;
+ static constexpr int HEAD_VERSION = 11;
+ static constexpr int COMPAT_VERSION = 1;
public:
+ static constexpr unsigned FLAG_SYNC = (1<<0);
+ static constexpr unsigned FLAG_NO_CAPSNAP = (1<<1); // unused
+ static constexpr unsigned FLAG_PENDING_CAPSNAP = (1<<2);
+
struct ceph_mds_caps_head head;
uint64_t size = 0;
struct ceph_mds_cap_peer peer;
- bufferlist snapbl;
- bufferlist xattrbl;
- bufferlist flockbl;
+ ceph::buffer::list snapbl;
+ ceph::buffer::list xattrbl;
+ ceph::buffer::list flockbl;
version_t inline_version = 0;
- bufferlist inline_data;
+ ceph::buffer::list inline_data;
// Receivers may not use their new caps until they have this OSD map
epoch_t osd_epoch_barrier = 0;
/* advisory CLIENT_CAPS_* flags to send to mds */
unsigned flags = 0;
- int get_caps() { return head.caps; }
- int get_wanted() { return head.wanted; }
- int get_dirty() { return head.dirty; }
- ceph_seq_t get_seq() { return head.seq; }
- ceph_seq_t get_issue_seq() { return head.issue_seq; }
- ceph_seq_t get_mseq() { return head.migrate_seq; }
-
- inodeno_t get_ino() { return inodeno_t(head.ino); }
- inodeno_t get_realm() { return inodeno_t(head.realm); }
- uint64_t get_cap_id() { return head.cap_id; }
-
- uint64_t get_size() { return size; }
- uint64_t get_max_size() { return max_size; }
- __u32 get_truncate_seq() { return truncate_seq; }
- uint64_t get_truncate_size() { return truncate_size; }
- utime_t get_ctime() { return ctime; }
- utime_t get_btime() { return btime; }
- utime_t get_mtime() { return mtime; }
- utime_t get_atime() { return atime; }
- __u64 get_change_attr() { return change_attr; }
- __u32 get_time_warp_seq() { return time_warp_seq; }
- uint64_t get_nfiles() { return nfiles; }
- uint64_t get_nsubdirs() { return nsubdirs; }
+ int get_caps() const { return head.caps; }
+ int get_wanted() const { return head.wanted; }
+ int get_dirty() const { return head.dirty; }
+ ceph_seq_t get_seq() const { return head.seq; }
+ ceph_seq_t get_issue_seq() const { return head.issue_seq; }
+ ceph_seq_t get_mseq() const { return head.migrate_seq; }
+
+ inodeno_t get_ino() const { return inodeno_t(head.ino); }
+ inodeno_t get_realm() const { return inodeno_t(head.realm); }
+ uint64_t get_cap_id() const { return head.cap_id; }
+
+ uint64_t get_size() const { return size; }
+ uint64_t get_max_size() const { return max_size; }
+ __u32 get_truncate_seq() const { return truncate_seq; }
+ uint64_t get_truncate_size() const { return truncate_size; }
+ utime_t get_ctime() const { return ctime; }
+ utime_t get_btime() const { return btime; }
+ utime_t get_mtime() const { return mtime; }
+ utime_t get_atime() const { return atime; }
+ __u64 get_change_attr() const { return change_attr; }
+ __u32 get_time_warp_seq() const { return time_warp_seq; }
+ uint64_t get_nfiles() const { return nfiles; }
+ uint64_t get_nsubdirs() const { return nsubdirs; }
bool dirstat_is_valid() const { return nfiles != -1 || nsubdirs != -1; }
- const file_layout_t& get_layout() {
+ const file_layout_t& get_layout() const {
return layout;
}
layout = l;
}
- int get_migrate_seq() { return head.migrate_seq; }
- int get_op() { return head.op; }
+ int get_migrate_seq() const { return head.migrate_seq; }
+ int get_op() const { return head.op; }
- uint64_t get_client_tid() { return get_tid(); }
+ uint64_t get_client_tid() const { return get_tid(); }
void set_client_tid(uint64_t s) { set_tid(s); }
- snapid_t get_snap_follows() { return snapid_t(head.snap_follows); }
+ snapid_t get_snap_follows() const { return snapid_t(head.snap_follows); }
void set_snap_follows(snapid_t s) { head.snap_follows = s; }
void set_caps(int c) { head.caps = c; }
}
void set_oldest_flush_tid(ceph_tid_t tid) { oldest_flush_tid = tid; }
- ceph_tid_t get_oldest_flush_tid() { return oldest_flush_tid; }
+ ceph_tid_t get_oldest_flush_tid() const { return oldest_flush_tid; }
void clear_dirty() { head.dirty = 0; }
+protected:
MClientCaps()
- : Message(CEPH_MSG_CLIENT_CAPS, HEAD_VERSION, COMPAT_VERSION) {}
+ : SafeMessage{CEPH_MSG_CLIENT_CAPS, HEAD_VERSION, COMPAT_VERSION} {}
MClientCaps(int op,
inodeno_t ino,
inodeno_t realm,
int dirty,
int mseq,
epoch_t oeb)
- : Message(CEPH_MSG_CLIENT_CAPS, HEAD_VERSION, COMPAT_VERSION),
+ : SafeMessage{CEPH_MSG_CLIENT_CAPS, HEAD_VERSION, COMPAT_VERSION},
osd_epoch_barrier(oeb) {
memset(&head, 0, sizeof(head));
head.op = op;
MClientCaps(int op,
inodeno_t ino, inodeno_t realm,
uint64_t id, int mseq, epoch_t oeb)
- : Message(CEPH_MSG_CLIENT_CAPS, HEAD_VERSION, COMPAT_VERSION),
+ : SafeMessage{CEPH_MSG_CLIENT_CAPS, HEAD_VERSION, COMPAT_VERSION},
osd_epoch_barrier(oeb) {
memset(&head, 0, sizeof(head));
head.op = op;
head.migrate_seq = mseq;
memset(&peer, 0, sizeof(peer));
}
+ ~MClientCaps() final {}
+
private:
file_layout_t layout;
- ~MClientCaps() override {}
-
public:
- const char *get_type_name() const override { return "Cfcap";}
- void print(ostream& out) const override {
+ std::string_view get_type_name() const override { return "Cfcap";}
+ void print(std::ostream& out) const override {
out << "client_caps(" << ceph_cap_op_name(head.op)
<< " ino " << inodeno_t(head.ino)
<< " " << head.cap_id
out << " size " << size << "/" << max_size;
if (truncate_seq)
out << " ts " << truncate_seq << "/" << truncate_size;
- out << " mtime " << mtime;
+ out << " mtime " << mtime
+ << " ctime " << ctime
+ << " change_attr " << change_attr;
if (time_warp_seq)
out << " tws " << time_warp_seq;
out << ")";
}
-
+
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
- ::decode(head, p);
- ceph_mds_caps_body_legacy body;
- ::decode(body, p);
+ using ceph::decode;
+ auto p = payload.cbegin();
+ decode(head, p);
if (head.op == CEPH_CAP_OP_EXPORT) {
+ ceph_mds_caps_export_body body;
+ decode(body, p);
peer = body.peer;
+ p += (sizeof(ceph_mds_caps_non_export_body) -
+ sizeof(ceph_mds_caps_export_body));
} else {
+ ceph_mds_caps_non_export_body body;
+ decode(body, p);
size = body.size;
max_size = body.max_size;
truncate_size = body.truncate_size;
layout.from_legacy(body.layout);
time_warp_seq = body.time_warp_seq;
}
- ::decode_nohead(head.snap_trace_len, snapbl, p);
+ ceph::decode_nohead(head.snap_trace_len, snapbl, p);
- assert(middle.length() == head.xattr_len);
+ ceph_assert(middle.length() == head.xattr_len);
if (head.xattr_len)
xattrbl = middle;
// conditionally decode flock metadata
if (header.version >= 2)
- ::decode(flockbl, p);
+ decode(flockbl, p);
if (header.version >= 3) {
if (head.op == CEPH_CAP_OP_IMPORT)
- ::decode(peer, p);
+ decode(peer, p);
}
if (header.version >= 4) {
- ::decode(inline_version, p);
- ::decode(inline_data, p);
+ decode(inline_version, p);
+ decode(inline_data, p);
} else {
inline_version = CEPH_INLINE_NONE;
}
if (header.version >= 5) {
- ::decode(osd_epoch_barrier, p);
+ decode(osd_epoch_barrier, p);
}
if (header.version >= 6) {
- ::decode(oldest_flush_tid, p);
+ decode(oldest_flush_tid, p);
}
if (header.version >= 7) {
- ::decode(caller_uid, p);
- ::decode(caller_gid, p);
+ decode(caller_uid, p);
+ decode(caller_gid, p);
}
if (header.version >= 8) {
- ::decode(layout.pool_ns, p);
+ decode(layout.pool_ns, p);
}
if (header.version >= 9) {
- ::decode(btime, p);
- ::decode(change_attr, p);
+ decode(btime, p);
+ decode(change_attr, p);
}
if (header.version >= 10) {
- ::decode(flags, p);
+ decode(flags, p);
}
if (header.version >= 11) {
decode(nfiles, p);
}
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
header.version = HEAD_VERSION;
head.snap_trace_len = snapbl.length();
head.xattr_len = xattrbl.length();
- ::encode(head, payload);
- ceph_mds_caps_body_legacy body;
+ encode(head, payload);
+ static_assert(sizeof(ceph_mds_caps_non_export_body) >
+ sizeof(ceph_mds_caps_export_body));
if (head.op == CEPH_CAP_OP_EXPORT) {
- memset(&body, 0, sizeof(body));
+ ceph_mds_caps_export_body body;
body.peer = peer;
+ encode(body, payload);
+ payload.append_zero(sizeof(ceph_mds_caps_non_export_body) -
+ sizeof(ceph_mds_caps_export_body));
} else {
+ ceph_mds_caps_non_export_body body;
body.size = size;
body.max_size = max_size;
body.truncate_size = truncate_size;
ctime.encode_timeval(&body.ctime);
layout.to_legacy(&body.layout);
body.time_warp_seq = time_warp_seq;
+ encode(body, payload);
}
- ::encode(body, payload);
- ::encode_nohead(snapbl, payload);
+ ceph::encode_nohead(snapbl, payload);
middle = xattrbl;
// conditionally include flock metadata
if (features & CEPH_FEATURE_FLOCK) {
- ::encode(flockbl, payload);
+ encode(flockbl, payload);
} else {
header.version = 1;
return;
if (features & CEPH_FEATURE_EXPORT_PEER) {
if (head.op == CEPH_CAP_OP_IMPORT)
- ::encode(peer, payload);
+ encode(peer, payload);
} else {
header.version = 2;
return;
}
if (features & CEPH_FEATURE_MDS_INLINE_DATA) {
- ::encode(inline_version, payload);
- ::encode(inline_data, payload);
+ encode(inline_version, payload);
+ encode(inline_data, payload);
} else {
- ::encode(inline_version, payload);
- ::encode(bufferlist(), payload);
+ encode(inline_version, payload);
+ encode(ceph::buffer::list(), payload);
}
- ::encode(osd_epoch_barrier, payload);
- ::encode(oldest_flush_tid, payload);
- ::encode(caller_uid, payload);
- ::encode(caller_gid, payload);
-
- ::encode(layout.pool_ns, payload);
- ::encode(btime, payload);
- ::encode(change_attr, payload);
- ::encode(flags, payload);
- ::encode(nfiles, payload);
- ::encode(nsubdirs, payload);
+ encode(osd_epoch_barrier, payload);
+ encode(oldest_flush_tid, payload);
+ encode(caller_uid, payload);
+ encode(caller_gid, payload);
+
+ encode(layout.pool_ns, payload);
+ encode(btime, payload);
+ encode(change_attr, payload);
+ encode(flags, payload);
+ encode(nfiles, payload);
+ encode(nsubdirs, payload);
}
+private:
+ template<class T, typename... Args>
+ friend boost::intrusive_ptr<T> ceph::make_message(Args&&... args);
+ template<class T, typename... Args>
+ friend MURef<T> crimson::make_message(Args&&... args);
};
#endif
projects / ceph.git / blobdiff