X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Ffld%2Ffld_request.c;h=8d7539d0aff4ef24e5efc0d01f65d59fa14bb7b1;hp=1aec284384d12b8c4b2c6afdc21a5169f5d258df;hb=3f3d6e175b891ddb063cd3b6a08ee1961aca72aa;hpb=a5b6ed491a5fcbe593f0fb8162b7be11d07ba4de;ds=sidebyside diff --git a/lustre/fld/fld_request.c b/lustre/fld/fld_request.c index 1aec284..8d7539d 100644 --- a/lustre/fld/fld_request.c +++ b/lustre/fld/fld_request.c @@ -45,7 +45,6 @@ #ifdef __KERNEL__ # include # include -# include # include #else /* __KERNEL__ */ # include @@ -54,12 +53,8 @@ #include #include -#include #include #include - -#include -#include #include #include #include @@ -79,41 +74,41 @@ static int fld_req_avail(struct client_obd *cli, struct mdc_cache_waiter *mcw) static void fld_enter_request(struct client_obd *cli) { - struct mdc_cache_waiter mcw; - struct l_wait_info lwi = { 0 }; - - client_obd_list_lock(&cli->cl_loi_list_lock); - if (cli->cl_r_in_flight >= cli->cl_max_rpcs_in_flight) { - cfs_list_add_tail(&mcw.mcw_entry, &cli->cl_cache_waiters); - cfs_waitq_init(&mcw.mcw_waitq); - client_obd_list_unlock(&cli->cl_loi_list_lock); - l_wait_event(mcw.mcw_waitq, fld_req_avail(cli, &mcw), &lwi); - } else { - cli->cl_r_in_flight++; - client_obd_list_unlock(&cli->cl_loi_list_lock); - } + struct mdc_cache_waiter mcw; + struct l_wait_info lwi = { 0 }; + + client_obd_list_lock(&cli->cl_loi_list_lock); + if (cli->cl_r_in_flight >= cli->cl_max_rpcs_in_flight) { + cfs_list_add_tail(&mcw.mcw_entry, &cli->cl_cache_waiters); + init_waitqueue_head(&mcw.mcw_waitq); + client_obd_list_unlock(&cli->cl_loi_list_lock); + l_wait_event(mcw.mcw_waitq, fld_req_avail(cli, &mcw), &lwi); + } else { + cli->cl_r_in_flight++; + client_obd_list_unlock(&cli->cl_loi_list_lock); + } } static void fld_exit_request(struct client_obd *cli) { - cfs_list_t *l, *tmp; - struct mdc_cache_waiter *mcw; - - client_obd_list_lock(&cli->cl_loi_list_lock); - cli->cl_r_in_flight--; - cfs_list_for_each_safe(l, tmp, &cli->cl_cache_waiters) { - - if (cli->cl_r_in_flight >= cli->cl_max_rpcs_in_flight) { - /* No free request slots anymore */ - break; - } - - mcw = cfs_list_entry(l, struct mdc_cache_waiter, mcw_entry); - cfs_list_del_init(&mcw->mcw_entry); - cli->cl_r_in_flight++; - cfs_waitq_signal(&mcw->mcw_waitq); - } - client_obd_list_unlock(&cli->cl_loi_list_lock); + cfs_list_t *l, *tmp; + struct mdc_cache_waiter *mcw; + + client_obd_list_lock(&cli->cl_loi_list_lock); + cli->cl_r_in_flight--; + cfs_list_for_each_safe(l, tmp, &cli->cl_cache_waiters) { + + if (cli->cl_r_in_flight >= cli->cl_max_rpcs_in_flight) { + /* No free request slots anymore */ + break; + } + + mcw = cfs_list_entry(l, struct mdc_cache_waiter, mcw_entry); + cfs_list_del_init(&mcw->mcw_entry); + cli->cl_r_in_flight++; + wake_up(&mcw->mcw_waitq); + } + client_obd_list_unlock(&cli->cl_loi_list_lock); } static int fld_rrb_hash(struct lu_client_fld *fld, @@ -130,7 +125,15 @@ fld_rrb_scan(struct lu_client_fld *fld, seqno_t seq) int hash; ENTRY; - hash = fld_rrb_hash(fld, seq); + /* Because almost all of special sequence located in MDT0, + * it should go to index 0 directly, instead of calculating + * hash again, and also if other MDTs is not being connected, + * the fld lookup requests(for seq on MDT0) should not be + * blocked because of other MDTs */ + if (fid_seq_is_norm(seq)) + hash = fld_rrb_hash(fld, seq); + else + hash = 0; cfs_list_for_each_entry(target, &fld->lcf_targets, ft_chain) { if (target->ft_idx == hash) @@ -279,33 +282,32 @@ EXPORT_SYMBOL(fld_client_del_target); #ifdef LPROCFS static int fld_client_proc_init(struct lu_client_fld *fld) { - int rc; - ENTRY; - - fld->lcf_proc_dir = lprocfs_register(fld->lcf_name, - fld_type_proc_dir, - NULL, NULL); - - if (IS_ERR(fld->lcf_proc_dir)) { - CERROR("%s: LProcFS failed in fld-init\n", - fld->lcf_name); - rc = PTR_ERR(fld->lcf_proc_dir); - RETURN(rc); - } + int rc; + ENTRY; - rc = lprocfs_add_vars(fld->lcf_proc_dir, - fld_client_proc_list, fld); - if (rc) { - CERROR("%s: Can't init FLD proc, rc %d\n", - fld->lcf_name, rc); - GOTO(out_cleanup, rc); - } + fld->lcf_proc_dir = lprocfs_seq_register(fld->lcf_name, + fld_type_proc_dir, + NULL, NULL); + if (IS_ERR(fld->lcf_proc_dir)) { + CERROR("%s: LProcFS failed in fld-init\n", + fld->lcf_name); + rc = PTR_ERR(fld->lcf_proc_dir); + RETURN(rc); + } + + rc = lprocfs_seq_add_vars(fld->lcf_proc_dir, + fld_client_proc_list, fld); + if (rc) { + CERROR("%s: Can't init FLD proc, rc %d\n", + fld->lcf_name, rc); + GOTO(out_cleanup, rc); + } - RETURN(0); + RETURN(0); out_cleanup: - fld_client_proc_fini(fld); - return rc; + fld_client_proc_fini(fld); + return rc; } void fld_client_proc_fini(struct lu_client_fld *fld) @@ -416,58 +418,92 @@ void fld_client_fini(struct lu_client_fld *fld) EXPORT_SYMBOL(fld_client_fini); int fld_client_rpc(struct obd_export *exp, - struct lu_seq_range *range, __u32 fld_op) + struct lu_seq_range *range, __u32 fld_op, + struct ptlrpc_request **reqp) { - struct ptlrpc_request *req; - struct lu_seq_range *prange; - __u32 *op; - int rc; - ENTRY; - - LASSERT(exp != NULL); - - req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp), &RQF_FLD_QUERY, - LUSTRE_MDS_VERSION, FLD_QUERY); - if (req == NULL) - RETURN(-ENOMEM); - - op = req_capsule_client_get(&req->rq_pill, &RMF_FLD_OPC); - *op = fld_op; - - prange = req_capsule_client_get(&req->rq_pill, &RMF_FLD_MDFLD); - *prange = *range; + struct ptlrpc_request *req = NULL; + struct lu_seq_range *prange; + __u32 *op; + int rc = 0; + struct obd_import *imp; + ENTRY; - ptlrpc_request_set_replen(req); + LASSERT(exp != NULL); + + imp = class_exp2cliimp(exp); + switch (fld_op) { + case FLD_QUERY: + req = ptlrpc_request_alloc_pack(imp, &RQF_FLD_QUERY, + LUSTRE_MDS_VERSION, FLD_QUERY); + if (req == NULL) + RETURN(-ENOMEM); + + /* XXX: only needed when talking to old server(< 2.6), it should + * be removed when < 2.6 server is not supported */ + op = req_capsule_client_get(&req->rq_pill, &RMF_FLD_OPC); + *op = FLD_LOOKUP; + + if (imp->imp_connect_flags_orig & OBD_CONNECT_MDS_MDS) + req->rq_allow_replay = 1; + break; + case FLD_READ: + req = ptlrpc_request_alloc_pack(imp, &RQF_FLD_READ, + LUSTRE_MDS_VERSION, FLD_READ); + if (req == NULL) + RETURN(-ENOMEM); + + req_capsule_set_size(&req->rq_pill, &RMF_GENERIC_DATA, + RCL_SERVER, PAGE_CACHE_SIZE); + break; + default: + rc = -EINVAL; + break; + } + + if (rc != 0) + RETURN(rc); + + prange = req_capsule_client_get(&req->rq_pill, &RMF_FLD_MDFLD); + *prange = *range; + ptlrpc_request_set_replen(req); req->rq_request_portal = FLD_REQUEST_PORTAL; + req->rq_reply_portal = MDC_REPLY_PORTAL; ptlrpc_at_set_req_timeout(req); - if (fld_op != FLD_LOOKUP) - mdc_get_rpc_lock(exp->exp_obd->u.cli.cl_rpc_lock, NULL); - fld_enter_request(&exp->exp_obd->u.cli); - rc = ptlrpc_queue_wait(req); - fld_exit_request(&exp->exp_obd->u.cli); - if (fld_op != FLD_LOOKUP) - mdc_put_rpc_lock(exp->exp_obd->u.cli.cl_rpc_lock, NULL); - if (rc) - GOTO(out_req, rc); - - prange = req_capsule_server_get(&req->rq_pill, &RMF_FLD_MDFLD); - if (prange == NULL) - GOTO(out_req, rc = -EFAULT); - *range = *prange; - EXIT; + fld_enter_request(&exp->exp_obd->u.cli); + rc = ptlrpc_queue_wait(req); + fld_exit_request(&exp->exp_obd->u.cli); + if (rc) + GOTO(out_req, rc); + + if (fld_op == FLD_QUERY) { + prange = req_capsule_server_get(&req->rq_pill, + &RMF_FLD_MDFLD); + if (prange == NULL) + GOTO(out_req, rc = -EFAULT); + *range = *prange; + } + + EXIT; out_req: - ptlrpc_req_finished(req); - return rc; + if (rc != 0 || reqp == NULL) { + ptlrpc_req_finished(req); + req = NULL; + } + + if (reqp != NULL) + *reqp = req; + + return rc; } int fld_client_lookup(struct lu_client_fld *fld, seqno_t seq, mdsno_t *mds, - __u32 flags, const struct lu_env *env) + __u32 flags, const struct lu_env *env) { - struct lu_seq_range res; - struct lu_fld_target *target; - int rc; - ENTRY; + struct lu_seq_range res = { 0 }; + struct lu_fld_target *target; + int rc; + ENTRY; fld->lcf_flags |= LUSTRE_FLD_RUN; @@ -485,26 +521,25 @@ int fld_client_lookup(struct lu_client_fld *fld, seqno_t seq, mdsno_t *mds, "target %s (idx "LPU64")\n", fld->lcf_name, seq, fld_target_name(target), target->ft_idx); - res.lsr_start = seq; - res.lsr_flags = flags; -#ifdef __KERNEL__ - if (target->ft_srv != NULL) { + res.lsr_start = seq; + fld_range_set_type(&res, flags); + +#if defined(__KERNEL__) && defined(HAVE_SERVER_SUPPORT) + if (target->ft_srv != NULL) { LASSERT(env != NULL); rc = fld_server_lookup(env, target->ft_srv, seq, &res); - } else { + } else #endif - rc = fld_client_rpc(target->ft_exp, - &res, FLD_LOOKUP); -#ifdef __KERNEL__ - } -#endif - - if (rc == 0) { - *mds = res.lsr_index; + { + rc = fld_client_rpc(target->ft_exp, &res, FLD_QUERY, NULL); + } + if (rc == 0) { + *mds = res.lsr_index; fld_cache_insert(fld->lcf_cache, &res); - } - RETURN(rc); + } + + RETURN(rc); } EXPORT_SYMBOL(fld_client_lookup); @@ -513,3 +548,41 @@ void fld_client_flush(struct lu_client_fld *fld) fld_cache_flush(fld->lcf_cache); } EXPORT_SYMBOL(fld_client_flush); + +#ifdef __KERNEL__ + +struct proc_dir_entry *fld_type_proc_dir; + +static int __init fld_mod_init(void) +{ + fld_type_proc_dir = lprocfs_seq_register(LUSTRE_FLD_NAME, + proc_lustre_root, + NULL, NULL); + if (IS_ERR(fld_type_proc_dir)) + return PTR_ERR(fld_type_proc_dir); + +#ifdef HAVE_SERVER_SUPPORT + fld_server_mod_init(); +#endif + + return 0; +} + +static void __exit fld_mod_exit(void) +{ +#ifdef HAVE_SERVER_SUPPORT + fld_server_mod_exit(); +#endif + + if (fld_type_proc_dir != NULL && !IS_ERR(fld_type_proc_dir)) { + lprocfs_remove(&fld_type_proc_dir); + fld_type_proc_dir = NULL; + } +} + +MODULE_AUTHOR("Sun Microsystems, Inc. "); +MODULE_DESCRIPTION("Lustre FLD"); +MODULE_LICENSE("GPL"); + +cfs_module(mdd, LUSTRE_VERSION_STRING, fld_mod_init, fld_mod_exit); +#endif /* __KERNEL__ */