X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fquota%2Fqsd_writeback.c;h=9a400135e4f574832bdc8c642e5b2a8c96769c88;hb=31170f9ceca91684ea66e0b16757881563a8cf26;hp=cafadd6aac9eb4fbc05509d30eaf06bcf743ec13;hpb=b2cb6fd1095f9c483b7bc1ebbbfdaef719aea87c;p=fs%2Flustre-release.git diff --git a/lustre/quota/qsd_writeback.c b/lustre/quota/qsd_writeback.c index cafadd6..9a40013 100644 --- a/lustre/quota/qsd_writeback.c +++ b/lustre/quota/qsd_writeback.c @@ -21,23 +21,18 @@ * GPL HEADER END */ /* - * Copyright (c) 2011, 2012, Intel, Inc. + * Copyright (c) 2012, 2017, Intel Corporation. * Use is subject to license terms. * * Author: Johann Lombardi * Author: Niu Yawei */ -#ifndef EXPORT_SYMTAB -# define EXPORT_SYMTAB -#endif - #define DEBUG_SUBSYSTEM S_LQUOTA +#include #include "qsd_internal.h" -extern cfs_mem_cache_t *upd_kmem; - /* * Allocate and fill an qsd_upd_rec structure to be processed by the writeback * thread. @@ -58,14 +53,13 @@ static struct qsd_upd_rec *qsd_upd_alloc(struct qsd_qtype_info *qqi, { struct qsd_upd_rec *upd; - OBD_SLAB_ALLOC_PTR_GFP(upd, upd_kmem, CFS_ALLOC_IO); + OBD_SLAB_ALLOC_PTR_GFP(upd, upd_kmem, GFP_NOFS); if (upd == NULL) { - CERROR("Failed to allocate upd"); return NULL; } /* fill it */ - CFS_INIT_LIST_HEAD(&upd->qur_link); + INIT_LIST_HEAD(&upd->qur_link); upd->qur_qqi = qqi; upd->qur_lqe = lqe; if (lqe) @@ -91,39 +85,63 @@ static void qsd_upd_add(struct qsd_instance *qsd, struct qsd_upd_rec *upd) if (!qsd->qsd_stopping) { list_add_tail(&upd->qur_link, &qsd->qsd_upd_list); /* wake up the upd thread */ - cfs_waitq_signal(&qsd->qsd_upd_thread.t_ctl_waitq); + wake_up(&qsd->qsd_upd_thread.t_ctl_waitq); } else { - CWARN("%s: discard deferred update.\n", qsd->qsd_svname); + CWARN("%s: discard update.\n", qsd->qsd_svname); if (upd->qur_lqe) - LQUOTA_WARN(upd->qur_lqe, "discard deferred update."); + LQUOTA_WARN(upd->qur_lqe, "discard update."); qsd_upd_free(upd); } } /* must hold the qsd_lock */ -static void qsd_add_deferred(cfs_list_t *list, struct qsd_upd_rec *upd) +static void qsd_add_deferred(struct qsd_instance *qsd, struct list_head *list, + struct qsd_upd_rec *upd) { - struct qsd_upd_rec *tmp; - - /* Sort the updates in ascending order */ - cfs_list_for_each_entry_reverse(tmp, list, qur_link) { + struct qsd_upd_rec *tmp, *n; - LASSERTF(upd->qur_ver != tmp->qur_ver, "ver:"LPU64"\n", - upd->qur_ver); + if (qsd->qsd_stopping) { + CWARN("%s: discard deferred udpate.\n", qsd->qsd_svname); + if (upd->qur_lqe) + LQUOTA_WARN(upd->qur_lqe, "discard deferred update."); + qsd_upd_free(upd); + return; + } - if (upd->qur_ver < tmp->qur_ver) { + /* Sort the updates in ascending order */ + list_for_each_entry_safe_reverse(tmp, n, list, qur_link) { + + /* There could be some legacy records which have duplicated + * version. Imagine following scenario: slave received global + * glimpse and queued a record in the deferred list, then + * master crash and rollback to an ealier version, then the + * version of queued record will be conflicting with later + * updates. We should just delete the legacy record in such + * case. */ + if (upd->qur_ver == tmp->qur_ver) { + if (tmp->qur_lqe) + LQUOTA_WARN(tmp->qur_lqe, "Found a conflict " + "record with ver:%llu", + tmp->qur_ver); + else + CWARN("%s: Found a conflict record with ver: " + "%llu\n", qsd->qsd_svname, tmp->qur_ver); + + list_del_init(&tmp->qur_link); + qsd_upd_free(tmp); + } else if (upd->qur_ver < tmp->qur_ver) { continue; } else { - cfs_list_add_tail(&upd->qur_link, &tmp->qur_link); + list_add_tail(&upd->qur_link, &tmp->qur_link); return; } } - cfs_list_add(&upd->qur_link, list); + list_add(&upd->qur_link, list); } /* must hold the qsd_lock */ -static void qsd_kickoff_deferred(struct qsd_qtype_info *qqi, cfs_list_t *list, - __u64 ver) +static void qsd_kickoff_deferred(struct qsd_qtype_info *qqi, + struct list_head *list, __u64 ver) { struct qsd_upd_rec *upd, *tmp; ENTRY; @@ -131,12 +149,12 @@ static void qsd_kickoff_deferred(struct qsd_qtype_info *qqi, cfs_list_t *list, /* Get the first update record in the list, which has the smallest * version, discard all records with versions smaller than the current * one */ - cfs_list_for_each_entry_safe(upd, tmp, list, qur_link) { + list_for_each_entry_safe(upd, tmp, list, qur_link) { if (upd->qur_ver <= ver) { /* drop this update */ - cfs_list_del_init(&upd->qur_link); + list_del_init(&upd->qur_link); CDEBUG(D_QUOTA, "%s: skipping deferred update ver:" - LPU64"/"LPU64", global:%d, qid:"LPU64"\n", + "%llu/%llu, global:%d, qid:%llu\n", qqi->qqi_qsd->qsd_svname, upd->qur_ver, ver, upd->qur_global, upd->qur_qid.qid_uid); qsd_upd_free(upd); @@ -146,15 +164,15 @@ static void qsd_kickoff_deferred(struct qsd_qtype_info *qqi, cfs_list_t *list, } /* No remaining deferred update */ - if (cfs_list_empty(list)) + if (list_empty(list)) RETURN_EXIT; CDEBUG(D_QUOTA, "%s: found deferred update record. " - "version:"LPU64"/"LPU64", global:%d, qid:"LPU64"\n", + "version:%llu/%llu, global:%d, qid:%llu\n", qqi->qqi_qsd->qsd_svname, upd->qur_ver, ver, upd->qur_global, upd->qur_qid.qid_uid); - LASSERTF(upd->qur_ver > ver, "lur_ver:"LPU64", cur_ver:"LPU64"\n", + LASSERTF(upd->qur_ver > ver, "lur_ver:%llu, cur_ver:%llu\n", upd->qur_ver, ver); /* Kick off the deferred udpate */ @@ -173,20 +191,20 @@ static void qsd_kickoff_deferred(struct qsd_qtype_info *qqi, cfs_list_t *list, */ void qsd_bump_version(struct qsd_qtype_info *qqi, __u64 ver, bool global) { - cfs_list_t *list; - __u64 *idx_ver; + struct list_head *list; + __u64 *idx_ver; idx_ver = global ? &qqi->qqi_glb_ver : &qqi->qqi_slv_ver; list = global ? &qqi->qqi_deferred_glb : &qqi->qqi_deferred_slv; - cfs_write_lock(&qqi->qqi_qsd->qsd_lock); + write_lock(&qqi->qqi_qsd->qsd_lock); *idx_ver = ver; if (global) qqi->qqi_glb_uptodate = 1; else qqi->qqi_slv_uptodate = 1; qsd_kickoff_deferred(qqi, list, ver); - cfs_write_unlock(&qqi->qqi_qsd->qsd_lock); + write_unlock(&qqi->qqi_qsd->qsd_lock); } /* @@ -197,7 +215,7 @@ void qsd_bump_version(struct qsd_qtype_info *qqi, __u64 ver, bool global) * \param qid - quota id * \param rec - global or slave record to be updated to disk * \param ver - new index file version - * \param global- ture : master record; false : slave record + * \param global- true: master record; false: slave record */ void qsd_upd_schedule(struct qsd_qtype_info *qqi, struct lquota_entry *lqe, union lquota_id *qid, union lquota_rec *rec, __u64 ver, @@ -208,7 +226,7 @@ void qsd_upd_schedule(struct qsd_qtype_info *qqi, struct lquota_entry *lqe, __u64 cur_ver; ENTRY; - CDEBUG(D_QUOTA, "%s: schedule update. global:%s, version:"LPU64"\n", + CDEBUG(D_QUOTA, "%s: schedule update. global:%s, version:%llu\n", qsd->qsd_svname, global ? "true" : "false", ver); upd = qsd_upd_alloc(qqi, lqe, qid, rec, ver, global); @@ -218,13 +236,13 @@ void qsd_upd_schedule(struct qsd_qtype_info *qqi, struct lquota_entry *lqe, /* If we don't want update index version, no need to sort the * records in version order, just schedule the updates instantly. */ if (ver == 0) { - cfs_write_lock(&qsd->qsd_lock); + write_lock(&qsd->qsd_lock); qsd_upd_add(qsd, upd); - cfs_write_unlock(&qsd->qsd_lock); + write_unlock(&qsd->qsd_lock); RETURN_EXIT; } - cfs_write_lock(&qsd->qsd_lock); + write_lock(&qsd->qsd_lock); cur_ver = global ? qqi->qqi_glb_ver : qqi->qqi_slv_ver; @@ -233,11 +251,11 @@ void qsd_upd_schedule(struct qsd_qtype_info *qqi, struct lquota_entry *lqe, /* legitimate race between glimpse AST and * reintegration */ CDEBUG(D_QUOTA, "%s: discarding glb update from glimpse" - " ver:"LPU64" local ver:"LPU64"\n", + " ver:%llu local ver:%llu\n", qsd->qsd_svname, ver, cur_ver); else - CERROR("%s: discard slv update, ver:"LPU64" local ver:" - LPU64"\n", qsd->qsd_svname, ver, cur_ver); + CERROR("%s: discard slv update, ver:%llu local ver:" + "%llu\n", qsd->qsd_svname, ver, cur_ver); qsd_upd_free(upd); } else if ((ver == cur_ver + 1) && qqi->qqi_glb_uptodate && qqi->qqi_slv_uptodate) { @@ -247,12 +265,12 @@ void qsd_upd_schedule(struct qsd_qtype_info *qqi, struct lquota_entry *lqe, /* Out of order update (the one with smaller version hasn't * reached slave or hasn't been flushed to disk yet), or * the reintegration is in progress. Defer the update. */ - cfs_list_t *list = global ? &qqi->qqi_deferred_glb : - &qqi->qqi_deferred_slv; - qsd_add_deferred(list, upd); + struct list_head *list = global ? &qqi->qqi_deferred_glb : + &qqi->qqi_deferred_slv; + qsd_add_deferred(qsd, list, upd); } - cfs_write_unlock(&qsd->qsd_lock); + write_unlock(&qsd->qsd_lock); EXIT; } @@ -276,17 +294,37 @@ static int qsd_process_upd(const struct lu_env *env, struct qsd_upd_rec *upd) rc = qsd_update_lqe(env, lqe, upd->qur_global, &upd->qur_rec); if (rc) GOTO(out, rc); + /* refresh usage */ + qsd_refresh_usage(env, lqe); + + spin_lock(&qqi->qqi_qsd->qsd_adjust_lock); + lqe->lqe_adjust_time = 0; + spin_unlock(&qqi->qqi_qsd->qsd_adjust_lock); + /* Report usage asynchronously */ - if (lqe->lqe_enforced && - !qsd_refresh_usage(env, lqe)) { - rc = qsd_dqacq(env, lqe, QSD_REP); - LQUOTA_DEBUG(lqe, "Report usage. rc:%d", rc); - } + rc = qsd_adjust(env, lqe); + if (rc) + LQUOTA_ERROR(lqe, "failed to report usage, rc:%d", rc); } rc = qsd_update_index(env, qqi, &upd->qur_qid, upd->qur_global, upd->qur_ver, &upd->qur_rec); out: + if (upd->qur_global && rc == 0 && + upd->qur_rec.lqr_glb_rec.qbr_softlimit == 0 && + upd->qur_rec.lqr_glb_rec.qbr_hardlimit == 0 && + (LQUOTA_FLAG(upd->qur_rec.lqr_glb_rec.qbr_time) & + LQUOTA_FLAG_DEFAULT)) { + lqe->lqe_is_default = true; + if (qqi->qqi_default_softlimit == 0 && + qqi->qqi_default_hardlimit == 0) + lqe->lqe_enforced = false; + else + lqe->lqe_enforced = true; + + LQUOTA_DEBUG(lqe, "update to use default quota"); + } + if (lqe && !IS_ERR(lqe)) { lqe_putref(lqe); upd->qur_lqe = NULL; @@ -299,79 +337,95 @@ void qsd_adjust_schedule(struct lquota_entry *lqe, bool defer, bool cancel) struct qsd_instance *qsd = lqe2qqi(lqe)->qqi_qsd; bool added = false; + read_lock(&qsd->qsd_lock); + if (qsd->qsd_stopping) { + read_unlock(&qsd->qsd_lock); + return; + } + read_unlock(&qsd->qsd_lock); + lqe_getref(lqe); - cfs_spin_lock(&qsd->qsd_adjust_lock); + spin_lock(&qsd->qsd_adjust_lock); /* the lqe is being queued for the per-ID lock cancel, we should * cancel the lock cancel and re-add it for quota adjust */ - if (!cfs_list_empty(&lqe->lqe_link) && + if (!list_empty(&lqe->lqe_link) && lqe->lqe_adjust_time == 0) { - cfs_list_del_init(&lqe->lqe_link); + list_del_init(&lqe->lqe_link); lqe_putref(lqe); } - if (cfs_list_empty(&lqe->lqe_link)) { - if (cancel) + if (list_empty(&lqe->lqe_link)) { + if (!cancel) { + lqe->lqe_adjust_time = ktime_get_seconds(); + if (defer) + lqe->lqe_adjust_time += QSD_WB_INTERVAL; + } else { lqe->lqe_adjust_time = 0; - else - lqe->lqe_adjust_time = defer ? - cfs_time_shift_64(QSD_WB_INTERVAL) : - cfs_time_current_64(); - /* lqe reference transfered to list */ + } + + /* lqe reference transferred to list */ if (defer) - cfs_list_add_tail(&lqe->lqe_link, + list_add_tail(&lqe->lqe_link, &qsd->qsd_adjust_list); else - cfs_list_add(&lqe->lqe_link, &qsd->qsd_adjust_list); + list_add(&lqe->lqe_link, &qsd->qsd_adjust_list); added = true; } - cfs_spin_unlock(&qsd->qsd_adjust_lock); + spin_unlock(&qsd->qsd_adjust_lock); if (added) - cfs_waitq_signal(&qsd->qsd_upd_thread.t_ctl_waitq); + wake_up(&qsd->qsd_upd_thread.t_ctl_waitq); else lqe_putref(lqe); } /* return true if there is pending writeback records or the pending * adjust requests */ -static bool qsd_job_pending(struct qsd_instance *qsd, cfs_list_t *upd, +static bool qsd_job_pending(struct qsd_instance *qsd, struct list_head *upd, bool *uptodate) { bool job_pending = false; int qtype; - LASSERT(cfs_list_empty(upd)); + LASSERT(list_empty(upd)); *uptodate = true; - cfs_spin_lock(&qsd->qsd_adjust_lock); - if (!cfs_list_empty(&qsd->qsd_adjust_list)) { + spin_lock(&qsd->qsd_adjust_lock); + if (!list_empty(&qsd->qsd_adjust_list)) { struct lquota_entry *lqe; - lqe = cfs_list_entry(qsd->qsd_adjust_list.next, + lqe = list_entry(qsd->qsd_adjust_list.next, struct lquota_entry, lqe_link); - if (cfs_time_beforeq_64(lqe->lqe_adjust_time, - cfs_time_current_64())) + if (ktime_get_seconds() >= lqe->lqe_adjust_time) job_pending = true; } - cfs_spin_unlock(&qsd->qsd_adjust_lock); + spin_unlock(&qsd->qsd_adjust_lock); - cfs_write_lock(&qsd->qsd_lock); - if (!cfs_list_empty(&qsd->qsd_upd_list)) { - cfs_list_splice_init(&qsd->qsd_upd_list, upd); + write_lock(&qsd->qsd_lock); + if (!list_empty(&qsd->qsd_upd_list)) { + list_splice_init(&qsd->qsd_upd_list, upd); job_pending = true; } - for (qtype = USRQUOTA; qtype < MAXQUOTAS; qtype++) { + for (qtype = USRQUOTA; qtype < LL_MAXQUOTAS; qtype++) { struct qsd_qtype_info *qqi = qsd->qsd_type_array[qtype]; + /* don't bother kicking off reintegration if space accounting + * failed to be enabled */ + if (qqi->qqi_acct_failed) + continue; + if (!qsd_type_enabled(qsd, qtype)) continue; - if (!qqi->qqi_glb_uptodate || !qqi->qqi_slv_uptodate) + if ((!qqi->qqi_glb_uptodate || !qqi->qqi_slv_uptodate) && + !qqi->qqi_reint) + /* global or slave index not up to date and reint + * thread not running */ *uptodate = false; } - cfs_write_unlock(&qsd->qsd_lock); + write_unlock(&qsd->qsd_lock); return job_pending; } @@ -379,15 +433,13 @@ static int qsd_upd_thread(void *arg) { struct qsd_instance *qsd = (struct qsd_instance *)arg; struct ptlrpc_thread *thread = &qsd->qsd_upd_thread; - struct l_wait_info lwi; - cfs_list_t queue; + struct list_head queue; struct qsd_upd_rec *upd, *n; - char pname[MTI_NAME_MAXLEN]; struct lu_env *env; int qtype, rc = 0; bool uptodate; - struct lquota_entry *lqe, *tmp; - __u64 cur_time; + struct lquota_entry *lqe; + time64_t cur_time; ENTRY; OBD_ALLOC_PTR(env); @@ -396,54 +448,52 @@ static int qsd_upd_thread(void *arg) rc = lu_env_init(env, LCT_DT_THREAD); if (rc) { - CERROR("%s: Fail to init env.", qsd->qsd_svname); + CERROR("%s: cannot init env: rc = %d\n", qsd->qsd_svname, rc); OBD_FREE_PTR(env); RETURN(rc); } - snprintf(pname, MTI_NAME_MAXLEN, "lquota_wb_%s", qsd->qsd_svname); - cfs_daemonize(pname); - thread_set_flags(thread, SVC_RUNNING); - cfs_waitq_signal(&thread->t_ctl_waitq); + wake_up(&thread->t_ctl_waitq); - CFS_INIT_LIST_HEAD(&queue); - lwi = LWI_TIMEOUT(cfs_time_seconds(QSD_WB_INTERVAL), NULL, NULL); + INIT_LIST_HEAD(&queue); while (1) { - l_wait_event(thread->t_ctl_waitq, - qsd_job_pending(qsd, &queue, &uptodate) || - !thread_is_running(thread), &lwi); + wait_event_idle_timeout( + thread->t_ctl_waitq, + qsd_job_pending(qsd, &queue, &uptodate) || + !thread_is_running(thread), + cfs_time_seconds(QSD_WB_INTERVAL)); - cfs_list_for_each_entry_safe(upd, n, &queue, qur_link) { - cfs_list_del_init(&upd->qur_link); + list_for_each_entry_safe(upd, n, &queue, qur_link) { + list_del_init(&upd->qur_link); qsd_process_upd(env, upd); qsd_upd_free(upd); } - cfs_spin_lock(&qsd->qsd_adjust_lock); - cur_time = cfs_time_current_64(); - cfs_list_for_each_entry_safe(lqe, tmp, &qsd->qsd_adjust_list, - lqe_link) { + spin_lock(&qsd->qsd_adjust_lock); + cur_time = ktime_get_seconds(); + while (!list_empty(&qsd->qsd_adjust_list)) { + lqe = list_entry(qsd->qsd_adjust_list.next, + struct lquota_entry, lqe_link); /* deferred items are sorted by time */ - if (!cfs_time_beforeq_64(lqe->lqe_adjust_time, - cur_time)) + if (lqe->lqe_adjust_time > cur_time) break; - cfs_list_del_init(&lqe->lqe_link); - cfs_spin_unlock(&qsd->qsd_adjust_lock); + list_del_init(&lqe->lqe_link); + spin_unlock(&qsd->qsd_adjust_lock); if (thread_is_running(thread) && uptodate) { qsd_refresh_usage(env, lqe); if (lqe->lqe_adjust_time == 0) qsd_id_lock_cancel(env, lqe); else - qsd_dqacq(env, lqe, QSD_ADJ); + qsd_adjust(env, lqe); } lqe_putref(lqe); - cfs_spin_lock(&qsd->qsd_adjust_lock); + spin_lock(&qsd->qsd_adjust_lock); } - cfs_spin_unlock(&qsd->qsd_adjust_lock); + spin_unlock(&qsd->qsd_adjust_lock); if (!thread_is_running(thread)) break; @@ -451,33 +501,33 @@ static int qsd_upd_thread(void *arg) if (uptodate) continue; - for (qtype = USRQUOTA; qtype < MAXQUOTAS; qtype++) + for (qtype = USRQUOTA; qtype < LL_MAXQUOTAS; qtype++) qsd_start_reint_thread(qsd->qsd_type_array[qtype]); } lu_env_fini(env); OBD_FREE_PTR(env); thread_set_flags(thread, SVC_STOPPED); - cfs_waitq_signal(&thread->t_ctl_waitq); + wake_up(&thread->t_ctl_waitq); RETURN(rc); } int qsd_start_upd_thread(struct qsd_instance *qsd) { struct ptlrpc_thread *thread = &qsd->qsd_upd_thread; - struct l_wait_info lwi = { 0 }; - int rc; + struct task_struct *task; ENTRY; - rc = cfs_create_thread(qsd_upd_thread, (void *)qsd, 0); - if (rc < 0) { - CERROR("Fail to start quota update thread. rc: %d\n", rc); + task = kthread_run(qsd_upd_thread, (void *)qsd, + "lquota_wb_%s", qsd->qsd_svname); + if (IS_ERR(task)) { + CERROR("fail to start quota update thread: rc = %ld\n", + PTR_ERR(task)); thread_set_flags(thread, SVC_STOPPED); - RETURN(rc); + RETURN(PTR_ERR(task)); } - l_wait_event(thread->t_ctl_waitq, - thread_is_running(thread) || thread_is_stopped(thread), - &lwi); + wait_event_idle(thread->t_ctl_waitq, + thread_is_running(thread) || thread_is_stopped(thread)); RETURN(0); } @@ -485,33 +535,33 @@ static void qsd_cleanup_deferred(struct qsd_instance *qsd) { int qtype; - for (qtype = USRQUOTA; qtype < MAXQUOTAS; qtype++) { + for (qtype = USRQUOTA; qtype < LL_MAXQUOTAS; qtype++) { struct qsd_upd_rec *upd, *tmp; struct qsd_qtype_info *qqi = qsd->qsd_type_array[qtype]; if (qqi == NULL) continue; - cfs_write_lock(&qsd->qsd_lock); - cfs_list_for_each_entry_safe(upd, tmp, &qqi->qqi_deferred_glb, - qur_link) { - CWARN("%s: Free global deferred upd: ID:"LPU64", " - "ver:"LPU64"/"LPU64"\n", qsd->qsd_svname, + write_lock(&qsd->qsd_lock); + list_for_each_entry_safe(upd, tmp, &qqi->qqi_deferred_glb, + qur_link) { + CWARN("%s: Free global deferred upd: ID:%llu, " + "ver:%llu/%llu\n", qsd->qsd_svname, upd->qur_qid.qid_uid, upd->qur_ver, qqi->qqi_glb_ver); list_del_init(&upd->qur_link); qsd_upd_free(upd); } - cfs_list_for_each_entry_safe(upd, tmp, &qqi->qqi_deferred_slv, - qur_link) { - CWARN("%s: Free slave deferred upd: ID:"LPU64", " - "ver:"LPU64"/"LPU64"\n", qsd->qsd_svname, + list_for_each_entry_safe(upd, tmp, &qqi->qqi_deferred_slv, + qur_link) { + CWARN("%s: Free slave deferred upd: ID:%llu, " + "ver:%llu/%llu\n", qsd->qsd_svname, upd->qur_qid.qid_uid, upd->qur_ver, qqi->qqi_slv_ver); list_del_init(&upd->qur_link); qsd_upd_free(upd); } - cfs_write_unlock(&qsd->qsd_lock); + write_unlock(&qsd->qsd_lock); } } @@ -519,27 +569,25 @@ static void qsd_cleanup_adjust(struct qsd_instance *qsd) { struct lquota_entry *lqe; - cfs_spin_lock(&qsd->qsd_adjust_lock); - while (!cfs_list_empty(&qsd->qsd_adjust_list)) { - lqe = cfs_list_entry(qsd->qsd_adjust_list.next, - struct lquota_entry, lqe_link); - cfs_list_del_init(&lqe->lqe_link); + spin_lock(&qsd->qsd_adjust_lock); + while (!list_empty(&qsd->qsd_adjust_list)) { + lqe = list_entry(qsd->qsd_adjust_list.next, + struct lquota_entry, lqe_link); + list_del_init(&lqe->lqe_link); lqe_putref(lqe); } - cfs_spin_unlock(&qsd->qsd_adjust_lock); + spin_unlock(&qsd->qsd_adjust_lock); } void qsd_stop_upd_thread(struct qsd_instance *qsd) { struct ptlrpc_thread *thread = &qsd->qsd_upd_thread; - struct l_wait_info lwi = { 0 }; if (!thread_is_stopped(thread)) { thread_set_flags(thread, SVC_STOPPING); - cfs_waitq_signal(&thread->t_ctl_waitq); + wake_up(&thread->t_ctl_waitq); - l_wait_event(thread->t_ctl_waitq, thread_is_stopped(thread), - &lwi); + wait_event_idle(thread->t_ctl_waitq, thread_is_stopped(thread)); } qsd_cleanup_deferred(qsd); qsd_cleanup_adjust(qsd);