[ceph.git] / ceph / src / mds / Server.h

// -*- 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_MDS_SERVER_H
#define CEPH_MDS_SERVER_H

#include "MDSRank.h"
#include "Mutation.h"

class OSDMap;
class PerfCounters;
class LogEvent;
class EMetaBlob;
class EUpdate;
class MMDSSlaveRequest;
struct SnapInfo;
class MClientRequest;
class MClientReply;
class MDLog;

enum {
  l_mdss_first = 1000,
  l_mdss_handle_client_request,
  l_mdss_handle_slave_request,
  l_mdss_handle_client_session,
  l_mdss_dispatch_client_request,
  l_mdss_req_lookuphash,
  l_mdss_req_lookupino,
  l_mdss_req_lookupparent,
  l_mdss_req_lookupname,
  l_mdss_req_lookup,
  l_mdss_req_lookupsnap,
  l_mdss_req_getattr,
  l_mdss_req_setattr,
  l_mdss_req_setlayout,
  l_mdss_req_setdirlayout,
  l_mdss_req_setxattr,
  l_mdss_req_rmxattr,
  l_mdss_req_readdir,
  l_mdss_req_setfilelock,
  l_mdss_req_getfilelock,
  l_mdss_req_create,
  l_mdss_req_open,
  l_mdss_req_mknod,
  l_mdss_req_link,
  l_mdss_req_unlink,
  l_mdss_req_rmdir,
  l_mdss_req_rename,
  l_mdss_req_mkdir,
  l_mdss_req_symlink,
  l_mdss_req_lssnap,
  l_mdss_req_mksnap,
  l_mdss_req_rmsnap,
  l_mdss_req_renamesnap,
  l_mdss_dispatch_slave_request,
  l_mdss_last,
};

class Server {
private:
  MDSRank *mds;
  MDCache *mdcache;
  MDLog *mdlog;
  PerfCounters *logger;

  // OSDMap full status, used to generate ENOSPC on some operations
  bool is_full;

  // State for while in reconnect
  MDSInternalContext *reconnect_done;
  int failed_reconnects;

  friend class MDSContinuation;
  friend class ServerContext;
  friend class ServerLogContext;

public:
  bool terminating_sessions;

  explicit Server(MDSRank *m);
  ~Server() {
    g_ceph_context->get_perfcounters_collection()->remove(logger);
    delete logger;
    delete reconnect_done;
  }

  void create_logger();

  // message handler
  void dispatch(Message *m);

  void handle_osd_map();

  // -- sessions and recovery --
  utime_t  reconnect_start;
  set<client_t> client_reconnect_gather;  // clients i need a reconnect msg from.
  bool waiting_for_reconnect(client_t c) const;
  void dump_reconnect_status(Formatter *f) const;

  Session *get_session(Message *m);
  void handle_client_session(class MClientSession *m);
  void _session_logged(Session *session, uint64_t state_seq, 
		       bool open, version_t pv, interval_set<inodeno_t>& inos,version_t piv);
  version_t prepare_force_open_sessions(map<client_t,entity_inst_t> &cm,
					map<client_t,uint64_t>& sseqmap);
  void finish_force_open_sessions(map<client_t,entity_inst_t> &cm,
				  map<client_t,uint64_t>& sseqmap,
				  bool dec_import=true);
  void flush_client_sessions(set<client_t>& client_set, MDSGatherBuilder& gather);
  void finish_flush_session(Session *session, version_t seq);
  void terminate_sessions();
  void find_idle_sessions();
  void kill_session(Session *session, Context *on_safe);
  void journal_close_session(Session *session, int state, Context *on_safe);
  void reconnect_clients(MDSInternalContext *reconnect_done_);
  void handle_client_reconnect(class MClientReconnect *m);
  //void process_reconnect_cap(CInode *in, int from, ceph_mds_cap_reconnect& capinfo);
  void reconnect_gather_finish();
  void reconnect_tick();
  void recover_filelocks(CInode *in, bufferlist locks, int64_t client);

  void recall_client_state(float ratio);
  void force_clients_readonly();

  // -- requests --
  void handle_client_request(MClientRequest *m);

