* GPL HEADER END
*/
/*
- * Copyright (c) 2011 Intel Corporation
+ * Copyright (c) 2011, 2014, Intel Corporation.
*
* Copyright 2012 Xyratex Technology Limited
*/
*/
#define DEBUG_SUBSYSTEM S_RPC
-#ifndef __KERNEL__
-#include <liblustre.h>
-#endif
#include <obd_support.h>
#include <obd_class.h>
#include <lustre_net.h>
#include <libcfs/libcfs.h>
#include "ptlrpc_internal.h"
-extern struct list_head ptlrpc_all_services;
-
/**
* NRS core object.
*/
spin_lock(&nrs->nrs_lock);
}
- LASSERT(cfs_list_empty(&policy->pol_list_queued));
+ LASSERT(list_empty(&policy->pol_list_queued));
LASSERT(policy->pol_req_queued == 0 &&
policy->pol_req_started == 0);
policy->pol_state = NRS_POL_STATE_STOPPED;
- if (cfs_atomic_dec_and_test(&policy->pol_desc->pd_refs))
+ if (atomic_dec_and_test(&policy->pol_desc->pd_refs))
module_put(policy->pol_desc->pd_owner);
EXIT;
* Increase the module usage count for policies registering from other
* modules.
*/
- if (cfs_atomic_inc_return(&policy->pol_desc->pd_refs) == 1 &&
+ if (atomic_inc_return(&policy->pol_desc->pd_refs) == 1 &&
!try_module_get(policy->pol_desc->pd_owner)) {
- cfs_atomic_dec(&policy->pol_desc->pd_refs);
+ atomic_dec(&policy->pol_desc->pd_refs);
CERROR("NRS: cannot get module for policy %s; is it alive?\n",
policy->pol_desc->pd_name);
RETURN(-ENODEV);
spin_lock(&nrs->nrs_lock);
if (rc != 0) {
- if (cfs_atomic_dec_and_test(&policy->pol_desc->pd_refs))
+ if (atomic_dec_and_test(&policy->pol_desc->pd_refs))
module_put(policy->pol_desc->pd_owner);
policy->pol_state = NRS_POL_STATE_STOPPED;
{
struct ptlrpc_nrs_policy *tmp;
- cfs_list_for_each_entry(tmp, &nrs->nrs_policy_list, pol_list) {
+ list_for_each_entry(tmp, &nrs->nrs_policy_list, pol_list) {
if (strncmp(tmp->pol_desc->pd_name, name,
NRS_POL_NAME_MAX) == 0) {
nrs_policy_get_locked(tmp);
LASSERT(policy->pol_state == NRS_POL_STATE_STOPPED);
}
- cfs_list_del(&policy->pol_list);
+ list_del(&policy->pol_list);
nrs->nrs_num_pols--;
nrs_policy_put_locked(policy);
policy->pol_state = NRS_POL_STATE_STOPPED;
policy->pol_flags = desc->pd_flags;
- CFS_INIT_LIST_HEAD(&policy->pol_list);
- CFS_INIT_LIST_HEAD(&policy->pol_list_queued);
+ INIT_LIST_HEAD(&policy->pol_list);
+ INIT_LIST_HEAD(&policy->pol_list_queued);
rc = nrs_policy_init(policy);
if (rc != 0) {
RETURN(-EEXIST);
}
- cfs_list_add_tail(&policy->pol_list, &nrs->nrs_policy_list);
+ list_add_tail(&policy->pol_list, &nrs->nrs_policy_list);
nrs->nrs_num_pols++;
if (policy->pol_flags & PTLRPC_NRS_FL_REG_START)
* Add the policy to the NRS head's list of policies with enqueued
* requests, if it has not been added there.
*/
- if (unlikely(cfs_list_empty(&policy->pol_list_queued)))
- cfs_list_add_tail(&policy->pol_list_queued,
+ if (unlikely(list_empty(&policy->pol_list_queued)))
+ list_add_tail(&policy->pol_list_queued,
&policy->pol_nrs->nrs_policy_queued);
}
LASSERT(mutex_is_locked(&nrs_core.nrs_mutex));
- cfs_list_for_each_entry(desc, &nrs_core.nrs_policies, pd_list) {
+ list_for_each_entry(desc, &nrs_core.nrs_policies, pd_list) {
if (nrs_policy_compatible(svc, desc)) {
rc = nrs_policy_register(nrs, desc);
if (rc != 0) {
nrs->nrs_svcpt = svcpt;
nrs->nrs_queue_type = queue;
spin_lock_init(&nrs->nrs_lock);
- CFS_INIT_LIST_HEAD(&nrs->nrs_policy_list);
- CFS_INIT_LIST_HEAD(&nrs->nrs_policy_queued);
+ INIT_LIST_HEAD(&nrs->nrs_policy_list);
+ INIT_LIST_HEAD(&nrs->nrs_policy_queued);
nrs->nrs_throttling = 0;
rc = nrs_register_policies_locked(nrs);
}
nrs->nrs_stopping = 1;
- cfs_list_for_each_entry_safe(policy, tmp, &nrs->nrs_policy_list,
+ list_for_each_entry_safe(policy, tmp, &nrs->nrs_policy_list,
pol_list) {
rc = nrs_policy_unregister(nrs, policy->pol_desc->pd_name);
LASSERT(rc == 0);
struct ptlrpc_nrs_pol_desc *tmp;
ENTRY;
- cfs_list_for_each_entry(tmp, &nrs_core.nrs_policies, pd_list) {
+ list_for_each_entry(tmp, &nrs_core.nrs_policies, pd_list) {
if (strncmp(tmp->pd_name, name, NRS_POL_NAME_MAX) == 0)
RETURN(tmp);
}
LASSERT(mutex_is_locked(&nrs_core.nrs_mutex));
LASSERT(mutex_is_locked(&ptlrpc_all_services_mutex));
- cfs_list_for_each_entry(svc, &ptlrpc_all_services, srv_list) {
+ list_for_each_entry(svc, &ptlrpc_all_services, srv_list) {
if (!nrs_policy_compatible(svc, desc) ||
unlikely(svc->srv_is_stopping))
if ((conf->nc_flags & PTLRPC_NRS_FL_REG_EXTERN) != 0)
desc->pd_owner = conf->nc_owner;
desc->pd_flags = conf->nc_flags;
- cfs_atomic_set(&desc->pd_refs, 0);
+ atomic_set(&desc->pd_refs, 0);
/**
* For policies that are held in the same module as NRS (currently
*/
mutex_lock(&ptlrpc_all_services_mutex);
- cfs_list_for_each_entry(svc, &ptlrpc_all_services, srv_list) {
+ list_for_each_entry(svc, &ptlrpc_all_services, srv_list) {
struct ptlrpc_service_part *svcpt;
int i;
int rc2;
mutex_unlock(&ptlrpc_all_services_mutex);
internal:
- cfs_list_add_tail(&desc->pd_list, &nrs_core.nrs_policies);
+ list_add_tail(&desc->pd_list, &nrs_core.nrs_policies);
fail:
mutex_unlock(&nrs_core.nrs_mutex);
CDEBUG(D_INFO, "Unregistering policy %s from NRS core.\n",
conf->nc_name);
- cfs_list_del(&desc->pd_list);
+ list_del(&desc->pd_list);
OBD_FREE_PTR(desc);
fail:
* Set up lprocfs interfaces for all supported policies for the
* service.
*/
- cfs_list_for_each_entry(desc, &nrs_core.nrs_policies, pd_list) {
+ list_for_each_entry(desc, &nrs_core.nrs_policies, pd_list) {
if (!nrs_policy_compatible(svc, desc))
continue;
* Clean up lprocfs interfaces for all supported policies for the
* service.
*/
- cfs_list_for_each_entry(desc, &nrs_core.nrs_policies, pd_list) {
+ list_for_each_entry(desc, &nrs_core.nrs_policies, pd_list) {
if (!nrs_policy_compatible(svc, desc))
continue;
* ptlrpc_nrs::nrs_policy_queued.
*/
if (unlikely(policy->pol_req_queued == 0)) {
- cfs_list_del_init(&policy->pol_list_queued);
+ list_del_init(&policy->pol_list_queued);
/**
* If there are other policies with queued requests, move the
LASSERT(policy->pol_req_queued <
policy->pol_nrs->nrs_req_queued);
- cfs_list_move_tail(&policy->pol_list_queued,
+ list_move_tail(&policy->pol_list_queued,
&policy->pol_nrs->nrs_policy_queued);
}
}
* Always try to drain requests from all NRS polices even if they are
* inactive, because the user can change policy status at runtime.
*/
- cfs_list_for_each_entry(policy, &nrs->nrs_policy_queued,
+ list_for_each_entry(policy, &nrs->nrs_policy_queued,
pol_list_queued) {
nrq = nrs_request_get(policy, peek, force);
if (nrq != NULL) {
RETURN(rc);
}
-
-/* ptlrpc/nrs_fifo.c */
-extern struct ptlrpc_nrs_pol_conf nrs_conf_fifo;
-#if defined HAVE_SERVER_SUPPORT && defined(__KERNEL__)
-/* ptlrpc/nrs_crr.c */
-extern struct ptlrpc_nrs_pol_conf nrs_conf_crrn;
-/* ptlrpc/nrs_orr.c */
-extern struct ptlrpc_nrs_pol_conf nrs_conf_orr;
-extern struct ptlrpc_nrs_pol_conf nrs_conf_trr;
-extern struct ptlrpc_nrs_pol_conf nrs_conf_tbf;
-#endif
-
/**
* Adds all policies that ship with the ptlrpc module, to NRS core's list of
* policies \e nrs_core.nrs_policies.
ENTRY;
mutex_init(&nrs_core.nrs_mutex);
- CFS_INIT_LIST_HEAD(&nrs_core.nrs_policies);
+ INIT_LIST_HEAD(&nrs_core.nrs_policies);
rc = ptlrpc_nrs_policy_register(&nrs_conf_fifo);
if (rc != 0)
GOTO(fail, rc);
-#if defined HAVE_SERVER_SUPPORT && defined(__KERNEL__)
+#ifdef HAVE_SERVER_SUPPORT
rc = ptlrpc_nrs_policy_register(&nrs_conf_crrn);
if (rc != 0)
GOTO(fail, rc);
rc = ptlrpc_nrs_policy_register(&nrs_conf_tbf);
if (rc != 0)
GOTO(fail, rc);
-#endif
+#endif /* HAVE_SERVER_SUPPORT */
RETURN(rc);
fail:
}
/**
- * Removes all policy desciptors from nrs_core::nrs_policies, and frees the
+ * Removes all policy descriptors from nrs_core::nrs_policies, and frees the
* policy descriptors.
*
* Since all PTLRPC services are stopped at this point, there are no more
struct ptlrpc_nrs_pol_desc *desc;
struct ptlrpc_nrs_pol_desc *tmp;
- cfs_list_for_each_entry_safe(desc, tmp, &nrs_core.nrs_policies,
+ list_for_each_entry_safe(desc, tmp, &nrs_core.nrs_policies,
pd_list) {
- cfs_list_del_init(&desc->pd_list);
+ list_del_init(&desc->pd_list);
OBD_FREE_PTR(desc);
}
}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff