X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fmdt%2Fmdt_internal.h;h=7db09e8b851fac6db019ff1108fe3182ddee261a;hp=f83d4e070622a00451ed670740b982a30ad7373e;hb=93dec71f65a4bbb170a35b04c60b8620b73ae4b1;hpb=50473b10366447d2a0754fecadca41b7e2ddb5e0 diff --git a/lustre/mdt/mdt_internal.h b/lustre/mdt/mdt_internal.h index f83d4e0..7db09e8 100644 --- a/lustre/mdt/mdt_internal.h +++ b/lustre/mdt/mdt_internal.h @@ -27,7 +27,7 @@ * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, 2012, Whamcloud, Inc. + * Copyright (c) 2011, 2013, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -50,16 +50,9 @@ #if defined(__KERNEL__) -/* - * struct ptlrpc_client - */ #include -#include -/* - * struct obd_connect_data - * struct lustre_handle - */ #include +#include #include #include #include @@ -67,11 +60,9 @@ #include #include #include -#include #include #include -#include -#include +#include /* check if request's xid is equal to last one or not*/ static inline int req_xid_is_last(struct ptlrpc_request *req) @@ -82,14 +73,72 @@ static inline int req_xid_is_last(struct ptlrpc_request *req) } struct mdt_object; + /* 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 (1ULL << 0) +#define CDT_NORETRY_ACTION (1ULL << 1) +#define CDT_POLICY_LAST CDT_NORETRY_ACTION +#define CDT_POLICY_SHIFT_COUNT 2 +#define CDT_POLICY_ALL (CDT_NONBLOCKING_RESTORE | \ + CDT_NORETRY_ACTION) + +/* when adding a new policy, do not forget to update + * lustre/mdt/mdt_coordinator.c::hsm_policy_names[] + */ +#define CDT_DEFAULT_POLICY CDT_NORETRY_ACTION + +enum cdt_states { CDT_STOPPED = 0, + CDT_INIT, + CDT_RUNNING, + CDT_DISABLE, + CDT_STOPPING }; + +/* when multiple lock are needed, the lock order is + * cdt_llog_lock + * cdt_agent_lock + * cdt_counter_lock + * cdt_restore_lock + * cdt_request_lock + */ +struct coordinator { + 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 */ + atomic_t cdt_compound_id; /**< compound id counter */ + __u64 cdt_last_cookie; /**< last cookie allocated */ + 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 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 */ + __u32 cdt_archive_id; /** archive id used when + * none are specified */ + __u64 cdt_max_request; /**< max count of started + * requests */ + atomic_t cdt_request_count; /**< current count of + * started requests */ + struct list_head cdt_requests; /**< list of started + * requests */ + struct list_head cdt_agents; /**< list of register + * agents */ + struct list_head cdt_restore_hdl; /**< list of restore lock + * handles */ }; /* mdt state flag bits */ @@ -97,17 +146,9 @@ struct mdt_file_data { #define MDT_FL_SYNCED 1 struct mdt_device { - /* super-class */ - struct md_device mdt_md_dev; - struct md_site mdt_mite; - struct ptlrpc_service *mdt_regular_service; - struct ptlrpc_service *mdt_readpage_service; - struct ptlrpc_service *mdt_xmds_service; - struct ptlrpc_service *mdt_setattr_service; - struct ptlrpc_service *mdt_mdsc_service; - struct ptlrpc_service *mdt_mdss_service; - struct ptlrpc_service *mdt_dtss_service; - struct ptlrpc_service *mdt_fld_service; + /* super-class */ + struct lu_device mdt_lu_dev; + struct seq_server_site mdt_seq_site; /* DLM name-space for meta-data locks maintained by this server */ struct ldlm_namespace *mdt_namespace; /* ptlrpc handle for MDS->client connections (for lock ASTs). */ @@ -119,21 +160,22 @@ struct mdt_device { struct obd_export *mdt_bottom_exp; /** target device */ struct lu_target mdt_lut; - /* - * Options bit-fields. - */ - struct { - signed int mo_user_xattr :1, - mo_acl :1, - mo_compat_resname:1, - mo_mds_capa :1, - mo_oss_capa :1, - mo_cos :1; - } mdt_opts; + /* + * Options bit-fields. + */ + struct { + unsigned int mo_user_xattr:1, + mo_acl:1, + mo_compat_resname:1, + mo_mds_capa:1, + mo_oss_capa:1, + mo_cos:1, + mo_coordinator:1; + } mdt_opts; /* mdt state flags */ unsigned long mdt_state; /* lock to protect IOepoch */ - cfs_spinlock_t mdt_ioepoch_lock; + spinlock_t mdt_ioepoch_lock; __u64 mdt_ioepoch; /* transaction callbacks */ @@ -144,10 +186,12 @@ struct mdt_device { int mdt_max_mdsize; int mdt_max_cookiesize; + int mdt_max_ea_size; + struct upcall_cache *mdt_identity_cache; /* sptlrpc rules */ - cfs_rwlock_t mdt_sptlrpc_lock; + rwlock_t mdt_sptlrpc_lock; struct sptlrpc_rule_set mdt_sptlrpc_rset; /* capability keys */ @@ -159,13 +203,16 @@ struct mdt_device { cfs_timer_t mdt_ck_timer; struct ptlrpc_thread mdt_ck_thread; struct lustre_capa_key mdt_capa_keys[2]; - unsigned int mdt_capa_conf:1, - mdt_som_conf:1; + unsigned int mdt_capa_conf:1, + mdt_som_conf:1, + /* Enable remote dir on non-MDT0 */ + mdt_enable_remote_dir:1; + gid_t mdt_enable_remote_dir_gid; /* statfs optimization: we cache a bit */ - struct obd_statfs mdt_osfs; - __u64 mdt_osfs_age; - cfs_spinlock_t mdt_osfs_lock; + struct obd_statfs mdt_osfs; + __u64 mdt_osfs_age; + spinlock_t mdt_osfs_lock; /* root squash */ uid_t mdt_squash_uid; @@ -173,10 +220,8 @@ struct mdt_device { cfs_list_t mdt_nosquash_nids; char *mdt_nosquash_str; int mdt_nosquash_strlen; - cfs_rw_semaphore_t mdt_squash_sem; + struct rw_semaphore mdt_squash_sem; - cfs_proc_dir_entry_t *mdt_proc_entry; - struct lprocfs_stats *mdt_stats; int mdt_sec_level; struct rename_stats mdt_rename_stats; struct lu_fid mdt_md_root_fid; @@ -185,26 +230,33 @@ struct mdt_device { struct obd_export *mdt_qmt_exp; /* quota master device associated with this MDT */ struct lu_device *mdt_qmt_dev; + + struct coordinator mdt_coordinator; }; -#define MDT_SERVICE_WATCHDOG_FACTOR (2) -#define MDT_ROCOMPAT_SUPP (OBD_ROCOMPAT_LOVOBJID) -#define MDT_INCOMPAT_SUPP (OBD_INCOMPAT_MDT | OBD_INCOMPAT_COMMON_LR | \ - OBD_INCOMPAT_FID | OBD_INCOMPAT_IAM_DIR | \ - OBD_INCOMPAT_LMM_VER | OBD_INCOMPAT_MULTI_OI) +#define MDT_SERVICE_WATCHDOG_FACTOR (2) +#define MDT_ROCOMPAT_SUPP (OBD_ROCOMPAT_LOVOBJID) +#define MDT_INCOMPAT_SUPP (OBD_INCOMPAT_MDT | OBD_INCOMPAT_COMMON_LR | \ + OBD_INCOMPAT_FID | OBD_INCOMPAT_IAM_DIR | \ + OBD_INCOMPAT_LMM_VER | OBD_INCOMPAT_MULTI_OI) #define MDT_COS_DEFAULT (0) struct mdt_object { - struct lu_object_header mot_header; - struct md_object mot_obj; + struct lu_object_header mot_header; + struct lu_object mot_obj; __u64 mot_ioepoch; __u64 mot_flags; int mot_ioepoch_count; int mot_writecount; /* Lock to protect object's IO epoch. */ - cfs_mutex_t mot_ioepoch_mutex; + struct mutex mot_ioepoch_mutex; /* Lock to protect create_data */ - cfs_mutex_t mot_lov_mutex; + 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; }; enum mdt_object_flags { @@ -239,15 +291,21 @@ struct mdt_lock_handle { struct lustre_handle mlh_pdo_lh; ldlm_mode_t mlh_pdo_mode; unsigned int mlh_pdo_hash; + + /* Remote regular lock */ + struct lustre_handle mlh_rreg_lh; + ldlm_mode_t mlh_rreg_mode; }; enum { - MDT_LH_PARENT, /* parent lockh */ - MDT_LH_CHILD, /* child lockh */ - MDT_LH_OLD, /* old lockh for rename */ - MDT_LH_NEW, /* new lockh for rename */ - MDT_LH_RMT, /* used for return lh to caller */ - MDT_LH_NR + 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_LOCAL, /* local lock never return to client */ + MDT_LH_NR }; enum { @@ -275,6 +333,60 @@ enum mdt_reint_flag { MRF_OPEN_TRUNC = 1 << 0, }; +struct mdt_thread_info; +struct tx_arg; +typedef int (*tx_exec_func_t)(const struct lu_env *, struct thandle *, + struct tx_arg *); + +struct tx_arg { + tx_exec_func_t exec_fn; + tx_exec_func_t undo_fn; + struct dt_object *object; + char *file; + struct update_reply *reply; + int line; + int index; + union { + struct { + const struct dt_rec *rec; + const struct dt_key *key; + } insert; + struct { + } ref; + struct { + struct lu_attr attr; + } attr_set; + struct { + struct lu_buf buf; + const char *name; + int flags; + __u32 csum; + } xattr_set; + struct { + struct lu_attr attr; + struct dt_allocation_hint hint; + struct dt_object_format dof; + struct lu_fid fid; + } create; + struct { + struct lu_buf buf; + loff_t pos; + } write; + struct { + struct ost_body *body; + } destroy; + } u; +}; + +#define TX_MAX_OPS 10 +struct thandle_exec_args { + struct thandle *ta_handle; + struct dt_device *ta_dev; + int ta_err; + struct tx_arg ta_args[TX_MAX_OPS]; + int ta_argno; /* used args */ +}; + /* * Common data shared by mdt-level handlers. This is allocated per-thread to * reduce stack consumption. @@ -300,6 +412,9 @@ struct mdt_thread_info { 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 @@ -336,7 +451,6 @@ struct mdt_thread_info { const struct ldlm_request *mti_dlm_req; __u32 mti_has_trans:1, /* has txn already? */ - mti_no_need_trans:1, mti_cross_ref:1; /* opdata for mdt_reint_open(), has the same as @@ -395,15 +509,24 @@ struct mdt_thread_info { struct md_attr attr; struct md_som_data data; } som; + struct { + struct dt_object_format mti_update_dof; + struct update_reply *mti_update_reply; + struct update *mti_update; + int mti_update_reply_index; + struct obdo mti_obdo; + struct dt_object *mti_dt_object; + } update; } mti_u; /* IO epoch related stuff. */ struct mdt_ioepoch *mti_ioepoch; __u64 mti_replayepoch; - loff_t mti_off; - struct lu_buf mti_buf; - struct lustre_capa_key mti_capa_key; + loff_t mti_off; + struct lu_buf mti_buf; + struct lu_buf mti_big_buf; + struct lustre_capa_key mti_capa_key; /* Ops object filename */ struct lu_name mti_name; @@ -414,8 +537,82 @@ struct mdt_thread_info { int mti_big_lmm_used; /* should be enough to fit lustre_mdt_attrs */ char mti_xattr_buf[128]; + struct thandle_exec_args mti_handle; + struct ldlm_enqueue_info mti_einfo; +}; + +/* ptlrpc request handler for MDT. All handlers are + * grouped into several slices - struct mdt_opc_slice, + * and stored in an array - mdt_handlers[]. + */ +struct mdt_handler { + /* The name of this handler. */ + const char *mh_name; + /* Fail id for this handler, checked at the beginning of this handler*/ + int mh_fail_id; + /* Operation code for this handler */ + __u32 mh_opc; + /* flags are listed in enum mdt_handler_flags below. */ + __u32 mh_flags; + /* The actual handler function to execute. */ + int (*mh_act)(struct mdt_thread_info *info); + /* Request format for this request. */ + const struct req_format *mh_fmt; +}; + +struct mdt_opc_slice { + __u32 mos_opc_start; + int mos_opc_end; + struct mdt_handler *mos_hs; }; +struct cdt_req_progress { + struct mutex crp_lock; /**< protect tree */ + struct interval_node *crp_root; /**< tree to track extent + * moved */ + struct interval_node **crp_node; /**< buffer for tree nodes + * vector of fixed size + * vectors */ + int crp_cnt; /**< # of used nodes */ + int crp_max; /**< # of allocated nodes */ +}; + +struct cdt_agent_req { + cfs_list_t car_request_list; /**< to chain all the req. */ + atomic_t car_refcount; /**< reference counter */ + __u64 car_compound_id; /**< compound id */ + __u64 car_flags; /**< request original flags */ + struct obd_uuid car_uuid; /**< agent doing the req. */ + __u32 car_archive_id; /**< archive id */ + int car_canceled; /**< request was canceled */ + cfs_time_t car_req_start; /**< start time */ + cfs_time_t car_req_update; /**< last update time */ + struct hsm_action_item *car_hai; /**< req. to the agent */ + 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 obd_uuid ha_uuid; /**< agent uuid */ + __u32 *ha_archive_id; /**< archive id */ + int ha_archive_cnt; /**< number of archive entries + * 0 means any archive */ + atomic_t ha_requests; /**< current request count */ + atomic_t ha_success; /**< number of successful + * actions */ + atomic_t ha_failure; /**< number of failed actions */ +}; + +struct cdt_restore_handle { + cfs_list_t crh_list; /**< to chain the handle */ + struct lu_fid crh_fid; /**< fid of the object */ + 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) { @@ -425,8 +622,8 @@ mdt_child_ops(struct mdt_device * m) static inline struct md_object *mdt_object_child(struct mdt_object *o) { - LASSERT(o); - return lu2md(lu_object_next(&o->mot_obj.mo_lu)); + LASSERT(o); + return lu2md(lu_object_next(&o->mot_obj)); } static inline struct ptlrpc_request *mdt_info_req(struct mdt_thread_info *info) @@ -434,57 +631,51 @@ static inline struct ptlrpc_request *mdt_info_req(struct mdt_thread_info *info) 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); - return info->mti_exp->exp_connect_flags; + LASSERT(info->mti_exp); + return exp_connect_flags(info->mti_exp); } static inline void mdt_object_get(const struct lu_env *env, - struct mdt_object *o) + struct mdt_object *o) { - ENTRY; - lu_object_get(&o->mot_obj.mo_lu); - EXIT; + ENTRY; + lu_object_get(&o->mot_obj); + EXIT; } static inline void mdt_object_put(const struct lu_env *env, - struct mdt_object *o) + struct mdt_object *o) { - ENTRY; - lu_object_put(env, &o->mot_obj.mo_lu); - EXIT; + ENTRY; + lu_object_put(env, &o->mot_obj); + EXIT; } static inline int mdt_object_exists(const struct mdt_object *o) { - return lu_object_exists(&o->mot_obj.mo_lu); + return lu_object_exists(&o->mot_obj); } -static inline const struct lu_fid *mdt_object_fid(const struct mdt_object *o) +static inline int mdt_object_remote(const struct mdt_object *o) { - return lu_object_fid(&o->mot_obj.mo_lu); + return lu_object_remote(&o->mot_obj); } -static inline int mdt_object_obf(const struct mdt_object *o) +static inline const struct lu_fid *mdt_object_fid(const struct mdt_object *o) { - return lu_fid_eq(mdt_object_fid(o), &LU_OBF_FID); + return lu_object_fid(&o->mot_obj); } static inline struct lu_site *mdt_lu_site(const struct mdt_device *mdt) { - return mdt->mdt_md_dev.md_lu_dev.ld_site; + return mdt->mdt_lu_dev.ld_site; } -static inline struct md_site *mdt_md_site(struct mdt_device *mdt) +static inline struct seq_server_site *mdt_seq_site(struct mdt_device *mdt) { - return &mdt->mdt_mite; + return &mdt->mdt_seq_site; } static inline void mdt_export_evict(struct obd_export *exp) @@ -493,6 +684,13 @@ static inline void mdt_export_evict(struct obd_export *exp) class_export_put(exp); } +/* Here we use LVB_TYPE to check dne client, because it is + * also landed on 2.4. */ +static inline int mdt_is_dne_client(struct obd_export *exp) +{ + return !!(exp_connect_flags(exp) & OBD_CONNECT_LVB_TYPE); +} + int mdt_get_disposition(struct ldlm_reply *rep, int flag); void mdt_set_disposition(struct mdt_thread_info *info, struct ldlm_reply *rep, int flag); @@ -515,6 +713,11 @@ int mdt_object_lock(struct mdt_thread_info *, struct mdt_lock_handle *, __u64, int); +int mdt_object_lock_try(struct mdt_thread_info *, + struct mdt_object *, + struct mdt_lock_handle *, + __u64, int); + void mdt_object_unlock(struct mdt_thread_info *, struct mdt_object *, struct mdt_lock_handle *, @@ -537,6 +740,9 @@ void mdt_object_unlock_put(struct mdt_thread_info *, void mdt_client_compatibility(struct mdt_thread_info *info); +int mdt_remote_object_lock(struct mdt_thread_info *mti, + struct mdt_object *o, struct lustre_handle *lh, + ldlm_mode_t mode, __u64 ibits); int mdt_close_unpack(struct mdt_thread_info *info); int mdt_reint_unpack(struct mdt_thread_info *info, __u32 op); int mdt_reint_rec(struct mdt_thread_info *, struct mdt_lock_handle *); @@ -572,13 +778,14 @@ int mdt_lock_new_child(struct mdt_thread_info *info, 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); -struct mdt_file_data *mdt_handle2mfd(struct mdt_thread_info *, - const struct lustre_handle *); +struct mdt_file_data *mdt_handle2mfd(struct mdt_export_data *med, + const struct lustre_handle *handle, + bool is_replay); enum { MDT_IOEPOCH_CLOSED = 0, @@ -599,12 +806,14 @@ int mdt_object_is_som_enabled(struct mdt_object *mo); int mdt_write_get(struct mdt_object *o); void mdt_write_put(struct mdt_object *o); int mdt_write_read(struct mdt_object *o); -struct mdt_file_data *mdt_mfd_new(void); +struct mdt_file_data *mdt_mfd_new(const struct mdt_export_data *med); int mdt_mfd_close(struct mdt_thread_info *info, struct mdt_file_data *mfd); void mdt_mfd_free(struct mdt_file_data *mfd); int mdt_close(struct mdt_thread_info *info); int mdt_attr_set(struct mdt_thread_info *info, struct mdt_object *mo, struct md_attr *ma, int flags); +int mdt_add_dirty_flag(struct mdt_thread_info *info, struct mdt_object *mo, + struct md_attr *ma); int mdt_done_writing(struct mdt_thread_info *info); int mdt_fix_reply(struct mdt_thread_info *info); int mdt_handle_last_unlink(struct mdt_thread_info *, struct mdt_object *, @@ -625,7 +834,56 @@ int mdt_version_get_check(struct mdt_thread_info *, struct mdt_object *, int); void mdt_version_get_save(struct mdt_thread_info *, struct mdt_object *, int); int mdt_version_get_check_save(struct mdt_thread_info *, struct mdt_object *, int); - +int mdt_handle_common(struct ptlrpc_request *req, + struct mdt_opc_slice *supported); +int mdt_connect(struct mdt_thread_info *info); +int mdt_disconnect(struct mdt_thread_info *info); +int mdt_set_info(struct mdt_thread_info *info); +int mdt_get_info(struct mdt_thread_info *info); +int mdt_getstatus(struct mdt_thread_info *info); +int mdt_getattr(struct mdt_thread_info *info); +int mdt_getattr_name(struct mdt_thread_info *info); +int mdt_statfs(struct mdt_thread_info *info); +int mdt_reint(struct mdt_thread_info *info); +int mdt_sync(struct mdt_thread_info *info); +int mdt_is_subdir(struct mdt_thread_info *info); +int mdt_obd_ping(struct mdt_thread_info *info); +int mdt_obd_log_cancel(struct mdt_thread_info *info); +int mdt_obd_qc_callback(struct mdt_thread_info *info); +int mdt_enqueue(struct mdt_thread_info *info); +int mdt_convert(struct mdt_thread_info *info); +int mdt_bl_callback(struct mdt_thread_info *info); +int mdt_cp_callback(struct mdt_thread_info *info); +int mdt_llog_create(struct mdt_thread_info *info); +int mdt_llog_destroy(struct mdt_thread_info *info); +int mdt_llog_read_header(struct mdt_thread_info *info); +int mdt_llog_next_block(struct mdt_thread_info *info); +int mdt_llog_prev_block(struct mdt_thread_info *info); +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 mdt_opc_slice mdt_fld_handlers[]; + +int mdt_quotacheck(struct mdt_thread_info *info); +int mdt_quotactl(struct mdt_thread_info *info); +int mdt_quota_dqacq(struct mdt_thread_info *info); +int mdt_swap_layouts(struct mdt_thread_info *info); + +extern struct lprocfs_vars lprocfs_mds_module_vars[]; +extern struct lprocfs_vars lprocfs_mds_obd_vars[]; + +int mdt_hsm_attr_set(struct mdt_thread_info *info, struct mdt_object *obj, + const struct md_hsm *mh); + +struct mdt_handler *mdt_handler_find(__u32 opc, + struct mdt_opc_slice *supported); /* mdt_idmap.c */ int mdt_init_sec_level(struct mdt_thread_info *); int mdt_init_idmap(struct mdt_thread_info *); @@ -641,18 +899,18 @@ int mdt_fix_attr_ucred(struct mdt_thread_info *, __u32); static inline struct mdt_device *mdt_dev(struct lu_device *d) { -// LASSERT(lu_device_is_mdt(d)); - return container_of0(d, struct mdt_device, mdt_md_dev.md_lu_dev); + return container_of0(d, struct mdt_device, mdt_lu_dev); } static inline struct dt_object *mdt_obj2dt(struct mdt_object *mo) { - struct lu_object *lo; - struct mdt_device *mdt = mdt_dev(mo->mot_obj.mo_lu.lo_dev); + struct lu_object *lo; + struct mdt_device *mdt = mdt_dev(mo->mot_obj.lo_dev); + + lo = lu_object_locate(mo->mot_obj.lo_header, + mdt->mdt_bottom->dd_lu_dev.ld_type); - lo = lu_object_locate(mo->mot_obj.mo_lu.lo_header, - mdt->mdt_bottom->dd_lu_dev.ld_type); - return lu2dt(lo); + return lu2dt(lo); } /* mdt/mdt_identity.c */ @@ -670,6 +928,104 @@ __u32 mdt_identity_get_perm(struct md_identity *, __u32, lnet_nid_t); int mdt_pack_remote_perm(struct mdt_thread_info *, struct mdt_object *, void *); +/* mdt/mdt_hsm.c */ +int mdt_hsm_state_get(struct mdt_thread_info *info); +int mdt_hsm_state_set(struct mdt_thread_info *info); +int mdt_hsm_action(struct mdt_thread_info *info); +int mdt_hsm_progress(struct mdt_thread_info *info); +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); +/* mdt/mdt_hsm_cdt_actions.c */ +extern const struct file_operations mdt_agent_actions_fops; +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, + __u64 compound_id, __u32 archive_id, + __u64 flags, struct hsm_action_item *hai); +int mdt_agent_record_update(const struct lu_env *env, + struct mdt_device *mdt, __u64 *cookies, + int cookies_count, enum agent_req_status status); +int mdt_agent_llog_update_rec(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); +struct cdt_agent_req *mdt_cdt_alloc_request(__u64 compound_id, __u32 archive_id, + __u64 flags, struct obd_uuid *uuid, + struct hsm_action_item *hai); +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, + 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, + const struct hsm_progress_kernel *pgs); +int mdt_cdt_remove_request(struct coordinator *cdt, __u64 cookie); +/* 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*/ static inline int mdt_fail_write(const struct lu_env *env, @@ -710,7 +1066,8 @@ static inline int mdt_check_resent(struct mdt_thread_info *info, RETURN(0); } -struct md_ucred *mdt_ucred(const struct mdt_thread_info *info); +struct lu_ucred *mdt_ucred(const struct mdt_thread_info *info); +struct lu_ucred *mdt_ucred_check(const struct mdt_thread_info *info); static inline int is_identity_get_disabled(struct upcall_cache *cache) { @@ -725,7 +1082,7 @@ static inline int mdt_fid_lock(struct ldlm_namespace *ns, ldlm_mode_t mode, ldlm_policy_data_t *policy, const struct ldlm_res_id *res_id, - int flags, const __u64 *client_cookie) + __u64 flags, const __u64 *client_cookie) { int rc; @@ -735,7 +1092,7 @@ static inline int mdt_fid_lock(struct ldlm_namespace *ns, rc = ldlm_cli_enqueue_local(ns, res_id, LDLM_IBITS, policy, mode, &flags, mdt_blocking_ast, ldlm_completion_ast, NULL, NULL, 0, - client_cookie, lh); + LVB_T_NONE, client_cookie, lh); return rc == ELDLM_OK ? 0 : -EIO; } @@ -793,7 +1150,6 @@ static inline struct lu_name *mdt_name_copy(struct lu_name *tlname, 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 { @@ -818,64 +1174,49 @@ enum { void mdt_counter_incr(struct ptlrpc_request *req, int opcode); void mdt_stats_counter_init(struct lprocfs_stats *stats); void lprocfs_mdt_init_vars(struct lprocfs_static_vars *lvars); +void lprocfs_mds_init_vars(struct lprocfs_static_vars *lvars); int mdt_procfs_init(struct mdt_device *mdt, const char *name); -int mdt_procfs_fini(struct mdt_device *mdt); +void mdt_procfs_fini(struct mdt_device *mdt); void mdt_rename_counter_tally(struct mdt_thread_info *info, struct mdt_device *mdt, struct ptlrpc_request *req, struct mdt_object *src, struct mdt_object *tgt); -void mdt_time_start(const struct mdt_thread_info *info); -void mdt_time_end(const struct mdt_thread_info *info, int idx); - /* Capability */ int mdt_ck_thread_start(struct mdt_device *mdt); 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); +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 void mdt_set_capainfo(struct mdt_thread_info *info, int offset, - const struct lu_fid *fid, - struct lustre_capa *capa) +static inline struct obd_device *mdt2obd_dev(const struct mdt_device *mdt) { - struct md_capainfo *ci; + return mdt->mdt_lu_dev.ld_obd; +} - LASSERT(offset >= 0 && offset < MD_CAPAINFO_MAX); - if (!info->mti_mdt->mdt_opts.mo_mds_capa || - !(info->mti_exp->exp_connect_flags & OBD_CONNECT_MDS_CAPA)) - return; +extern const struct lu_device_operations mdt_lu_ops; - ci = md_capainfo(info->mti_env); - LASSERT(ci); - ci->mc_fid[offset] = *fid; - ci->mc_capa[offset] = capa; +static inline int lu_device_is_mdt(struct lu_device *d) +{ + return ergo(d != NULL && d->ld_ops != NULL, d->ld_ops == &mdt_lu_ops); } -static inline void mdt_dump_capainfo(struct mdt_thread_info *info) +static inline struct mdt_device *lu2mdt_dev(struct lu_device *d) { - 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); - } + LASSERTF(lu_device_is_mdt(d), "It is %s instead of MDT %p %p\n", + d->ld_type->ldt_name, d->ld_ops, &mdt_lu_ops); + return container_of0(d, struct mdt_device, mdt_lu_dev); } -static inline struct obd_device *mdt2obd_dev(const struct mdt_device *mdt) +static inline char *mdt_obd_name(struct mdt_device *mdt) { - return mdt->mdt_md_dev.md_lu_dev.ld_obd; + return mdt->mdt_lu_dev.ld_obd->obd_name; } + +int mds_mod_init(void); +void mds_mod_exit(void); + #endif /* __KERNEL__ */ #endif /* _MDT_H */