X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;ds=sidebyside;f=lustre%2Ffid%2Ffid_request.c;h=4f7fdf53f39497500419f18fa9427e6d9700f6e1;hb=7817e4c785d075aae76b635dcf799064590833b0;hp=95fae057ee8d7e7849fc3ff505bb1694bba1e75a;hpb=8b5cfb9463fd97eaebf5bcf98ae445f71fa6c365;p=fs%2Flustre-release.git diff --git a/lustre/fid/fid_request.c b/lustre/fid/fid_request.c index 95fae05..4f7fdf5 100644 --- a/lustre/fid/fid_request.c +++ b/lustre/fid/fid_request.c @@ -27,7 +27,7 @@ * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, 2012, Intel Corporation. + * Copyright (c) 2011, 2014, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -42,19 +42,11 @@ #define DEBUG_SUBSYSTEM S_FID -#ifdef __KERNEL__ -# include -# include -#else /* __KERNEL__ */ -# include -#endif - +#include +#include #include #include -#include -#include #include -#include #include /* mdc RPC locks */ #include @@ -72,6 +64,7 @@ static int seq_client_rpc(struct lu_client_seq *seq, int rc; ENTRY; + LASSERT(exp != NULL && !IS_ERR(exp)); req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp), &RQF_SEQ_QUERY, LUSTRE_MDS_VERSION, SEQ_QUERY); if (req == NULL) @@ -89,9 +82,9 @@ static int seq_client_rpc(struct lu_client_seq *seq, in->lsr_index = seq->lcs_space.lsr_index; if (seq->lcs_type == LUSTRE_SEQ_METADATA) - in->lsr_flags = LU_SEQ_RANGE_MDT; + fld_range_set_mdt(in); else - in->lsr_flags = LU_SEQ_RANGE_OST; + fld_range_set_ost(in); if (opc == SEQ_ALLOC_SUPER) { req->rq_request_portal = SEQ_CONTROLLER_PORTAL; @@ -106,19 +99,25 @@ static int seq_client_rpc(struct lu_client_seq *seq, req->rq_no_delay = req->rq_no_resend = 1; debug_mask = D_CONSOLE; } else { - if (seq->lcs_type == LUSTRE_SEQ_METADATA) + if (seq->lcs_type == LUSTRE_SEQ_METADATA) { + req->rq_reply_portal = MDC_REPLY_PORTAL; req->rq_request_portal = SEQ_METADATA_PORTAL; - else + } else { + req->rq_reply_portal = OSC_REPLY_PORTAL; req->rq_request_portal = SEQ_DATA_PORTAL; + } + debug_mask = D_INFO; } ptlrpc_at_set_req_timeout(req); - if (seq->lcs_type == LUSTRE_SEQ_METADATA) + if (opc != SEQ_ALLOC_SUPER && seq->lcs_type == LUSTRE_SEQ_METADATA) mdc_get_rpc_lock(exp->exp_obd->u.cli.cl_rpc_lock, NULL); + rc = ptlrpc_queue_wait(req); - if (seq->lcs_type == LUSTRE_SEQ_METADATA) + + if (opc != SEQ_ALLOC_SUPER && seq->lcs_type == LUSTRE_SEQ_METADATA) mdc_put_rpc_lock(exp->exp_obd->u.cli.cl_rpc_lock, NULL); if (rc) GOTO(out_req, rc); @@ -156,13 +155,15 @@ int seq_client_alloc_super(struct lu_client_seq *seq, mutex_lock(&seq->lcs_mutex); -#ifdef __KERNEL__ if (seq->lcs_srv) { +#ifdef HAVE_SEQ_SERVER LASSERT(env != NULL); rc = seq_server_alloc_super(seq->lcs_srv, &seq->lcs_space, env); - } else { +#else + rc = 0; #endif + } else { /* Check whether the connection to seq controller has been * setup (lcs_exp != NULL) */ if (seq->lcs_exp == NULL) { @@ -172,9 +173,7 @@ int seq_client_alloc_super(struct lu_client_seq *seq, rc = seq_client_rpc(seq, &seq->lcs_space, SEQ_ALLOC_SUPER, "super"); -#ifdef __KERNEL__ } -#endif mutex_unlock(&seq->lcs_mutex); RETURN(rc); } @@ -186,12 +185,14 @@ static int seq_client_alloc_meta(const struct lu_env *env, int rc; ENTRY; -#ifdef __KERNEL__ if (seq->lcs_srv) { +#ifdef HAVE_SEQ_SERVER LASSERT(env != NULL); rc = seq_server_alloc_meta(seq->lcs_srv, &seq->lcs_space, env); - } else { +#else + rc = 0; #endif + } else { do { /* If meta server return -EINPROGRESS or EAGAIN, * it means meta server might not be ready to @@ -200,15 +201,14 @@ static int seq_client_alloc_meta(const struct lu_env *env, rc = seq_client_rpc(seq, &seq->lcs_space, SEQ_ALLOC_META, "meta"); } while (rc == -EINPROGRESS || rc == -EAGAIN); -#ifdef __KERNEL__ } -#endif + RETURN(rc); } /* Allocate new sequence for client. */ static int seq_client_alloc_seq(const struct lu_env *env, - struct lu_client_seq *seq, seqno_t *seqnr) + struct lu_client_seq *seq, u64 *seqnr) { int rc; ENTRY; @@ -240,46 +240,45 @@ static int seq_client_alloc_seq(const struct lu_env *env, } static int seq_fid_alloc_prep(struct lu_client_seq *seq, - cfs_waitlink_t *link) + wait_queue_t *link) { - if (seq->lcs_update) { - cfs_waitq_add(&seq->lcs_waitq, link); - cfs_set_current_state(CFS_TASK_UNINT); + if (seq->lcs_update) { + add_wait_queue(&seq->lcs_waitq, link); + set_current_state(TASK_UNINTERRUPTIBLE); mutex_unlock(&seq->lcs_mutex); - cfs_waitq_wait(link, CFS_TASK_UNINT); + waitq_wait(link, TASK_UNINTERRUPTIBLE); mutex_lock(&seq->lcs_mutex); - cfs_waitq_del(&seq->lcs_waitq, link); - cfs_set_current_state(CFS_TASK_RUNNING); - return -EAGAIN; - } - ++seq->lcs_update; + remove_wait_queue(&seq->lcs_waitq, link); + set_current_state(TASK_RUNNING); + return -EAGAIN; + } + ++seq->lcs_update; mutex_unlock(&seq->lcs_mutex); - return 0; + return 0; } static void seq_fid_alloc_fini(struct lu_client_seq *seq) { - LASSERT(seq->lcs_update == 1); + LASSERT(seq->lcs_update == 1); mutex_lock(&seq->lcs_mutex); - --seq->lcs_update; - cfs_waitq_signal(&seq->lcs_waitq); + --seq->lcs_update; + wake_up(&seq->lcs_waitq); } /** - * Allocate the whole seq to the caller, currently it would be - * only used by echo client to access MDT + * Allocate the whole seq to the caller. **/ int seq_client_get_seq(const struct lu_env *env, - struct lu_client_seq *seq, seqno_t *seqnr) + struct lu_client_seq *seq, u64 *seqnr) { - cfs_waitlink_t link; - int rc; + wait_queue_t link; + int rc; - LASSERT(seqnr != NULL); + LASSERT(seqnr != NULL); mutex_lock(&seq->lcs_mutex); - cfs_waitlink_init(&link); + init_waitqueue_entry_current(&link); while (1) { rc = seq_fid_alloc_prep(seq, &link); @@ -301,11 +300,13 @@ int seq_client_get_seq(const struct lu_env *env, /* Since the caller require the whole seq, * so marked this seq to be used */ - LASSERT(seq->lcs_type == LUSTRE_SEQ_METADATA); - seq->lcs_fid.f_oid = LUSTRE_METADATA_SEQ_MAX_WIDTH; + if (seq->lcs_type == LUSTRE_SEQ_METADATA) + seq->lcs_fid.f_oid = LUSTRE_METADATA_SEQ_MAX_WIDTH; + else + seq->lcs_fid.f_oid = LUSTRE_DATA_SEQ_MAX_WIDTH; + seq->lcs_fid.f_seq = *seqnr; seq->lcs_fid.f_ver = 0; - /* * Inform caller that sequence switch is performed to allow it * to setup FLD for it. @@ -319,23 +320,23 @@ EXPORT_SYMBOL(seq_client_get_seq); /* Allocate new fid on passed client @seq and save it to @fid. */ int seq_client_alloc_fid(const struct lu_env *env, - struct lu_client_seq *seq, struct lu_fid *fid) + struct lu_client_seq *seq, struct lu_fid *fid) { - cfs_waitlink_t link; - int rc; - ENTRY; + wait_queue_t link; + int rc; + ENTRY; - LASSERT(seq != NULL); - LASSERT(fid != NULL); + LASSERT(seq != NULL); + LASSERT(fid != NULL); - cfs_waitlink_init(&link); + init_waitqueue_entry_current(&link); mutex_lock(&seq->lcs_mutex); if (OBD_FAIL_CHECK(OBD_FAIL_SEQ_EXHAUST)) seq->lcs_fid.f_oid = seq->lcs_width; while (1) { - seqno_t seqnr; + u64 seqnr; if (!fid_is_zero(&seq->lcs_fid) && fid_oid(&seq->lcs_fid) < seq->lcs_width) { @@ -389,23 +390,23 @@ EXPORT_SYMBOL(seq_client_alloc_fid); */ void seq_client_flush(struct lu_client_seq *seq) { - cfs_waitlink_t link; + wait_queue_t link; - LASSERT(seq != NULL); - cfs_waitlink_init(&link); + LASSERT(seq != NULL); + init_waitqueue_entry_current(&link); mutex_lock(&seq->lcs_mutex); - while (seq->lcs_update) { - cfs_waitq_add(&seq->lcs_waitq, &link); - cfs_set_current_state(CFS_TASK_UNINT); + while (seq->lcs_update) { + add_wait_queue(&seq->lcs_waitq, &link); + set_current_state(TASK_UNINTERRUPTIBLE); mutex_unlock(&seq->lcs_mutex); - cfs_waitq_wait(&link, CFS_TASK_UNINT); + waitq_wait(&link, TASK_UNINTERRUPTIBLE); mutex_lock(&seq->lcs_mutex); - cfs_waitq_del(&seq->lcs_waitq, &link); - cfs_set_current_state(CFS_TASK_RUNNING); - } + remove_wait_queue(&seq->lcs_waitq, &link); + set_current_state(TASK_RUNNING); + } fid_zero(&seq->lcs_fid); /** @@ -420,18 +421,28 @@ void seq_client_flush(struct lu_client_seq *seq) } EXPORT_SYMBOL(seq_client_flush); -static void seq_client_proc_fini(struct lu_client_seq *seq); +static void seq_client_proc_fini(struct lu_client_seq *seq) +{ +#ifdef CONFIG_PROC_FS + ENTRY; + if (seq->lcs_proc_dir) { + if (!IS_ERR(seq->lcs_proc_dir)) + lprocfs_remove(&seq->lcs_proc_dir); + seq->lcs_proc_dir = NULL; + } + EXIT; +#endif /* CONFIG_PROC_FS */ +} -#ifdef LPROCFS static int seq_client_proc_init(struct lu_client_seq *seq) { +#ifdef CONFIG_PROC_FS int rc; ENTRY; - seq->lcs_proc_dir = lprocfs_register(seq->lcs_name, - seq_type_proc_dir, - NULL, NULL); - + seq->lcs_proc_dir = lprocfs_seq_register(seq->lcs_name, + seq_type_proc_dir, + NULL, NULL); if (IS_ERR(seq->lcs_proc_dir)) { CERROR("%s: LProcFS failed in seq-init\n", seq->lcs_name); @@ -439,8 +450,8 @@ static int seq_client_proc_init(struct lu_client_seq *seq) RETURN(rc); } - rc = lprocfs_add_vars(seq->lcs_proc_dir, - seq_client_proc_list, seq); + rc = lprocfs_seq_add_vars(seq->lcs_proc_dir, + seq_client_proc_list, seq); if (rc) { CERROR("%s: Can't init sequence manager " "proc, rc %d\n", seq->lcs_name, rc); @@ -452,30 +463,12 @@ static int seq_client_proc_init(struct lu_client_seq *seq) out_cleanup: seq_client_proc_fini(seq); return rc; -} -static void seq_client_proc_fini(struct lu_client_seq *seq) -{ - ENTRY; - if (seq->lcs_proc_dir) { - if (!IS_ERR(seq->lcs_proc_dir)) - lprocfs_remove(&seq->lcs_proc_dir); - seq->lcs_proc_dir = NULL; - } - EXIT; -} -#else -static int seq_client_proc_init(struct lu_client_seq *seq) -{ - return 0; +#else /* !CONFIG_PROC_FS */ + return 0; +#endif /* CONFIG_PROC_FS */ } -static void seq_client_proc_fini(struct lu_client_seq *seq) -{ - return; -} -#endif - int seq_client_init(struct lu_client_seq *seq, struct obd_export *exp, enum lu_cli_type type, @@ -497,14 +490,12 @@ int seq_client_init(struct lu_client_seq *seq, else seq->lcs_width = LUSTRE_DATA_SEQ_MAX_WIDTH; - cfs_waitq_init(&seq->lcs_waitq); + init_waitqueue_head(&seq->lcs_waitq); /* Make sure that things are clear before work is started. */ seq_client_flush(seq); if (exp != NULL) seq->lcs_exp = class_export_get(exp); - else if (type == LUSTRE_SEQ_METADATA) - LASSERT(seq->lcs_srv != NULL); snprintf(seq->lcs_name, sizeof(seq->lcs_name), "cli-%s", prefix); @@ -531,3 +522,85 @@ void seq_client_fini(struct lu_client_seq *seq) EXIT; } EXPORT_SYMBOL(seq_client_fini); + +int client_fid_init(struct obd_device *obd, + struct obd_export *exp, enum lu_cli_type type) +{ + struct client_obd *cli = &obd->u.cli; + char *prefix; + int rc; + ENTRY; + + OBD_ALLOC_PTR(cli->cl_seq); + if (cli->cl_seq == NULL) + RETURN(-ENOMEM); + + OBD_ALLOC(prefix, MAX_OBD_NAME + 5); + if (prefix == NULL) + GOTO(out_free_seq, rc = -ENOMEM); + + snprintf(prefix, MAX_OBD_NAME + 5, "cli-%s", obd->obd_name); + + /* Init client side sequence-manager */ + rc = seq_client_init(cli->cl_seq, exp, type, prefix, NULL); + OBD_FREE(prefix, MAX_OBD_NAME + 5); + if (rc) + GOTO(out_free_seq, rc); + + RETURN(rc); +out_free_seq: + OBD_FREE_PTR(cli->cl_seq); + cli->cl_seq = NULL; + return rc; +} +EXPORT_SYMBOL(client_fid_init); + +int client_fid_fini(struct obd_device *obd) +{ + struct client_obd *cli = &obd->u.cli; + ENTRY; + + if (cli->cl_seq != NULL) { + seq_client_fini(cli->cl_seq); + OBD_FREE_PTR(cli->cl_seq); + cli->cl_seq = NULL; + } + + RETURN(0); +} +EXPORT_SYMBOL(client_fid_fini); + +struct proc_dir_entry *seq_type_proc_dir; + +static int __init fid_mod_init(void) +{ + seq_type_proc_dir = lprocfs_seq_register(LUSTRE_SEQ_NAME, + proc_lustre_root, + NULL, NULL); + if (IS_ERR(seq_type_proc_dir)) + return PTR_ERR(seq_type_proc_dir); + +# ifdef HAVE_SERVER_SUPPORT + fid_server_mod_init(); +# endif + + return 0; +} + +static void __exit fid_mod_exit(void) +{ +# ifdef HAVE_SERVER_SUPPORT + fid_server_mod_exit(); +# endif + + if (seq_type_proc_dir != NULL && !IS_ERR(seq_type_proc_dir)) { + lprocfs_remove(&seq_type_proc_dir); + seq_type_proc_dir = NULL; + } +} + +MODULE_AUTHOR("Sun Microsystems, Inc. "); +MODULE_DESCRIPTION("Lustre FID Module"); +MODULE_LICENSE("GPL"); + +cfs_module(fid, "0.1.0", fid_mod_init, fid_mod_exit);