X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fmdt%2Fmdt_internal.h;h=44a5d68c6be062c59eb267f38a15f58f2d8733b2;hb=bc962bde3b109b99c924137ed281d9400637e295;hp=aa6c6cc547e33a0c3ac9c38e15f6d26101f596b7;hpb=4c98c57e9fe2c30f5401f18f5ab024cdb7cf5b7b;p=fs%2Flustre-release.git diff --git a/lustre/mdt/mdt_internal.h b/lustre/mdt/mdt_internal.h index aa6c6cc..44a5d68 100644 --- a/lustre/mdt/mdt_internal.h +++ b/lustre/mdt/mdt_internal.h @@ -1,6 +1,4 @@ -/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- - * vim:expandtab:shiftwidth=8:tabstop=8: - * +/* * GPL HEADER START * * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. @@ -26,8 +24,10 @@ * GPL HEADER END */ /* - * Copyright 2008 Sun Microsystems, Inc. All rights reserved + * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. + * + * Copyright (c) 2011, 2013, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -71,11 +71,12 @@ #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_mdt_data.med_lcd; + 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); } @@ -84,19 +85,24 @@ struct mdt_object; /* file data for open files on MDS */ struct mdt_file_data { struct portals_handle mfd_handle; /* must be first */ - struct list_head mfd_list; /* protected by med_open_lock */ + 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 */ - int mfd_mode; /* open mode provided by client */ struct mdt_object *mfd_object; /* point to opened object */ }; +/* mdt state flag bits */ +#define MDT_FL_CFGLOG 0 +#define MDT_FL_SYNCED 1 + struct mdt_device { /* super-class */ struct md_device mdt_md_dev; + struct seq_server_site mdt_seq_site; struct ptlrpc_service *mdt_regular_service; struct ptlrpc_service *mdt_readpage_service; - struct ptlrpc_service *mdt_xmds_service; + struct ptlrpc_service *mdt_out_service; struct ptlrpc_service *mdt_setattr_service; struct ptlrpc_service *mdt_mdsc_service; struct ptlrpc_service *mdt_mdss_service; @@ -107,8 +113,10 @@ struct mdt_device { /* ptlrpc handle for MDS->client connections (for lock ASTs). */ struct ptlrpc_client *mdt_ldlm_client; /* underlying device */ + struct obd_export *mdt_child_exp; struct md_device *mdt_child; struct dt_device *mdt_bottom; + struct obd_export *mdt_bottom_exp; /** target device */ struct lu_target mdt_lut; /* @@ -123,10 +131,9 @@ struct mdt_device { mo_cos :1; } mdt_opts; /* mdt state flags */ - __u32 mdt_fl_cfglog:1, - mdt_fl_synced:1; - /* lock to pretect epoch and write count */ - spinlock_t mdt_ioepoch_lock; + unsigned long mdt_state; + /* lock to protect IOepoch */ + spinlock_t mdt_ioepoch_lock; __u64 mdt_ioepoch; /* transaction callbacks */ @@ -140,7 +147,7 @@ struct mdt_device { struct upcall_cache *mdt_identity_cache; /* sptlrpc rules */ - rwlock_t mdt_sptlrpc_lock; + rwlock_t mdt_sptlrpc_lock; struct sptlrpc_rule_set mdt_sptlrpc_rset; /* capability keys */ @@ -152,41 +159,71 @@ 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; + unsigned int mdt_capa_conf:1, + mdt_som_conf:1, + mdt_enable_remote_dir:1; + + /* statfs optimization: we cache a bit */ + struct obd_statfs mdt_osfs; + __u64 mdt_osfs_age; + spinlock_t mdt_osfs_lock; /* root squash */ uid_t mdt_squash_uid; gid_t mdt_squash_gid; - struct list_head mdt_nosquash_nids; + cfs_list_t mdt_nosquash_nids; char *mdt_nosquash_str; int mdt_nosquash_strlen; - struct rw_semaphore 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; -#define mdt_transno_lock mdt_lut.lut_translock -#define mdt_last_transno mdt_lut.lut_last_transno -#define mdt_last_rcvd mdt_lut.lut_last_rcvd -#define mdt_mount_count mdt_lut.lut_mount_count -#define mdt_lsd mdt_lut.lut_lsd -#define mdt_client_bitmap_lock mdt_lut.lut_client_bitmap_lock -#define mdt_client_bitmap mdt_lut.lut_client_bitmap + /* connection to quota master */ + struct obd_export *mdt_qmt_exp; + /* quota master device associated with this MDT */ + struct lu_device *mdt_qmt_dev; +}; -#define MDT_SERVICE_WATCHDOG_FACTOR (2) -#define MDT_ROCOMPAT_SUPP (OBD_ROCOMPAT_LOVOBJID) -#define MDT_INCOMPAT_SUPP (OBD_INCOMPAT_MDT | OBD_INCOMPAT_COMMON_LR) -#define MDT_COS_DEFAULT (1) +#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; __u64 mot_ioepoch; __u64 mot_flags; - int mot_epochcount; + int mot_ioepoch_count; int mot_writecount; + /* Lock to protect object's IO epoch. */ + struct mutex mot_ioepoch_mutex; + /* 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), }; struct mdt_lock_handle { @@ -207,6 +244,7 @@ enum { 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 @@ -234,7 +272,58 @@ struct mdt_reint_record { }; enum mdt_reint_flag { - MRF_SETATTR_LOCKED = 1 << 0, + MRF_OPEN_TRUNC = 1 << 0, +}; + +struct mdt_thread_info; +struct tx_arg; +typedef int (*tx_exec_func_t)(struct mdt_thread_info *, 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; + int line; + struct update_reply *reply; + 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; + } 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 */ }; /* @@ -298,7 +387,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 @@ -320,8 +408,8 @@ struct mdt_thread_info { struct mdt_reint_record mti_rr; /** md objects included in operation */ - struct mdt_object *mti_mos[PTLRPC_NUM_VERSIONS]; - + struct mdt_object *mti_mos; + __u64 mti_ver[PTLRPC_NUM_VERSIONS]; /* * Operation specification (currently create and lookup) */ @@ -346,75 +434,103 @@ struct mdt_thread_info { 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 kstatfs ksfs; /* for mdt_statfs() */ + 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; } mti_u; /* IO epoch related stuff. */ - struct mdt_epoch *mti_epoch; + struct mdt_ioepoch *mti_ioepoch; __u64 mti_replayepoch; - /* server and client data buffers */ - struct lr_server_data mti_lsd; - struct lsd_client_data mti_lcd; loff_t mti_off; - struct txn_param mti_txn_param; struct lu_buf mti_buf; struct lustre_capa_key mti_capa_key; /* Ops object filename */ struct lu_name mti_name; - struct md_attr mti_tmp_attr; + /* per-thread values, can be re-used */ + 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; }; -#define mti_parent mti_mos[0] -#define mti_child mti_mos[1] -#define mti_parent1 mti_mos[2] -#define mti_child1 mti_mos[3] - -typedef void (*mdt_cb_t)(const struct mdt_device *mdt, __u64 transno, - void *data, int err); -struct mdt_commit_cb { - mdt_cb_t mdt_cb_func; - void *mdt_cb_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; }; -enum mdt_txn_op { - MDT_TXN_CAPA_KEYS_WRITE_OP, - MDT_TXN_LAST_RCVD_WRITE_OP, +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) }; -/* - * Info allocated per-transaction. - */ -#define MDT_MAX_COMMIT_CB 4 -struct mdt_txn_info { - __u64 txi_transno; - unsigned int txi_cb_count; - struct lut_commit_cb txi_cb[MDT_MAX_COMMIT_CB]; +struct mdt_opc_slice { + __u32 mos_opc_start; + int mos_opc_end; + struct mdt_handler *mos_hs; }; -extern struct lu_context_key mdt_txn_key; - -static inline void mdt_trans_add_cb(const struct thandle *th, - lut_cb_t cb_func, void *cb_data) -{ - struct mdt_txn_info *txi; - - txi = lu_context_key_get(&th->th_ctx, &mdt_txn_key); - LASSERT(txi->txi_cb_count < ARRAY_SIZE(txi->txi_cb)); - - /* add new callback */ - txi->txi_cb[txi->txi_cb_count].lut_cb_func = cb_func; - txi->txi_cb[txi->txi_cb_count].lut_cb_data = cb_data; - txi->txi_cb_count++; -} - static inline const struct md_device_operations * mdt_child_ops(struct mdt_device * m) { @@ -433,6 +549,12 @@ 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); @@ -460,19 +582,24 @@ static inline int mdt_object_exists(const struct mdt_object *o) return lu_object_exists(&o->mot_obj.mo_lu); } -static inline const struct lu_fid *mdt_object_fid(struct mdt_object *o) +static inline const struct lu_fid *mdt_object_fid(const struct mdt_object *o) { return lu_object_fid(&o->mot_obj.mo_lu); } +static inline int mdt_object_obf(const struct mdt_object *o) +{ + return lu_fid_eq(mdt_object_fid(o), &LU_OBF_FID); +} + static inline struct lu_site *mdt_lu_site(const struct mdt_device *mdt) { return mdt->mdt_md_dev.md_lu_dev.ld_site; } -static inline struct md_site *mdt_md_site(const struct mdt_device *mdt) +static inline struct seq_server_site *mdt_seq_site(struct mdt_device *mdt) { - return lu_site2md(mdt_lu_site(mdt)); + return &mdt->mdt_seq_site; } static inline void mdt_export_evict(struct obd_export *exp) @@ -503,11 +630,19 @@ 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 *, int decref); +struct mdt_object *mdt_object_new(const struct lu_env *, + struct mdt_device *, + const struct lu_fid *); struct mdt_object *mdt_object_find(const struct lu_env *, struct mdt_device *, const struct lu_fid *); @@ -520,11 +655,11 @@ void mdt_object_unlock_put(struct mdt_thread_info *, struct mdt_lock_handle *, int decref); +void mdt_client_compatibility(struct mdt_thread_info *info); + 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 *); -void mdt_pack_size2body(struct mdt_thread_info *info, - struct mdt_object *o); void mdt_pack_attr2body(struct mdt_thread_info *info, struct mdt_body *b, const struct lu_attr *attr, const struct lu_fid *fid); @@ -546,14 +681,6 @@ int mdt_fs_setup(const struct lu_env *, struct mdt_device *, struct obd_device *, struct lustre_sb_info *lsi); void mdt_fs_cleanup(const struct lu_env *, struct mdt_device *); -int mdt_client_del(const struct lu_env *env, - struct mdt_device *mdt); -int mdt_client_add(const struct lu_env *env, - struct mdt_device *mdt, - int cl_idx); -int mdt_client_new(const struct lu_env *env, - struct mdt_device *mdt); - int mdt_export_stats_init(struct obd_device *obd, struct obd_export *exp, void *client_nid); @@ -572,36 +699,40 @@ int mdt_reint_open(struct mdt_thread_info *info, struct mdt_file_data *mdt_handle2mfd(struct mdt_thread_info *, const struct lustre_handle *); -int mdt_epoch_open(struct mdt_thread_info *info, struct mdt_object *o); -void mdt_sizeonmds_enable(struct mdt_thread_info *info, struct mdt_object *mo); -int mdt_sizeonmds_enabled(struct mdt_object *mo); -int mdt_write_get(struct mdt_device *mdt, struct mdt_object *o); -int mdt_write_read(struct mdt_device *mdt, struct mdt_object *o); + +enum { + MDT_IOEPOCH_CLOSED = 0, + MDT_IOEPOCH_OPENED = 1, + MDT_IOEPOCH_GETATTR = 2, +}; + +enum { + MDT_SOM_DISABLE = 0, + MDT_SOM_ENABLE = 1, +}; + +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_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); 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, - int flags); + 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); -void mdt_shrink_reply(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 *); void mdt_reconstruct_open(struct mdt_thread_info *, struct mdt_lock_handle *); -void mdt_trans_credit_init(const struct lu_env *env, - struct mdt_device *mdt, - enum mdt_txn_op op); -struct thandle* mdt_trans_start(const struct lu_env *env, - struct mdt_device *mdt); -void mdt_trans_stop(const struct lu_env *env, - struct mdt_device *mdt, struct thandle *th); -int mdt_record_write(const struct lu_env *env, - struct dt_object *dt, const struct lu_buf *buf, - loff_t *pos, struct thandle *th); -int mdt_record_read(const struct lu_env *env, - struct dt_object *dt, struct lu_buf *buf, loff_t *pos); - 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); @@ -612,8 +743,55 @@ int mdt_check_ucred(struct mdt_thread_info *); int mdt_init_ucred(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 *, int); - +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); + +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, + 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 *); @@ -633,6 +811,16 @@ static inline struct mdt_device *mdt_dev(struct lu_device *d) return container_of0(d, struct mdt_device, mdt_md_dev.md_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); + + lo = lu_object_locate(mo->mot_obj.mo_lu.lo_header, + mdt->mdt_bottom->dd_lu_dev.ld_type); + return lu2dt(lo); +} + /* mdt/mdt_identity.c */ #define MDT_IDENTITY_UPCALL_PATH "/usr/sbin/l_getidentity" @@ -648,17 +836,28 @@ __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); + extern struct lu_context_key mdt_thread_key; /* debug issues helper starts here*/ -static inline void mdt_fail_write(const struct lu_env *env, - struct dt_device *dd, int id) +static inline int mdt_fail_write(const struct lu_env *env, + struct dt_device *dd, int id) { if (OBD_FAIL_CHECK_ORSET(id, OBD_FAIL_ONCE)) { - CERROR(LUSTRE_MDT_NAME": obd_fail_loc=%x, fail write ops\n", + CERROR(LUSTRE_MDT_NAME": cfs_fail_loc=%x, fail write ops\n", id); - dd->dd_ops->dt_ro(env, dd); + return dd->dd_ops->dt_ro(env, dd); /* We set FAIL_ONCE because we never "un-fail" a device */ } + + return 0; } static inline struct mdt_export_data *mdt_req2med(struct ptlrpc_request *req) @@ -681,12 +880,13 @@ static inline int mdt_check_resent(struct mdt_thread_info *info, RETURN(1); } DEBUG_REQ(D_HA, req, "no reply for RESENT req (have "LPD64")", - req->rq_export->exp_mdt_data.med_lcd->lcd_last_xid); + req->rq_export->exp_target_data.ted_lcd->lcd_last_xid); } 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) { @@ -701,7 +901,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; @@ -710,8 +910,8 @@ 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, NULL, client_cookie, lh); + ldlm_completion_ast, NULL, NULL, 0, + LVB_T_NONE, client_cookie, lh); return rc == ELDLM_OK ? 0 : -EIO; } @@ -736,6 +936,9 @@ static inline ldlm_mode_t mdt_mdl_mode2dlm_mode(mdl_mode_t 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) { @@ -766,18 +969,38 @@ 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 { + LPROC_MDT_OPEN = 0, + LPROC_MDT_CLOSE, + LPROC_MDT_MKNOD, + LPROC_MDT_LINK, + LPROC_MDT_UNLINK, + LPROC_MDT_MKDIR, + LPROC_MDT_RMDIR, + LPROC_MDT_RENAME, + LPROC_MDT_GETATTR, + LPROC_MDT_SETATTR, + LPROC_MDT_GETXATTR, + LPROC_MDT_SETXATTR, + LPROC_MDT_STATFS, + LPROC_MDT_SYNC, + LPROC_MDT_SAMEDIR_RENAME, + LPROC_MDT_CROSSDIR_RENAME, + LPROC_MDT_LAST, +}; +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_time_start(const struct mdt_thread_info *info); -void mdt_time_end(const struct mdt_thread_info *info, int idx); - -enum { - LPROC_MDT_NR -}; +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); @@ -791,14 +1014,14 @@ static inline void mdt_set_capainfo(struct mdt_thread_info *info, int offset, { struct md_capainfo *ci; - LASSERT(offset >= 0 && offset <= MD_CAPAINFO_MAX); + 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; ci = md_capainfo(info->mti_env); LASSERT(ci); - ci->mc_fid[offset] = fid; + ci->mc_fid[offset] = *fid; ci->mc_capa[offset] = capa; } @@ -810,16 +1033,14 @@ static inline void mdt_dump_capainfo(struct mdt_thread_info *info) if (!ci) return; for (i = 0; i < MD_CAPAINFO_MAX; i++) { - if (!ci->mc_fid[i]) - continue; if (!ci->mc_capa[i]) { CERROR("no capa for index %d "DFID"\n", - i, PFID(ci->mc_fid[i])); + 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])); + i, PFID(&ci->mc_fid[i])); continue; } DEBUG_CAPA(D_ERROR, ci->mc_capa[i], "index %d", i); @@ -830,5 +1051,58 @@ static inline struct obd_device *mdt2obd_dev(const struct mdt_device *mdt) { return mdt->mdt_md_dev.md_lu_dev.ld_obd; } + +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_md_dev.md_lu_dev); +} + +static inline char *mdt_obd_name(struct mdt_device *mdt) +{ + return mdt->mdt_md_dev.md_lu_dev.ld_obd->obd_name; +} + +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__) + + #endif /* __KERNEL__ */ #endif /* _MDT_H */