  void journal_and_reply(MDRequestRef& mdr, CInode *tracei, CDentry *tracedn,
			 LogEvent *le, MDSLogContextBase *fin);
  void submit_mdlog_entry(LogEvent *le, MDSLogContextBase *fin,
                          MDRequestRef& mdr, const char *evt);
  void dispatch_client_request(MDRequestRef& mdr);
  void early_reply(MDRequestRef& mdr, CInode *tracei, CDentry *tracedn);
  void respond_to_request(MDRequestRef& mdr, int r = 0);
  void set_trace_dist(Session *session, MClientReply *reply, CInode *in, CDentry *dn,
		      snapid_t snapid,
		      int num_dentries_wanted,
		      MDRequestRef& mdr);

  void encode_empty_dirstat(bufferlist& bl);
  void encode_infinite_lease(bufferlist& bl);
  void encode_null_lease(bufferlist& bl);

  void handle_slave_request(MMDSSlaveRequest *m);
  void handle_slave_request_reply(MMDSSlaveRequest *m);
  void dispatch_slave_request(MDRequestRef& mdr);
  void handle_slave_auth_pin(MDRequestRef& mdr);
  void handle_slave_auth_pin_ack(MDRequestRef& mdr, MMDSSlaveRequest *ack);

  // some helpers
  bool check_fragment_space(MDRequestRef& mdr, CDir *in);
  bool check_access(MDRequestRef& mdr, CInode *in, unsigned mask);
  bool _check_access(Session *session, CInode *in, unsigned mask, int caller_uid, int caller_gid, int setattr_uid, int setattr_gid);
  CDir *validate_dentry_dir(MDRequestRef& mdr, CInode *diri, const string& dname);
  CDir *traverse_to_auth_dir(MDRequestRef& mdr, vector<CDentry*> &trace, filepath refpath);
  CDentry *prepare_null_dentry(MDRequestRef& mdr, CDir *dir, const string& dname, bool okexist=false);
  CDentry *prepare_stray_dentry(MDRequestRef& mdr, CInode *in);
  CInode* prepare_new_inode(MDRequestRef& mdr, CDir *dir, inodeno_t useino, unsigned mode,
			    file_layout_t *layout=NULL);
  void journal_allocated_inos(MDRequestRef& mdr, EMetaBlob *blob);
  void apply_allocated_inos(MDRequestRef& mdr, Session *session);

  CInode* rdlock_path_pin_ref(MDRequestRef& mdr, int n, set<SimpleLock*>& rdlocks, bool want_auth,
			      bool no_want_auth=false,
			      file_layout_t **layout=NULL,
			      bool no_lookup=false);
  CDentry* rdlock_path_xlock_dentry(MDRequestRef& mdr, int n,
                                    set<SimpleLock*>& rdlocks,
                                    set<SimpleLock*>& wrlocks,
				    set<SimpleLock*>& xlocks, bool okexist,
				    bool mustexist, bool alwaysxlock,
				    file_layout_t **layout=NULL);

  CDir* try_open_auth_dirfrag(CInode *diri, frag_t fg, MDRequestRef& mdr);


  // requests on existing inodes.
  void handle_client_getattr(MDRequestRef& mdr, bool is_lookup);
  void handle_client_lookup_ino(MDRequestRef& mdr,
				bool want_parent, bool want_dentry);
  void _lookup_ino_2(MDRequestRef& mdr, int r);
  void handle_client_readdir(MDRequestRef& mdr);
  void handle_client_file_setlock(MDRequestRef& mdr);
  void handle_client_file_readlock(MDRequestRef& mdr);

  void handle_client_setattr(MDRequestRef& mdr);
  void handle_client_setlayout(MDRequestRef& mdr);
  void handle_client_setdirlayout(MDRequestRef& mdr);

  int parse_layout_vxattr(string name, string value, const OSDMap& osdmap,
			  file_layout_t *layout, bool validate=true);
  int parse_quota_vxattr(string name, string value, quota_info_t *quota);
  int check_layout_vxattr(MDRequestRef& mdr,
                          string name,
                          string value,
                          file_layout_t *layout);
  void handle_set_vxattr(MDRequestRef& mdr, CInode *cur,
			 file_layout_t *dir_layout,
			 set<SimpleLock*> rdlocks,
			 set<SimpleLock*> wrlocks,
			 set<SimpleLock*> xlocks);
  void handle_remove_vxattr(MDRequestRef& mdr, CInode *cur,
			    file_layout_t *dir_layout,
			    set<SimpleLock*> rdlocks,
			    set<SimpleLock*> wrlocks,
			    set<SimpleLock*> xlocks);
  void handle_client_setxattr(MDRequestRef& mdr);
  void handle_client_removexattr(MDRequestRef& mdr);

