* GPL HEADER END
*/
/*
- * Copyright (c) 2012 Intel, Inc.
+ * Copyright (c) 2012, 2014, Intel Corporation.
* Use is subject to license terms.
*
* Author: Johann Lombardi <johann.lombardi@intel.com>
* Author: Niu Yawei <yawei.niu@intel.com>
*/
-#ifndef EXPORT_SYMTAB
-# define EXPORT_SYMTAB
-#endif
-
#define DEBUG_SUBSYSTEM S_LQUOTA
+#include <linux/kthread.h>
+
#include <lustre_dlm.h>
+#include <lustre_swab.h>
#include <obd_class.h>
#include "qmt_internal.h"
struct obd_uuid *uuid;
struct lquota_lvb *lvb;
struct ldlm_resource *res = (*lockp)->l_resource;
- int rc;
+ struct ldlm_reply *ldlm_rep;
+ int rc, lvb_len;
ENTRY;
req_capsule_extend(&req->rq_pill, &RQF_LDLM_INTENT_QUOTA);
if (repbody == NULL)
RETURN(err_serious(-EFAULT));
+ ldlm_rep = req_capsule_server_get(&req->rq_pill, &RMF_DLM_REP);
+ if (ldlm_rep == NULL)
+ RETURN(err_serious(-EFAULT));
+
uuid = &(*lockp)->l_export->exp_client_uuid;
switch (it->opc) {
break;
default:
- CERROR("%s: invalid intent opcode: "LPU64"\n", qmt->qmt_svname,
+ CERROR("%s: invalid intent opcode: %llu\n", qmt->qmt_svname,
it->opc);
- GOTO(out, rc = err_serious(-EINVAL));
+ GOTO(out, rc = -EINVAL);
}
/* on success, pack lvb in reply */
lvb = req_capsule_server_get(&req->rq_pill, &RMF_DLM_LVB);
- ldlm_lvbo_fill(*lockp, lvb, ldlm_lvbo_size(*lockp));
- EXIT;
+ lvb_len = ldlm_lvbo_size(*lockp);
+ lvb_len = ldlm_lvbo_fill(*lockp, lvb, lvb_len);
+ if (lvb_len < 0)
+ GOTO(out, rc = lvb_len);
+
+ req_capsule_shrink(&req->rq_pill, &RMF_DLM_LVB, lvb_len, RCL_SERVER);
out:
- return rc;
+ ldlm_rep->lock_policy_res2 = clear_serious(rc);
+ EXIT;
+ return ELDLM_OK;
}
/*
/* initialize environment */
rc = lu_env_init(env, LCT_MD_THREAD);
- if (rc) {
- OBD_FREE_PTR(env);
- RETURN(rc);
- }
+ if (rc != 0)
+ GOTO(out_free, rc);
qti = qmt_info(env);
/* extract global index FID and quota identifier */
- fid_extract_quota_resid(&res->lr_name, &qti->qti_fid, &qti->qti_id);
+ fid_extract_from_quota_res(&qti->qti_fid, &qti->qti_id, &res->lr_name);
/* sanity check the global index FID */
rc = lquota_extract_fid(&qti->qti_fid, &pool_id, &pool_type, &qtype);
CDEBUG(D_QUOTA, DFID" initialized lvb\n", PFID(&qti->qti_fid));
}
- res->lr_lvb_len = sizeof(struct lquota_lvb);
+ res->lr_lvb_len = sizeof(struct lquota_lvb);
EXIT;
out:
lu_env_fini(env);
+out_free:
OBD_FREE_PTR(env);
return rc;
}
LASSERT(lqe != NULL);
lqe_getref(lqe);
- LQUOTA_DEBUG(lqe, "releasing:"LPU64" may release:"LPU64,
+ LQUOTA_DEBUG(lqe, "releasing:%llu may release:%llu",
lvb->lvb_id_rel, lvb->lvb_id_may_rel);
if (lvb->lvb_id_rel == 0) {
QUOTA_DQACQ_FL_REL, lvb->lvb_id_rel, 0, &qti->qti_body);
if (rc || qti->qti_body.qb_count != lvb->lvb_id_rel)
LQUOTA_ERROR(lqe, "failed to release quota space on glimpse "
- LPU64"!="LPU64" rc:%d\n", qti->qti_body.qb_count,
+ "%llu!=%llu : rc = %d\n", qti->qti_body.qb_count,
lvb->lvb_id_rel, rc);
class_export_put(exp);
if (rc)
struct ldlm_resource *res, union ldlm_gl_desc *desc,
qmt_glimpse_cb_t cb, void *arg)
{
- cfs_list_t *tmp, *pos;
- CFS_LIST_HEAD(gl_list);
+ struct list_head *tmp, *pos;
+ struct list_head gl_list = LIST_HEAD_INIT(gl_list);
int rc = 0;
ENTRY;
lock_res(res);
/* scan list of granted locks */
- cfs_list_for_each(pos, &res->lr_granted) {
+ list_for_each(pos, &res->lr_granted) {
struct ldlm_glimpse_work *work;
struct ldlm_lock *lock;
struct obd_uuid *uuid;
- lock = cfs_list_entry(pos, struct ldlm_lock, l_res_link);
+ lock = list_entry(pos, struct ldlm_lock, l_res_link);
LASSERT(lock->l_export);
uuid = &lock->l_export->exp_client_uuid;
continue;
}
- cfs_list_add_tail(&work->gl_list, &gl_list);
+ list_add_tail(&work->gl_list, &gl_list);
work->gl_lock = LDLM_LOCK_GET(lock);
work->gl_flags = 0;
work->gl_desc = desc;
}
unlock_res(res);
- if (cfs_list_empty(&gl_list)) {
+ if (list_empty(&gl_list)) {
CDEBUG(D_QUOTA, "%s: nobody to notify\n", qmt->qmt_svname);
RETURN(0);
}
/* issue glimpse callbacks to all connected slaves */
rc = ldlm_glimpse_locks(res, &gl_list);
- cfs_list_for_each_safe(pos, tmp, &gl_list) {
+ list_for_each_safe(pos, tmp, &gl_list) {
struct ldlm_glimpse_work *work;
- work = cfs_list_entry(pos, struct ldlm_glimpse_work, gl_list);
+ work = list_entry(pos, struct ldlm_glimpse_work, gl_list);
- cfs_list_del(&work->gl_list);
+ list_del(&work->gl_list);
CERROR("%s: failed to notify %s of new quota settings\n",
qmt->qmt_svname,
obd_uuid2str(&work->gl_lock->l_export->exp_client_uuid));
struct qmt_thread_info *qti = qmt_info(env);
struct qmt_pool_info *pool = lqe2qpi(lqe);
struct ldlm_resource *res = NULL;
- int rc;
ENTRY;
lquota_generate_fid(&qti->qti_fid, pool->qpi_key & 0x0000ffff,
fid_build_reg_res_name(&qti->qti_fid, &qti->qti_resid);
res = ldlm_resource_get(pool->qpi_qmt->qmt_ns, NULL, &qti->qti_resid,
LDLM_PLAIN, 0);
- if (res == NULL) {
+ if (IS_ERR(res)) {
/* this might happen if no slaves have enqueued global quota
* locks yet */
LQUOTA_DEBUG(lqe, "failed to lookup ldlm resource associated "
RETURN_EXIT;
}
- rc = qmt_glimpse_lock(env, pool->qpi_qmt, res, &qti->qti_gl_desc,
- NULL, NULL);
+ qmt_glimpse_lock(env, pool->qpi_qmt, res, &qti->qti_gl_desc,
+ NULL, NULL);
ldlm_resource_putref(res);
EXIT;
}
struct qmt_thread_info *qti = qmt_info(env);
struct qmt_pool_info *pool = lqe2qpi(lqe);
struct ldlm_resource *res = NULL;
- int rc;
ENTRY;
if (!lqe->lqe_enforced)
lquota_generate_fid(&qti->qti_fid, pool->qpi_key & 0x0000ffff,
pool->qpi_key >> 16, lqe->lqe_site->lqs_qtype);
- fid_build_quota_resid(&qti->qti_fid, &lqe->lqe_id, &qti->qti_resid);
+ fid_build_quota_res_name(&qti->qti_fid, &lqe->lqe_id, &qti->qti_resid);
res = ldlm_resource_get(qmt->qmt_ns, NULL, &qti->qti_resid, LDLM_PLAIN,
0);
- if (res == NULL) {
+ if (IS_ERR(res)) {
/* this might legitimately happens if slaves haven't had the
* opportunity to enqueue quota lock yet. */
LQUOTA_DEBUG(lqe, "failed to lookup ldlm resource for per-ID "
lqe_write_unlock(lqe);
/* issue glimpse callback to slaves */
- rc = qmt_glimpse_lock(env, qmt, res, &qti->qti_gl_desc,
- uuid ? qmt_id_lock_cb : NULL, (void *)uuid);
+ qmt_glimpse_lock(env, qmt, res, &qti->qti_gl_desc,
+ uuid ? qmt_id_lock_cb : NULL, (void *)uuid);
lqe_write_lock(lqe);
if (lqe->lqe_revoke_time == 0 &&
lqe_getref(lqe);
spin_lock(&qmt->qmt_reba_lock);
- if (!qmt->qmt_stopping && cfs_list_empty(&lqe->lqe_link)) {
- cfs_list_add_tail(&lqe->lqe_link, &qmt->qmt_reba_list);
+ if (!qmt->qmt_stopping && list_empty(&lqe->lqe_link)) {
+ list_add_tail(&lqe->lqe_link, &qmt->qmt_reba_list);
added = true;
}
spin_unlock(&qmt->qmt_reba_lock);
if (added)
- cfs_waitq_signal(&qmt->qmt_reba_thread.t_ctl_waitq);
+ wake_up(&qmt->qmt_reba_thread.t_ctl_waitq);
else
lqe_putref(lqe);
EXIT;
struct l_wait_info lwi = { 0 };
struct lu_env *env;
struct lquota_entry *lqe, *tmp;
- char pname[MTI_NAME_MAXLEN];
int rc;
ENTRY;
RETURN(rc);
}
- snprintf(pname, MTI_NAME_MAXLEN, "qmt_reba_%s", qmt->qmt_svname);
- cfs_daemonize(pname);
-
thread_set_flags(thread, SVC_RUNNING);
- cfs_waitq_signal(&thread->t_ctl_waitq);
+ wake_up(&thread->t_ctl_waitq);
while (1) {
l_wait_event(thread->t_ctl_waitq,
- !cfs_list_empty(&qmt->qmt_reba_list) ||
+ !list_empty(&qmt->qmt_reba_list) ||
!thread_is_running(thread), &lwi);
spin_lock(&qmt->qmt_reba_lock);
- cfs_list_for_each_entry_safe(lqe, tmp, &qmt->qmt_reba_list,
- lqe_link) {
- cfs_list_del_init(&lqe->lqe_link);
+ list_for_each_entry_safe(lqe, tmp, &qmt->qmt_reba_list,
+ lqe_link) {
+ list_del_init(&lqe->lqe_link);
spin_unlock(&qmt->qmt_reba_lock);
if (thread_is_running(thread))
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);
}
{
struct ptlrpc_thread *thread = &qmt->qmt_reba_thread;
struct l_wait_info lwi = { 0 };
- int rc;
+ struct task_struct *task;
ENTRY;
- rc = cfs_create_thread(qmt_reba_thread, (void *)qmt, 0);
- if (rc < 0) {
- CERROR("%s: failed to start rebalance thread (%d)\n",
- qmt->qmt_svname, rc);
+ task = kthread_run(qmt_reba_thread, (void *)qmt,
+ "qmt_reba_%s", qmt->qmt_svname);
+ if (IS_ERR(task)) {
+ CERROR("%s: failed to start rebalance thread (%ld)\n",
+ qmt->qmt_svname, PTR_ERR(task));
thread_set_flags(thread, SVC_STOPPED);
- RETURN(rc);
+ RETURN(PTR_ERR(task));
}
l_wait_event(thread->t_ctl_waitq,
struct l_wait_info lwi = { 0 };
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);
}
- LASSERT(cfs_list_empty(&qmt->qmt_reba_list));
+ LASSERT(list_empty(&qmt->qmt_reba_list));
}