X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;ds=sidebyside;f=lustre%2Ffld%2Ffld_request.c;h=4b402cb75c3df8417701253e283243e08db31170;hb=d335e310d4bf490509998ddbb1824e38cff20998;hp=995581a775aa49dfc0078c774e011c2061a182cc;hpb=ec0c7b569d5a2f25c8ea80f515d2bdc853abc7df;p=fs%2Flustre-release.git diff --git a/lustre/fld/fld_request.c b/lustre/fld/fld_request.c index 995581a..4b402cb 100644 --- a/lustre/fld/fld_request.c +++ b/lustre/fld/fld_request.c @@ -45,8 +45,7 @@ #ifdef __KERNEL__ # include # include -# include -# include +# include #else /* __KERNEL__ */ # include # include @@ -54,68 +53,13 @@ #include #include -#include #include #include - -#include -#include #include #include #include #include "fld_internal.h" -/* TODO: these 3 functions are copies of flow-control code from mdc_lib.c - * It should be common thing. The same about mdc RPC lock */ -static int fld_req_avail(struct client_obd *cli, struct mdc_cache_waiter *mcw) -{ - int rc; - ENTRY; - client_obd_list_lock(&cli->cl_loi_list_lock); - rc = cfs_list_empty(&mcw->mcw_entry); - client_obd_list_unlock(&cli->cl_loi_list_lock); - RETURN(rc); -}; - -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); - } -} - -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); -} - static int fld_rrb_hash(struct lu_client_fld *fld, seqno_t seq) { @@ -140,16 +84,25 @@ fld_rrb_scan(struct lu_client_fld *fld, seqno_t seq) else hash = 0; - cfs_list_for_each_entry(target, &fld->lcf_targets, ft_chain) { +again: + list_for_each_entry(target, &fld->lcf_targets, ft_chain) { if (target->ft_idx == hash) RETURN(target); } + if (hash != 0) { + /* It is possible the remote target(MDT) are not connected to + * with client yet, so we will refer this to MDT0, which should + * be connected during mount */ + hash = 0; + goto again; + } + CERROR("%s: Can't find target by hash %d (seq "LPX64"). " "Targets (%d):\n", fld->lcf_name, hash, seq, fld->lcf_count); - cfs_list_for_each_entry(target, &fld->lcf_targets, ft_chain) { + list_for_each_entry(target, &fld->lcf_targets, ft_chain) { const char *srv_name = target->ft_srv != NULL ? target->ft_srv->lsf_name : ""; const char *exp_name = target->ft_exp != NULL ? @@ -232,7 +185,7 @@ int fld_client_add_target(struct lu_client_fld *fld, RETURN(-ENOMEM); spin_lock(&fld->lcf_lock); - cfs_list_for_each_entry(tmp, &fld->lcf_targets, ft_chain) { + list_for_each_entry(tmp, &fld->lcf_targets, ft_chain) { if (tmp->ft_idx == tar->ft_idx) { spin_unlock(&fld->lcf_lock); OBD_FREE_PTR(target); @@ -248,8 +201,7 @@ int fld_client_add_target(struct lu_client_fld *fld, target->ft_srv = tar->ft_srv; target->ft_idx = tar->ft_idx; - cfs_list_add_tail(&target->ft_chain, - &fld->lcf_targets); + list_add_tail(&target->ft_chain, &fld->lcf_targets); fld->lcf_count++; spin_unlock(&fld->lcf_lock); @@ -265,11 +217,10 @@ int fld_client_del_target(struct lu_client_fld *fld, __u64 idx) ENTRY; spin_lock(&fld->lcf_lock); - cfs_list_for_each_entry_safe(target, tmp, - &fld->lcf_targets, ft_chain) { + list_for_each_entry_safe(target, tmp, &fld->lcf_targets, ft_chain) { if (target->ft_idx == idx) { fld->lcf_count--; - cfs_list_del(&target->ft_chain); + list_del(&target->ft_chain); spin_unlock(&fld->lcf_lock); if (target->ft_exp != NULL) @@ -287,33 +238,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); + int rc; + ENTRY; - 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); - } + 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_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); - } + 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) @@ -367,7 +317,7 @@ int fld_client_init(struct lu_client_fld *fld, spin_lock_init(&fld->lcf_lock); fld->lcf_hash = &fld_hash[hash]; fld->lcf_flags = LUSTRE_FLD_INIT; - CFS_INIT_LIST_HEAD(&fld->lcf_targets); + INIT_LIST_HEAD(&fld->lcf_targets); cache_size = FLD_CLIENT_CACHE_SIZE / sizeof(struct fld_cache_entry); @@ -403,10 +353,9 @@ void fld_client_fini(struct lu_client_fld *fld) ENTRY; spin_lock(&fld->lcf_lock); - cfs_list_for_each_entry_safe(target, tmp, - &fld->lcf_targets, ft_chain) { + list_for_each_entry_safe(target, tmp, &fld->lcf_targets, ft_chain) { fld->lcf_count--; - cfs_list_del(&target->ft_chain); + list_del(&target->ft_chain); if (target->ft_exp != NULL) class_export_put(target->ft_exp); OBD_FREE_PTR(target); @@ -424,55 +373,101 @@ 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 ptlrpc_request *req = NULL; struct lu_seq_range *prange; __u32 *op; - int rc; + int rc = 0; struct obd_import *imp; ENTRY; LASSERT(exp != NULL); +again: imp = class_exp2cliimp(exp); - req = ptlrpc_request_alloc_pack(imp, &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; + 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; + + /* For MDS_MDS seq lookup, it will always use LWP connection, + * but LWP will be evicted after restart, so cause the error. + * so we will set no_delay for seq lookup request, once the + * request fails because of the eviction. always retry here */ + if (imp->imp_connect_flags_orig & OBD_CONNECT_MDS_MDS) { + req->rq_allow_replay = 1; + req->rq_no_delay = 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; + } - prange = req_capsule_client_get(&req->rq_pill, &RMF_FLD_MDFLD); - *prange = *range; + if (rc != 0) + RETURN(rc); - ptlrpc_request_set_replen(req); + 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 && - imp->imp_connect_flags_orig & OBD_CONNECT_MDS_MDS) - req->rq_allow_replay = 1; - - 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); + obd_get_request_slot(&exp->exp_obd->u.cli); + rc = ptlrpc_queue_wait(req); + obd_put_request_slot(&exp->exp_obd->u.cli); + if (rc != 0) { + if (rc == -EWOULDBLOCK || rc == -ESHUTDOWN) { + /* For no_delay req(see above), EWOULDBLOCK and + * ESHUTDOWN means the connection is being evicted, + * but this seq lookup should not return error, + * since it would cause unecessary failure of the + * application, instead it should retry here */ + ptlrpc_req_finished(req); + rc = 0; + goto again; + } + 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; + 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, @@ -501,22 +496,22 @@ int fld_client_lookup(struct lu_client_fld *fld, seqno_t seq, mdsno_t *mds, res.lsr_start = seq; fld_range_set_type(&res, flags); -#ifdef __KERNEL__ + +#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__ + { + rc = fld_client_rpc(target->ft_exp, &res, FLD_QUERY, NULL); } -#endif if (rc == 0) { *mds = res.lsr_index; - fld_cache_insert(fld->lcf_cache, &res); } + RETURN(rc); } EXPORT_SYMBOL(fld_client_lookup); @@ -526,3 +521,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__ */