  void handle_client_fsync(MDRequestRef& mdr);

  // open
  void handle_client_open(MDRequestRef& mdr);
  void handle_client_openc(MDRequestRef& mdr);  // O_CREAT variant.
  void do_open_truncate(MDRequestRef& mdr, int cmode);  // O_TRUNC variant.

  // namespace changes
  void handle_client_mknod(MDRequestRef& mdr);
  void handle_client_mkdir(MDRequestRef& mdr);
  void handle_client_symlink(MDRequestRef& mdr);

  // link
  void handle_client_link(MDRequestRef& mdr);
  void _link_local(MDRequestRef& mdr, CDentry *dn, CInode *targeti);
  void _link_local_finish(MDRequestRef& mdr,
			  CDentry *dn, CInode *targeti,
			  version_t, version_t);

  void _link_remote(MDRequestRef& mdr, bool inc, CDentry *dn, CInode *targeti);
  void _link_remote_finish(MDRequestRef& mdr, bool inc, CDentry *dn, CInode *targeti,
			   version_t);

  void handle_slave_link_prep(MDRequestRef& mdr);
  void _logged_slave_link(MDRequestRef& mdr, CInode *targeti);
  void _commit_slave_link(MDRequestRef& mdr, int r, CInode *targeti);
  void _committed_slave(MDRequestRef& mdr);  // use for rename, too
  void handle_slave_link_prep_ack(MDRequestRef& mdr, MMDSSlaveRequest *m);
  void do_link_rollback(bufferlist &rbl, mds_rank_t master, MDRequestRef& mdr);
  void _link_rollback_finish(MutationRef& mut, MDRequestRef& mdr);

  // unlink
  void handle_client_unlink(MDRequestRef& mdr);
  bool _dir_is_nonempty_unlocked(MDRequestRef& mdr, CInode *rmdiri);
  bool _dir_is_nonempty(MDRequestRef& mdr, CInode *rmdiri);
  void _unlink_local(MDRequestRef& mdr, CDentry *dn, CDentry *straydn);
  void _unlink_local_finish(MDRequestRef& mdr,
			    CDentry *dn, CDentry *straydn,
			    version_t);
  bool _rmdir_prepare_witness(MDRequestRef& mdr, mds_rank_t who, vector<CDentry*>& trace, CDentry *straydn);
  void handle_slave_rmdir_prep(MDRequestRef& mdr);
  void _logged_slave_rmdir(MDRequestRef& mdr, CDentry *srcdn, CDentry *straydn);
  void _commit_slave_rmdir(MDRequestRef& mdr, int r);
  void handle_slave_rmdir_prep_ack(MDRequestRef& mdr, MMDSSlaveRequest *ack);
  void do_rmdir_rollback(bufferlist &rbl, mds_rank_t master, MDRequestRef& mdr);
  void _rmdir_rollback_finish(MDRequestRef& mdr, metareqid_t reqid, CDentry *dn, CDentry *straydn);

  // rename
  void handle_client_rename(MDRequestRef& mdr);
  void _rename_finish(MDRequestRef& mdr,
		      CDentry *srcdn, CDentry *destdn, CDentry *straydn);

  void handle_client_lssnap(MDRequestRef& mdr);
  void handle_client_mksnap(MDRequestRef& mdr);
  void _mksnap_finish(MDRequestRef& mdr, CInode *diri, SnapInfo &info);
  void handle_client_rmsnap(MDRequestRef& mdr);
  void _rmsnap_finish(MDRequestRef& mdr, CInode *diri, snapid_t snapid);
  void handle_client_renamesnap(MDRequestRef& mdr);
  void _renamesnap_finish(MDRequestRef& mdr, CInode *diri, snapid_t snapid);


