#if defined(__KERNEL__)
-#include <obd_class.h>
#include <lustre_net.h>
#include <lustre/lustre_idl.h>
+#include <obd_class.h>
#include <lustre_disk.h>
#include <lu_target.h>
#include <md_object.h>
#include <lustre_fid.h>
#include <lustre_fld.h>
-#include <lustre_mdt.h>
#include <lustre_req_layout.h>
#include <lustre_sec.h>
-#include <lvfs.h>
#include <lustre_idmap.h>
#include <lustre_eacl.h>
#include <lustre_quota.h>
/* file data for open files on MDS */
struct mdt_file_data {
- struct portals_handle mfd_handle; /* must be first */
- int mfd_mode; /* open mode provided by client */
- cfs_list_t mfd_list; /* protected by med_open_lock */
- __u64 mfd_xid; /* xid of the open request */
- struct lustre_handle mfd_old_handle; /* old handle in replay case */
- struct mdt_object *mfd_object; /* point to opened object */
+ struct portals_handle mfd_handle; /* must be first */
+ __u64 mfd_mode; /* open mode provided by client */
+ cfs_list_t mfd_list; /* protected by med_open_lock */
+ __u64 mfd_xid; /* xid of the open request */
+ struct lustre_handle mfd_old_handle; /* old handle in replay case */
+ struct mdt_object *mfd_object; /* point to opened object */
};
#define CDT_NONBLOCKING_RESTORE 0x0000000000000001ULL
/* when adding a new policy, do not forget to update
* lustre/mdt/mdt_coordinator.c::hsm_policy_names[]
*/
-#define CDT_DEFAULT_POLICY 0x0000000000000000ULL
+#define CDT_DEFAULT_POLICY CDT_NORETRY_ACTION
enum cdt_states { CDT_STOPPED = 0,
CDT_INIT,
* cdt_request_lock
*/
struct coordinator {
- struct ptlrpc_thread *cdt_thread; /**< coordinator thread */
+ struct ptlrpc_thread cdt_thread; /**< coordinator thread */
struct lu_env cdt_env; /**< coordinator lustre
* env */
+ struct lu_context cdt_session; /** session for lu_ucred */
struct proc_dir_entry *cdt_proc_dir; /**< cdt /proc directory */
__u64 cdt_policy; /**< flags to defined
* policy */
enum cdt_states cdt_state; /**< state */
- cfs_atomic_t cdt_compound_id; /**< compound id counter */
+ atomic_t cdt_compound_id; /**< compound id counter */
__u64 cdt_last_cookie; /**< last cookie allocated */
- struct semaphore cdt_counter_lock; /**< protect request
- * counter */
- struct semaphore cdt_llog_lock; /**< protect llog access */
+ struct mutex cdt_llog_lock; /**< protect llog access */
struct rw_semaphore cdt_agent_lock; /**< protect agent list */
struct rw_semaphore cdt_request_lock; /**< protect request list */
- struct semaphore cdt_restore_lock; /**< protect restore list */
+ struct mutex cdt_restore_lock; /**< protect restore list */
cfs_time_t cdt_loop_period; /**< llog scan period */
cfs_time_t cdt_delay; /**< request grace delay */
cfs_time_t cdt_timeout; /**< request timeout */
__u64 cdt_max_request; /**< max count of started
* requests */
- __u64 cdt_request_count; /**< current count of
+ atomic_t cdt_request_count; /**< current count of
* started requests */
cfs_list_t cdt_requests; /**< list of started
* requests */
int mdt_max_mdsize;
int mdt_max_cookiesize;
+ int mdt_max_ea_size;
+
struct upcall_cache *mdt_identity_cache;
/* sptlrpc rules */
struct mutex mot_ioepoch_mutex;
/* Lock to protect create_data */
struct mutex mot_lov_mutex;
+ /* Lock to protect lease open.
+ * Lease open acquires write lock; normal open acquires read lock */
+ struct rw_semaphore mot_open_sem;
+ atomic_t mot_lease_count;
+ atomic_t mot_open_count;
+ /* A lock to protect EA data from racing setxattr and getxattrall */
+ struct rw_semaphore mot_xattr_sem;
};
enum mdt_object_flags {
};
enum {
- MDT_LH_PARENT, /* parent lockh */
- MDT_LH_CHILD, /* child lockh */
- MDT_LH_OLD, /* old lockh for rename */
+ MDT_LH_PARENT, /* parent lockh */
+ MDT_LH_CHILD, /* child lockh */
+ MDT_LH_OLD, /* old lockh for rename */
MDT_LH_LAYOUT = MDT_LH_OLD, /* layout lock */
- MDT_LH_NEW, /* new lockh for rename */
- MDT_LH_RMT, /* used for return lh to caller */
- MDT_LH_NR
+ MDT_LH_NEW, /* new lockh for rename */
+ MDT_LH_RMT, /* used for return lh to caller */
+ MDT_LH_LOCAL, /* local lock never return to client */
+ MDT_LH_NR
};
enum {
struct mdt_device *mti_mdt;
const struct lu_env *mti_env;
+ /* XXX: temporary flag to have healthy mti during OUT calls
+ * to be removed upon moving MDT to the unified target code */
+ bool mti_txn_compat;
/*
* Additional fail id that can be set by handler. Passed to
const struct req_format *mh_fmt;
};
-enum mdt_handler_flags {
- /*
- * struct mdt_body is passed in the incoming message, and object
- * identified by this fid exists on disk.
- *
- * "habeo corpus" == "I have a body"
- */
- HABEO_CORPUS = (1 << 0),
- /*
- * struct ldlm_request is passed in the incoming message.
- *
- * "habeo clavis" == "I have a key"
- */
- HABEO_CLAVIS = (1 << 1),
- /*
- * this request has fixed reply format, so that reply message can be
- * packed by generic code.
- *
- * "habeo refero" == "I have a reply"
- */
- HABEO_REFERO = (1 << 2),
- /*
- * this request will modify something, so check whether the filesystem
- * is readonly or not, then return -EROFS to client asap if necessary.
- *
- * "mutabor" == "I shall modify"
- */
- MUTABOR = (1 << 3)
-};
-
struct mdt_opc_slice {
__u32 mos_opc_start;
int mos_opc_end;
struct cdt_req_progress car_progress; /**< track data mvt
* progress */
};
+extern struct kmem_cache *mdt_hsm_car_kmem;
struct hsm_agent {
cfs_list_t ha_list; /**< to chain the agents */
struct ldlm_extent crh_extent; /**< extent of the restore */
struct mdt_lock_handle crh_lh; /**< lock handle */
};
+extern struct kmem_cache *mdt_hsm_cdt_kmem; /** restore handle slab cache */
static inline const struct md_device_operations *
mdt_child_ops(struct mdt_device * m)
return info->mti_pill ? info->mti_pill->rc_req : NULL;
}
-static inline int req_is_replay(struct ptlrpc_request *req)
-{
- LASSERT(req->rq_reqmsg);
- return !!(lustre_msg_get_flags(req->rq_reqmsg) & MSG_REPLAY);
-}
-
static inline __u64 mdt_conn_flags(struct mdt_thread_info *info)
{
LASSERT(info->mti_exp);
struct mdt_lock_handle *child_lockh);
void mdt_mfd_set_mode(struct mdt_file_data *mfd,
- int mode);
+ __u64 mode);
int mdt_reint_open(struct mdt_thread_info *info,
struct mdt_lock_handle *lhc);
int mdt_sec_ctx_handle(struct mdt_thread_info *info);
int mdt_readpage(struct mdt_thread_info *info);
int mdt_obd_idx_read(struct mdt_thread_info *info);
+int mdt_tgt_connect(struct tgt_session_info *tsi);
+void mdt_thread_info_init(struct ptlrpc_request *req,
+ struct mdt_thread_info *mti);
+void mdt_thread_info_fini(struct mdt_thread_info *mti);
extern struct mdt_opc_slice mdt_regular_handlers[];
extern struct mdt_opc_slice mdt_seq_handlers[];
extern struct lprocfs_vars lprocfs_mds_obd_vars[];
int mdt_hsm_attr_set(struct mdt_thread_info *info, struct mdt_object *obj,
- struct md_hsm *mh);
+ const struct md_hsm *mh);
struct mdt_handler *mdt_handler_find(__u32 opc,
struct mdt_opc_slice *supported);
int mdt_hsm_ct_register(struct mdt_thread_info *info);
int mdt_hsm_ct_unregister(struct mdt_thread_info *info);
int mdt_hsm_request(struct mdt_thread_info *info);
-/* HSM restore cannot be active yet, until the coordinator
- * patch is landed, so this function always returns false for now, but
- * allows the other parts of the code to start checking for this.
- */
-static inline bool mdt_hsm_restore_is_running(struct mdt_thread_info *mti,
- const struct lu_fid *fid)
-{
- return false;
-}
-
/* mdt/mdt_hsm_cdt_actions.c */
extern const struct file_operations mdt_agent_actions_fops;
-void dump_llog_agent_req_rec(char *prefix, struct llog_agent_req_rec *larr);
+void dump_llog_agent_req_rec(const char *prefix,
+ const struct llog_agent_req_rec *larr);
int cdt_llog_process(const struct lu_env *env, struct mdt_device *mdt,
llog_cb_t cb, void *data);
int mdt_agent_record_add(const struct lu_env *env, struct mdt_device *mdt,
struct llog_handle *llh,
struct llog_agent_req_rec *larr);
+/* mdt/mdt_hsm_cdt_agent.c */
+extern const struct file_operations mdt_hsm_agent_fops;
+int mdt_hsm_agent_register(struct mdt_thread_info *info,
+ const struct obd_uuid *uuid,
+ int nr_archives, __u32 *archive_num);
+int mdt_hsm_agent_register_mask(struct mdt_thread_info *info,
+ const struct obd_uuid *uuid,
+ __u32 archive_mask);
+int mdt_hsm_agent_unregister(struct mdt_thread_info *info,
+ const struct obd_uuid *uuid);
+int mdt_hsm_agent_update_statistics(struct coordinator *cdt,
+ int succ_rq, int fail_rq, int new_rq,
+ const struct obd_uuid *uuid);
+int mdt_hsm_find_best_agent(struct coordinator *cdt, __u32 archive,
+ struct obd_uuid *uuid);
+int mdt_hsm_agent_send(struct mdt_thread_info *mti, struct hsm_action_list *hal,
+ bool purge);
+int mdt_hsm_coordinator_update(struct mdt_thread_info *mti,
+ struct hsm_progress_kernel *pgs);
+/* mdt/mdt_hsm_cdt_client.c */
+int mdt_hsm_add_actions(struct mdt_thread_info *info,
+ struct hsm_action_list *hal, __u64 *compound_id);
+int mdt_hsm_get_actions(struct mdt_thread_info *mti,
+ struct hsm_action_list *hal);
+int mdt_hsm_get_running(struct mdt_thread_info *mti,
+ struct hsm_action_list *hal);
+bool mdt_hsm_restore_is_running(struct mdt_thread_info *mti,
+ const struct lu_fid *fid);
/* mdt/mdt_hsm_cdt_requests.c */
extern const struct file_operations mdt_hsm_request_fops;
void dump_requests(char *prefix, struct coordinator *cdt);
void mdt_cdt_free_request(struct cdt_agent_req *car);
int mdt_cdt_add_request(struct coordinator *cdt, struct cdt_agent_req *new_car);
struct cdt_agent_req *mdt_cdt_find_request(struct coordinator *cdt,
- __u64 cookie,
+ const __u64 cookie,
const struct lu_fid *fid);
void mdt_cdt_get_work_done(struct cdt_agent_req *car, __u64 *done_sz);
void mdt_cdt_get_request(struct cdt_agent_req *car);
void mdt_cdt_put_request(struct cdt_agent_req *car);
struct cdt_agent_req *mdt_cdt_update_request(struct coordinator *cdt,
- struct hsm_progress_kernel *pgs);
+ const struct hsm_progress_kernel *pgs);
int mdt_cdt_remove_request(struct coordinator *cdt, __u64 cookie);
-
-/* fake functions, will be remove with patch LU-3342 */
-static inline int mdt_hsm_agent_update_statistics(struct coordinator *cdt,
- int succ_rq, int fail_rq,
- int new_rq,
- const struct obd_uuid *uuid)
-{
- return 0;
-}
+/* mdt/mdt_coordinator.c */
+void mdt_hsm_dump_hal(int level, const char *prefix,
+ struct hsm_action_list *hal);
+/* coordinator management */
+int mdt_hsm_cdt_init(struct mdt_device *mdt);
+int mdt_hsm_cdt_start(struct mdt_device *mdt);
+int mdt_hsm_cdt_stop(struct mdt_device *mdt);
+int mdt_hsm_cdt_fini(struct mdt_device *mdt);
+int mdt_hsm_cdt_wakeup(struct mdt_device *mdt);
+
+/* coordinator control /proc interface */
+int lprocfs_wr_hsm_cdt_control(struct file *file, const char *buffer,
+ unsigned long count, void *data);
+int lprocfs_rd_hsm_cdt_control(char *page, char **start, off_t off,
+ int count, int *eof, void *data);
+/* md_hsm helpers */
+struct mdt_object *mdt_hsm_get_md_hsm(struct mdt_thread_info *mti,
+ const struct lu_fid *fid,
+ struct md_hsm *hsm);
+/* actions/request helpers */
+int mdt_hsm_add_hal(struct mdt_thread_info *mti,
+ struct hsm_action_list *hal, struct obd_uuid *uuid);
+bool mdt_hsm_is_action_compat(const struct hsm_action_item *hai,
+ const int hal_an, const __u64 rq_flags,
+ const struct md_hsm *hsm);
+int mdt_hsm_update_request_state(struct mdt_thread_info *mti,
+ struct hsm_progress_kernel *pgs,
+ const int update_record);
extern struct lu_context_key mdt_thread_key;
/* debug issues helper starts here*/
void mdt_enable_cos(struct mdt_device *, int);
int mdt_cos_is_enabled(struct mdt_device *);
-int mdt_hsm_copytool_send(struct obd_export *exp);
/* lprocfs stuff */
enum {
void mdt_ck_thread_stop(struct mdt_device *mdt);
void mdt_ck_timer_callback(unsigned long castmeharder);
int mdt_capa_keys_init(const struct lu_env *env, struct mdt_device *mdt);
-
-static inline void mdt_set_capainfo(struct mdt_thread_info *info, int offset,
- const struct lu_fid *fid,
- struct lustre_capa *capa)
-{
- struct md_capainfo *ci;
-
- LASSERT(offset >= 0 && offset < MD_CAPAINFO_MAX);
- if (!info->mti_mdt->mdt_opts.mo_mds_capa ||
- !(exp_connect_flags(info->mti_exp) & OBD_CONNECT_MDS_CAPA))
- return;
-
- ci = md_capainfo(info->mti_env);
- LASSERT(ci);
- ci->mc_fid[offset] = *fid;
- ci->mc_capa[offset] = capa;
-}
-
-static inline void mdt_dump_capainfo(struct mdt_thread_info *info)
-{
- struct md_capainfo *ci = md_capainfo(info->mti_env);
- int i;
-
- if (!ci)
- return;
- for (i = 0; i < MD_CAPAINFO_MAX; i++) {
- if (!ci->mc_capa[i]) {
- CERROR("no capa for index %d "DFID"\n",
- i, PFID(&ci->mc_fid[i]));
- continue;
- }
- if (ci->mc_capa[i] == BYPASS_CAPA) {
- CERROR("bypass for index %d "DFID"\n",
- i, PFID(&ci->mc_fid[i]));
- continue;
- }
- DEBUG_CAPA(D_ERROR, ci->mc_capa[i], "index %d", i);
- }
-}
+void mdt_set_capainfo(struct mdt_thread_info *info, int offset,
+ const struct lu_fid *fid, struct lustre_capa *capa);
+void mdt_dump_capainfo(struct mdt_thread_info *info);
static inline struct obd_device *mdt2obd_dev(const struct mdt_device *mdt)
{
int mds_mod_init(void);
void mds_mod_exit(void);
-/* Update handlers */
-int out_handle(struct mdt_thread_info *info);
-
-#define out_tx_create(info, obj, attr, fid, dof, th, reply, idx) \
- __out_tx_create(info, obj, attr, fid, dof, th, reply, idx, \
- __FILE__, __LINE__)
-
-#define out_tx_attr_set(info, obj, attr, th, reply, idx) \
- __out_tx_attr_set(info, obj, attr, th, reply, idx, \
- __FILE__, __LINE__)
-
-#define out_tx_xattr_set(info, obj, buf, name, fl, th, reply, idx) \
- __out_tx_xattr_set(info, obj, buf, name, fl, th, reply, idx, \
- __FILE__, __LINE__)
-
-#define out_tx_ref_add(info, obj, th, reply, idx) \
- __out_tx_ref_add(info, obj, th, reply, idx, __FILE__, __LINE__)
-
-#define out_tx_ref_del(info, obj, th, reply, idx) \
- __out_tx_ref_del(info, obj, th, reply, idx, __FILE__, __LINE__)
-
-#define out_tx_index_insert(info, obj, th, name, fid, reply, idx) \
- __out_tx_index_insert(info, obj, th, name, fid, reply, idx, \
- __FILE__, __LINE__)
-
-#define out_tx_index_delete(info, obj, th, name, reply, idx) \
- __out_tx_index_delete(info, obj, th, name, reply, idx, \
- __FILE__, __LINE__)
-
-#define out_tx_destroy(info, obj, th, reply, idx) \
- __out_tx_destroy(info, obj, th, reply, idx, __FILE__, __LINE__)
-
#endif /* __KERNEL__ */
#endif /* _MDT_H */
git://git.whamcloud.com / fs / lustre-release.git / blobdiff