X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Ffid%2Ffid_handler.c;h=9f378a5a1bb835d2706075179127497bf7685240;hb=4c066a61d5bc4b59e6fd23d5416500f0e61be3a1;hp=de145149a15ed2f5548a7b336336f48349c5bf50;hpb=f95393b0d0a59cf3dc2f29cffc35dcc4cc9d7728;p=fs%2Flustre-release.git diff --git a/lustre/fid/fid_handler.c b/lustre/fid/fid_handler.c index de14514..9f378a5 100644 --- a/lustre/fid/fid_handler.c +++ b/lustre/fid/fid_handler.c @@ -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. @@ -28,6 +26,8 @@ /* * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. + * + * Copyright (c) 2011, 2015, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -40,33 +40,23 @@ * Author: Yury Umanets */ -#ifndef EXPORT_SYMTAB -# define EXPORT_SYMTAB -#endif #define DEBUG_SUBSYSTEM S_FID -#ifdef __KERNEL__ -# include -# include -#else /* __KERNEL__ */ -# include -#endif - +#include +#include #include #include -#include #include -#include #include #include #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, - const struct lu_env *env) +int seq_server_set_cli(const struct lu_env *env, struct lu_server_seq *seq, + struct lu_client_seq *cli) { int rc = 0; ENTRY; @@ -75,29 +65,28 @@ int seq_server_set_cli(struct lu_server_seq *seq, * Ask client for new range, assign that range to ->seq_space and write * seq state to backing store should be atomic. */ - cfs_down(&seq->lss_sem); + mutex_lock(&seq->lss_mutex); - if (cli == NULL) { - CDEBUG(D_INFO, "%s: Detached sequence client %s\n", - seq->lss_name, cli->lcs_name); - seq->lss_cli = cli; - GOTO(out_up, rc = 0); - } + if (cli == NULL) { + CDEBUG(D_INFO, "%s: Detached sequence client\n", seq->lss_name); + seq->lss_cli = NULL; + GOTO(out_up, rc = 0); + } - if (seq->lss_cli != NULL) { - CERROR("%s: Sequence controller is already " - "assigned\n", seq->lss_name); - GOTO(out_up, rc = -EINVAL); - } + if (seq->lss_cli != NULL) { + CDEBUG(D_HA, "%s: Sequence controller is already " + "assigned\n", seq->lss_name); + GOTO(out_up, rc = -EEXIST); + } CDEBUG(D_INFO, "%s: Attached sequence controller %s\n", seq->lss_name, cli->lcs_name); - seq->lss_cli = cli; - cli->lcs_space.lsr_mdt = seq->lss_site->ms_node_id; - EXIT; + seq->lss_cli = cli; + cli->lcs_space.lsr_index = seq->lss_site->ss_node_id; + EXIT; out_up: - cfs_up(&seq->lss_sem); + mutex_unlock(&seq->lss_mutex); return rc; } EXPORT_SYMBOL(seq_server_set_cli); @@ -105,13 +94,13 @@ EXPORT_SYMBOL(seq_server_set_cli); * allocate \a w units of sequence from range \a from. */ static inline void range_alloc(struct lu_seq_range *to, - struct lu_seq_range *from, - __u64 width) + struct lu_seq_range *from, + __u64 width) { - width = min(range_space(from), width); - to->lsr_start = from->lsr_start; - to->lsr_end = from->lsr_start + width; - from->lsr_start += width; + width = min(lu_seq_range_space(from), width); + to->lsr_start = from->lsr_start; + to->lsr_end = from->lsr_start + width; + from->lsr_start += width; } /** @@ -125,26 +114,26 @@ static int __seq_server_alloc_super(struct lu_server_seq *seq, struct lu_seq_range *out, const struct lu_env *env) { - struct lu_seq_range *space = &seq->lss_space; - int rc; - ENTRY; + struct lu_seq_range *space = &seq->lss_space; + int rc; + ENTRY; - LASSERT(range_is_sane(space)); + LASSERT(lu_seq_range_is_sane(space)); - if (range_is_exhausted(space)) { - CERROR("%s: Sequences space is exhausted\n", - seq->lss_name); - RETURN(-ENOSPC); - } else { - range_alloc(out, space, seq->lss_width); - } + if (lu_seq_range_is_exhausted(space)) { + CERROR("%s: Sequences space is exhausted\n", + seq->lss_name); + RETURN(-ENOSPC); + } else { + range_alloc(out, space, seq->lss_width); + } - rc = seq_store_update(env, seq, out, 1 /* sync */); + rc = seq_store_update(env, seq, out, 1 /* sync */); - CDEBUG(D_INFO, "%s: super-sequence allocation rc = %d " - DRANGE"\n", seq->lss_name, rc, PRANGE(out)); + LCONSOLE_INFO("%s: super-sequence allocation rc = %d " DRANGE"\n", + seq->lss_name, rc, PRANGE(out)); - RETURN(rc); + RETURN(rc); } int seq_server_alloc_super(struct lu_server_seq *seq, @@ -154,13 +143,48 @@ int seq_server_alloc_super(struct lu_server_seq *seq, int rc; ENTRY; - cfs_down(&seq->lss_sem); + mutex_lock(&seq->lss_mutex); rc = __seq_server_alloc_super(seq, out, env); - cfs_up(&seq->lss_sem); + mutex_unlock(&seq->lss_mutex); 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) { @@ -171,7 +195,6 @@ static int __seq_set_init(const struct lu_env *env, range_alloc(&seq->lss_hiwater_set, space, seq->lss_set_width); rc = seq_store_update(env, seq, NULL, 1); - seq->lss_set_transno = 0; return rc; } @@ -188,101 +211,140 @@ static int __seq_set_init(const struct lu_env *env, * * when lss_lowater_set reaches the end it is replaced with hiwater one and * a write operation is initiated to allocate new hiwater range. - * if last seq write opearion is still not commited, current operation is + * if last seq write opearion is still not committed, current operation is * flaged as sync write op. */ static int range_alloc_set(const struct lu_env *env, - struct lu_seq_range *out, - struct lu_server_seq *seq) + struct lu_seq_range *out, + struct lu_server_seq *seq) { - struct lu_seq_range *space = &seq->lss_space; - struct lu_seq_range *loset = &seq->lss_lowater_set; - struct lu_seq_range *hiset = &seq->lss_hiwater_set; - int rc = 0; + struct lu_seq_range *space = &seq->lss_space; + struct lu_seq_range *loset = &seq->lss_lowater_set; + struct lu_seq_range *hiset = &seq->lss_hiwater_set; + int rc = 0; - if (range_is_zero(loset)) - __seq_set_init(env, seq); + if (lu_seq_range_is_zero(loset)) + __seq_set_init(env, seq); - if (OBD_FAIL_CHECK(OBD_FAIL_SEQ_ALLOC)) /* exhaust set */ - loset->lsr_start = loset->lsr_end; + if (OBD_FAIL_CHECK(OBD_FAIL_SEQ_ALLOC)) /* exhaust set */ + loset->lsr_start = loset->lsr_end; - if (range_is_exhausted(loset)) { - /* reached high water mark. */ - struct lu_device *dev = seq->lss_site->ms_lu.ls_top_dev; - struct lu_target *tg = dev->ld_obd->u.obt.obt_lut; - int obd_num_clients = dev->ld_obd->obd_num_exports; - __u64 set_sz; - int sync = 0; + if (lu_seq_range_is_exhausted(loset)) { + /* reached high water mark. */ + struct lu_device *dev = seq->lss_site->ss_lu->ls_top_dev; + int obd_num_clients = dev->ld_obd->obd_num_exports; + __u64 set_sz; - /* calculate new seq width based on number of clients */ - set_sz = max(seq->lss_set_width, - obd_num_clients * seq->lss_width); - set_sz = min(range_space(space), set_sz); + /* calculate new seq width based on number of clients */ + set_sz = max(seq->lss_set_width, + obd_num_clients * seq->lss_width); + set_sz = min(lu_seq_range_space(space), set_sz); - /* Switch to hiwater range now */ - loset = hiset; - /* allocate new hiwater range */ - range_alloc(hiset, space, set_sz); + /* Switch to hiwater range now */ + *loset = *hiset; + /* allocate new hiwater range */ + range_alloc(hiset, space, set_sz); - if (seq->lss_set_transno > dev->ld_obd->obd_last_committed) - sync = 1; + /* update ondisk seq with new *space */ + rc = seq_store_update(env, seq, NULL, seq->lss_need_sync); + } - /* update ondisk seq with new *space */ - rc = seq_store_update(env, seq, NULL, sync); + LASSERTF(!lu_seq_range_is_exhausted(loset) || + lu_seq_range_is_sane(loset), + DRANGE"\n", PRANGE(loset)); - /* set new hiwater transno */ - cfs_spin_lock(&tg->lut_translock); - seq->lss_set_transno = tg->lut_last_transno; - cfs_spin_unlock(&tg->lut_translock); - } - - LASSERTF(!range_is_exhausted(loset) || range_is_sane(loset), - DRANGE"\n", PRANGE(loset)); + if (rc == 0) + range_alloc(out, loset, seq->lss_width); - if (rc == 0) - range_alloc(out, loset, seq->lss_width); + RETURN(rc); +} - RETURN(rc); +/** + * Check if the sequence server has sequence avaible + * + * Check if the sequence server has sequence avaible, if not, then + * allocating super sequence from sequence manager (MDT0). + * + * \param[in] env execution environment + * \param[in] seq server sequence + * + * \retval negative errno if allocating new sequence fails + * \retval 0 if there is enough sequence or allocating + * new sequence succeeds + */ +int seq_server_check_and_alloc_super(const struct lu_env *env, + struct lu_server_seq *seq) +{ + struct lu_seq_range *space = &seq->lss_space; + int rc = 0; + + ENTRY; + + /* Check if available space ends and allocate new super seq */ + if (lu_seq_range_is_exhausted(space)) { + if (!seq->lss_cli) { + CERROR("%s: No sequence controller is attached.\n", + seq->lss_name); + RETURN(-ENODEV); + } + + rc = seq_client_alloc_super(seq->lss_cli, env); + if (rc) { + CDEBUG(D_HA, "%s: Can't allocate super-sequence:" + " rc %d\n", seq->lss_name, rc); + RETURN(rc); + } + + /* Saving new range to allocation space. */ + *space = seq->lss_cli->lcs_space; + LASSERT(lu_seq_range_is_sane(space)); + if (seq->lss_cli->lcs_srv == NULL) { + struct lu_server_fld *fld; + + /* Insert it to the local FLDB */ + fld = seq->lss_site->ss_server_fld; + mutex_lock(&fld->lsf_lock); + rc = fld_insert_entry(env, fld, space); + mutex_unlock(&fld->lsf_lock); + } + } + + if (lu_seq_range_is_zero(&seq->lss_lowater_set)) + __seq_set_init(env, seq); + + RETURN(rc); } +EXPORT_SYMBOL(seq_server_check_and_alloc_super); static int __seq_server_alloc_meta(struct lu_server_seq *seq, - struct lu_seq_range *out, - const struct lu_env *env) + struct lu_seq_range *out, + const struct lu_env *env) { - struct lu_seq_range *space = &seq->lss_space; - int rc = 0; + struct lu_seq_range *space = &seq->lss_space; + int rc = 0; - ENTRY; + ENTRY; - LASSERT(range_is_sane(space)); + LASSERT(lu_seq_range_is_sane(space)); - /* Check if available space ends and allocate new super seq */ - if (range_is_exhausted(space)) { - if (!seq->lss_cli) { - CERROR("%s: No sequence controller is attached.\n", - seq->lss_name); - RETURN(-ENODEV); - } - - rc = seq_client_alloc_super(seq->lss_cli, env); - if (rc) { - CERROR("%s: Can't allocate super-sequence, rc %d\n", - seq->lss_name, rc); - RETURN(rc); - } + rc = seq_server_check_and_alloc_super(env, seq); + if (rc < 0) { + CERROR("%s: Allocated super-sequence failed: rc = %d\n", + seq->lss_name, rc); + RETURN(rc); + } - /* Saving new range to allocation space. */ - *space = seq->lss_cli->lcs_space; - LASSERT(range_is_sane(space)); - } + rc = range_alloc_set(env, out, seq); + if (rc != 0) { + CERROR("%s: Allocated meta-sequence failed: rc = %d\n", + seq->lss_name, rc); + RETURN(rc); + } - rc = range_alloc_set(env, out, seq); - if (rc == 0) { - CDEBUG(D_INFO, "%s: Allocated meta-sequence " - DRANGE"\n", seq->lss_name, PRANGE(out)); - } + CDEBUG(D_INFO, "%s: Allocated meta-sequence " DRANGE"\n", + seq->lss_name, PRANGE(out)); - RETURN(rc); + RETURN(rc); } int seq_server_alloc_meta(struct lu_server_seq *seq, @@ -292,9 +354,9 @@ int seq_server_alloc_meta(struct lu_server_seq *seq, int rc; ENTRY; - cfs_down(&seq->lss_sem); + mutex_lock(&seq->lss_mutex); rc = __seq_server_alloc_meta(seq, out, env); - cfs_up(&seq->lss_sem); + mutex_unlock(&seq->lss_mutex); RETURN(rc); } @@ -304,157 +366,128 @@ static int seq_server_handle(struct lu_site *site, const struct lu_env *env, __u32 opc, struct lu_seq_range *out) { - int rc; - struct md_site *mite; - ENTRY; - - mite = lu_site2md(site); - switch (opc) { - case SEQ_ALLOC_META: - if (!mite->ms_server_seq) { - CERROR("Sequence server is not " - "initialized\n"); - RETURN(-EINVAL); - } - rc = seq_server_alloc_meta(mite->ms_server_seq, out, env); - break; - case SEQ_ALLOC_SUPER: - if (!mite->ms_control_seq) { - CERROR("Sequence controller is not " - "initialized\n"); - RETURN(-EINVAL); - } - rc = seq_server_alloc_super(mite->ms_control_seq, out, env); - break; - default: - rc = -EINVAL; - break; - } - - RETURN(rc); + int rc; + struct seq_server_site *ss_site; + ENTRY; + + ss_site = lu_site2seq(site); + + switch (opc) { + case SEQ_ALLOC_META: + if (!ss_site->ss_server_seq) { + CERROR("Sequence server is not " + "initialized\n"); + RETURN(-EINVAL); + } + rc = seq_server_alloc_meta(ss_site->ss_server_seq, out, env); + break; + case SEQ_ALLOC_SUPER: + if (!ss_site->ss_control_seq) { + CERROR("Sequence controller is not " + "initialized\n"); + RETURN(-EINVAL); + } + rc = seq_server_alloc_super(ss_site->ss_control_seq, out, env); + break; + default: + rc = -EINVAL; + break; + } + + 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_mdt = tmp->lsr_mdt; - 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); - -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); -} - -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); +LU_CONTEXT_KEY_DEFINE(seq, LCT_MD_THREAD | LCT_DT_THREAD); - 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); +extern const struct file_operations seq_fld_proc_seq_fops; - 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) { - int rc; - ENTRY; - - seq->lss_proc_dir = lprocfs_register(seq->lss_name, - seq_type_proc_dir, - NULL, NULL); - if (IS_ERR(seq->lss_proc_dir)) { - rc = PTR_ERR(seq->lss_proc_dir); - RETURN(rc); - } - - rc = lprocfs_add_vars(seq->lss_proc_dir, - seq_server_proc_list, seq); - if (rc) { - CERROR("%s: Can't init sequence manager " - "proc, rc %d\n", seq->lss_name, rc); - GOTO(out_cleanup, rc); - } - - RETURN(0); +#ifdef CONFIG_PROC_FS + int rc; + ENTRY; + + seq->lss_proc_dir = lprocfs_register(seq->lss_name, + seq_type_proc_dir, + NULL, NULL); + if (IS_ERR(seq->lss_proc_dir)) { + rc = PTR_ERR(seq->lss_proc_dir); + RETURN(rc); + } + + rc = lprocfs_add_vars(seq->lss_proc_dir, seq_server_proc_list, seq); + if (rc) { + CERROR("%s: Can't init sequence manager " + "proc, rc %d\n", seq->lss_name, rc); + 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; + seq_server_proc_fini(seq); + return rc; +#else /* !CONFIG_PROC_FS */ + return 0; +#endif /* CONFIG_PROC_FS */ } static void seq_server_proc_fini(struct lu_server_seq *seq) { +#ifdef CONFIG_PROC_FS ENTRY; if (seq->lss_proc_dir != NULL) { if (!IS_ERR(seq->lss_proc_dir)) @@ -462,43 +495,45 @@ static void seq_server_proc_fini(struct lu_server_seq *seq) seq->lss_proc_dir = NULL; } EXIT; -} -#else -static int seq_server_proc_init(struct lu_server_seq *seq) -{ - return 0; +#endif /* CONFIG_PROC_FS */ } -static void seq_server_proc_fini(struct lu_server_seq *seq) +int seq_server_init(const struct lu_env *env, + struct lu_server_seq *seq, + struct dt_device *dev, + const char *prefix, + enum lu_mgr_type type, + struct seq_server_site *ss) { - return; -} -#endif + int rc, is_srv = (type == LUSTRE_SEQ_SERVER); + ENTRY; + LASSERT(dev != NULL); + LASSERT(prefix != NULL); + LASSERT(ss != NULL); + LASSERT(ss->ss_lu != NULL); -int seq_server_init(struct lu_server_seq *seq, - struct dt_device *dev, - const char *prefix, - enum lu_mgr_type type, - struct md_site *ms, - const struct lu_env *env) -{ - int rc, is_srv = (type == LUSTRE_SEQ_SERVER); - ENTRY; + /* 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; - LASSERT(dev != NULL); - LASSERT(prefix != NULL); + 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 = ms; - range_init(&seq->lss_space); + seq->lss_cli = NULL; + seq->lss_type = type; + seq->lss_site = ss; + lu_seq_range_init(&seq->lss_space); - range_init(&seq->lss_lowater_set); - range_init(&seq->lss_hiwater_set); - seq->lss_set_width = LUSTRE_SEQ_BATCH_WIDTH; + lu_seq_range_init(&seq->lss_lowater_set); + lu_seq_range_init(&seq->lss_hiwater_set); + seq->lss_set_width = LUSTRE_SEQ_BATCH_WIDTH; - cfs_sema_init(&seq->lss_sem, 1); + mutex_init(&seq->lss_mutex); seq->lss_width = is_srv ? LUSTRE_SEQ_META_WIDTH : LUSTRE_SEQ_SUPER_WIDTH; @@ -518,10 +553,10 @@ int seq_server_init(struct lu_server_seq *seq, LUSTRE_SEQ_ZERO_RANGE: LUSTRE_SEQ_SPACE_RANGE; - seq->lss_space.lsr_mdt = ms->ms_node_id; - CDEBUG(D_INFO, "%s: No data found " - "on store. Initialize space\n", - seq->lss_name); + seq->lss_space.lsr_index = ss->ss_node_id; + LCONSOLE_INFO("%s: No data found " + "on store. Initialize space\n", + seq->lss_name); rc = seq_store_update(env, seq, NULL, 0); if (rc) { @@ -534,12 +569,12 @@ int seq_server_init(struct lu_server_seq *seq, GOTO(out, rc); } - if (is_srv) { - LASSERT(range_is_sane(&seq->lss_space)); - } else { - LASSERT(!range_is_zero(&seq->lss_space) && - range_is_sane(&seq->lss_space)); - } + if (is_srv) { + LASSERT(lu_seq_range_is_sane(&seq->lss_space)); + } else { + LASSERT(!lu_seq_range_is_zero(&seq->lss_space) && + lu_seq_range_is_sane(&seq->lss_space)); + } rc = seq_server_proc_init(seq); if (rc) @@ -565,51 +600,40 @@ void seq_server_fini(struct lu_server_seq *seq, } EXPORT_SYMBOL(seq_server_fini); -cfs_proc_dir_entry_t *seq_type_proc_dir = NULL; - -static struct lu_local_obj_desc llod_seq_srv = { - .llod_name = LUSTRE_SEQ_SRV_NAME, - .llod_oid = FID_SEQ_SRV_OID, - .llod_is_index = 0, -}; - -static struct lu_local_obj_desc llod_seq_ctl = { - .llod_name = LUSTRE_SEQ_CTL_NAME, - .llod_oid = FID_SEQ_CTL_OID, - .llod_is_index = 0, -}; - -static int __init fid_mod_init(void) +int seq_site_fini(const struct lu_env *env, struct seq_server_site *ss) { - 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); - - llo_local_obj_register(&llod_seq_srv); - llo_local_obj_register(&llod_seq_ctl); - - LU_CONTEXT_KEY_INIT(&seq_thread_key); - lu_context_key_register(&seq_thread_key); - return 0; + if (ss == NULL) + RETURN(0); + + if (ss->ss_server_seq) { + seq_server_fini(ss->ss_server_seq, env); + OBD_FREE_PTR(ss->ss_server_seq); + ss->ss_server_seq = NULL; + } + + if (ss->ss_control_seq) { + seq_server_fini(ss->ss_control_seq, env); + OBD_FREE_PTR(ss->ss_control_seq); + ss->ss_control_seq = NULL; + } + + if (ss->ss_client_seq) { + seq_client_fini(ss->ss_client_seq); + OBD_FREE_PTR(ss->ss_client_seq); + ss->ss_client_seq = NULL; + } + + RETURN(0); } +EXPORT_SYMBOL(seq_site_fini); -static void __exit fid_mod_exit(void) +int fid_server_mod_init(void) { - llo_local_obj_unregister(&llod_seq_srv); - llo_local_obj_unregister(&llod_seq_ctl); - - 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_INIT(&seq_thread_key); + return lu_context_key_register(&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 +void fid_server_mod_exit(void) +{ + lu_context_key_degister(&seq_thread_key); +}