X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fmdt%2Fmdt_internal.h;h=8829027e45639cbf2df34481348ee87c55bcaf06;hp=81b0b20363316d4f58321ba5d064fffa3bcc9246;hb=91144acb3dc1120c00797269afa621c94cb64e1e;hpb=612f27788166e2f1153cb5f2c4b4bffba9a42235 diff --git a/lustre/mdt/mdt_internal.h b/lustre/mdt/mdt_internal.h index 81b0b20..8829027 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, 2013, Intel Corporation. + * Copyright (c) 2011, 2015, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -48,53 +48,52 @@ #ifndef _MDT_INTERNAL_H #define _MDT_INTERNAL_H -#if defined(__KERNEL__) -#include +#include #include #include +#include #include #include #include #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) -{ - struct lsd_client_data *lcd = req->rq_export->exp_target_data.ted_lcd; - return (req->rq_xid == lcd->lcd_last_xid || - req->rq_xid == lcd->lcd_last_close_xid); -} +#include 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 */ + /** portals handle must be first */ + struct portals_handle mfd_handle; + /** open mode provided by client */ + __u64 mfd_mode; + /** protected by med_open_lock */ + struct list_head mfd_list; + /** xid of the open request */ + __u64 mfd_xid; + /** old handle in replay case */ + struct lustre_handle mfd_old_handle; + /** point to opened object */ + struct mdt_object *mfd_object; }; -#define CDT_NONBLOCKING_RESTORE 0x0000000000000001ULL -#define CDT_NORETRY_ACTION 0x0000000000000002ULL -#define CDT_POLICY_MASK CDT_NONBLOCKING_RESTORE | \ - CDT_NORETRY_ACTION +#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 0x0000000000000000ULL +#define CDT_DEFAULT_POLICY CDT_NORETRY_ACTION enum cdt_states { CDT_STOPPED = 0, CDT_INIT, @@ -110,34 +109,45 @@ enum cdt_states { CDT_STOPPED = 0, * cdt_request_lock */ struct coordinator { - struct ptlrpc_thread *cdt_thread; /**< coordinator thread */ - struct lu_env cdt_env; /**< coordinator lustre - * env */ - 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 */ - __u64 cdt_last_cookie; /**< last cookie allocated */ - struct semaphore cdt_counter_lock; /**< protect request - * counter */ - struct semaphore 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 */ - 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 - * started requests */ - cfs_list_t cdt_requests; /**< list of started - * requests */ - cfs_list_t cdt_agents; /**< list of register - * agents */ - cfs_list_t cdt_restore_hdl; /**< list of restore lock - * handles */ + 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; /**< policy flags */ + 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_grace_delay; /**< request grace + * delay */ + cfs_time_t cdt_active_req_timeout; /**< request timeout */ + __u32 cdt_default_archive_id; /**< archive id used + * when none are + * specified */ + __u64 cdt_max_requests; /**< 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 */ + /* Bitmasks indexed by the HSMA_XXX constants. */ + __u64 cdt_user_request_mask; + __u64 cdt_group_request_mask; + __u64 cdt_other_request_mask; }; /* mdt state flag bits */ @@ -165,17 +175,12 @@ struct mdt_device { 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_evict_tgt_nids:1, mo_coordinator:1; } mdt_opts; /* mdt state flags */ unsigned long mdt_state; - /* lock to protect IOepoch */ - spinlock_t mdt_ioepoch_lock; - __u64 mdt_ioepoch; /* transaction callbacks */ struct dt_txn_callback mdt_txn_cb; @@ -183,27 +188,15 @@ struct mdt_device { /* these values should be updated from lov if necessary. * or should be placed somewhere else. */ int mdt_max_mdsize; - int mdt_max_cookiesize; + + int mdt_max_ea_size; struct upcall_cache *mdt_identity_cache; - /* sptlrpc rules */ - rwlock_t mdt_sptlrpc_lock; - struct sptlrpc_rule_set mdt_sptlrpc_rset; - - /* capability keys */ - unsigned long mdt_capa_timeout; - __u32 mdt_capa_alg; - struct dt_object *mdt_ck_obj; - unsigned long mdt_ck_timeout; - unsigned long mdt_ck_expiry; - 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, /* Enable remote dir on non-MDT0 */ - mdt_enable_remote_dir:1; + mdt_enable_remote_dir:1, + mdt_skip_lfsck:1; gid_t mdt_enable_remote_dir_gid; /* statfs optimization: we cache a bit */ @@ -212,14 +205,8 @@ struct mdt_device { spinlock_t mdt_osfs_lock; /* root squash */ - uid_t mdt_squash_uid; - gid_t mdt_squash_gid; - cfs_list_t mdt_nosquash_nids; - char *mdt_nosquash_str; - int mdt_nosquash_strlen; - struct rw_semaphore mdt_squash_sem; - - int mdt_sec_level; + struct root_squash_info mdt_squash; + struct rename_stats mdt_rename_stats; struct lu_fid mdt_md_root_fid; @@ -229,74 +216,64 @@ struct mdt_device { struct lu_device *mdt_qmt_dev; struct coordinator mdt_coordinator; + + /* inter-MDT connection count */ + atomic_t mdt_mds_mds_conns; + + /* MDT device async commit count, used for debug and sanity test */ + atomic_t mdt_async_commit_count; }; #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) +enum mdt_object_flags { + /** lov object has been created. */ + MOF_LOV_CREATED = 1 << 0, +}; + struct mdt_object { 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. */ - struct mutex mot_ioepoch_mutex; + enum mdt_object_flags mot_flags; + int mot_write_count; + spinlock_t mot_write_lock; /* Lock to protect create_data */ struct mutex mot_lov_mutex; -}; - -enum mdt_object_flags { - /** SOM attributes are changed. */ - MOF_SOM_CHANGE = (1 << 0), - /** - * The SOM recovery state for mdt object. - * This state is an in-memory equivalent of an absent SOM EA, used - * instead of invalidating SOM EA while IOEpoch is still opened when - * a client eviction occurs or a client fails to obtain SOM attributes. - * It indicates that the last IOEpoch holder will need to obtain SOM - * attributes under [0;EOF] extent lock to flush all the client's - * cached of evicted from MDS clients (but not necessary evicted from - * OST) before taking ost attributes. - */ - MOF_SOM_RECOV = (1 << 1), - /** File has been just created. */ - MOF_SOM_CREATED = (1 << 2), - /** lov object has been created. */ - MOF_LOV_CREATED = (1 << 3), + /* 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; }; struct mdt_lock_handle { - /* Lock type, reg for cross-ref use or pdo lock. */ - mdl_type_t mlh_type; + /* Lock type, reg for cross-ref use or pdo lock. */ + mdl_type_t mlh_type; - /* Regular lock */ - struct lustre_handle mlh_reg_lh; - ldlm_mode_t mlh_reg_mode; + /* Regular lock */ + struct lustre_handle mlh_reg_lh; + enum ldlm_mode mlh_reg_mode; - /* Pdirops lock */ - struct lustre_handle mlh_pdo_lh; - ldlm_mode_t mlh_pdo_mode; - unsigned int mlh_pdo_hash; + /* Pdirops lock */ + struct lustre_handle mlh_pdo_lh; + enum ldlm_mode mlh_pdo_mode; + unsigned int mlh_pdo_hash; /* Remote regular lock */ - struct lustre_handle mlh_rreg_lh; - ldlm_mode_t mlh_rreg_mode; + struct lustre_handle mlh_rreg_lh; + enum ldlm_mode mlh_rreg_mode; }; 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 { @@ -304,80 +281,29 @@ enum { MDT_CROSS_LOCK }; +/* Special magical errno for communicaiton between mdt_reint_open() + * and mdt_intent_reint() which means return the lock to the client + * for subsequent cross ref open. Previously we used plain -EREMOTE + * but other functions called in that path might return it too and + * confuse us. This is not returned to the client. See LU-5370. */ +#define MDT_EREMOTE_OPEN (EREMOTE + 1024) + struct mdt_reint_record { - mdt_reint_t rr_opcode; - const struct lustre_handle *rr_handle; - const struct lu_fid *rr_fid1; - const struct lu_fid *rr_fid2; - const char *rr_name; - int rr_namelen; - const char *rr_tgt; - int rr_tgtlen; - const void *rr_eadata; - int rr_eadatalen; - int rr_logcookielen; - const struct llog_cookie *rr_logcookies; - __u32 rr_flags; + mdt_reint_t rr_opcode; + const struct lustre_handle *rr_handle; + const struct lu_fid *rr_fid1; + const struct lu_fid *rr_fid2; + struct lu_name rr_name; + struct lu_name rr_tgt_name; + void *rr_eadata; + int rr_eadatalen; + __u32 rr_flags; }; 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. @@ -404,12 +330,6 @@ struct mdt_thread_info { struct mdt_device *mti_mdt; const struct lu_env *mti_env; - /* - * Additional fail id that can be set by handler. Passed to - * target_send_reply(). - */ - int mti_fail_id; - /* transaction number of current request */ __u64 mti_transno; @@ -459,8 +379,6 @@ struct mdt_thread_info { */ struct mdt_reint_record mti_rr; - /** md objects included in operation */ - struct mdt_object *mti_mos; __u64 mti_ver[PTLRPC_NUM_VERSIONS]; /* * Operation specification (currently create and lookup) @@ -474,115 +392,103 @@ struct mdt_thread_info { * They should be initialized explicitly by the user themselves. */ - /* XXX: If something is in a union, make sure they do not conflict */ - - struct lu_fid mti_tmp_fid1; - struct lu_fid mti_tmp_fid2; - ldlm_policy_data_t mti_policy; /* for mdt_object_lock() and - * mdt_rename_lock() */ - struct ldlm_res_id mti_res_id; /* for mdt_object_lock() and - mdt_rename_lock() */ - union { - struct obd_uuid uuid[2]; /* for mdt_seq_init_cli() */ - char ns_name[48]; /* for mdt_init0() */ - struct lustre_cfg_bufs bufs; /* for mdt_stack_fini() */ - struct obd_statfs osfs; /* for mdt_statfs() */ + /* XXX: If something is in a union, make sure they do not conflict */ + struct lu_fid mti_tmp_fid1; + struct lu_fid mti_tmp_fid2; + union ldlm_policy_data mti_policy; /* for mdt_object_lock() */ + struct ldlm_res_id mti_res_id; /* and mdt_rename_lock() */ + union { + struct obd_uuid uuid[2]; /* for mdt_seq_init_cli() */ + char ns_name[48];/* for mdt_init0() */ + struct lustre_cfg_bufs bufs; /* for mdt_stack_fini() */ + struct obd_statfs osfs; /* for mdt_statfs() */ struct { /* for mdt_readpage() */ struct lu_rdpg mti_rdpg; /* for mdt_sendpage() */ struct l_wait_info mti_wait_info; } rdpg; - struct { - 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; + struct md_attr attr; + } hsm; } mti_u; - /* IO epoch related stuff. */ - struct mdt_ioepoch *mti_ioepoch; - __u64 mti_replayepoch; - + struct lustre_handle mti_close_handle; 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; - /* per-thread values, can be re-used */ + /* per-thread values, can be re-used, may be vmalloc'd */ void *mti_big_lmm; int mti_big_lmmsize; /* big_lmm buffer was used and must be used in reply */ 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; + struct tg_reply_data *mti_reply_data; }; -/* 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; +extern struct lu_context_key mdt_thread_key; + +static inline struct mdt_thread_info *mdt_th_info(const struct lu_env *env) +{ + struct mdt_thread_info *mti; + + lu_env_refill((void *)env); + mti = lu_context_key_get(&env->le_ctx, &mdt_thread_key); + LASSERT(mti); + return mti; +} + +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 */ }; -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 cdt_agent_req { + struct list_head 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 { + struct list_head 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 mdt_opc_slice { - __u32 mos_opc_start; - int mos_opc_end; - struct mdt_handler *mos_hs; +struct cdt_restore_handle { + struct list_head 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) @@ -602,12 +508,6 @@ 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); @@ -658,49 +558,55 @@ static inline struct seq_server_site *mdt_seq_site(struct mdt_device *mdt) static inline void mdt_export_evict(struct obd_export *exp) { class_fail_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) +static inline bool 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); +static inline bool mdt_is_striped_client(struct obd_export *exp) +{ + return exp_connect_flags(exp) & OBD_CONNECT_DIR_STRIPE; +} + +__u64 mdt_get_disposition(struct ldlm_reply *rep, __u64 op_flag); void mdt_set_disposition(struct mdt_thread_info *info, - struct ldlm_reply *rep, int flag); + struct ldlm_reply *rep, __u64 op_flag); void mdt_clear_disposition(struct mdt_thread_info *info, - struct ldlm_reply *rep, int flag); + struct ldlm_reply *rep, __u64 op_flag); + +void mdt_lock_pdo_init(struct mdt_lock_handle *lh, enum ldlm_mode lock_mode, + const struct lu_name *lname); + +void mdt_lock_reg_init(struct mdt_lock_handle *lh, enum ldlm_mode lm); + +int mdt_lock_setup(struct mdt_thread_info *info, struct mdt_object *mo, + struct mdt_lock_handle *lh); -void mdt_lock_pdo_init(struct mdt_lock_handle *lh, - ldlm_mode_t lm, const char *name, - int namelen); +int mdt_check_resent_lock(struct mdt_thread_info *info, struct mdt_object *mo, + struct mdt_lock_handle *lhc); -void mdt_lock_reg_init(struct mdt_lock_handle *lh, - ldlm_mode_t lm); +int mdt_object_lock(struct mdt_thread_info *info, struct mdt_object *mo, + struct mdt_lock_handle *lh, __u64 ibits); -int mdt_lock_setup(struct mdt_thread_info *info, - struct mdt_object *o, - struct mdt_lock_handle *lh); +int mdt_reint_object_lock(struct mdt_thread_info *info, struct mdt_object *o, + struct mdt_lock_handle *lh, __u64 ibits, + bool cos_incompat); -int mdt_object_lock(struct mdt_thread_info *, - struct mdt_object *, - struct mdt_lock_handle *, - __u64, int); +int mdt_object_lock_try(struct mdt_thread_info *info, struct mdt_object *mo, + struct mdt_lock_handle *lh, __u64 ibits); -int mdt_object_lock_try(struct mdt_thread_info *, - struct mdt_object *, - struct mdt_lock_handle *, - __u64, int); +int mdt_reint_object_lock_try(struct mdt_thread_info *info, + struct mdt_object *o, struct mdt_lock_handle *lh, + __u64 ibits, bool cos_incompat); -void mdt_object_unlock(struct mdt_thread_info *, - struct mdt_object *, - struct mdt_lock_handle *, - int decref); +void mdt_object_unlock(struct mdt_thread_info *info, struct mdt_object *mo, + struct mdt_lock_handle *lh, int decref); -struct mdt_object *mdt_object_new(const struct lu_env *, +struct mdt_object *mdt_object_new(const struct lu_env *env, struct mdt_device *, const struct lu_fid *); struct mdt_object *mdt_object_find(const struct lu_env *, @@ -718,11 +624,25 @@ 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); + struct mdt_object *o, const struct lu_fid *fid, + struct lustre_handle *lh, + enum ldlm_mode mode, __u64 ibits, bool nonblock); + +enum mdt_name_flags { + MNF_FIX_ANON = 1, +}; + +int mdt_name_unpack(struct req_capsule *pill, + const struct req_msg_field *field, + struct lu_name *ln, + enum mdt_name_flags flags); 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 *); +#ifdef CONFIG_FS_POSIX_ACL +int mdt_pack_acl2body(struct mdt_thread_info *info, struct mdt_body *repbody, + struct mdt_object *o, struct lu_nodemap *nodemap); +#endif void mdt_pack_attr2body(struct mdt_thread_info *info, struct mdt_body *b, const struct lu_attr *attr, const struct lu_fid *fid); @@ -748,49 +668,36 @@ int mdt_export_stats_init(struct obd_device *obd, struct obd_export *exp, void *client_nid); -int mdt_pin(struct mdt_thread_info* info); - int mdt_lock_new_child(struct mdt_thread_info *info, struct mdt_object *o, 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 *); - -enum { - MDT_IOEPOCH_CLOSED = 0, - MDT_IOEPOCH_OPENED = 1, - MDT_IOEPOCH_GETATTR = 2, -}; - -enum { - MDT_SOM_DISABLE = 0, - MDT_SOM_ENABLE = 1, -}; +struct mdt_file_data *mdt_handle2mfd(struct mdt_export_data *med, + const struct lustre_handle *handle, + bool is_replay); +int mdt_get_info(struct tgt_session_info *tsi); int mdt_attr_get_complex(struct mdt_thread_info *info, struct mdt_object *o, struct md_attr *ma); -int mdt_ioepoch_open(struct mdt_thread_info *info, struct mdt_object *o, - int created); -int mdt_object_is_som_enabled(struct mdt_object *mo); +int mdt_big_xattr_get(struct mdt_thread_info *info, struct mdt_object *o, + const char *name); +int mdt_stripe_get(struct mdt_thread_info *info, struct mdt_object *o, + struct md_attr *ma, const char *name); 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_close(struct tgt_session_info *tsi); 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 *, const struct md_attr *); @@ -800,67 +707,38 @@ struct lu_buf *mdt_buf(const struct lu_env *env, void *area, ssize_t len); const struct lu_buf *mdt_buf_const(const struct lu_env *env, const void *area, ssize_t len); -void mdt_dump_lmm(int level, const struct lov_mds_md *lmm); +void mdt_dump_lmm(int level, const struct lov_mds_md *lmm, __u64 valid); +void mdt_dump_lmv(unsigned int level, const union lmv_mds_md *lmv); +bool allow_client_chgrp(struct mdt_thread_info *info, struct lu_ucred *uc); int mdt_check_ucred(struct mdt_thread_info *); int mdt_init_ucred(struct mdt_thread_info *, struct mdt_body *); +int mdt_init_ucred_intent_getattr(struct mdt_thread_info *, struct mdt_body *); int mdt_init_ucred_reint(struct mdt_thread_info *); void mdt_exit_ucred(struct mdt_thread_info *); 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); - -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[]; +void mdt_thread_info_init(struct ptlrpc_request *req, + struct mdt_thread_info *mti); +void mdt_thread_info_fini(struct mdt_thread_info *mti); +struct mdt_thread_info *tsi2mdt_info(struct tgt_session_info *tsi); int mdt_hsm_attr_set(struct mdt_thread_info *info, struct mdt_object *obj, - struct md_hsm *mh); - -struct mdt_handler *mdt_handler_find(__u32 opc, - struct mdt_opc_slice *supported); + const struct md_hsm *mh); + +int mdt_remote_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc, + void *data, int flag); +int mdt_links_read(struct mdt_thread_info *info, + struct mdt_object *mdt_obj, + struct linkea_data *ldata); +int mdt_close_internal(struct mdt_thread_info *info, struct ptlrpc_request *req, + struct mdt_body *repbody); /* mdt_idmap.c */ -int mdt_init_sec_level(struct mdt_thread_info *); -int mdt_init_idmap(struct mdt_thread_info *); +int mdt_init_idmap(struct tgt_session_info *tsi); void mdt_cleanup_idmap(struct mdt_export_data *); -int mdt_handle_idmap(struct mdt_thread_info *); +int mdt_handle_idmap(struct tgt_session_info *tsi); int ptlrpc_user_desc_do_idmap(struct ptlrpc_request *, struct ptlrpc_user_desc *); void mdt_body_reverse_idmap(struct mdt_thread_info *, @@ -874,6 +752,11 @@ static inline struct mdt_device *mdt_dev(struct lu_device *d) return container_of0(d, struct mdt_device, mdt_lu_dev); } +static inline struct mdt_object *mdt_obj(struct lu_object *o) +{ + return container_of0(o, struct mdt_object, mot_obj); +} + static inline struct dt_object *mdt_obj2dt(struct mdt_object *mo) { struct lu_object *lo; @@ -900,18 +783,22 @@ __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_recovery.c */ +__u64 mdt_req_from_lrd(struct ptlrpc_request *req, struct tg_reply_data *trd); + /* 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); +int mdt_hsm_state_get(struct tgt_session_info *tsi); +int mdt_hsm_state_set(struct tgt_session_info *tsi); +int mdt_hsm_action(struct tgt_session_info *tsi); +int mdt_hsm_progress(struct tgt_session_info *tsi); +int mdt_hsm_ct_register(struct tgt_session_info *tsi); +int mdt_hsm_ct_unregister(struct tgt_session_info *tsi); +int mdt_hsm_request(struct tgt_session_info *tsi); /* 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); +extern const struct file_operations mdt_hsm_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, @@ -920,11 +807,89 @@ int mdt_agent_record_add(const struct lu_env *env, struct mdt_device *mdt, 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_active_requests_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 */ +ssize_t mdt_hsm_cdt_control_seq_write(struct file *file, + const char __user *buffer, + size_t count, loff_t *off); +int mdt_hsm_cdt_control_seq_show(struct seq_file *m, void *data); +int hsm_cdt_procfs_init(struct mdt_device *mdt); +void hsm_cdt_procfs_fini(struct mdt_device *mdt); +struct lprocfs_vars *hsm_cdt_get_proc_vars(void); +/* 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); + +int mdt_close_swap_layouts(struct mdt_thread_info *info, + struct mdt_object *o, struct md_attr *ma); extern struct lu_context_key mdt_thread_key; + /* debug issues helper starts here*/ static inline int mdt_fail_write(const struct lu_env *env, struct dt_device *dd, int id) @@ -941,7 +906,12 @@ static inline int mdt_fail_write(const struct lu_env *env, static inline struct mdt_export_data *mdt_req2med(struct ptlrpc_request *req) { - return &req->rq_export->exp_mdt_data; + return &req->rq_export->exp_mdt_data; +} + +static inline struct mdt_device *mdt_exp2dev(struct obd_export *exp) +{ + return mdt_dev(exp->exp_obd->obd_lu_dev); } typedef void (*mdt_reconstruct_t)(struct mdt_thread_info *mti, @@ -950,18 +920,27 @@ static inline int mdt_check_resent(struct mdt_thread_info *info, mdt_reconstruct_t reconstruct, struct mdt_lock_handle *lhc) { - struct ptlrpc_request *req = mdt_info_req(info); - ENTRY; - - if (lustre_msg_get_flags(req->rq_reqmsg) & MSG_RESENT) { - if (req_xid_is_last(req)) { - reconstruct(info, lhc); - RETURN(1); - } - DEBUG_REQ(D_HA, req, "no reply for RESENT req (have "LPD64")", - req->rq_export->exp_target_data.ted_lcd->lcd_last_xid); - } - RETURN(0); + struct ptlrpc_request *req = mdt_info_req(info); + int rc = 0; + ENTRY; + + if (lustre_msg_get_flags(req->rq_reqmsg) & MSG_RESENT) { + OBD_ALLOC_PTR(info->mti_reply_data); + if (info->mti_reply_data == NULL) + RETURN(-ENOMEM); + + if (req_can_reconstruct(req, info->mti_reply_data)) { + reconstruct(info, lhc); + rc = 1; + } else { + DEBUG_REQ(D_HA, req, + "no reply data found for RESENT req"); + rc = 0; + } + OBD_FREE_PTR(info->mti_reply_data); + info->mti_reply_data = NULL; + } + RETURN(rc); } struct lu_ucred *mdt_ucred(const struct mdt_thread_info *info); @@ -976,79 +955,53 @@ int mdt_blocking_ast(struct ldlm_lock*, struct ldlm_lock_desc*, void*, int); /* Issues dlm lock on passed @ns, @f stores it lock handle into @lh. */ static inline int mdt_fid_lock(struct ldlm_namespace *ns, - struct lustre_handle *lh, - ldlm_mode_t mode, - ldlm_policy_data_t *policy, - const struct ldlm_res_id *res_id, + struct lustre_handle *lh, enum ldlm_mode mode, + union ldlm_policy_data *policy, + const struct ldlm_res_id *res_id, __u64 flags, const __u64 *client_cookie) { - int rc; + int rc; - LASSERT(ns != NULL); - LASSERT(lh != NULL); + LASSERT(ns != NULL); + LASSERT(lh != NULL); - rc = ldlm_cli_enqueue_local(ns, res_id, LDLM_IBITS, policy, - mode, &flags, mdt_blocking_ast, - ldlm_completion_ast, NULL, NULL, 0, + rc = ldlm_cli_enqueue_local(ns, res_id, LDLM_IBITS, policy, + mode, &flags, mdt_blocking_ast, + ldlm_completion_ast, NULL, NULL, 0, LVB_T_NONE, client_cookie, lh); - return rc == ELDLM_OK ? 0 : -EIO; + return rc == ELDLM_OK ? 0 : -EIO; } -static inline void mdt_fid_unlock(struct lustre_handle *lh, - ldlm_mode_t mode) +static inline void mdt_fid_unlock(struct lustre_handle *lh, enum ldlm_mode mode) { - ldlm_lock_decref(lh, mode); + ldlm_lock_decref(lh, mode); +} + +static inline bool mdt_slc_is_enabled(struct mdt_device *mdt) +{ + return mdt->mdt_lut.lut_sync_lock_cancel == BLOCKING_SYNC_ON_CANCEL; } extern mdl_mode_t mdt_mdl_lock_modes[]; -extern ldlm_mode_t mdt_dlm_lock_modes[]; +extern enum ldlm_mode mdt_dlm_lock_modes[]; -static inline mdl_mode_t mdt_dlm_mode2mdl_mode(ldlm_mode_t mode) +static inline mdl_mode_t mdt_dlm_mode2mdl_mode(enum ldlm_mode mode) { - LASSERT(IS_PO2(mode)); - return mdt_mdl_lock_modes[mode]; + LASSERT(IS_PO2(mode)); + return mdt_mdl_lock_modes[mode]; } -static inline ldlm_mode_t mdt_mdl_mode2dlm_mode(mdl_mode_t mode) +static inline enum ldlm_mode mdt_mdl_mode2dlm_mode(mdl_mode_t mode) { - LASSERT(IS_PO2(mode)); - return mdt_dlm_lock_modes[mode]; + LASSERT(IS_PO2(mode)); + return mdt_dlm_lock_modes[mode]; } /* mdt_lvb.c */ extern struct ldlm_valblock_ops mdt_lvbo; -static inline struct lu_name *mdt_name(const struct lu_env *env, - char *name, int namelen) -{ - struct lu_name *lname; - struct mdt_thread_info *mti; - - LASSERT(namelen > 0); - /* trailing '\0' in buffer */ - LASSERT(name[namelen] == '\0'); - - mti = lu_context_key_get(&env->le_ctx, &mdt_thread_key); - lname = &mti->mti_name; - lname->ln_name = name; - lname->ln_namelen = namelen; - return lname; -} - -static inline struct lu_name *mdt_name_copy(struct lu_name *tlname, - struct lu_name *slname) -{ - LASSERT(tlname); - LASSERT(slname); - - tlname->ln_name = slname->ln_name; - tlname->ln_namelen = slname->ln_namelen; - return 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 { @@ -1072,60 +1025,17 @@ 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); void mdt_procfs_fini(struct mdt_device *mdt); + +/* lustre/mdt_mdt_lproc.c */ +int lprocfs_mdt_open_files_seq_open(struct inode *inode, + struct file *file); 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); -/* 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); - -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); - } -} - static inline struct obd_device *mdt2obd_dev(const struct mdt_device *mdt) { return mdt->mdt_lu_dev.ld_obd; @@ -1133,18 +1043,6 @@ static inline struct obd_device *mdt2obd_dev(const struct mdt_device *mdt) extern const struct lu_device_operations mdt_lu_ops; -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 struct mdt_device *lu2mdt_dev(struct lu_device *d) -{ - 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 char *mdt_obd_name(struct mdt_device *mdt) { return mdt->mdt_lu_dev.ld_obd->obd_name; @@ -1153,37 +1051,15 @@ static inline char *mdt_obd_name(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__) +static inline char *mdt_req_get_jobid(struct ptlrpc_request *req) +{ + struct obd_export *exp = req->rq_export; + char *jobid = NULL; -#define out_tx_index_delete(info, obj, th, name, reply, idx) \ - __out_tx_index_delete(info, obj, th, name, reply, idx, \ - __FILE__, __LINE__) + if (exp_connect_flags(exp) & OBD_CONNECT_JOBSTATS) + jobid = lustre_msg_get_jobid(req->rq_reqmsg); -#define out_tx_destroy(info, obj, th, reply, idx) \ - __out_tx_destroy(info, obj, th, reply, idx, __FILE__, __LINE__) + return jobid; +} -#endif /* __KERNEL__ */ -#endif /* _MDT_H */ +#endif /* _MDT_INTERNAL_H */