X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Ffid%2Ffid_handler.c;h=07c007010ce08e12e98d14fc561e00e143634c9c;hp=c44f031c3bfd56e54e194e0f3405bd24e3acb2b1;hb=1ecf5bd5a3bece3d615d037a332792e360b49a09;hpb=b1e595c09e1b07a6840142b3ae015b8a5a8affeb diff --git a/lustre/fid/fid_handler.c b/lustre/fid/fid_handler.c index c44f031..07c0070 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, 2013, Intel Corporation. + * Copyright (c) 2011, 2014, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -94,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; } /** @@ -118,9 +118,9 @@ static int __seq_server_alloc_super(struct lu_server_seq *seq, int rc; ENTRY; - LASSERT(range_is_sane(space)); + LASSERT(lu_seq_range_is_sane(space)); - if (range_is_exhausted(space)) { + if (lu_seq_range_is_exhausted(space)) { CERROR("%s: Sequences space is exhausted\n", seq->lss_name); RETURN(-ENOSPC); @@ -215,62 +215,73 @@ static int __seq_set_init(const struct lu_env *env, * 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. */ + 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; + 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); - /* 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, seq->lss_need_sync); + } - LASSERTF(!range_is_exhausted(loset) || range_is_sane(loset), - DRANGE"\n", PRANGE(loset)); + LASSERTF(!lu_seq_range_is_exhausted(loset) || + lu_seq_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); } -static int __seq_server_alloc_meta(struct lu_server_seq *seq, - struct lu_seq_range *out, - const struct lu_env *env) +/** + * 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; - LASSERT(range_is_sane(space)); - /* Check if available space ends and allocate new super seq */ - if (range_is_exhausted(space)) { + if (lu_seq_range_is_exhausted(space)) { if (!seq->lss_cli) { CERROR("%s: No sequence controller is attached.\n", seq->lss_name); @@ -279,14 +290,14 @@ static int __seq_server_alloc_meta(struct lu_server_seq *seq, 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); + 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(range_is_sane(space)); + LASSERT(lu_seq_range_is_sane(space)); if (seq->lss_cli->lcs_srv == NULL) { struct lu_server_fld *fld; @@ -298,6 +309,31 @@ static int __seq_server_alloc_meta(struct lu_server_seq *seq, } } + 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 *space = &seq->lss_space; + int rc = 0; + + ENTRY; + + LASSERT(lu_seq_range_is_sane(space)); + + 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); + } + rc = range_alloc_set(env, out, seq); if (rc != 0) { CERROR("%s: Allocated meta-sequence failed: rc = %d\n", @@ -410,20 +446,19 @@ extern const struct file_operations seq_fld_proc_seq_fops; static int seq_server_proc_init(struct lu_server_seq *seq) { -#ifdef LPROCFS +#ifdef CONFIG_PROC_FS int rc; ENTRY; - seq->lss_proc_dir = lprocfs_seq_register(seq->lss_name, - seq_type_proc_dir, - NULL, NULL); + 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_seq_add_vars(seq->lss_proc_dir, - seq_server_proc_list, seq); + 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); @@ -445,14 +480,14 @@ static int seq_server_proc_init(struct lu_server_seq *seq) out_cleanup: seq_server_proc_fini(seq); return rc; -#else /* LPROCFS */ +#else /* !CONFIG_PROC_FS */ return 0; -#endif +#endif /* CONFIG_PROC_FS */ } static void seq_server_proc_fini(struct lu_server_seq *seq) { -#ifdef LPROCFS +#ifdef CONFIG_PROC_FS ENTRY; if (seq->lss_proc_dir != NULL) { if (!IS_ERR(seq->lss_proc_dir)) @@ -460,7 +495,7 @@ static void seq_server_proc_fini(struct lu_server_seq *seq) seq->lss_proc_dir = NULL; } EXIT; -#endif /* LPROCFS */ +#endif /* CONFIG_PROC_FS */ } int seq_server_init(const struct lu_env *env, @@ -492,11 +527,11 @@ int seq_server_init(const struct lu_env *env, seq->lss_cli = NULL; seq->lss_type = type; seq->lss_site = ss; - range_init(&seq->lss_space); + 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; mutex_init(&seq->lss_mutex); @@ -534,12 +569,12 @@ int seq_server_init(const struct lu_env *env, 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)