X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;ds=sidebyside;f=lustre%2Ffid%2Ffid_handler.c;h=f80efb99e39b2f8975d8f27c1b5695eeb0c004d2;hb=c03d8b1fe386cfb7b8bf58923d293b87832481f9;hp=e36935f61476a53c3dcba2384a8d9dbc3db17cdd;hpb=00e814ff75c4da15a769f18736c70ab1e6a5b174;p=fs%2Flustre-release.git diff --git a/lustre/fid/fid_handler.c b/lustre/fid/fid_handler.c index e36935f..f80efb9 100644 --- a/lustre/fid/fid_handler.c +++ b/lustre/fid/fid_handler.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, 2013, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -42,13 +42,8 @@ #define DEBUG_SUBSYSTEM S_FID -#ifdef __KERNEL__ -# include -# include -#else /* __KERNEL__ */ -# include -#endif - +#include +#include #include #include #include @@ -58,7 +53,8 @@ #include #include "fid_internal.h" -#ifdef __KERNEL__ +static void seq_server_proc_fini(struct lu_server_seq *seq); + /* Assigns client to sequence controller node. */ int seq_server_set_cli(struct lu_server_seq *seq, struct lu_client_seq *cli, @@ -157,6 +153,41 @@ int seq_server_alloc_super(struct lu_server_seq *seq, RETURN(rc); } +int seq_server_alloc_spec(struct lu_server_seq *seq, + struct lu_seq_range *spec, + const struct lu_env *env) +{ + struct lu_seq_range *space = &seq->lss_space; + int rc = -ENOSPC; + ENTRY; + + /* + * In some cases (like recovery after a disaster) + * we may need to allocate sequences manually + * Notice some sequences can be lost if requested + * range doesn't start at the beginning of current + * free space. Also notice it's not possible now + * to allocate sequences out of natural order. + */ + if (spec->lsr_start >= spec->lsr_end) + RETURN(-EINVAL); + if (spec->lsr_flags != LU_SEQ_RANGE_MDT && + spec->lsr_flags != LU_SEQ_RANGE_OST) + RETURN(-EINVAL); + + mutex_lock(&seq->lss_mutex); + if (spec->lsr_start >= space->lsr_start) { + space->lsr_start = spec->lsr_end; + rc = seq_store_update(env, seq, spec, 1 /* sync */); + + LCONSOLE_INFO("%s: "DRANGE" sequences allocated: rc = %d \n", + seq->lss_name, PRANGE(spec), rc); + } + mutex_unlock(&seq->lss_mutex); + + RETURN(rc); +} + static int __seq_set_init(const struct lu_env *env, struct lu_server_seq *seq) { @@ -298,6 +329,7 @@ static int seq_server_handle(struct lu_site *site, ENTRY; ss_site = lu_site2seq(site); + switch (opc) { case SEQ_ALLOC_META: if (!ss_site->ss_server_seq) { @@ -323,100 +355,57 @@ static int seq_server_handle(struct lu_site *site, RETURN(rc); } -static int seq_req_handle(struct ptlrpc_request *req, - const struct lu_env *env, - struct seq_thread_info *info) +static int seq_handler(struct tgt_session_info *tsi) { - struct lu_seq_range *out, *tmp; - struct lu_site *site; - int rc = -EPROTO; - __u32 *opc; - ENTRY; + struct lu_seq_range *out, *tmp; + struct lu_site *site; + int rc; + __u32 *opc; - LASSERT(!(lustre_msg_get_flags(req->rq_reqmsg) & MSG_REPLAY)); - site = req->rq_export->exp_obd->obd_lu_dev->ld_site; - LASSERT(site != NULL); + ENTRY; - rc = req_capsule_server_pack(info->sti_pill); - if (rc) - RETURN(err_serious(rc)); + LASSERT(!(lustre_msg_get_flags(tgt_ses_req(tsi)->rq_reqmsg) & MSG_REPLAY)); + site = tsi->tsi_exp->exp_obd->obd_lu_dev->ld_site; + LASSERT(site != NULL); - opc = req_capsule_client_get(info->sti_pill, &RMF_SEQ_OPC); - if (opc != NULL) { - out = req_capsule_server_get(info->sti_pill, &RMF_SEQ_RANGE); - if (out == NULL) - RETURN(err_serious(-EPROTO)); + opc = req_capsule_client_get(tsi->tsi_pill, &RMF_SEQ_OPC); + if (opc != NULL) { + out = req_capsule_server_get(tsi->tsi_pill, &RMF_SEQ_RANGE); + if (out == NULL) + RETURN(err_serious(-EPROTO)); - tmp = req_capsule_client_get(info->sti_pill, &RMF_SEQ_RANGE); + tmp = req_capsule_client_get(tsi->tsi_pill, &RMF_SEQ_RANGE); - /* seq client passed mdt id, we need to pass that using out - * range parameter */ + /* seq client passed mdt id, we need to pass that using out + * range parameter */ - out->lsr_index = tmp->lsr_index; - out->lsr_flags = tmp->lsr_flags; - rc = seq_server_handle(site, env, *opc, out); - } else - rc = err_serious(-EPROTO); + out->lsr_index = tmp->lsr_index; + out->lsr_flags = tmp->lsr_flags; + rc = seq_server_handle(site, tsi->tsi_env, *opc, out); + } else { + rc = err_serious(-EPROTO); + } - RETURN(rc); + RETURN(rc); } +struct tgt_handler seq_handlers[] = { +TGT_SEQ_HDL(HABEO_REFERO, SEQ_QUERY, seq_handler), +}; +EXPORT_SYMBOL(seq_handlers); + /* context key constructor/destructor: seq_key_init, seq_key_fini */ LU_KEY_INIT_FINI(seq, struct seq_thread_info); /* context key: seq_thread_key */ LU_CONTEXT_KEY_DEFINE(seq, LCT_MD_THREAD | LCT_DT_THREAD); -static void seq_thread_info_init(struct ptlrpc_request *req, - struct seq_thread_info *info) -{ - info->sti_pill = &req->rq_pill; - /* Init request capsule */ - req_capsule_init(info->sti_pill, req, RCL_SERVER); - req_capsule_set(info->sti_pill, &RQF_SEQ_QUERY); -} +extern const struct file_operations seq_fld_proc_seq_fops; -static void seq_thread_info_fini(struct seq_thread_info *info) -{ - req_capsule_fini(info->sti_pill); -} - -static int seq_handle(struct ptlrpc_request *req) -{ - const struct lu_env *env; - struct seq_thread_info *info; - int rc; - - env = req->rq_svc_thread->t_env; - LASSERT(env != NULL); - - info = lu_context_key_get(&env->le_ctx, &seq_thread_key); - LASSERT(info != NULL); - - seq_thread_info_init(req, info); - rc = seq_req_handle(req, env, info); - /* XXX: we don't need replay but MDT assign transno in any case, - * remove it manually before reply*/ - lustre_msg_set_transno(req->rq_repmsg, 0); - seq_thread_info_fini(info); - - return rc; -} - -/* - * Entry point for handling FLD RPCs called from MDT. - */ -int seq_query(struct com_thread_info *info) -{ - return seq_handle(info->cti_pill->rc_req); -} -EXPORT_SYMBOL(seq_query); - -static void seq_server_proc_fini(struct lu_server_seq *seq); - -#ifdef LPROCFS static int seq_server_proc_init(struct lu_server_seq *seq) { +#ifdef LPROCFS + int rc; ENTRY; @@ -436,15 +425,29 @@ static int seq_server_proc_init(struct lu_server_seq *seq) GOTO(out_cleanup, rc); } + if (seq->lss_type == LUSTRE_SEQ_CONTROLLER) { + rc = lprocfs_seq_create(seq->lss_proc_dir, "fldb", 0644, + &seq_fld_proc_seq_fops, seq); + if (rc) { + CERROR("%s: Can't create fldb for sequence manager " + "proc: rc = %d\n", seq->lss_name, rc); + GOTO(out_cleanup, rc); + } + } + RETURN(0); out_cleanup: seq_server_proc_fini(seq); return rc; +#else /* LPROCFS */ + return 0; +#endif } static void seq_server_proc_fini(struct lu_server_seq *seq) { +#ifdef LPROCFS ENTRY; if (seq->lss_proc_dir != NULL) { if (!IS_ERR(seq->lss_proc_dir)) @@ -452,19 +455,8 @@ static void seq_server_proc_fini(struct lu_server_seq *seq) seq->lss_proc_dir = NULL; } EXIT; +#endif /* LPROCFS */ } -#else -static int seq_server_proc_init(struct lu_server_seq *seq) -{ - return 0; -} - -static void seq_server_proc_fini(struct lu_server_seq *seq) -{ - return; -} -#endif - int seq_server_init(struct lu_server_seq *seq, struct dt_device *dev, @@ -473,14 +465,25 @@ int seq_server_init(struct lu_server_seq *seq, struct seq_server_site *ss, const struct lu_env *env) { - int rc, is_srv = (type == LUSTRE_SEQ_SERVER); - ENTRY; + int rc, is_srv = (type == LUSTRE_SEQ_SERVER); + ENTRY; - LASSERT(dev != NULL); - LASSERT(prefix != NULL); + LASSERT(dev != NULL); + LASSERT(prefix != NULL); LASSERT(ss != NULL); LASSERT(ss->ss_lu != NULL); + /* A compile-time check for FIDs that used to be in lustre_idl.h + * but is moved here to remove CLASSERT/LASSERT in that header. + * Check all lu_fid fields are converted in fid_cpu_to_le() and friends + * and that there is no padding added by compiler to the struct. */ + { + struct lu_fid tst; + + CLASSERT(sizeof(tst) == sizeof(tst.f_seq) + + sizeof(tst.f_oid) + sizeof(tst.f_ver)); + } + seq->lss_cli = NULL; seq->lss_type = type; seq->lss_site = ss; @@ -584,33 +587,13 @@ int seq_site_fini(const struct lu_env *env, struct seq_server_site *ss) } EXPORT_SYMBOL(seq_site_fini); -cfs_proc_dir_entry_t *seq_type_proc_dir = NULL; - -static int __init fid_mod_init(void) +int fid_server_mod_init(void) { - seq_type_proc_dir = lprocfs_register(LUSTRE_SEQ_NAME, - proc_lustre_root, - NULL, NULL); - if (IS_ERR(seq_type_proc_dir)) - return PTR_ERR(seq_type_proc_dir); - - LU_CONTEXT_KEY_INIT(&seq_thread_key); - lu_context_key_register(&seq_thread_key); - return 0; + LU_CONTEXT_KEY_INIT(&seq_thread_key); + return lu_context_key_register(&seq_thread_key); } -static void __exit fid_mod_exit(void) +void fid_server_mod_exit(void) { - lu_context_key_degister(&seq_thread_key); - if (seq_type_proc_dir != NULL && !IS_ERR(seq_type_proc_dir)) { - lprocfs_remove(&seq_type_proc_dir); - seq_type_proc_dir = NULL; - } + lu_context_key_degister(&seq_thread_key); } - -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); -#endif