#define DEBUG_SUBSYSTEM S_LDLM
-#ifdef __KERNEL__
-# include <libcfs/libcfs.h>
-#else
-# include <liblustre.h>
-#endif
+#include <libcfs/libcfs.h>
#include <obd.h>
#include <obd_class.h>
#include <lustre_dlm.h>
}
spin_lock(&imp->imp_lock);
- cfs_list_for_each_entry(item, &imp->imp_conn_list, oic_item) {
+ list_for_each_entry(item, &imp->imp_conn_list, oic_item) {
if (obd_uuid_equals(uuid, &item->oic_uuid)) {
if (priority) {
- cfs_list_del(&item->oic_item);
- cfs_list_add(&item->oic_item,
+ list_del(&item->oic_item);
+ list_add(&item->oic_item,
&imp->imp_conn_list);
item->oic_last_attempt = 0;
}
imp_conn->oic_uuid = *uuid;
imp_conn->oic_last_attempt = 0;
if (priority)
- cfs_list_add(&imp_conn->oic_item, &imp->imp_conn_list);
+ list_add(&imp_conn->oic_item, &imp->imp_conn_list);
else
- cfs_list_add_tail(&imp_conn->oic_item,
+ list_add_tail(&imp_conn->oic_item,
&imp->imp_conn_list);
CDEBUG(D_HA, "imp %p@%s: add connection %s at %s\n",
imp, imp->imp_obd->obd_name, uuid->uuid,
ENTRY;
spin_lock(&imp->imp_lock);
- if (cfs_list_empty(&imp->imp_conn_list)) {
+ if (list_empty(&imp->imp_conn_list)) {
LASSERT(!imp->imp_connection);
GOTO(out, rc);
}
- cfs_list_for_each_entry(imp_conn, &imp->imp_conn_list, oic_item) {
+ list_for_each_entry(imp_conn, &imp->imp_conn_list, oic_item) {
if (!obd_uuid_equals(uuid, &imp_conn->oic_uuid))
continue;
LASSERT(imp_conn->oic_conn);
}
}
- cfs_list_del(&imp_conn->oic_item);
+ list_del(&imp_conn->oic_item);
ptlrpc_connection_put(imp_conn->oic_conn);
OBD_FREE(imp_conn, sizeof(*imp_conn));
CDEBUG(D_HA, "imp %p@%s: remove connection %s\n",
ENTRY;
spin_lock(&imp->imp_lock);
- cfs_list_for_each_entry(conn, &imp->imp_conn_list, oic_item) {
+ list_for_each_entry(conn, &imp->imp_conn_list, oic_item) {
/* Check if conn UUID does have this peer NID. */
if (class_check_uuid(&conn->oic_uuid, peer)) {
*uuid = conn->oic_uuid;
min_t(unsigned int, LUSTRE_CFG_BUFLEN(lcfg, 2),
sizeof(server_uuid)));
- cli->cl_dirty = 0;
- cli->cl_avail_grant = 0;
- /* FIXME: Should limit this for the sum of all cl_dirty_max. */
- cli->cl_dirty_max = OSC_MAX_DIRTY_DEFAULT * 1024 * 1024;
- if (cli->cl_dirty_max >> PAGE_CACHE_SHIFT > totalram_pages / 8)
- cli->cl_dirty_max = totalram_pages << (PAGE_CACHE_SHIFT - 3);
- CFS_INIT_LIST_HEAD(&cli->cl_cache_waiters);
- CFS_INIT_LIST_HEAD(&cli->cl_loi_ready_list);
- CFS_INIT_LIST_HEAD(&cli->cl_loi_hp_ready_list);
- CFS_INIT_LIST_HEAD(&cli->cl_loi_write_list);
- CFS_INIT_LIST_HEAD(&cli->cl_loi_read_list);
+ cli->cl_dirty_pages = 0;
+ cli->cl_avail_grant = 0;
+ /* FIXME: Should limit this for the sum of all cl_dirty_max_pages. */
+ /* cl_dirty_max_pages may be changed at connect time in
+ * ptlrpc_connect_interpret(). */
+ client_adjust_max_dirty(cli);
+ INIT_LIST_HEAD(&cli->cl_cache_waiters);
+ INIT_LIST_HEAD(&cli->cl_loi_ready_list);
+ INIT_LIST_HEAD(&cli->cl_loi_hp_ready_list);
+ INIT_LIST_HEAD(&cli->cl_loi_write_list);
+ INIT_LIST_HEAD(&cli->cl_loi_read_list);
client_obd_list_lock_init(&cli->cl_loi_list_lock);
atomic_set(&cli->cl_pending_w_pages, 0);
atomic_set(&cli->cl_pending_r_pages, 0);
spin_lock_init(&cli->cl_write_offset_hist.oh_lock);
/* lru for osc. */
- CFS_INIT_LIST_HEAD(&cli->cl_lru_osc);
+ INIT_LIST_HEAD(&cli->cl_lru_osc);
atomic_set(&cli->cl_lru_shrinkers, 0);
atomic_set(&cli->cl_lru_busy, 0);
atomic_set(&cli->cl_lru_in_list, 0);
- CFS_INIT_LIST_HEAD(&cli->cl_lru_list);
+ INIT_LIST_HEAD(&cli->cl_lru_list);
client_obd_list_lock_init(&cli->cl_lru_list_lock);
atomic_set(&cli->cl_unstable_count, 0);
cli->cl_chunkbits = PAGE_CACHE_SHIFT;
if (!strcmp(name, LUSTRE_MDC_NAME)) {
- cli->cl_max_rpcs_in_flight = MDC_MAX_RIF_DEFAULT;
+ cli->cl_max_rpcs_in_flight = OBD_MAX_RIF_DEFAULT;
} else if (totalram_pages >> (20 - PAGE_CACHE_SHIFT) <= 128 /* MB */) {
cli->cl_max_rpcs_in_flight = 2;
} else if (totalram_pages >> (20 - PAGE_CACHE_SHIFT) <= 256 /* MB */) {
cli->cl_max_rpcs_in_flight = 4;
} else {
if (osc_on_mdt(obddev->obd_name))
- cli->cl_max_rpcs_in_flight = MDS_OSC_MAX_RIF_DEFAULT;
+ cli->cl_max_rpcs_in_flight = OBD_MAX_RIF_MAX;
else
- cli->cl_max_rpcs_in_flight = OSC_MAX_RIF_DEFAULT;
+ cli->cl_max_rpcs_in_flight = OBD_MAX_RIF_DEFAULT;
}
rc = ldlm_get_ref();
if (rc) {
/* complete all outstanding replies */
spin_lock(&exp->exp_lock);
- while (!cfs_list_empty(&exp->exp_outstanding_replies)) {
+ while (!list_empty(&exp->exp_outstanding_replies)) {
struct ptlrpc_reply_state *rs =
- cfs_list_entry(exp->exp_outstanding_replies.next,
+ list_entry(exp->exp_outstanding_replies.next,
struct ptlrpc_reply_state, rs_exp_list);
struct ptlrpc_service_part *svcpt = rs->rs_svcpt;
spin_lock(&svcpt->scp_rep_lock);
- cfs_list_del_init(&rs->rs_exp_list);
+ list_del_init(&rs->rs_exp_list);
spin_lock(&rs->rs_lock);
ptlrpc_schedule_difficult_reply(rs);
spin_unlock(&rs->rs_lock);
}
EXPORT_SYMBOL(target_client_add_cb);
-#ifdef __KERNEL__
static void
check_and_start_recovery_timer(struct obd_device *obd,
struct ptlrpc_request *req, int new_client);
-#else
-static inline void
-check_and_start_recovery_timer(struct obd_device *obd,
- struct ptlrpc_request *req, int new_client)
-{
-}
-#endif
int target_handle_connect(struct ptlrpc_request *req)
{
}
}
- if ((lustre_msg_get_op_flags(req->rq_reqmsg) & MSG_CONNECT_INITIAL) &&
- (data->ocd_connect_flags & OBD_CONNECT_MDS))
- mds_conn = true;
-
- if ((data->ocd_connect_flags & OBD_CONNECT_LIGHTWEIGHT) != 0)
- lw_client = true;
+ if (lustre_msg_get_op_flags(req->rq_reqmsg) & MSG_CONNECT_INITIAL) {
+ mds_conn = (data->ocd_connect_flags & OBD_CONNECT_MDS) != 0;
+ lw_client = (data->ocd_connect_flags &
+ OBD_CONNECT_LIGHTWEIGHT) != 0;
+ }
/* lctl gets a backstage, all-access pass. */
if (obd_uuid_equals(&cluuid, &target->obd_uuid))
class_export_put(export);
export = NULL;
rc = -EALREADY;
- } else if (mds_conn && export->exp_connection) {
+ } else if ((mds_conn || lw_client) && export->exp_connection != NULL) {
spin_unlock(&export->exp_lock);
- if (req->rq_peer.nid != export->exp_connection->c_peer.nid)
- /* MDS reconnected after failover. */
- LCONSOLE_WARN("%s: Received MDS connection from "
+ if (req->rq_peer.nid != export->exp_connection->c_peer.nid)
+ /* MDS or LWP reconnected after failover. */
+ LCONSOLE_WARN("%s: Received %s connection from "
"%s, removing former export from %s\n",
- target->obd_name, libcfs_nid2str(req->rq_peer.nid),
+ target->obd_name, mds_conn ? "MDS" : "LWP",
+ libcfs_nid2str(req->rq_peer.nid),
libcfs_nid2str(export->exp_connection->c_peer.nid));
else
/* New MDS connection from the same NID. */
- LCONSOLE_WARN("%s: Received new MDS connection from "
- "%s, removing former export from same NID\n",
- target->obd_name, libcfs_nid2str(req->rq_peer.nid));
+ LCONSOLE_WARN("%s: Received new %s connection from "
+ "%s, removing former export from same NID\n",
+ target->obd_name, mds_conn ? "MDS" : "LWP",
+ libcfs_nid2str(req->rq_peer.nid));
class_fail_export(export);
class_export_put(export);
export = NULL;
if (rc)
GOTO(out, rc);
-#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 6, 50, 0)
+#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 6, 53, 0)
/* 2.2.0 clients always swab nidtbl entries due to a bug, so server
* will do the swabbing for if the client is using the same endianness.
*
* will never do MNE swabbing, let the client handle that. LU-1644 */
export->exp_need_mne_swab = !ptlrpc_req_need_swab(req) &&
!(data->ocd_connect_flags & OBD_CONNECT_MNE_SWAB);
-#else
-#warning "LU-1644: Remove old OBD_CONNECT_MNE_SWAB fixup and exp_need_mne_swab"
#endif
LASSERT(target->u.obt.obt_magic == OBT_MAGIC);
spin_unlock(&export->exp_lock);
spin_lock(&target->obd_dev_lock);
- cfs_list_del_init(&export->exp_obd_chain_timed);
+ list_del_init(&export->exp_obd_chain_timed);
spin_unlock(&target->obd_dev_lock);
} else {
spin_unlock(&export->exp_lock);
if (export->exp_connection != NULL) {
/* Check to see if connection came from another NID. */
if ((export->exp_connection->c_peer.nid != req->rq_peer.nid) &&
- !cfs_hlist_unhashed(&export->exp_nid_hash))
+ !hlist_unhashed(&export->exp_nid_hash))
cfs_hash_del(export->exp_obd->obd_nid_hash,
&export->exp_connection->c_peer.nid,
&export->exp_nid_hash);
export->exp_connection = ptlrpc_connection_get(req->rq_peer,
req->rq_self,
&remote_uuid);
- if (cfs_hlist_unhashed(&export->exp_nid_hash)) {
+ if (hlist_unhashed(&export->exp_nid_hash)) {
cfs_hash_add(export->exp_obd->obd_nid_hash,
&export->exp_connection->c_peer.nid,
&export->exp_nid_hash);
static void target_request_copy_get(struct ptlrpc_request *req)
{
class_export_rpc_inc(req->rq_export);
- LASSERT(cfs_list_empty(&req->rq_list));
- CFS_INIT_LIST_HEAD(&req->rq_replay_list);
+ LASSERT(list_empty(&req->rq_list));
+ INIT_LIST_HEAD(&req->rq_replay_list);
/* Increase refcount to keep request in queue. */
atomic_inc(&req->rq_refcount);
static void target_request_copy_put(struct ptlrpc_request *req)
{
- LASSERT(cfs_list_empty(&req->rq_replay_list));
+ LASSERT(list_empty(&req->rq_replay_list));
LASSERT_ATOMIC_POS(&req->rq_export->exp_replay_count);
atomic_dec(&req->rq_export->exp_replay_count);
LASSERT(exp);
spin_lock(&exp->exp_lock);
- cfs_list_for_each_entry(reqiter, &exp->exp_req_replay_queue,
+ list_for_each_entry(reqiter, &exp->exp_req_replay_queue,
rq_replay_list) {
if (lustre_msg_get_transno(reqiter->rq_reqmsg) == transno) {
dup = 1;
CERROR("invalid flags %x of resent replay\n",
lustre_msg_get_flags(req->rq_reqmsg));
} else {
- cfs_list_add_tail(&req->rq_replay_list,
+ list_add_tail(&req->rq_replay_list,
&exp->exp_req_replay_queue);
}
static void target_exp_dequeue_req_replay(struct ptlrpc_request *req)
{
- LASSERT(!cfs_list_empty(&req->rq_replay_list));
+ LASSERT(!list_empty(&req->rq_replay_list));
LASSERT(req->rq_export);
spin_lock(&req->rq_export->exp_lock);
- cfs_list_del_init(&req->rq_replay_list);
+ list_del_init(&req->rq_replay_list);
spin_unlock(&req->rq_export->exp_lock);
}
-#ifdef __KERNEL__
static void target_finish_recovery(struct obd_device *obd)
{
ENTRY;
ldlm_reprocess_all_ns(obd->obd_namespace);
spin_lock(&obd->obd_recovery_task_lock);
- if (!cfs_list_empty(&obd->obd_req_replay_queue) ||
- !cfs_list_empty(&obd->obd_lock_replay_queue) ||
- !cfs_list_empty(&obd->obd_final_req_queue)) {
+ if (!list_empty(&obd->obd_req_replay_queue) ||
+ !list_empty(&obd->obd_lock_replay_queue) ||
+ !list_empty(&obd->obd_final_req_queue)) {
CERROR("%s: Recovery queues ( %s%s%s) are not empty\n",
obd->obd_name,
- cfs_list_empty(&obd->obd_req_replay_queue) ? "" : "req ",
- cfs_list_empty(&obd->obd_lock_replay_queue) ? \
+ list_empty(&obd->obd_req_replay_queue) ? "" : "req ",
+ list_empty(&obd->obd_lock_replay_queue) ? \
"" : "lock ",
- cfs_list_empty(&obd->obd_final_req_queue) ? \
+ list_empty(&obd->obd_final_req_queue) ? \
"" : "final ");
spin_unlock(&obd->obd_recovery_task_lock);
LBUG();
static void abort_req_replay_queue(struct obd_device *obd)
{
struct ptlrpc_request *req, *n;
- cfs_list_t abort_list;
+ struct list_head abort_list;
- CFS_INIT_LIST_HEAD(&abort_list);
+ INIT_LIST_HEAD(&abort_list);
spin_lock(&obd->obd_recovery_task_lock);
- cfs_list_splice_init(&obd->obd_req_replay_queue, &abort_list);
+ list_splice_init(&obd->obd_req_replay_queue, &abort_list);
spin_unlock(&obd->obd_recovery_task_lock);
- cfs_list_for_each_entry_safe(req, n, &abort_list, rq_list) {
+ list_for_each_entry_safe(req, n, &abort_list, rq_list) {
DEBUG_REQ(D_WARNING, req, "aborted:");
req->rq_status = -ENOTCONN;
if (ptlrpc_error(req)) {
static void abort_lock_replay_queue(struct obd_device *obd)
{
struct ptlrpc_request *req, *n;
- cfs_list_t abort_list;
+ struct list_head abort_list;
- CFS_INIT_LIST_HEAD(&abort_list);
+ INIT_LIST_HEAD(&abort_list);
spin_lock(&obd->obd_recovery_task_lock);
- cfs_list_splice_init(&obd->obd_lock_replay_queue, &abort_list);
+ list_splice_init(&obd->obd_lock_replay_queue, &abort_list);
spin_unlock(&obd->obd_recovery_task_lock);
- cfs_list_for_each_entry_safe(req, n, &abort_list, rq_list){
+ list_for_each_entry_safe(req, n, &abort_list, rq_list) {
DEBUG_REQ(D_ERROR, req, "aborted:");
req->rq_status = -ENOTCONN;
if (ptlrpc_error(req)) {
void target_cleanup_recovery(struct obd_device *obd)
{
struct ptlrpc_request *req, *n;
- cfs_list_t clean_list;
+ struct list_head clean_list;
ENTRY;
- CFS_INIT_LIST_HEAD(&clean_list);
+ INIT_LIST_HEAD(&clean_list);
spin_lock(&obd->obd_dev_lock);
if (!obd->obd_recovering) {
spin_unlock(&obd->obd_dev_lock);
spin_lock(&obd->obd_recovery_task_lock);
target_cancel_recovery_timer(obd);
- cfs_list_splice_init(&obd->obd_req_replay_queue, &clean_list);
+ list_splice_init(&obd->obd_req_replay_queue, &clean_list);
spin_unlock(&obd->obd_recovery_task_lock);
- cfs_list_for_each_entry_safe(req, n, &clean_list, rq_list) {
+ list_for_each_entry_safe(req, n, &clean_list, rq_list) {
LASSERT(req->rq_reply_state == 0);
target_exp_dequeue_req_replay(req);
target_request_copy_put(req);
}
spin_lock(&obd->obd_recovery_task_lock);
- cfs_list_splice_init(&obd->obd_lock_replay_queue, &clean_list);
- cfs_list_splice_init(&obd->obd_final_req_queue, &clean_list);
+ list_splice_init(&obd->obd_lock_replay_queue, &clean_list);
+ list_splice_init(&obd->obd_final_req_queue, &clean_list);
spin_unlock(&obd->obd_recovery_task_lock);
- cfs_list_for_each_entry_safe(req, n, &clean_list, rq_list){
+ list_for_each_entry_safe(req, n, &clean_list, rq_list) {
LASSERT(req->rq_reply_state == 0);
target_request_copy_put(req);
}
ENTRY;
spin_lock(&obd->obd_recovery_task_lock);
- if (!cfs_list_empty(&obd->obd_req_replay_queue)) {
- req = cfs_list_entry(obd->obd_req_replay_queue.next,
+ if (!list_empty(&obd->obd_req_replay_queue)) {
+ req = list_entry(obd->obd_req_replay_queue.next,
struct ptlrpc_request, rq_list);
req_transno = lustre_msg_get_transno(req->rq_reqmsg);
} else {
int wake_up = 0;
spin_lock(&obd->obd_recovery_task_lock);
- if (!cfs_list_empty(&obd->obd_lock_replay_queue)) {
+ if (!list_empty(&obd->obd_lock_replay_queue)) {
CDEBUG(D_HA, "waking for next lock\n");
wake_up = 1;
} else if (atomic_read(&obd->obd_lock_replay_clients) == 0) {
}
spin_lock(&obd->obd_recovery_task_lock);
- if (!cfs_list_empty(&obd->obd_req_replay_queue)) {
- req = cfs_list_entry(obd->obd_req_replay_queue.next,
+ if (!list_empty(&obd->obd_req_replay_queue)) {
+ req = list_entry(obd->obd_req_replay_queue.next,
struct ptlrpc_request, rq_list);
- cfs_list_del_init(&req->rq_list);
+ list_del_init(&req->rq_list);
obd->obd_requests_queued_for_recovery--;
spin_unlock(&obd->obd_recovery_task_lock);
} else {
spin_unlock(&obd->obd_recovery_task_lock);
- LASSERT(cfs_list_empty(&obd->obd_req_replay_queue));
+ LASSERT(list_empty(&obd->obd_req_replay_queue));
LASSERT(atomic_read(&obd->obd_req_replay_clients) == 0);
/** evict exports failed VBR */
class_disconnect_stale_exports(obd, exp_vbr_healthy);
abort_lock_replay_queue(obd);
spin_lock(&obd->obd_recovery_task_lock);
- if (!cfs_list_empty(&obd->obd_lock_replay_queue)) {
- req = cfs_list_entry(obd->obd_lock_replay_queue.next,
+ if (!list_empty(&obd->obd_lock_replay_queue)) {
+ req = list_entry(obd->obd_lock_replay_queue.next,
struct ptlrpc_request, rq_list);
- cfs_list_del_init(&req->rq_list);
+ list_del_init(&req->rq_list);
spin_unlock(&obd->obd_recovery_task_lock);
} else {
spin_unlock(&obd->obd_recovery_task_lock);
- LASSERT(cfs_list_empty(&obd->obd_lock_replay_queue));
+ LASSERT(list_empty(&obd->obd_lock_replay_queue));
LASSERT(atomic_read(&obd->obd_lock_replay_clients) == 0);
/** evict exports failed VBR */
class_disconnect_stale_exports(obd, exp_vbr_healthy);
struct ptlrpc_request *req = NULL;
spin_lock(&obd->obd_recovery_task_lock);
- if (!cfs_list_empty(&obd->obd_final_req_queue)) {
- req = cfs_list_entry(obd->obd_final_req_queue.next,
+ if (!list_empty(&obd->obd_final_req_queue)) {
+ req = list_entry(obd->obd_final_req_queue.next,
struct ptlrpc_request, rq_list);
- cfs_list_del_init(&req->rq_list);
+ list_del_init(&req->rq_list);
spin_unlock(&obd->obd_recovery_task_lock);
if (req->rq_export->exp_in_recovery) {
spin_lock(&req->rq_export->exp_lock);
return req;
}
-static int handle_recovery_req(struct ptlrpc_thread *thread,
- struct ptlrpc_request *req,
- svc_handler_t handler)
+static void handle_recovery_req(struct ptlrpc_thread *thread,
+ struct ptlrpc_request *req,
+ svc_handler_t handler)
{
- int rc;
-
ENTRY;
/**
* it after that, discard such request silently
*/
if (req->rq_export->exp_disconnected)
- GOTO(reqcopy_put, rc = 0);
+ RETURN_EXIT;
req->rq_session.lc_thread = thread;
req->rq_svc_thread = thread;
}
extend_recovery_timer(class_exp2obd(req->rq_export), to, true);
}
-reqcopy_put:
- RETURN(rc);
+ EXIT;
}
static int target_recovery_thread(void *arg)
libcfs_nid2str(req->rq_peer.nid));
handle_recovery_req(thread, req,
trd->trd_recovery_handler);
- target_request_copy_put(req);
+ /* Because the waiting client can not send ping to server,
+ * so we need refresh the last_request_time, to avoid the
+ * export is being evicted */
+ ptlrpc_update_export_timer(req->rq_export, 0);
+ target_request_copy_put(req);
}
delta = (jiffies - delta) / HZ;
}
EXPORT_SYMBOL(target_recovery_init);
-#endif /* __KERNEL__ */
static int target_process_req_flags(struct obd_device *obd,
struct ptlrpc_request *req)
int target_queue_recovery_request(struct ptlrpc_request *req,
struct obd_device *obd)
{
- cfs_list_t *tmp;
- int inserted = 0;
__u64 transno = lustre_msg_get_transno(req->rq_reqmsg);
- ENTRY;
+ struct ptlrpc_request *reqiter;
+ int inserted = 0;
+ ENTRY;
if (obd->obd_recovery_data.trd_processing_task == current_pid()) {
/* Processing the queue right now, don't re-add. */
wake_up(&obd->obd_next_transno_waitq);
spin_lock(&obd->obd_recovery_task_lock);
if (obd->obd_recovering) {
- cfs_list_add_tail(&req->rq_list,
+ list_add_tail(&req->rq_list,
&obd->obd_final_req_queue);
} else {
spin_unlock(&obd->obd_recovery_task_lock);
RETURN(-ENOTCONN);
}
LASSERT(req->rq_export->exp_lock_replay_needed);
- cfs_list_add_tail(&req->rq_list, &obd->obd_lock_replay_queue);
+ list_add_tail(&req->rq_list, &obd->obd_lock_replay_queue);
spin_unlock(&obd->obd_recovery_task_lock);
RETURN(0);
}
* buffers (eg mdt_body, ost_body etc) have NOT been swabbed. */
if (!transno) {
- CFS_INIT_LIST_HEAD(&req->rq_list);
+ INIT_LIST_HEAD(&req->rq_list);
DEBUG_REQ(D_HA, req, "not queueing");
RETURN(1);
}
spin_lock(&obd->obd_recovery_task_lock);
if (transno < obd->obd_next_recovery_transno) {
/* Processing the queue right now, don't re-add. */
- LASSERT(cfs_list_empty(&req->rq_list));
+ LASSERT(list_empty(&req->rq_list));
spin_unlock(&obd->obd_recovery_task_lock);
RETURN(1);
}
RETURN(0);
}
- /* XXX O(n^2) */
+ /* XXX O(n^2) */
spin_lock(&obd->obd_recovery_task_lock);
- LASSERT(obd->obd_recovering);
- cfs_list_for_each(tmp, &obd->obd_req_replay_queue) {
- struct ptlrpc_request *reqiter =
- cfs_list_entry(tmp, struct ptlrpc_request, rq_list);
-
- if (lustre_msg_get_transno(reqiter->rq_reqmsg) > transno) {
- cfs_list_add_tail(&req->rq_list, &reqiter->rq_list);
- inserted = 1;
- break;
- }
+ LASSERT(obd->obd_recovering);
+ list_for_each_entry(reqiter, &obd->obd_req_replay_queue, rq_list) {
+ if (lustre_msg_get_transno(reqiter->rq_reqmsg) > transno) {
+ list_add_tail(&req->rq_list, &reqiter->rq_list);
+ inserted = 1;
+ goto added;
+ }
if (unlikely(lustre_msg_get_transno(reqiter->rq_reqmsg) ==
transno)) {
RETURN(0);
}
}
-
+added:
if (!inserted)
- cfs_list_add_tail(&req->rq_list, &obd->obd_req_replay_queue);
+ list_add_tail(&req->rq_list, &obd->obd_req_replay_queue);
obd->obd_requests_queued_for_recovery++;
spin_unlock(&obd->obd_recovery_task_lock);
}
/* must be an export if locks saved */
- LASSERT (req->rq_export != NULL);
+ LASSERT(req->rq_export != NULL);
/* req/reply consistent */
LASSERT(rs->rs_svcpt == svcpt);
/* "fresh" reply */
- LASSERT (!rs->rs_scheduled);
- LASSERT (!rs->rs_scheduled_ever);
- LASSERT (!rs->rs_handled);
- LASSERT (!rs->rs_on_net);
- LASSERT (rs->rs_export == NULL);
- LASSERT (cfs_list_empty(&rs->rs_obd_list));
- LASSERT (cfs_list_empty(&rs->rs_exp_list));
+ LASSERT(!rs->rs_scheduled);
+ LASSERT(!rs->rs_scheduled_ever);
+ LASSERT(!rs->rs_handled);
+ LASSERT(!rs->rs_on_net);
+ LASSERT(rs->rs_export == NULL);
+ LASSERT(list_empty(&rs->rs_obd_list));
+ LASSERT(list_empty(&rs->rs_exp_list));
- exp = class_export_get (req->rq_export);
+ exp = class_export_get(req->rq_export);
/* disable reply scheduling while I'm setting up */
rs->rs_scheduled = 1;
rs->rs_transno, exp->exp_last_committed);
if (rs->rs_transno > exp->exp_last_committed) {
/* not committed already */
- cfs_list_add_tail(&rs->rs_obd_list,
+ list_add_tail(&rs->rs_obd_list,
&exp->exp_uncommitted_replies);
}
spin_unlock(&exp->exp_uncommitted_replies_lock);
spin_lock(&exp->exp_lock);
- cfs_list_add_tail(&rs->rs_exp_list, &exp->exp_outstanding_replies);
+ list_add_tail(&rs->rs_exp_list, &exp->exp_outstanding_replies);
spin_unlock(&exp->exp_lock);
netrc = target_send_reply_msg(req, rc, fail_id);
spin_lock(&rs->rs_lock);
if (rs->rs_transno <= exp->exp_last_committed ||
(!rs->rs_on_net && !rs->rs_no_ack) ||
- cfs_list_empty(&rs->rs_exp_list) || /* completed already */
- cfs_list_empty(&rs->rs_obd_list)) {
+ list_empty(&rs->rs_exp_list) || /* completed already */
+ list_empty(&rs->rs_obd_list)) {
CDEBUG(D_HA, "Schedule reply immediately\n");
ptlrpc_dispatch_difficult_reply(rs);
} else {
- cfs_list_add(&rs->rs_list, &svcpt->scp_rep_active);
+ list_add(&rs->rs_list, &svcpt->scp_rep_active);
rs->rs_scheduled = 0; /* allow notifier to schedule */
}
spin_unlock(&rs->rs_lock);
void ldlm_dump_export_locks(struct obd_export *exp)
{
spin_lock(&exp->exp_locks_list_guard);
- if (!cfs_list_empty(&exp->exp_locks_list)) {
+ if (!list_empty(&exp->exp_locks_list)) {
struct ldlm_lock *lock;
CERROR("dumping locks for export %p,"
"ignore if the unmount doesn't hang\n", exp);
- cfs_list_for_each_entry(lock, &exp->exp_locks_list,
+ list_for_each_entry(lock, &exp->exp_locks_list,
l_exp_refs_link)
LDLM_ERROR(lock, "lock:");
}