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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
// -*- 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) 2004-2006 Sage Weil <sage@newdream.net>
*
* 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 CEPH_MMDSSLAVEREQUEST_H
#define CEPH_MMDSSLAVEREQUEST_H
#include "mds/mds_types.h"
#include "include/filepath.h"
#include "msg/Message.h"
class MMDSSlaveRequest : public Message {
public:
static const int OP_XLOCK = 1;
static const int OP_XLOCKACK = -1;
static const int OP_UNXLOCK = 2;
static const int OP_AUTHPIN = 3;
static const int OP_AUTHPINACK = -3;
static const int OP_LINKPREP = 4;
static const int OP_UNLINKPREP = 5;
static const int OP_LINKPREPACK = -4;
static const int OP_RENAMEPREP = 7;
static const int OP_RENAMEPREPACK = -7;
static const int OP_WRLOCK = 8;
static const int OP_WRLOCKACK = -8;
static const int OP_UNWRLOCK = 9;
static const int OP_RMDIRPREP = 10;
static const int OP_RMDIRPREPACK = -10;
static const int OP_FINISH = 17;
static const int OP_COMMITTED = -18;
static const int OP_ABORT = 20; // used for recovery only
//static const int OP_COMMIT = 21; // used for recovery only
const static char *get_opname(int o) {
switch (o) {
case OP_XLOCK: return "xlock";
case OP_XLOCKACK: return "xlock_ack";
case OP_UNXLOCK: return "unxlock";
case OP_AUTHPIN: return "authpin";
case OP_AUTHPINACK: return "authpin_ack";
case OP_LINKPREP: return "link_prep";
case OP_LINKPREPACK: return "link_prep_ack";
case OP_UNLINKPREP: return "unlink_prep";
case OP_RENAMEPREP: return "rename_prep";
case OP_RENAMEPREPACK: return "rename_prep_ack";
case OP_FINISH: return "finish"; // commit
case OP_COMMITTED: return "committed";
case OP_WRLOCK: return "wrlock";
case OP_WRLOCKACK: return "wrlock_ack";
case OP_UNWRLOCK: return "unwrlock";
case OP_RMDIRPREP: return "rmdir_prep";
case OP_RMDIRPREPACK: return "rmdir_prep_ack";
case OP_ABORT: return "abort";
//case OP_COMMIT: return "commit";
default: assert(0); return 0;
}
}
private:
metareqid_t reqid;
__u32 attempt;
__s16 op;
// for locking
__u16 lock_type; // lock object type
MDSCacheObjectInfo object_info;
// for authpins
vector<MDSCacheObjectInfo> authpins;
public:
// for rename prep
filepath srcdnpath;
filepath destdnpath;
set<__s32> witnesses;
bufferlist inode_export;
version_t inode_export_v;
bufferlist srci_replica;
utime_t now;
bufferlist stray; // stray dir + dentry
public:
metareqid_t get_reqid() { return reqid; }
__u32 get_attempt() const { return attempt; }
int get_op() { return op; }
bool is_reply() { return op < 0; }
int get_lock_type() { return lock_type; }
MDSCacheObjectInfo &get_object_info() { return object_info; }
MDSCacheObjectInfo &get_authpin_freeze() { return object_info; }
vector<MDSCacheObjectInfo>& get_authpins() { return authpins; }
void set_lock_type(int t) { lock_type = t; }
// ----
MMDSSlaveRequest() : Message(MSG_MDS_SLAVE_REQUEST) { }
MMDSSlaveRequest(metareqid_t ri, __u32 att, int o) :
Message(MSG_MDS_SLAVE_REQUEST),
reqid(ri), attempt(att), op(o) { }
private:
~MMDSSlaveRequest() {}
public:
void encode_payload(uint64_t features) {
::encode(reqid, payload);
::encode(attempt, payload);
::encode(op, payload);
::encode(lock_type, payload);
::encode(object_info, payload);
::encode(authpins, payload);
::encode(srcdnpath, payload);
::encode(destdnpath, payload);
::encode(witnesses, payload);
::encode(now, payload);
::encode(inode_export, payload);
::encode(inode_export_v, payload);
::encode(srci_replica, payload);
::encode(stray, payload);
}
void decode_payload() {
bufferlist::iterator p = payload.begin();
::decode(reqid, p);
::decode(attempt, p);
::decode(op, p);
::decode(lock_type, p);
::decode(object_info, p);
::decode(authpins, p);
::decode(srcdnpath, p);
::decode(destdnpath, p);
::decode(witnesses, p);
::decode(now, p);
::decode(inode_export, p);
::decode(inode_export_v, p);
::decode(srci_replica, p);
::decode(stray, p);
}
const char *get_type_name() const { return "slave_request"; }
void print(ostream& out) const {
out << "slave_request(" << reqid
<< "." << attempt
<< " " << get_opname(op)
<< ")";
}
};
#endif
|
