X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fquota%2Fqmt_entry.c;h=d3ed2545d0cc95063b583615a0e3d597d0607697;hb=refs%2Fchanges%2F76%2F36276%2F2;hp=47a1ccfca186f9215f496e416beacc673db10cde;hpb=2b294992edce5af7b79d4300ed3aa1ea6a8db850;p=fs%2Flustre-release.git diff --git a/lustre/quota/qmt_entry.c b/lustre/quota/qmt_entry.c index 47a1ccf..d3ed254 100644 --- a/lustre/quota/qmt_entry.c +++ b/lustre/quota/qmt_entry.c @@ -21,7 +21,7 @@ * GPL HEADER END */ /* - * Copyright (c) 2012, 2013, Intel Corporation. + * Copyright (c) 2012, 2016, Intel Corporation. * Use is subject to license terms. * * Author: Johann Lombardi @@ -46,6 +46,55 @@ static void qmt_lqe_init(struct lquota_entry *lqe, void *arg) init_rwsem(&lqe->lqe_sem); } +/* Apply the default quota setting to the specified quota entry + * + * \param env - is the environment passed by the caller + * \param pool - is the quota pool of the quota entry + * \param lqe - is the lquota_entry object to apply default quota on + * \param create_record - if true, an global quota record will be created and + * write to the disk. + * + * \retval 0 : success + * \retval -ve : other appropriate errors + */ +int qmt_lqe_set_default(const struct lu_env *env, struct qmt_pool_info *pool, + struct lquota_entry *lqe, bool create_record) +{ + struct lquota_entry *lqe_def; + int rc = 0; + + ENTRY; + + if (lqe->lqe_id.qid_uid == 0) + RETURN(0); + + lqe_def = pool->qpi_grace_lqe[lqe->lqe_site->lqs_qtype]; + + LQUOTA_DEBUG(lqe, "inherit default quota"); + + lqe->lqe_is_default = true; + lqe->lqe_hardlimit = lqe_def->lqe_hardlimit; + lqe->lqe_softlimit = lqe_def->lqe_softlimit; + + if (create_record) { + lqe->lqe_uptodate = true; + rc = qmt_set_with_lqe(env, pool->qpi_qmt, lqe, 0, 0, + LQUOTA_GRACE_FLAG(0, LQUOTA_FLAG_DEFAULT), + QIF_TIMES, true, false); + + if (rc != 0) + LQUOTA_ERROR(lqe, "failed to create the global quota" + " record: %d", rc); + } + + if (lqe->lqe_hardlimit == 0 && lqe->lqe_softlimit == 0) + lqe->lqe_enforced = false; + else + lqe->lqe_enforced = true; + + RETURN(rc); +} + /* * Update a lquota entry. This is done by reading quota settings from the global * index. The lquota entry must be write locked. @@ -70,22 +119,19 @@ static int qmt_lqe_read(const struct lu_env *env, struct lquota_entry *lqe, switch (rc) { case -ENOENT: - /* no such entry, assume quota isn't enforced for this user */ - lqe->lqe_enforced = false; + qmt_lqe_set_default(env, pool, lqe, true); break; case 0: /* copy quota settings from on-disk record */ lqe->lqe_granted = qti->qti_glb_rec.qbr_granted; lqe->lqe_hardlimit = qti->qti_glb_rec.qbr_hardlimit; lqe->lqe_softlimit = qti->qti_glb_rec.qbr_softlimit; - lqe->lqe_gracetime = qti->qti_glb_rec.qbr_time; - - if (lqe->lqe_hardlimit == 0 && lqe->lqe_softlimit == 0) - /* {hard,soft}limit=0 means no quota enforced */ - lqe->lqe_enforced = false; - else - lqe->lqe_enforced = true; + lqe->lqe_gracetime = LQUOTA_GRACE(qti->qti_glb_rec.qbr_time); + if (lqe->lqe_hardlimit == 0 && lqe->lqe_softlimit == 0 && + (LQUOTA_FLAG(qti->qti_glb_rec.qbr_time) & + LQUOTA_FLAG_DEFAULT)) + qmt_lqe_set_default(env, pool, lqe, false); break; default: LQUOTA_ERROR(lqe, "failed to read quota entry from disk, rc:%d", @@ -93,6 +139,13 @@ static int qmt_lqe_read(const struct lu_env *env, struct lquota_entry *lqe, RETURN(rc); } + if (lqe->lqe_id.qid_uid == 0 || + (lqe->lqe_hardlimit == 0 && lqe->lqe_softlimit == 0)) + /* {hard,soft}limit=0 means no quota enforced */ + lqe->lqe_enforced = false; + else + lqe->lqe_enforced = true; + LQUOTA_DEBUG(lqe, "read"); RETURN(0); } @@ -107,22 +160,21 @@ static int qmt_lqe_read(const struct lu_env *env, struct lquota_entry *lqe, */ static void qmt_lqe_debug(struct lquota_entry *lqe, void *arg, struct libcfs_debug_msg_data *msgdata, - const char *fmt, va_list args) + struct va_format *vaf) { struct qmt_pool_info *pool = (struct qmt_pool_info *)arg; - libcfs_debug_vmsg2(msgdata, fmt, args, - "qmt:%s pool:%d-%s id:"LPU64" enforced:%d hard:"LPU64 - " soft:"LPU64" granted:"LPU64" time:"LPU64" qunit:" - LPU64" edquot:%d may_rel:"LPU64" revoke:"LPU64"\n", - pool->qpi_qmt->qmt_svname, - pool->qpi_key & 0x0000ffff, - RES_NAME(pool->qpi_key >> 16), - lqe->lqe_id.qid_uid, lqe->lqe_enforced, - lqe->lqe_hardlimit, lqe->lqe_softlimit, - lqe->lqe_granted, lqe->lqe_gracetime, - lqe->lqe_qunit, lqe->lqe_edquot, lqe->lqe_may_rel, - lqe->lqe_revoke_time); + libcfs_debug_msg(msgdata, + "%pV qmt:%s pool:%s-%s id:%llu enforced:%d hard:%llu soft:%llu granted:%llu time:%llu qunit: %llu edquot:%d may_rel:%llu revoke:%lld default:%s\n", + vaf, pool->qpi_qmt->qmt_svname, + RES_NAME(pool->qpi_rtype), + pool->qpi_name, + lqe->lqe_id.qid_uid, lqe->lqe_enforced, + lqe->lqe_hardlimit, lqe->lqe_softlimit, + lqe->lqe_granted, lqe->lqe_gracetime, + lqe->lqe_qunit, lqe->lqe_edquot, lqe->lqe_may_rel, + lqe->lqe_revoke_time, + lqe->lqe_is_default ? "yes" : "no"); } /* @@ -264,9 +316,15 @@ int qmt_glb_write(const struct lu_env *env, struct thandle *th, /* fill global index with updated quota settings */ rec->qbr_granted = lqe->lqe_granted; - rec->qbr_hardlimit = lqe->lqe_hardlimit; - rec->qbr_softlimit = lqe->lqe_softlimit; - rec->qbr_time = lqe->lqe_gracetime; + if (lqe->lqe_is_default) { + rec->qbr_hardlimit = 0; + rec->qbr_softlimit = 0; + rec->qbr_time = LQUOTA_GRACE_FLAG(0, LQUOTA_FLAG_DEFAULT); + } else { + rec->qbr_hardlimit = lqe->lqe_hardlimit; + rec->qbr_softlimit = lqe->lqe_softlimit; + rec->qbr_time = lqe->lqe_gracetime; + } /* write new quota settings */ rc = lquota_disk_write(env, th, LQE_GLB_OBJ(lqe), &lqe->lqe_id, @@ -327,7 +385,7 @@ int qmt_slv_read(const struct lu_env *env, struct lquota_entry *lqe, RETURN(rc); } - LQUOTA_DEBUG(lqe, "successful slv read "LPU64, *granted); + LQUOTA_DEBUG(lqe, "successful slv read %llu", *granted); RETURN(0); } @@ -360,7 +418,7 @@ int qmt_slv_write(const struct lu_env *env, struct thandle *th, LASSERT(lqe_is_master(lqe)); LASSERT(lqe_is_locked(lqe)); - LQUOTA_DEBUG(lqe, "write slv "DFID" granted:"LPU64, + LQUOTA_DEBUG(lqe, "write slv "DFID" granted:%llu", PFID(lu_object_fid(&slv_obj->do_lu)), granted); /* never delete the entry, otherwise, it'll not be transferred @@ -375,7 +433,7 @@ int qmt_slv_write(const struct lu_env *env, struct thandle *th, (struct dt_rec *)rec, flags, ver); if (rc) { LQUOTA_ERROR(lqe, "failed to update slave index "DFID" granted:" - LPU64, PFID(lu_object_fid(&slv_obj->do_lu)), + "%llu", PFID(lu_object_fid(&slv_obj->do_lu)), granted); RETURN(rc); } @@ -425,7 +483,9 @@ void qmt_adjust_edquot(struct lquota_entry *lqe, __u64 now) /* See comment in qmt_adjust_qunit(). LU-4139 */ if (qmt_hard_exhausted(lqe) || - pool->qpi_key >> 16 == LQUOTA_RES_MD) { + pool->qpi_rtype != LQUOTA_RES_DT) { + time64_t lapse; + /* we haven't reached the minimal qunit yet so there is * still hope that the rebalancing process might free * up some quota space */ @@ -437,15 +497,11 @@ void qmt_adjust_edquot(struct lquota_entry *lqe, __u64 now) RETURN_EXIT; /* Let's give more time to slave to release space */ - if (lqe->lqe_may_rel != 0 && - cfs_time_before_64(cfs_time_shift_64( - -QMT_REBA_TIMEOUT), - lqe->lqe_revoke_time)) + lapse = ktime_get_seconds() - QMT_REBA_TIMEOUT; + if (lqe->lqe_may_rel != 0 && lqe->lqe_revoke_time > lapse) RETURN_EXIT; } else { - /* When exceeding softlimit, block qunit will be shrunk - * to (4 * least_qunit) finally. */ - if (lqe->lqe_qunit > (pool->qpi_least_qunit << 2)) + if (lqe->lqe_qunit > pool->qpi_soft_least_qunit) RETURN_EXIT; } @@ -487,12 +543,11 @@ static __u64 qmt_calc_softlimit(struct lquota_entry *lqe, bool *oversoft) LASSERT(lqe->lqe_softlimit != 0); *oversoft = false; /* No need to do special tweaking for inode limit */ - if (pool->qpi_key >> 16 == LQUOTA_RES_MD) + if (pool->qpi_rtype != LQUOTA_RES_DT) return lqe->lqe_softlimit; - /* Added (least_qunit * 4) as margin */ if (lqe->lqe_granted <= lqe->lqe_softlimit + - (pool->qpi_least_qunit << 2)) { + pool->qpi_soft_least_qunit) { return lqe->lqe_softlimit; } else if (lqe->lqe_hardlimit != 0) { *oversoft = true; @@ -531,7 +586,7 @@ __u64 qmt_alloc_expand(struct lquota_entry *lqe, __u64 granted, __u64 spare) remaining = qmt_calc_softlimit(lqe, &oversoft); if (remaining == 0) remaining = lqe->lqe_granted + - (pool->qpi_least_qunit << 2); + pool->qpi_soft_least_qunit; } else { remaining = lqe->lqe_hardlimit; } @@ -600,10 +655,10 @@ void qmt_adjust_qunit(const struct lu_env *env, struct lquota_entry *lqe) bool oversoft; /* As a compromise of write performance and the grace time * accuracy, the block qunit size will be shrunk to - * (4 * least_qunit) when over softlimit. LU-4139. */ + * qpi_soft_least_qunit when over softlimit. LU-4139. */ limit = qmt_calc_softlimit(lqe, &oversoft); if (oversoft) - qunit2 = pool->qpi_least_qunit << 2; + qunit2 = pool->qpi_soft_least_qunit; if (limit == 0) GOTO(done, qunit = qunit2); } else if (lqe->lqe_hardlimit != 0) { @@ -641,8 +696,14 @@ void qmt_adjust_qunit(const struct lu_env *env, struct lquota_entry *lqe) /* current qunit value still fits, let's see if we can afford to * increase qunit now ... * To increase qunit again, we have to be under 25% */ - while (limit >= lqe->lqe_granted + 6 * qunit * slv_cnt) + while (qunit && limit >= lqe->lqe_granted + 6 * qunit * slv_cnt) qunit <<= 2; + + if (!qunit) { + qunit = limit; + do_div(qunit, 2 * slv_cnt); + } + } else { /* shrink qunit until we find a suitable value */ while (qunit > pool->qpi_least_qunit && @@ -657,7 +718,7 @@ done: /* keep current qunit */ RETURN_EXIT; - LQUOTA_DEBUG(lqe, "%s qunit to "LPU64, + LQUOTA_DEBUG(lqe, "%s qunit to %llu", lqe->lqe_qunit < qunit ? "increasing" : "decreasing", qunit); @@ -672,7 +733,7 @@ done: qmt_id_lock_notify(pool->qpi_qmt, lqe); else if (lqe->lqe_qunit == pool->qpi_least_qunit) /* initial qunit value is the smallest one */ - lqe->lqe_revoke_time = cfs_time_current_64(); + lqe->lqe_revoke_time = ktime_get_seconds(); EXIT; } @@ -687,6 +748,6 @@ void qmt_revalidate(const struct lu_env *env, struct lquota_entry *lqe) * were initialized */ qmt_adjust_qunit(env, lqe); if (lqe->lqe_qunit != 0) - qmt_adjust_edquot(lqe, cfs_time_current_sec()); + qmt_adjust_edquot(lqe, ktime_get_real_seconds()); } }