  // helpers
  bool _rename_prepare_witness(MDRequestRef& mdr, mds_rank_t who, set<mds_rank_t> &witnesse,
			       vector<CDentry*>& srctrace, vector<CDentry*>& dsttrace, CDentry *straydn);
  version_t _rename_prepare_import(MDRequestRef& mdr, CDentry *srcdn, bufferlist *client_map_bl);
  bool _need_force_journal(CInode *diri, bool empty);
  void _rename_prepare(MDRequestRef& mdr,
		       EMetaBlob *metablob, bufferlist *client_map_bl,
		       CDentry *srcdn, CDentry *destdn, CDentry *straydn);
  /* set not_journaling=true if you're going to discard the results --
   * this bypasses the asserts to make sure we're journaling the right
   * things on the right nodes */
  void _rename_apply(MDRequestRef& mdr, CDentry *srcdn, CDentry *destdn, CDentry *straydn);

  // slaving
  void handle_slave_rename_prep(MDRequestRef& mdr);
  void handle_slave_rename_prep_ack(MDRequestRef& mdr, MMDSSlaveRequest *m);
  void handle_slave_rename_notify_ack(MDRequestRef& mdr, MMDSSlaveRequest *m);
  void _slave_rename_sessions_flushed(MDRequestRef& mdr);
  void _logged_slave_rename(MDRequestRef& mdr, CDentry *srcdn, CDentry *destdn, CDentry *straydn);
  void _commit_slave_rename(MDRequestRef& mdr, int r, CDentry *srcdn, CDentry *destdn, CDentry *straydn);
  void do_rename_rollback(bufferlist &rbl, mds_rank_t master, MDRequestRef& mdr, bool finish_mdr=false);
  void _rename_rollback_finish(MutationRef& mut, MDRequestRef& mdr, CDentry *srcdn, version_t srcdnpv,
			       CDentry *destdn, CDentry *staydn, bool finish_mdr);

private:
  void reply_client_request(MDRequestRef& mdr, MClientReply *reply);
};

