ceph/src/mds/Server.h

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