#endif
Commit	Line	Data
7c673cae FG	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	#ifndef CEPH_MDS_SERVER_H
	16	#define CEPH_MDS_SERVER_H
	17
	18	#include "MDSRank.h"
	19	#include "Mutation.h"
	20
	21	class OSDMap;
	22	class PerfCounters;
	23	class LogEvent;
	24	class EMetaBlob;
	25	class EUpdate;
	26	class MMDSSlaveRequest;
	27	struct SnapInfo;
	28	class MClientRequest;
	29	class MClientReply;
	30	class MDLog;
	31
	32	enum {
	33	l_mdss_first = 1000,
	34	l_mdss_handle_client_request,
	35	l_mdss_handle_slave_request,
	36	l_mdss_handle_client_session,
	37	l_mdss_dispatch_client_request,
	38	l_mdss_req_lookuphash,
	39	l_mdss_req_lookupino,
	40	l_mdss_req_lookupparent,
	41	l_mdss_req_lookupname,
	42	l_mdss_req_lookup,
	43	l_mdss_req_lookupsnap,
	44	l_mdss_req_getattr,
	45	l_mdss_req_setattr,
	46	l_mdss_req_setlayout,
	47	l_mdss_req_setdirlayout,
	48	l_mdss_req_setxattr,
	49	l_mdss_req_rmxattr,
	50	l_mdss_req_readdir,
	51	l_mdss_req_setfilelock,
	52	l_mdss_req_getfilelock,
	53	l_mdss_req_create,
	54	l_mdss_req_open,
	55	l_mdss_req_mknod,
	56	l_mdss_req_link,
	57	l_mdss_req_unlink,
	58	l_mdss_req_rmdir,
	59	l_mdss_req_rename,
	60	l_mdss_req_mkdir,
	61	l_mdss_req_symlink,
	62	l_mdss_req_lssnap,
	63	l_mdss_req_mksnap,
	64	l_mdss_req_rmsnap,
65	l_mdss_req_renamesnap,
66	l_mdss_dispatch_slave_request,
67	l_mdss_last,
68	};
69
70	class Server {
71	private:
72	MDSRank *mds;
73	MDCache *mdcache;
74	MDLog *mdlog;
75	PerfCounters *logger;
76
77	// OSDMap full status, used to generate ENOSPC on some operations
78	bool is_full;
79
80	// State for while in reconnect
81	MDSInternalContext *reconnect_done;
82	int failed_reconnects;
83
84	friend class MDSContinuation;
85	friend class ServerContext;
86	friend class ServerLogContext;
87
88	public:
89	bool terminating_sessions;
90
91	explicit Server(MDSRank *m);
92	~Server() {
93	g_ceph_context->get_perfcounters_collection()->remove(logger);
94	delete logger;
95	delete reconnect_done;
96	}
97
98	void create_logger();
99
100	// message handler
101	void dispatch(Message *m);
102
103	void handle_osd_map();
104
105	// -- sessions and recovery --
106	utime_t reconnect_start;
107	set<client_t> client_reconnect_gather; // clients i need a reconnect msg from.
108	bool waiting_for_reconnect(client_t c) const;
109	void dump_reconnect_status(Formatter *f) const;
110
111	Session get_session(Message m);
112	void handle_client_session(class MClientSession *m);
113	void _session_logged(Session *session, uint64_t state_seq,
114	bool open, version_t pv, interval_set<inodeno_t>& inos,version_t piv);
115	version_t prepare_force_open_sessions(map<client_t,entity_inst_t> &cm,
116	map<client_t,uint64_t>& sseqmap);
117	void finish_force_open_sessions(map<client_t,entity_inst_t> &cm,
118	map<client_t,uint64_t>& sseqmap,
119	bool dec_import=true);
120	void flush_client_sessions(set<client_t>& client_set, MDSGatherBuilder& gather);
121	void finish_flush_session(Session *session, version_t seq);
122	void terminate_sessions();
123	void find_idle_sessions();
124	void kill_session(Session session, Context on_safe);
125	void journal_close_session(Session session, int state, Context on_safe);
126	void reconnect_clients(MDSInternalContext *reconnect_done_);
127	void handle_client_reconnect(class MClientReconnect *m);
128	//void process_reconnect_cap(CInode *in, int from, ceph_mds_cap_reconnect& capinfo);
129	void reconnect_gather_finish();
130	void reconnect_tick();
131	void recover_filelocks(CInode *in, bufferlist locks, int64_t client);
132
133	void recall_client_state(float ratio);
134	void force_clients_readonly();
135
136	// -- requests --
137	void handle_client_request(MClientRequest *m);
138
139	void journal_and_reply(MDRequestRef& mdr, CInode tracei, CDentry tracedn,
140	LogEvent le, MDSLogContextBase fin);
141	void submit_mdlog_entry(LogEvent le, MDSLogContextBase fin,
142	MDRequestRef& mdr, const char *evt);
143	void dispatch_client_request(MDRequestRef& mdr);
144	void early_reply(MDRequestRef& mdr, CInode tracei, CDentry tracedn);
145	void respond_to_request(MDRequestRef& mdr, int r = 0);
146	void set_trace_dist(Session session, MClientReply reply, CInode in, CDentry dn,
147	snapid_t snapid,
148	int num_dentries_wanted,
149	MDRequestRef& mdr);
150
151	void encode_empty_dirstat(bufferlist& bl);
152	void encode_infinite_lease(bufferlist& bl);
153	void encode_null_lease(bufferlist& bl);
154
155	void handle_slave_request(MMDSSlaveRequest *m);
156	void handle_slave_request_reply(MMDSSlaveRequest *m);
157	void dispatch_slave_request(MDRequestRef& mdr);
158	void handle_slave_auth_pin(MDRequestRef& mdr);
159	void handle_slave_auth_pin_ack(MDRequestRef& mdr, MMDSSlaveRequest *ack);
160
161	// some helpers
162	bool check_fragment_space(MDRequestRef& mdr, CDir *in);
163	bool check_access(MDRequestRef& mdr, CInode *in, unsigned mask);
164	bool _check_access(Session session, CInode in, unsigned mask, int caller_uid, int caller_gid, int setattr_uid, int setattr_gid);
165	CDir validate_dentry_dir(MDRequestRef& mdr, CInode diri, const string& dname);
166	CDir traverse_to_auth_dir(MDRequestRef& mdr, vector<CDentry> &trace, filepath refpath);
167	CDentry prepare_null_dentry(MDRequestRef& mdr, CDir dir, const string& dname, bool okexist=false);
168	CDentry prepare_stray_dentry(MDRequestRef& mdr, CInode in);
169	CInode* prepare_new_inode(MDRequestRef& mdr, CDir *dir, inodeno_t useino, unsigned mode,
170	file_layout_t *layout=NULL);
171	void journal_allocated_inos(MDRequestRef& mdr, EMetaBlob *blob);
172	void apply_allocated_inos(MDRequestRef& mdr, Session *session);
173
174	CInode* rdlock_path_pin_ref(MDRequestRef& mdr, int n, set<SimpleLock*>& rdlocks, bool want_auth,
175	bool no_want_auth=false,
176	file_layout_t **layout=NULL,
177	bool no_lookup=false);
178	CDentry* rdlock_path_xlock_dentry(MDRequestRef& mdr, int n,
179	set<SimpleLock*>& rdlocks,
180	set<SimpleLock*>& wrlocks,
181	set<SimpleLock*>& xlocks, bool okexist,
182	bool mustexist, bool alwaysxlock,
183	file_layout_t **layout=NULL);
184
185	CDir* try_open_auth_dirfrag(CInode *diri, frag_t fg, MDRequestRef& mdr);
186
187
188	// requests on existing inodes.
189	void handle_client_getattr(MDRequestRef& mdr, bool is_lookup);
190	void handle_client_lookup_ino(MDRequestRef& mdr,
191	bool want_parent, bool want_dentry);
192	void _lookup_ino_2(MDRequestRef& mdr, int r);
193	void handle_client_readdir(MDRequestRef& mdr);
194	void handle_client_file_setlock(MDRequestRef& mdr);
195	void handle_client_file_readlock(MDRequestRef& mdr);
196
197	void handle_client_setattr(MDRequestRef& mdr);
198	void handle_client_setlayout(MDRequestRef& mdr);
199	void handle_client_setdirlayout(MDRequestRef& mdr);
200
201	int parse_layout_vxattr(string name, string value, const OSDMap& osdmap,
202	file_layout_t *layout, bool validate=true);
203	int parse_quota_vxattr(string name, string value, quota_info_t *quota);
204	int check_layout_vxattr(MDRequestRef& mdr,
205	string name,
206	string value,
207	file_layout_t *layout);
208	void handle_set_vxattr(MDRequestRef& mdr, CInode *cur,
209	file_layout_t *dir_layout,
210	set<SimpleLock*> rdlocks,
211	set<SimpleLock*> wrlocks,
212	set<SimpleLock*> xlocks);
213	void handle_remove_vxattr(MDRequestRef& mdr, CInode *cur,
214	file_layout_t *dir_layout,
215	set<SimpleLock*> rdlocks,
216	set<SimpleLock*> wrlocks,
217	set<SimpleLock*> xlocks);
218	void handle_client_setxattr(MDRequestRef& mdr);
219	void handle_client_removexattr(MDRequestRef& mdr);
220
221	void handle_client_fsync(MDRequestRef& mdr);
222
223	// open
224	void handle_client_open(MDRequestRef& mdr);
225	void handle_client_openc(MDRequestRef& mdr); // O_CREAT variant.
226	void do_open_truncate(MDRequestRef& mdr, int cmode); // O_TRUNC variant.
227
228	// namespace changes
229	void handle_client_mknod(MDRequestRef& mdr);
230	void handle_client_mkdir(MDRequestRef& mdr);
231	void handle_client_symlink(MDRequestRef& mdr);
232
233	// link
234	void handle_client_link(MDRequestRef& mdr);
235	void _link_local(MDRequestRef& mdr, CDentry dn, CInode targeti);
236	void _link_local_finish(MDRequestRef& mdr,
237	CDentry dn, CInode targeti,
238	version_t, version_t);
239
240	void _link_remote(MDRequestRef& mdr, bool inc, CDentry dn, CInode targeti);
241	void _link_remote_finish(MDRequestRef& mdr, bool inc, CDentry dn, CInode targeti,
242	version_t);
243
244	void handle_slave_link_prep(MDRequestRef& mdr);
245	void _logged_slave_link(MDRequestRef& mdr, CInode *targeti);
246	void _commit_slave_link(MDRequestRef& mdr, int r, CInode *targeti);
247	void _committed_slave(MDRequestRef& mdr); // use for rename, too
248	void handle_slave_link_prep_ack(MDRequestRef& mdr, MMDSSlaveRequest *m);
249	void do_link_rollback(bufferlist &rbl, mds_rank_t master, MDRequestRef& mdr);
250	void _link_rollback_finish(MutationRef& mut, MDRequestRef& mdr);
251
252	// unlink
253	void handle_client_unlink(MDRequestRef& mdr);
254	bool _dir_is_nonempty_unlocked(MDRequestRef& mdr, CInode *rmdiri);
255	bool _dir_is_nonempty(MDRequestRef& mdr, CInode *rmdiri);
256	void _unlink_local(MDRequestRef& mdr, CDentry dn, CDentry straydn);
257	void _unlink_local_finish(MDRequestRef& mdr,
258	CDentry dn, CDentry straydn,
259	version_t);
260	bool _rmdir_prepare_witness(MDRequestRef& mdr, mds_rank_t who, vector<CDentry>& trace, CDentry straydn);
261	void handle_slave_rmdir_prep(MDRequestRef& mdr);
262	void _logged_slave_rmdir(MDRequestRef& mdr, CDentry srcdn, CDentry straydn);
263	void _commit_slave_rmdir(MDRequestRef& mdr, int r);
264	void handle_slave_rmdir_prep_ack(MDRequestRef& mdr, MMDSSlaveRequest *ack);
265	void do_rmdir_rollback(bufferlist &rbl, mds_rank_t master, MDRequestRef& mdr);
266	void _rmdir_rollback_finish(MDRequestRef& mdr, metareqid_t reqid, CDentry dn, CDentry straydn);
267
268	// rename
269	void handle_client_rename(MDRequestRef& mdr);
270	void _rename_finish(MDRequestRef& mdr,
271	CDentry srcdn, CDentry destdn, CDentry *straydn);
272
273	void handle_client_lssnap(MDRequestRef& mdr);
274	void handle_client_mksnap(MDRequestRef& mdr);
275	void _mksnap_finish(MDRequestRef& mdr, CInode *diri, SnapInfo &info);
276	void handle_client_rmsnap(MDRequestRef& mdr);
277	void _rmsnap_finish(MDRequestRef& mdr, CInode *diri, snapid_t snapid);
278	void handle_client_renamesnap(MDRequestRef& mdr);
279	void _renamesnap_finish(MDRequestRef& mdr, CInode *diri, snapid_t snapid);
280
281
282	// helpers
283	bool _rename_prepare_witness(MDRequestRef& mdr, mds_rank_t who, set<mds_rank_t> &witnesse,
284	vector<CDentry>& srctrace, vector<CDentry>& dsttrace, CDentry *straydn);
285	version_t _rename_prepare_import(MDRequestRef& mdr, CDentry srcdn, bufferlist client_map_bl);
286	bool _need_force_journal(CInode *diri, bool empty);
287	void _rename_prepare(MDRequestRef& mdr,
288	EMetaBlob metablob, bufferlist client_map_bl,
289	CDentry srcdn, CDentry destdn, CDentry *straydn);
290	/* set not_journaling=true if you're going to discard the results --
291	* this bypasses the asserts to make sure we're journaling the right
292	* things on the right nodes */
293	void _rename_apply(MDRequestRef& mdr, CDentry srcdn, CDentry destdn, CDentry *straydn);
294
295	// slaving
296	void handle_slave_rename_prep(MDRequestRef& mdr);
297	void handle_slave_rename_prep_ack(MDRequestRef& mdr, MMDSSlaveRequest *m);
298	void handle_slave_rename_notify_ack(MDRequestRef& mdr, MMDSSlaveRequest *m);
299	void _slave_rename_sessions_flushed(MDRequestRef& mdr);
300	void _logged_slave_rename(MDRequestRef& mdr, CDentry srcdn, CDentry destdn, CDentry *straydn);
301	void _commit_slave_rename(MDRequestRef& mdr, int r, CDentry srcdn, CDentry destdn, CDentry *straydn);
302	void do_rename_rollback(bufferlist &rbl, mds_rank_t master, MDRequestRef& mdr, bool finish_mdr=false);
303	void _rename_rollback_finish(MutationRef& mut, MDRequestRef& mdr, CDentry *srcdn, version_t srcdnpv,
304	CDentry destdn, CDentry staydn, bool finish_mdr);
305
306	private:
307	void reply_client_request(MDRequestRef& mdr, MClientReply *reply);
308	};
309
310	#endif