-/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
- * vim:expandtab:shiftwidth=8:tabstop=8:
- *
+/*
* GPL HEADER START
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
+ * Copyright (c) 2012, Intel Corporation.
+ *
* Copyright (C) 2006 Myricom, Inc.
*/
/*
* Author: Scott Atchley <atchley at myri.com>
*/
+#include <asm/page.h>
#include "mxlnd.h"
mx_endpoint_addr_t MX_EPA_NULL; /* use to determine if an endpoint is NULL */
rxs = &conn->mxk_rx_idle;
- cfs_spin_lock(&conn->mxk_lock);
+ spin_lock(&conn->mxk_lock);
- if (cfs_list_empty (rxs)) {
- cfs_spin_unlock(&conn->mxk_lock);
- return NULL;
- }
+ if (cfs_list_empty (rxs)) {
+ spin_unlock(&conn->mxk_lock);
+ return NULL;
+ }
- rx = cfs_list_entry (rxs->next, kmx_ctx_t, mxc_list);
- cfs_list_del_init(&rx->mxc_list);
- cfs_spin_unlock(&conn->mxk_lock);
+ rx = cfs_list_entry (rxs->next, kmx_ctx_t, mxc_list);
+ cfs_list_del_init(&rx->mxc_list);
+ spin_unlock(&conn->mxk_lock);
#if MXLND_DEBUG
if (rx->mxc_get != rx->mxc_put) {
rx->mxc_put++;
LASSERT(rx->mxc_get == rx->mxc_put);
- cfs_spin_lock(&conn->mxk_lock);
- cfs_list_add(&rx->mxc_list, rxs);
- cfs_spin_unlock(&conn->mxk_lock);
- return 0;
+ spin_lock(&conn->mxk_lock);
+ cfs_list_add(&rx->mxc_list, rxs);
+ spin_unlock(&conn->mxk_lock);
+ return 0;
}
kmx_ctx_t *
mxlnd_get_idle_tx(void)
{
- cfs_list_t *tmp = &kmxlnd_data.kmx_tx_idle;
- kmx_ctx_t *tx = NULL;
+ cfs_list_t *tmp = &kmxlnd_data.kmx_tx_idle;
+ kmx_ctx_t *tx = NULL;
- cfs_spin_lock(&kmxlnd_data.kmx_tx_idle_lock);
+ spin_lock(&kmxlnd_data.kmx_tx_idle_lock);
- if (cfs_list_empty (&kmxlnd_data.kmx_tx_idle)) {
- CNETERR("%d txs in use\n", kmxlnd_data.kmx_tx_used);
- cfs_spin_unlock(&kmxlnd_data.kmx_tx_idle_lock);
- return NULL;
- }
+ if (cfs_list_empty (&kmxlnd_data.kmx_tx_idle)) {
+ CNETERR("%d txs in use\n", kmxlnd_data.kmx_tx_used);
+ spin_unlock(&kmxlnd_data.kmx_tx_idle_lock);
+ return NULL;
+ }
tmp = &kmxlnd_data.kmx_tx_idle;
tx = cfs_list_entry (tmp->next, kmx_ctx_t, mxc_list);
kmxlnd_data.kmx_tx_next_cookie = 1;
}
kmxlnd_data.kmx_tx_used++;
- cfs_spin_unlock(&kmxlnd_data.kmx_tx_idle_lock);
+ spin_unlock(&kmxlnd_data.kmx_tx_idle_lock);
LASSERT (tx->mxc_get == tx->mxc_put);
tx->mxc_put++;
LASSERT(tx->mxc_get == tx->mxc_put);
- cfs_spin_lock(&kmxlnd_data.kmx_tx_idle_lock);
- cfs_list_add_tail(&tx->mxc_list, &kmxlnd_data.kmx_tx_idle);
- kmxlnd_data.kmx_tx_used--;
- cfs_spin_unlock(&kmxlnd_data.kmx_tx_idle_lock);
+ spin_lock(&kmxlnd_data.kmx_tx_idle_lock);
+ cfs_list_add_tail(&tx->mxc_list, &kmxlnd_data.kmx_tx_idle);
+ kmxlnd_data.kmx_tx_used--;
+ spin_unlock(&kmxlnd_data.kmx_tx_idle_lock);
- if (lntmsg[0] != NULL) lnet_finalize(kmxlnd_data.kmx_ni, lntmsg[0], result);
- if (lntmsg[1] != NULL) lnet_finalize(kmxlnd_data.kmx_ni, lntmsg[1], result);
- return 0;
+ if (lntmsg[0] != NULL)
+ lnet_finalize(kmxlnd_data.kmx_ni, lntmsg[0], result);
+ if (lntmsg[1] != NULL)
+ lnet_finalize(kmxlnd_data.kmx_ni, lntmsg[1], result);
+ return 0;
}
static inline void
mxlnd_set_conn_status(kmx_conn_t *conn, int status)
{
- conn->mxk_status = status;
- cfs_mb();
+ conn->mxk_status = status;
+ smp_mb();
}
/**
do {
found = 0;
- cfs_spin_lock(&conn->mxk_lock);
+ spin_lock(&conn->mxk_lock);
cfs_list_for_each_entry_safe(ctx, next, &conn->mxk_pending,
mxc_list) {
cfs_list_del_init(&ctx->mxc_list);
if (result == 1) {
ctx->mxc_errno = -ECONNABORTED;
ctx->mxc_state = MXLND_CTX_CANCELED;
- cfs_spin_unlock(&conn->mxk_lock);
- cfs_spin_lock(&kmxlnd_data.kmx_conn_lock);
+ spin_unlock(&conn->mxk_lock);
+ spin_lock(&kmxlnd_data.kmx_conn_lock);
/* we may be holding the global lock,
* move to orphan list so that it can free it */
cfs_list_add_tail(&ctx->mxc_list,
&kmxlnd_data.kmx_orphan_msgs);
count++;
- cfs_spin_unlock(&kmxlnd_data.kmx_conn_lock);
- cfs_spin_lock(&conn->mxk_lock);
- }
- break;
- }
- }
- cfs_spin_unlock(&conn->mxk_lock);
- }
- while (found);
+ spin_unlock(&kmxlnd_data.kmx_conn_lock);
+ spin_lock(&conn->mxk_lock);
+ }
+ break;
+ }
+ }
+ spin_unlock(&conn->mxk_lock);
+ } while (found);
- return count;
+ return count;
}
int
mxlnd_cancel_queued_txs(kmx_conn_t *conn)
{
- int count = 0;
- cfs_list_t *tmp = NULL;
+ int count = 0;
+ cfs_list_t *tmp = NULL;
- cfs_spin_lock(&conn->mxk_lock);
+ spin_lock(&conn->mxk_lock);
while (!cfs_list_empty(&conn->mxk_tx_free_queue) ||
!cfs_list_empty(&conn->mxk_tx_credit_queue)) {
tx = cfs_list_entry(tmp->next, kmx_ctx_t, mxc_list);
cfs_list_del_init(&tx->mxc_list);
- cfs_spin_unlock(&conn->mxk_lock);
- tx->mxc_errno = -ECONNABORTED;
- tx->mxc_state = MXLND_CTX_CANCELED;
- /* move to orphan list and then abort */
- cfs_spin_lock(&kmxlnd_data.kmx_conn_lock);
- cfs_list_add_tail(&tx->mxc_list, &kmxlnd_data.kmx_orphan_msgs);
- cfs_spin_unlock(&kmxlnd_data.kmx_conn_lock);
- count++;
- cfs_spin_lock(&conn->mxk_lock);
- }
- cfs_spin_unlock(&conn->mxk_lock);
+ spin_unlock(&conn->mxk_lock);
+ tx->mxc_errno = -ECONNABORTED;
+ tx->mxc_state = MXLND_CTX_CANCELED;
+ /* move to orphan list and then abort */
+ spin_lock(&kmxlnd_data.kmx_conn_lock);
+ cfs_list_add_tail(&tx->mxc_list, &kmxlnd_data.kmx_orphan_msgs);
+ spin_unlock(&kmxlnd_data.kmx_conn_lock);
+ count++;
+ spin_lock(&conn->mxk_lock);
+ }
+ spin_unlock(&conn->mxk_lock);
- return count;
+ return count;
}
void
void
mxlnd_conn_disconnect(kmx_conn_t *conn, int mx_dis, int send_bye)
{
- mx_endpoint_addr_t epa = conn->mxk_epa;
- int valid = !mxlnd_endpoint_addr_null(epa);
- int count = 0;
+ mx_endpoint_addr_t epa = conn->mxk_epa;
+ int valid = !mxlnd_endpoint_addr_null(epa);
+ int count = 0;
- cfs_spin_lock(&conn->mxk_lock);
- if (conn->mxk_status == MXLND_CONN_DISCONNECT) {
- cfs_spin_unlock(&conn->mxk_lock);
- return;
- }
- mxlnd_set_conn_status(conn, MXLND_CONN_DISCONNECT);
- conn->mxk_timeout = 0;
- cfs_spin_unlock(&conn->mxk_lock);
+ spin_lock(&conn->mxk_lock);
+ if (conn->mxk_status == MXLND_CONN_DISCONNECT) {
+ spin_unlock(&conn->mxk_lock);
+ return;
+ }
+ mxlnd_set_conn_status(conn, MXLND_CONN_DISCONNECT);
+ conn->mxk_timeout = 0;
+ spin_unlock(&conn->mxk_lock);
- count = mxlnd_cancel_queued_txs(conn);
- count += mxlnd_conn_cancel_pending_rxs(conn);
+ count = mxlnd_cancel_queued_txs(conn);
+ count += mxlnd_conn_cancel_pending_rxs(conn);
- if (count)
- cfs_up(&kmxlnd_data.kmx_conn_sem); /* let connd call kmxlnd_abort_msgs() */
+ if (count) /* let connd call kmxlnd_abort_msgs() */
+ up(&kmxlnd_data.kmx_conn_sem);
if (send_bye && valid &&
conn->mxk_peer->mxp_nid != kmxlnd_data.kmx_ni->ni_nid) {
mxlnd_sleep(msecs_to_jiffies(20));
}
- if (cfs_atomic_read(&kmxlnd_data.kmx_shutdown) != 1) {
- unsigned long last_msg = 0;
+ if (atomic_read(&kmxlnd_data.kmx_shutdown) != 1) {
+ unsigned long last_msg = 0;
/* notify LNET that we are giving up on this peer */
if (cfs_time_after(conn->mxk_last_rx, conn->mxk_last_tx))
memset(conn->mxk_rxs, 0, MXLND_RX_MSGS() * sizeof(kmx_ctx_t));
- conn->mxk_peer = peer;
- CFS_INIT_LIST_HEAD(&conn->mxk_list);
- CFS_INIT_LIST_HEAD(&conn->mxk_zombie);
- cfs_atomic_set(&conn->mxk_refcount, 2); /* ref for owning peer
- and one for the caller */
- if (peer->mxp_nid == kmxlnd_data.kmx_ni->ni_nid) {
- u64 nic_id = 0ULL;
+ conn->mxk_peer = peer;
+ CFS_INIT_LIST_HEAD(&conn->mxk_list);
+ CFS_INIT_LIST_HEAD(&conn->mxk_zombie);
+ atomic_set(&conn->mxk_refcount, 2); /* ref for owning peer
+ and one for the caller */
+ if (peer->mxp_nid == kmxlnd_data.kmx_ni->ni_nid) {
+ u64 nic_id = 0ULL;
u32 ep_id = 0;
/* this is localhost, set the epa and status as up */
mxlnd_set_conn_status(conn, MXLND_CONN_INIT);
/* mxk_epa - to be set after mx_iconnect() */
}
- cfs_spin_lock_init(&conn->mxk_lock);
+ spin_lock_init(&conn->mxk_lock);
/* conn->mxk_timeout = 0 */
/* conn->mxk_last_tx = 0 */
/* conn->mxk_last_rx = 0 */
mxlnd_conn_alloc(kmx_conn_t **connp, kmx_peer_t *peer)
{
int ret = 0;
- cfs_rwlock_t *g_lock = &kmxlnd_data.kmx_global_lock;
+ rwlock_t *g_lock = &kmxlnd_data.kmx_global_lock;
- cfs_write_lock(g_lock);
+ write_lock(g_lock);
ret = mxlnd_conn_alloc_locked(connp, peer);
- cfs_write_unlock(g_lock);
+ write_unlock(g_lock);
return ret;
}
int
mxlnd_q_pending_ctx(kmx_ctx_t *ctx)
{
- int ret = 0;
- kmx_conn_t *conn = ctx->mxc_conn;
+ int ret = 0;
+ kmx_conn_t *conn = ctx->mxc_conn;
- ctx->mxc_state = MXLND_CTX_PENDING;
- if (conn != NULL) {
- cfs_spin_lock(&conn->mxk_lock);
+ ctx->mxc_state = MXLND_CTX_PENDING;
+ if (conn != NULL) {
+ spin_lock(&conn->mxk_lock);
if (conn->mxk_status >= MXLND_CONN_INIT) {
cfs_list_add_tail(&ctx->mxc_list, &conn->mxk_pending);
if (conn->mxk_timeout == 0 || ctx->mxc_deadline < conn->mxk_timeout) {
ctx->mxc_state = MXLND_CTX_COMPLETED;
ret = -1;
}
- cfs_spin_unlock(&conn->mxk_lock);
- }
- return ret;
+ spin_unlock(&conn->mxk_lock);
+ }
+ return ret;
}
int
kmx_ctx_t *next = NULL;
LASSERT(conn != NULL);
- cfs_spin_lock(&conn->mxk_lock);
+ spin_lock(&conn->mxk_lock);
cfs_list_del_init(&ctx->mxc_list);
conn->mxk_timeout = 0;
if (!cfs_list_empty(&conn->mxk_pending)) {
kmx_ctx_t, mxc_list);
conn->mxk_timeout = next->mxc_deadline;
}
- cfs_spin_unlock(&conn->mxk_lock);
- }
- return 0;
+ spin_unlock(&conn->mxk_lock);
+ }
+ return 0;
}
/**
void
mxlnd_peer_free(kmx_peer_t *peer)
{
- CDEBUG(D_NET, "freeing peer 0x%p %s\n", peer, libcfs_nid2str(peer->mxp_nid));
+ CDEBUG(D_NET, "freeing peer 0x%p %s\n", peer, libcfs_nid2str(peer->mxp_nid));
- LASSERT (cfs_atomic_read(&peer->mxp_refcount) == 0);
+ LASSERT (atomic_read(&peer->mxp_refcount) == 0);
- if (!cfs_list_empty(&peer->mxp_list)) {
- /* assume we are locked */
- cfs_list_del_init(&peer->mxp_list);
- }
+ if (!cfs_list_empty(&peer->mxp_list)) {
+ /* assume we are locked */
+ cfs_list_del_init(&peer->mxp_list);
+ }
- MXLND_FREE(peer, sizeof (*peer));
- cfs_atomic_dec(&kmxlnd_data.kmx_npeers);
- return;
+ MXLND_FREE(peer, sizeof (*peer));
+ atomic_dec(&kmxlnd_data.kmx_npeers);
+ return;
}
static int
if (tmp_id != 0ULL)
ret = 0;
break;
- } else if (ret == -EHOSTUNREACH && try < tries) {
- /* add a little backoff */
- CDEBUG(D_NET, "sleeping for %d jiffies\n",
- CFS_HZ/4);
- mxlnd_sleep(CFS_HZ/4);
- }
+ } else if (ret == -EHOSTUNREACH && try < tries) {
+ /* add a little backoff */
+ CDEBUG(D_NET, "sleeping for %lu jiffies\n",
+ msecs_to_jiffies(MSEC_PER_SEC / 4));
+ mxlnd_sleep(msecs_to_jiffies(MSEC_PER_SEC / 4));
+ }
}
} while (try++ < tries);
CDEBUG(D_NET, "done trying. ret = %d\n", ret);
if (tmp_id == 0ULL)
ret = -EHOSTUNREACH;
-#ifdef __LITTLE_ENDIAN
+#if __BYTE_ORDER == __LITTLE_ENDIAN
*nic_id = ___arch__swab64(tmp_id);
#else
*nic_id = tmp_id;
memset(peer, 0, sizeof(*peer));
- CFS_INIT_LIST_HEAD(&peer->mxp_list);
- peer->mxp_nid = nid;
- /* peer->mxp_ni unused - may be used for multi-rail */
- cfs_atomic_set(&peer->mxp_refcount, 1); /* ref for kmx_peers list */
+ CFS_INIT_LIST_HEAD(&peer->mxp_list);
+ peer->mxp_nid = nid;
+ /* peer->mxp_ni unused - may be used for multi-rail */
+ atomic_set(&peer->mxp_refcount, 1); /* ref for kmx_peers list */
peer->mxp_board = board;
peer->mxp_ep_id = ep_id;
int hash = 0;
kmx_peer_t *peer = NULL;
kmx_peer_t *old = NULL;
- cfs_rwlock_t *g_lock = &kmxlnd_data.kmx_global_lock;
+ rwlock_t *g_lock = &kmxlnd_data.kmx_global_lock;
- cfs_read_lock(g_lock);
+ read_lock(g_lock);
peer = mxlnd_find_peer_by_nid_locked(nid); /* adds peer ref */
if ((peer && peer->mxp_conn) || /* found peer with conn or */
(!peer && !create)) { /* did not find peer and do not create one */
- cfs_read_unlock(g_lock);
+ read_unlock(g_lock);
return peer;
}
- cfs_read_unlock(g_lock);
+ read_unlock(g_lock);
/* if peer but _not_ conn */
if (peer && !peer->mxp_conn) {
if (create) {
- cfs_write_lock(g_lock);
+ write_lock(g_lock);
if (!peer->mxp_conn) { /* check again */
/* create the conn */
ret = mxlnd_conn_alloc_locked(&peer->mxp_conn, peer);
mxlnd_conn_decref(peer->mxp_conn);
}
}
- cfs_write_unlock(g_lock);
+ write_unlock(g_lock);
}
return peer;
}
if (ret != 0) /* no memory, peer is NULL */
return NULL;
- cfs_write_lock(g_lock);
+ write_lock(g_lock);
/* look again */
old = mxlnd_find_peer_by_nid_locked(nid);
mxlnd_peer_decref(peer);
peer = old;
} else {
- /* no other peer, use this one */
- cfs_list_add_tail(&peer->mxp_list,
- &kmxlnd_data.kmx_peers[hash]);
- cfs_atomic_inc(&kmxlnd_data.kmx_npeers);
- mxlnd_peer_addref(peer);
- mxlnd_conn_decref(peer->mxp_conn); /* drop ref from peer_alloc */
+ /* no other peer, use this one */
+ cfs_list_add_tail(&peer->mxp_list,
+ &kmxlnd_data.kmx_peers[hash]);
+ atomic_inc(&kmxlnd_data.kmx_npeers);
+ mxlnd_peer_addref(peer);
+ mxlnd_conn_decref(peer->mxp_conn); /* drop ref from peer_alloc */
}
- cfs_write_unlock(g_lock);
+ write_unlock(g_lock);
return peer;
}
mx_decompose_endpoint_addr2(source, &nic_id, &ep_id, &sid);
mxlnd_parse_match(match_value, &msg_type, &error, &cookie);
- cfs_read_lock(&kmxlnd_data.kmx_global_lock);
+ read_lock(&kmxlnd_data.kmx_global_lock);
mx_get_endpoint_addr_context(source, (void **) &conn);
if (conn) {
mxlnd_conn_addref(conn); /* add ref for this function */
peer = conn->mxk_peer;
}
- cfs_read_unlock(&kmxlnd_data.kmx_global_lock);
+ read_unlock(&kmxlnd_data.kmx_global_lock);
if (msg_type == MXLND_MSG_BYE) {
if (conn) {
mxlnd_send_message(source, MXLND_MSG_CONN_ACK, ENOMEM, 0);
return MX_RECV_FINISHED;
}
- cfs_spin_lock(&kmxlnd_data.kmx_conn_lock);
- cfs_list_add_tail(&cp->mxr_list, &kmxlnd_data.kmx_conn_reqs);
- cfs_spin_unlock(&kmxlnd_data.kmx_conn_lock);
- cfs_up(&kmxlnd_data.kmx_conn_sem);
- return MX_RECV_FINISHED;
- }
+ spin_lock(&kmxlnd_data.kmx_conn_lock);
+ cfs_list_add_tail(&cp->mxr_list, &kmxlnd_data.kmx_conn_reqs);
+ spin_unlock(&kmxlnd_data.kmx_conn_lock);
+ up(&kmxlnd_data.kmx_conn_sem);
+ return MX_RECV_FINISHED;
+ }
if (msg_type == MXLND_MSG_CONN_ACK) {
kmx_connparams_t *cp = NULL;
const int expected = offsetof(kmx_msg_t, mxm_u) +
CNETERR("unable to alloc kmx_connparams_t"
" from %llx:%d\n", nic_id, ep_id);
mxlnd_conn_disconnect(conn, 1, 1);
- } else {
- cfs_spin_lock(&kmxlnd_data.kmx_conn_lock);
- cfs_list_add_tail(&cp->mxr_list,
- &kmxlnd_data.kmx_conn_reqs);
- cfs_spin_unlock(&kmxlnd_data.kmx_conn_lock);
- cfs_up(&kmxlnd_data.kmx_conn_sem);
- }
+ } else {
+ spin_lock(&kmxlnd_data.kmx_conn_lock);
+ cfs_list_add_tail(&cp->mxr_list,
+ &kmxlnd_data.kmx_conn_reqs);
+ spin_unlock(&kmxlnd_data.kmx_conn_lock);
+ up(&kmxlnd_data.kmx_conn_sem);
+ }
}
mxlnd_conn_decref(conn); /* drop ref taken above */
int ret = -ENOENT;
kmx_peer_t *peer = NULL;
- cfs_read_lock(&kmxlnd_data.kmx_global_lock);
+ read_lock(&kmxlnd_data.kmx_global_lock);
for (i = 0; i < MXLND_HASH_SIZE; i++) {
cfs_list_for_each_entry(peer, &kmxlnd_data.kmx_peers[i],
mxp_list) {
- if (index-- == 0) {
- *nidp = peer->mxp_nid;
- *count = cfs_atomic_read(&peer->mxp_refcount);
- ret = 0;
- break;
- }
+ if (index-- == 0) {
+ *nidp = peer->mxp_nid;
+ *count = atomic_read(&peer->mxp_refcount);
+ ret = 0;
+ break;
+ }
}
}
- cfs_read_unlock(&kmxlnd_data.kmx_global_lock);
+ read_unlock(&kmxlnd_data.kmx_global_lock);
return ret;
}
if (nid != LNET_NID_ANY) {
peer = mxlnd_find_peer_by_nid(nid, 0); /* adds peer ref */
}
- cfs_write_lock(&kmxlnd_data.kmx_global_lock);
+ write_lock(&kmxlnd_data.kmx_global_lock);
if (nid != LNET_NID_ANY) {
if (peer == NULL) {
ret = -ENOENT;
}
}
}
- cfs_write_unlock(&kmxlnd_data.kmx_global_lock);
+ write_unlock(&kmxlnd_data.kmx_global_lock);
return ret;
}
kmx_peer_t *peer = NULL;
kmx_conn_t *conn = NULL;
- cfs_read_lock(&kmxlnd_data.kmx_global_lock);
+ read_lock(&kmxlnd_data.kmx_global_lock);
for (i = 0; i < MXLND_HASH_SIZE; i++) {
cfs_list_for_each_entry(peer, &kmxlnd_data.kmx_peers[i],
mxp_list) {
}
mxlnd_conn_addref(conn); /* add ref here, dec in ctl() */
- cfs_read_unlock(&kmxlnd_data.kmx_global_lock);
+ read_unlock(&kmxlnd_data.kmx_global_lock);
return conn;
}
}
}
- cfs_read_unlock(&kmxlnd_data.kmx_global_lock);
+ read_unlock(&kmxlnd_data.kmx_global_lock);
return NULL;
}
int ret = 0;
kmx_peer_t *peer = NULL;
- cfs_write_lock(&kmxlnd_data.kmx_global_lock);
+ write_lock(&kmxlnd_data.kmx_global_lock);
if (nid != LNET_NID_ANY) {
peer = mxlnd_find_peer_by_nid_locked(nid); /* adds peer ref */
if (peer == NULL) {
mxlnd_close_matching_conns_locked(peer);
}
}
- cfs_write_unlock(&kmxlnd_data.kmx_global_lock);
+ write_unlock(&kmxlnd_data.kmx_global_lock);
return ret;
}
static inline void
mxlnd_peer_queue_tx(kmx_ctx_t *tx)
{
- LASSERT(tx->mxc_peer != NULL);
- LASSERT(tx->mxc_conn != NULL);
- cfs_spin_lock(&tx->mxc_conn->mxk_lock);
- mxlnd_peer_queue_tx_locked(tx);
- cfs_spin_unlock(&tx->mxc_conn->mxk_lock);
+ LASSERT(tx->mxc_peer != NULL);
+ LASSERT(tx->mxc_conn != NULL);
+ spin_lock(&tx->mxc_conn->mxk_lock);
+ mxlnd_peer_queue_tx_locked(tx);
+ spin_unlock(&tx->mxc_conn->mxk_lock);
- return;
+ return;
}
/**
mxlnd_peer_queue_tx(tx);
mxlnd_check_sends(peer);
} else {
- cfs_spin_lock(&kmxlnd_data.kmx_tx_queue_lock);
- cfs_list_add_tail(&tx->mxc_list, &kmxlnd_data.kmx_tx_queue);
- cfs_spin_unlock(&kmxlnd_data.kmx_tx_queue_lock);
- cfs_up(&kmxlnd_data.kmx_tx_queue_sem);
- }
+ spin_lock(&kmxlnd_data.kmx_tx_queue_lock);
+ cfs_list_add_tail(&tx->mxc_list, &kmxlnd_data.kmx_tx_queue);
+ spin_unlock(&kmxlnd_data.kmx_tx_queue_lock);
+ up(&kmxlnd_data.kmx_tx_queue_sem);
+ }
done:
- return;
+ return;
}
int
ctx->mxc_nseg = niov;
sum = 0;
for (i = 0; i < niov; i++) {
- seg[i].segment_ptr = lnet_page2phys(kiov[first_kiov + i].kiov_page);
+ seg[i].segment_ptr =
+ page_to_phys(kiov[first_kiov + i].kiov_page);
seg[i].segment_length = kiov[first_kiov + i].kiov_len;
if (i == 0) {
seg[i].segment_ptr += (u64) first_kiov_offset;
int nob = 0;
uint32_t length = 0;
kmx_peer_t *peer = NULL;
- cfs_rwlock_t *g_lock = &kmxlnd_data.kmx_global_lock;
+ rwlock_t *g_lock =&kmxlnd_data.kmx_global_lock;
CDEBUG(D_NET, "sending %d bytes in %d frags to %s\n",
payload_nob, payload_niov, libcfs_id2str(target));
if (unlikely(peer->mxp_incompatible)) {
mxlnd_peer_decref(peer); /* drop ref taken above */
} else {
- cfs_read_lock(g_lock);
- conn = peer->mxp_conn;
- if (conn && conn->mxk_status != MXLND_CONN_DISCONNECT) {
- mxlnd_conn_addref(conn);
- } else {
- conn = NULL;
- }
- cfs_read_unlock(g_lock);
+ read_lock(g_lock);
+ conn = peer->mxp_conn;
+ if (conn && conn->mxk_status != MXLND_CONN_DISCONNECT)
+ mxlnd_conn_addref(conn);
+ else
+ conn = NULL;
+ read_unlock(g_lock);
mxlnd_peer_decref(peer); /* drop peer ref taken above */
if (!conn)
return -ENOTCONN;
if (repost) {
/* we received a message, increment peer's outstanding credits */
- if (credit == 1) {
- cfs_spin_lock(&conn->mxk_lock);
- conn->mxk_outstanding++;
- cfs_spin_unlock(&conn->mxk_lock);
- }
+ if (credit == 1) {
+ spin_lock(&conn->mxk_lock);
+ conn->mxk_outstanding++;
+ spin_unlock(&conn->mxk_lock);
+ }
/* we are done with the rx */
mxlnd_put_idle_rx(rx);
mxlnd_conn_decref(conn);
void
mxlnd_sleep(unsigned long timeout)
{
- cfs_set_current_state(CFS_TASK_INTERRUPTIBLE);
- cfs_schedule_timeout(timeout);
- return;
+ set_current_state(TASK_INTERRUPTIBLE);
+ schedule_timeout(timeout);
+ return;
}
/**
kmx_ctx_t *tx = NULL;
kmx_peer_t *peer = NULL;
cfs_list_t *queue = &kmxlnd_data.kmx_tx_queue;
- cfs_spinlock_t *tx_q_lock = &kmxlnd_data.kmx_tx_queue_lock;
- cfs_rwlock_t *g_lock = &kmxlnd_data.kmx_global_lock;
-
- cfs_daemonize("mxlnd_tx_queued");
-
- while (!(cfs_atomic_read(&kmxlnd_data.kmx_shutdown))) {
- ret = cfs_down_interruptible(&kmxlnd_data.kmx_tx_queue_sem);
- if (cfs_atomic_read(&kmxlnd_data.kmx_shutdown))
- break;
- if (ret != 0) // Should we check for -EINTR?
- continue;
- cfs_spin_lock(tx_q_lock);
- if (cfs_list_empty (&kmxlnd_data.kmx_tx_queue)) {
- cfs_spin_unlock(tx_q_lock);
- continue;
- }
- tx = cfs_list_entry (queue->next, kmx_ctx_t, mxc_list);
- cfs_list_del_init(&tx->mxc_list);
- cfs_spin_unlock(tx_q_lock);
-
- found = 0;
- peer = mxlnd_find_peer_by_nid(tx->mxc_nid, 0); /* adds peer ref */
- if (peer != NULL) {
- tx->mxc_peer = peer;
- cfs_write_lock(g_lock);
- if (peer->mxp_conn == NULL) {
- ret = mxlnd_conn_alloc_locked(&peer->mxp_conn, peer);
- if (ret != 0) {
- /* out of memory, give up and fail tx */
- tx->mxc_errno = -ENOMEM;
- mxlnd_peer_decref(peer);
- cfs_write_unlock(g_lock);
- mxlnd_put_idle_tx(tx);
- continue;
- }
- }
- tx->mxc_conn = peer->mxp_conn;
- mxlnd_conn_addref(tx->mxc_conn); /* for this tx */
- mxlnd_peer_decref(peer); /* drop peer ref taken above */
- cfs_write_unlock(g_lock);
+ spinlock_t *tx_q_lock = &kmxlnd_data.kmx_tx_queue_lock;
+ rwlock_t *g_lock = &kmxlnd_data.kmx_global_lock;
+
+ while (!(atomic_read(&kmxlnd_data.kmx_shutdown))) {
+ ret = down_interruptible(&kmxlnd_data.kmx_tx_queue_sem);
+ if (atomic_read(&kmxlnd_data.kmx_shutdown))
+ break;
+ if (ret != 0) /* Should we check for -EINTR? */
+ continue;
+ spin_lock(tx_q_lock);
+ if (cfs_list_empty(&kmxlnd_data.kmx_tx_queue)) {
+ spin_unlock(tx_q_lock);
+ continue;
+ }
+ tx = cfs_list_entry(queue->next, kmx_ctx_t, mxc_list);
+ cfs_list_del_init(&tx->mxc_list);
+ spin_unlock(tx_q_lock);
+
+ found = 0;
+ peer = mxlnd_find_peer_by_nid(tx->mxc_nid, 0); /* adds ref*/
+ if (peer != NULL) {
+ tx->mxc_peer = peer;
+ write_lock(g_lock);
+ if (peer->mxp_conn == NULL) {
+ ret = mxlnd_conn_alloc_locked(&peer->mxp_conn,
+ peer);
+ if (ret != 0) {
+ /* out of memory: give up, fail tx */
+ tx->mxc_errno = -ENOMEM;
+ mxlnd_peer_decref(peer);
+ write_unlock(g_lock);
+ mxlnd_put_idle_tx(tx);
+ continue;
+ }
+ }
+ tx->mxc_conn = peer->mxp_conn;
+ mxlnd_conn_addref(tx->mxc_conn); /* for this tx */
+ mxlnd_peer_decref(peer); /* drop peer ref taken above */
+ write_unlock(g_lock);
mxlnd_queue_tx(tx);
found = 1;
}
/* add peer to global peer list, but look to see
* if someone already created it after we released
* the read lock */
- cfs_write_lock(g_lock);
+ write_lock(g_lock);
old = mxlnd_find_peer_by_nid_locked(peer->mxp_nid);
if (old) {
/* we have a peer ref on old */
}
}
- if (found == 0) {
- cfs_list_add_tail(&peer->mxp_list,
- &kmxlnd_data.kmx_peers[hash]);
- cfs_atomic_inc(&kmxlnd_data.kmx_npeers);
- } else {
+ if (found == 0) {
+ cfs_list_add_tail(&peer->mxp_list,
+ &kmxlnd_data.kmx_peers[hash]);
+ atomic_inc(&kmxlnd_data.kmx_npeers);
+ } else {
tx->mxc_peer = old;
tx->mxc_conn = old->mxp_conn;
LASSERT(old->mxp_conn != NULL);
mxlnd_conn_decref(peer->mxp_conn); /* drop peer's ref */
mxlnd_peer_decref(peer);
}
- cfs_write_unlock(g_lock);
+ write_unlock(g_lock);
mxlnd_queue_tx(tx);
}
mx_nic_id_to_board_number(peer->mxp_nic_id, &peer->mxp_board);
}
if (peer->mxp_nic_id == 0ULL && conn->mxk_status == MXLND_CONN_WAIT) {
- /* not mapped yet, return */
- cfs_spin_lock(&conn->mxk_lock);
- mxlnd_set_conn_status(conn, MXLND_CONN_INIT);
- cfs_spin_unlock(&conn->mxk_lock);
+ /* not mapped yet, return */
+ spin_lock(&conn->mxk_lock);
+ mxlnd_set_conn_status(conn, MXLND_CONN_INIT);
+ spin_unlock(&conn->mxk_lock);
}
}
peer->mxp_ep_id, MXLND_MSG_MAGIC, match,
(void *) peer, &request);
if (unlikely(mxret != MX_SUCCESS)) {
- cfs_spin_lock(&conn->mxk_lock);
- mxlnd_set_conn_status(conn, MXLND_CONN_FAIL);
- cfs_spin_unlock(&conn->mxk_lock);
+ spin_lock(&conn->mxk_lock);
+ mxlnd_set_conn_status(conn, MXLND_CONN_FAIL);
+ spin_unlock(&conn->mxk_lock);
CNETERR("mx_iconnect() failed with %s (%d) to %s\n",
mx_strerror(mxret), mxret, libcfs_nid2str(peer->mxp_nid));
mxlnd_conn_decref(conn);
}
- mx_set_request_timeout(kmxlnd_data.kmx_endpt, request,
- MXLND_CONNECT_TIMEOUT/CFS_HZ*1000);
- return;
+ mx_set_request_timeout(kmxlnd_data.kmx_endpt, request,
+ jiffies_to_msecs(MXLND_CONNECT_TIMEOUT));
+ return;
}
#define MXLND_STATS 0
LASSERT(peer != NULL);
return -1;
}
- cfs_write_lock(&kmxlnd_data.kmx_global_lock);
- conn = peer->mxp_conn;
- /* NOTE take a ref for the duration of this function since it is called
- * when there might not be any queued txs for this peer */
- if (conn) {
- if (conn->mxk_status == MXLND_CONN_DISCONNECT) {
- cfs_write_unlock(&kmxlnd_data.kmx_global_lock);
- return -1;
- }
- mxlnd_conn_addref(conn); /* for duration of this function */
- }
- cfs_write_unlock(&kmxlnd_data.kmx_global_lock);
+ write_lock(&kmxlnd_data.kmx_global_lock);
+ conn = peer->mxp_conn;
+ /* NOTE take a ref for the duration of this function since it is
+ * called when there might not be any queued txs for this peer */
+ if (conn) {
+ if (conn->mxk_status == MXLND_CONN_DISCONNECT) {
+ write_unlock(&kmxlnd_data.kmx_global_lock);
+ return -1;
+ }
+ mxlnd_conn_addref(conn); /* for duration of this function */
+ }
+ write_unlock(&kmxlnd_data.kmx_global_lock);
/* do not add another ref for this tx */
}
#if MXLND_STATS
- if (cfs_time_after(jiffies, last)) {
- last = jiffies + CFS_HZ;
- CDEBUG(D_NET, "status= %s credits= %d outstanding= %d ntx_msgs= %d "
- "ntx_posted= %d ntx_data= %d data_posted= %d\n",
- mxlnd_connstatus_to_str(conn->mxk_status), conn->mxk_credits,
- conn->mxk_outstanding, conn->mxk_ntx_msgs, conn->mxk_ntx_posted,
- conn->mxk_ntx_data, conn->mxk_data_posted);
- }
+ if (cfs_time_after(jiffies, last)) {
+ last = jiffies + msecs_to_jiffies(MSEC_PER_SEC);
+ CDEBUG(D_NET, "status= %s credits= %d outstanding= %d ntx_msgs= %d "
+ "ntx_posted= %d ntx_data= %d data_posted= %d\n",
+ mxlnd_connstatus_to_str(conn->mxk_status), conn->mxk_credits,
+ conn->mxk_outstanding, conn->mxk_ntx_msgs, conn->mxk_ntx_posted,
+ conn->mxk_ntx_data, conn->mxk_data_posted);
+ }
#endif
- cfs_spin_lock(&conn->mxk_lock);
+ spin_lock(&conn->mxk_lock);
ntx_posted = conn->mxk_ntx_posted;
credits = conn->mxk_credits;
conn->mxk_status == MXLND_CONN_FAIL)) {
CDEBUG(D_NET, "status=%s\n", mxlnd_connstatus_to_str(conn->mxk_status));
mxlnd_set_conn_status(conn, MXLND_CONN_WAIT);
- cfs_spin_unlock(&conn->mxk_lock);
+ spin_unlock(&conn->mxk_lock);
mxlnd_iconnect(peer, (u8) MXLND_MSG_ICON_REQ);
goto done;
}
cfs_time_aftereq(jiffies, tx->mxc_deadline)) {
cfs_list_del_init(&tx->mxc_list);
tx->mxc_errno = -ECONNABORTED;
- cfs_spin_unlock(&conn->mxk_lock);
+ spin_unlock(&conn->mxk_lock);
mxlnd_put_idle_tx(tx);
mxlnd_conn_decref(conn);
goto done;
(conn->mxk_ntx_msgs >= 1)) {
conn->mxk_credits++;
conn->mxk_ntx_posted--;
- cfs_spin_unlock(&conn->mxk_lock);
+ spin_unlock(&conn->mxk_lock);
/* redundant NOOP */
mxlnd_put_idle_tx(tx);
mxlnd_conn_decref(conn);
mxret = MX_SUCCESS;
status = conn->mxk_status;
- cfs_spin_unlock(&conn->mxk_lock);
+ spin_unlock(&conn->mxk_lock);
if (likely((status == MXLND_CONN_READY) ||
(msg_type == MXLND_MSG_CONN_REQ) ||
&tx->mxc_mxreq);
} else {
/* send a DATA tx */
- cfs_spin_lock(&conn->mxk_lock);
- conn->mxk_ntx_data--;
- conn->mxk_data_posted++;
- cfs_spin_unlock(&conn->mxk_lock);
+ spin_lock(&conn->mxk_lock);
+ conn->mxk_ntx_data--;
+ conn->mxk_data_posted++;
+ spin_unlock(&conn->mxk_lock);
CDEBUG(D_NET, "sending %s 0x%llx\n",
mxlnd_msgtype_to_str(msg_type),
tx->mxc_cookie);
tx->mxc_errno = -ECONNABORTED;
}
if (credit) {
- cfs_spin_lock(&conn->mxk_lock);
- conn->mxk_ntx_posted--;
- conn->mxk_credits++;
- cfs_spin_unlock(&conn->mxk_lock);
- } else if (msg_type == MXLND_MSG_PUT_DATA ||
- msg_type == MXLND_MSG_GET_DATA) {
- cfs_spin_lock(&conn->mxk_lock);
- conn->mxk_data_posted--;
- cfs_spin_unlock(&conn->mxk_lock);
- }
- if (msg_type != MXLND_MSG_PUT_DATA &&
- msg_type != MXLND_MSG_GET_DATA &&
- msg_type != MXLND_MSG_CONN_REQ &&
- msg_type != MXLND_MSG_CONN_ACK) {
- cfs_spin_lock(&conn->mxk_lock);
- conn->mxk_outstanding += tx->mxc_msg->mxm_credits;
- cfs_spin_unlock(&conn->mxk_lock);
+ spin_lock(&conn->mxk_lock);
+ conn->mxk_ntx_posted--;
+ conn->mxk_credits++;
+ spin_unlock(&conn->mxk_lock);
+ } else if (msg_type == MXLND_MSG_PUT_DATA ||
+ msg_type == MXLND_MSG_GET_DATA) {
+ spin_lock(&conn->mxk_lock);
+ conn->mxk_data_posted--;
+ spin_unlock(&conn->mxk_lock);
+ }
+ if (msg_type != MXLND_MSG_PUT_DATA &&
+ msg_type != MXLND_MSG_GET_DATA &&
+ msg_type != MXLND_MSG_CONN_REQ &&
+ msg_type != MXLND_MSG_CONN_ACK) {
+ spin_lock(&conn->mxk_lock);
+ conn->mxk_outstanding +=
+ tx->mxc_msg->mxm_credits;
+ spin_unlock(&conn->mxk_lock);
}
if (msg_type != MXLND_MSG_CONN_REQ &&
msg_type != MXLND_MSG_CONN_ACK) {
mxlnd_conn_decref(conn);
}
}
- cfs_spin_lock(&conn->mxk_lock);
- }
+ spin_lock(&conn->mxk_lock);
+ }
done_locked:
- cfs_spin_unlock(&conn->mxk_lock);
+ spin_unlock(&conn->mxk_lock);
done:
- mxlnd_conn_decref(conn); /* drop ref taken at start of function */
- return found;
+ mxlnd_conn_decref(conn); /* drop ref taken at start of function */
+ return found;
}
if (failed) {
if (tx->mxc_errno == 0) tx->mxc_errno = -EIO;
} else {
- cfs_spin_lock(&conn->mxk_lock);
- conn->mxk_last_tx = cfs_time_current(); /* jiffies */
- cfs_spin_unlock(&conn->mxk_lock);
- }
-
- switch (type) {
-
- case MXLND_MSG_GET_DATA:
- cfs_spin_lock(&conn->mxk_lock);
- if (conn->mxk_incarnation == tx->mxc_incarnation) {
- conn->mxk_outstanding++;
- conn->mxk_data_posted--;
- }
- cfs_spin_unlock(&conn->mxk_lock);
- break;
-
- case MXLND_MSG_PUT_DATA:
- cfs_spin_lock(&conn->mxk_lock);
- if (conn->mxk_incarnation == tx->mxc_incarnation) {
- conn->mxk_data_posted--;
- }
- cfs_spin_unlock(&conn->mxk_lock);
- break;
+ spin_lock(&conn->mxk_lock);
+ conn->mxk_last_tx = cfs_time_current(); /* jiffies */
+ spin_unlock(&conn->mxk_lock);
+ }
+
+ switch (type) {
+
+ case MXLND_MSG_GET_DATA:
+ spin_lock(&conn->mxk_lock);
+ if (conn->mxk_incarnation == tx->mxc_incarnation) {
+ conn->mxk_outstanding++;
+ conn->mxk_data_posted--;
+ }
+ spin_unlock(&conn->mxk_lock);
+ break;
+
+ case MXLND_MSG_PUT_DATA:
+ spin_lock(&conn->mxk_lock);
+ if (conn->mxk_incarnation == tx->mxc_incarnation) {
+ conn->mxk_data_posted--;
+ }
+ spin_unlock(&conn->mxk_lock);
+ break;
case MXLND_MSG_NOOP:
case MXLND_MSG_PUT_REQ:
mx_strstatus(code), code, tx->mxc_errno,
libcfs_nid2str(tx->mxc_nid));
if (!peer->mxp_incompatible) {
- cfs_spin_lock(&conn->mxk_lock);
- if (code == MX_STATUS_BAD_SESSION)
- mxlnd_set_conn_status(conn, MXLND_CONN_INIT);
- else
- mxlnd_set_conn_status(conn, MXLND_CONN_FAIL);
- cfs_spin_unlock(&conn->mxk_lock);
+ spin_lock(&conn->mxk_lock);
+ if (code == MX_STATUS_BAD_SESSION)
+ mxlnd_set_conn_status(conn,
+ MXLND_CONN_INIT);
+ else
+ mxlnd_set_conn_status(conn,
+ MXLND_CONN_FAIL);
+ spin_unlock(&conn->mxk_lock);
}
}
break;
}
if (credit) {
- cfs_spin_lock(&conn->mxk_lock);
- if (conn->mxk_incarnation == tx->mxc_incarnation) {
- conn->mxk_ntx_posted--;
- }
- cfs_spin_unlock(&conn->mxk_lock);
+ spin_lock(&conn->mxk_lock);
+ if (conn->mxk_incarnation == tx->mxc_incarnation) {
+ conn->mxk_ntx_posted--;
+ }
+ spin_unlock(&conn->mxk_lock);
}
mxlnd_put_idle_tx(tx);
} /* else peer and conn == NULL */
if (conn == NULL && peer != NULL) {
- cfs_write_lock(&kmxlnd_data.kmx_global_lock);
+ write_lock(&kmxlnd_data.kmx_global_lock);
conn = peer->mxp_conn;
if (conn) {
mxlnd_conn_addref(conn); /* conn takes ref... */
conn_ref = 1;
peer_ref = 0;
}
- cfs_write_unlock(&kmxlnd_data.kmx_global_lock);
+ write_unlock(&kmxlnd_data.kmx_global_lock);
rx->mxc_conn = conn;
}
LASSERT(peer != NULL && conn != NULL);
if (msg->mxm_credits != 0) {
- cfs_spin_lock(&conn->mxk_lock);
+ spin_lock(&conn->mxk_lock);
if (msg->mxm_srcstamp == conn->mxk_incarnation) {
if ((conn->mxk_credits + msg->mxm_credits) >
*kmxlnd_tunables.kmx_peercredits) {
LASSERT(conn->mxk_credits >= 0);
LASSERT(conn->mxk_credits <= *kmxlnd_tunables.kmx_peercredits);
}
- cfs_spin_unlock(&conn->mxk_lock);
+ spin_unlock(&conn->mxk_lock);
}
CDEBUG(D_NET, "switch %s for rx (0x%llx)\n", mxlnd_msgtype_to_str(type), seq);
if (ret < 0) {
CDEBUG(D_NET, "setting PEER_CONN_FAILED\n");
- cfs_spin_lock(&conn->mxk_lock);
- mxlnd_set_conn_status(conn, MXLND_CONN_FAIL);
- cfs_spin_unlock(&conn->mxk_lock);
- }
+ spin_lock(&conn->mxk_lock);
+ mxlnd_set_conn_status(conn, MXLND_CONN_FAIL);
+ spin_unlock(&conn->mxk_lock);
+ }
cleanup:
- if (conn != NULL) {
- cfs_spin_lock(&conn->mxk_lock);
- conn->mxk_last_rx = cfs_time_current(); /* jiffies */
- cfs_spin_unlock(&conn->mxk_lock);
+ if (conn != NULL) {
+ spin_lock(&conn->mxk_lock);
+ conn->mxk_last_rx = cfs_time_current(); /* jiffies */
+ spin_unlock(&conn->mxk_lock);
}
if (repost) {
type == MXLND_MSG_EAGER ||
type == MXLND_MSG_PUT_REQ ||
type == MXLND_MSG_NOOP) {
- cfs_spin_lock(&conn->mxk_lock);
- conn->mxk_outstanding++;
- cfs_spin_unlock(&conn->mxk_lock);
+ spin_lock(&conn->mxk_lock);
+ conn->mxk_outstanding++;
+ spin_unlock(&conn->mxk_lock);
}
}
if (conn_ref) mxlnd_conn_decref(conn);
peer->mxp_nid,
peer->mxp_nic_id,
peer->mxp_ep_id);
- cfs_spin_lock(&conn->mxk_lock);
- mxlnd_set_conn_status(conn, MXLND_CONN_FAIL);
- cfs_spin_unlock(&conn->mxk_lock);
+ spin_lock(&conn->mxk_lock);
+ mxlnd_set_conn_status(conn, MXLND_CONN_FAIL);
+ spin_unlock(&conn->mxk_lock);
if (cfs_time_after(jiffies, peer->mxp_reconnect_time +
MXLND_CONNECT_TIMEOUT)) {
return;
}
mx_decompose_endpoint_addr2(status.source, &nic_id, &ep_id, &sid);
- cfs_write_lock(&kmxlnd_data.kmx_global_lock);
- cfs_spin_lock(&conn->mxk_lock);
- conn->mxk_epa = status.source;
- mx_set_endpoint_addr_context(conn->mxk_epa, (void *) conn);
- if (msg_type == MXLND_MSG_ICON_ACK && likely(!peer->mxp_incompatible)) {
- mxlnd_set_conn_status(conn, MXLND_CONN_READY);
- }
- cfs_spin_unlock(&conn->mxk_lock);
- cfs_write_unlock(&kmxlnd_data.kmx_global_lock);
-
- /* mx_iconnect() succeeded, reset delay to 0 */
- cfs_write_lock(&kmxlnd_data.kmx_global_lock);
- peer->mxp_reconnect_time = 0;
- peer->mxp_conn->mxk_sid = sid;
- cfs_write_unlock(&kmxlnd_data.kmx_global_lock);
+ write_lock(&kmxlnd_data.kmx_global_lock);
+ spin_lock(&conn->mxk_lock);
+ conn->mxk_epa = status.source;
+ mx_set_endpoint_addr_context(conn->mxk_epa, (void *) conn);
+ if (msg_type == MXLND_MSG_ICON_ACK && likely(!peer->mxp_incompatible)) {
+ mxlnd_set_conn_status(conn, MXLND_CONN_READY);
+ }
+ spin_unlock(&conn->mxk_lock);
+ write_unlock(&kmxlnd_data.kmx_global_lock);
+
+ /* mx_iconnect() succeeded, reset delay to 0 */
+ write_lock(&kmxlnd_data.kmx_global_lock);
+ peer->mxp_reconnect_time = 0;
+ peer->mxp_conn->mxk_sid = sid;
+ write_unlock(&kmxlnd_data.kmx_global_lock);
/* marshal CONN_REQ or CONN_ACK msg */
/* we are still using the conn ref from iconnect() - do not take another */
CNETERR("Can't obtain %s tx for %s\n",
mxlnd_msgtype_to_str(type),
libcfs_nid2str(peer->mxp_nid));
- cfs_spin_lock(&conn->mxk_lock);
- mxlnd_set_conn_status(conn, MXLND_CONN_FAIL);
- cfs_spin_unlock(&conn->mxk_lock);
+ spin_lock(&conn->mxk_lock);
+ mxlnd_set_conn_status(conn, MXLND_CONN_FAIL);
+ spin_unlock(&conn->mxk_lock);
mxlnd_conn_decref(conn);
return;
}
mxlnd_request_waitd(void *arg)
{
long id = (long) arg;
- char name[24];
__u32 result = 0;
mx_return_t mxret = MX_SUCCESS;
mx_status_t status;
int count = 0;
#endif
- memset(name, 0, sizeof(name));
- snprintf(name, sizeof(name), "mxlnd_request_waitd_%02ld", id);
- cfs_daemonize(name);
-
memset(&status, 0, sizeof(status));
CDEBUG(D_NET, "%s starting\n", name);
- while (!(cfs_atomic_read(&kmxlnd_data.kmx_shutdown))) {
- u8 msg_type = 0;
+ while (!(atomic_read(&kmxlnd_data.kmx_shutdown))) {
+ u8 msg_type = 0;
mxret = MX_SUCCESS;
result = 0;
mxret = mx_wait_any(kmxlnd_data.kmx_endpt, MXLND_WAIT_TIMEOUT,
0ULL, 0ULL, &status, &result);
#endif
- if (unlikely(cfs_atomic_read(&kmxlnd_data.kmx_shutdown)))
- break;
+ if (unlikely(atomic_read(&kmxlnd_data.kmx_shutdown)))
+ break;
if (result != 1) {
/* nothing completed... */
unsigned long next = 0; /* jiffies */
kmx_peer_t *peer = NULL;
kmx_conn_t *conn = NULL;
- cfs_rwlock_t *g_lock = &kmxlnd_data.kmx_global_lock;
+ rwlock_t *g_lock = &kmxlnd_data.kmx_global_lock;
- cfs_read_lock(g_lock);
- for (i = 0; i < MXLND_HASH_SIZE; i++) {
- cfs_list_for_each_entry(peer, &kmxlnd_data.kmx_peers[i],
- mxp_list) {
+ read_lock(g_lock);
+ for (i = 0; i < MXLND_HASH_SIZE; i++) {
+ cfs_list_for_each_entry(peer, &kmxlnd_data.kmx_peers[i],
+ mxp_list) {
- if (unlikely(cfs_atomic_read(&kmxlnd_data.kmx_shutdown))) {
- cfs_read_unlock(g_lock);
- return next;
- }
+ if (unlikely(atomic_read(&kmxlnd_data.kmx_shutdown))) {
+ read_unlock(g_lock);
+ return next;
+ }
conn = peer->mxp_conn;
if (conn) {
continue;
}
- cfs_spin_lock(&conn->mxk_lock);
+ spin_lock(&conn->mxk_lock);
- /* if nothing pending (timeout == 0) or
- * if conn is already disconnected,
- * skip this conn */
- if (conn->mxk_timeout == 0 ||
- conn->mxk_status == MXLND_CONN_DISCONNECT) {
- cfs_spin_unlock(&conn->mxk_lock);
+ /* if nothing pending (timeout == 0) or
+ * if conn is already disconnected,
+ * skip this conn */
+ if (conn->mxk_timeout == 0 ||
+ conn->mxk_status == MXLND_CONN_DISCONNECT) {
+ spin_unlock(&conn->mxk_lock);
mxlnd_conn_decref(conn);
continue;
}
disconnect = 0;
- if (cfs_time_aftereq(now, conn->mxk_timeout)) {
- disconnect = 1;
- }
- cfs_spin_unlock(&conn->mxk_lock);
+ if (cfs_time_aftereq(now, conn->mxk_timeout))
+ disconnect = 1;
+ spin_unlock(&conn->mxk_lock);
- if (disconnect) {
- mxlnd_conn_disconnect(conn, 1, 1);
- }
- mxlnd_conn_decref(conn);
- }
- }
- cfs_read_unlock(g_lock);
- if (next == 0) next = now + MXLND_COMM_TIMEOUT;
+ if (disconnect)
+ mxlnd_conn_disconnect(conn, 1, 1);
+ mxlnd_conn_decref(conn);
+ }
+ }
+ read_unlock(g_lock);
+ if (next == 0)
+ next = now + MXLND_COMM_TIMEOUT;
- return next;
+ return next;
}
void
kmx_msg_t *msg = &cp->mxr_msg;
kmx_peer_t *peer = cp->mxr_peer;
kmx_conn_t *conn = NULL;
- cfs_rwlock_t *g_lock = &kmxlnd_data.kmx_global_lock;
+ rwlock_t *g_lock = &kmxlnd_data.kmx_global_lock;
mx_decompose_endpoint_addr2(cp->mxr_epa, &nic_id, &ep_id, &sid);
}
peer->mxp_conn->mxk_sid = sid;
LASSERT(peer->mxp_ep_id == ep_id);
- cfs_write_lock(g_lock);
+ write_lock(g_lock);
existing_peer = mxlnd_find_peer_by_nid_locked(msg->mxm_srcnid);
if (existing_peer) {
mxlnd_conn_decref(peer->mxp_conn);
peer = existing_peer;
mxlnd_conn_addref(peer->mxp_conn);
conn = peer->mxp_conn;
- } else {
- cfs_list_add_tail(&peer->mxp_list,
- &kmxlnd_data.kmx_peers[hash]);
- cfs_atomic_inc(&kmxlnd_data.kmx_npeers);
- }
- cfs_write_unlock(g_lock);
+ } else {
+ cfs_list_add_tail(&peer->mxp_list,
+ &kmxlnd_data.kmx_peers[hash]);
+ atomic_inc(&kmxlnd_data.kmx_npeers);
+ }
+ write_unlock(g_lock);
} else {
ret = mxlnd_conn_alloc(&conn, peer); /* adds 2nd ref */
- cfs_write_lock(g_lock);
+ write_lock(g_lock);
mxlnd_peer_decref(peer); /* drop ref taken above */
- cfs_write_unlock(g_lock);
+ write_unlock(g_lock);
if (ret != 0) {
CNETERR("Cannot allocate mxp_conn\n");
goto cleanup;
conn = peer->mxp_conn;
}
}
- cfs_write_lock(g_lock);
- peer->mxp_incompatible = incompatible;
- cfs_write_unlock(g_lock);
- cfs_spin_lock(&conn->mxk_lock);
- conn->mxk_incarnation = msg->mxm_srcstamp;
- mxlnd_set_conn_status(conn, MXLND_CONN_WAIT);
- cfs_spin_unlock(&conn->mxk_lock);
+ write_lock(g_lock);
+ peer->mxp_incompatible = incompatible;
+ write_unlock(g_lock);
+ spin_lock(&conn->mxk_lock);
+ conn->mxk_incarnation = msg->mxm_srcstamp;
+ mxlnd_set_conn_status(conn, MXLND_CONN_WAIT);
+ spin_unlock(&conn->mxk_lock);
/* handle_conn_ack() will create the CONN_ACK msg */
mxlnd_iconnect(peer, (u8) MXLND_MSG_ICON_ACK);
ret = -1;
goto failed;
}
- cfs_write_lock(&kmxlnd_data.kmx_global_lock);
- peer->mxp_incompatible = incompatible;
- cfs_write_unlock(&kmxlnd_data.kmx_global_lock);
- cfs_spin_lock(&conn->mxk_lock);
+ write_lock(&kmxlnd_data.kmx_global_lock);
+ peer->mxp_incompatible = incompatible;
+ write_unlock(&kmxlnd_data.kmx_global_lock);
+ spin_lock(&conn->mxk_lock);
conn->mxk_credits = *kmxlnd_tunables.kmx_peercredits;
conn->mxk_outstanding = 0;
conn->mxk_incarnation = msg->mxm_srcstamp;
libcfs_nid2str(msg->mxm_srcnid));
mxlnd_set_conn_status(conn, MXLND_CONN_READY);
}
- cfs_spin_unlock(&conn->mxk_lock);
+ spin_unlock(&conn->mxk_lock);
- if (!incompatible)
- mxlnd_check_sends(peer);
+ if (!incompatible)
+ mxlnd_check_sends(peer);
failed:
- if (ret < 0) {
- cfs_spin_lock(&conn->mxk_lock);
- mxlnd_set_conn_status(conn, MXLND_CONN_FAIL);
- cfs_spin_unlock(&conn->mxk_lock);
- }
+ if (ret < 0) {
+ spin_lock(&conn->mxk_lock);
+ mxlnd_set_conn_status(conn, MXLND_CONN_FAIL);
+ spin_unlock(&conn->mxk_lock);
+ }
- if (incompatible) mxlnd_conn_disconnect(conn, 0, 0);
+ if (incompatible) mxlnd_conn_disconnect(conn, 0, 0);
- mxlnd_connparams_free(cp);
- return;
+ mxlnd_connparams_free(cp);
+ return;
}
int
mxlnd_abort_msgs(void)
{
- int count = 0;
- cfs_list_t *orphans = &kmxlnd_data.kmx_orphan_msgs;
- cfs_spinlock_t *g_conn_lock = &kmxlnd_data.kmx_conn_lock;
+ int count = 0;
+ cfs_list_t *orphans = &kmxlnd_data.kmx_orphan_msgs;
+ spinlock_t *g_conn_lock = &kmxlnd_data.kmx_conn_lock;
- /* abort orphans */
- cfs_spin_lock(g_conn_lock);
- while (!cfs_list_empty(orphans)) {
- kmx_ctx_t *ctx = NULL;
- kmx_conn_t *conn = NULL;
+ /* abort orphans */
+ spin_lock(g_conn_lock);
+ while (!cfs_list_empty(orphans)) {
+ kmx_ctx_t *ctx = NULL;
+ kmx_conn_t *conn = NULL;
- ctx = cfs_list_entry(orphans->next, kmx_ctx_t, mxc_list);
- cfs_list_del_init(&ctx->mxc_list);
- cfs_spin_unlock(g_conn_lock);
+ ctx = cfs_list_entry(orphans->next, kmx_ctx_t, mxc_list);
+ cfs_list_del_init(&ctx->mxc_list);
+ spin_unlock(g_conn_lock);
ctx->mxc_errno = -ECONNABORTED;
conn = ctx->mxc_conn;
}
count++;
- cfs_spin_lock(g_conn_lock);
- }
- cfs_spin_unlock(g_conn_lock);
+ spin_lock(g_conn_lock);
+ }
+ spin_unlock(g_conn_lock);
- return count;
+ return count;
}
int
mxlnd_free_conn_zombies(void)
{
- int count = 0;
- cfs_list_t *zombies = &kmxlnd_data.kmx_conn_zombies;
- cfs_spinlock_t *g_conn_lock = &kmxlnd_data.kmx_conn_lock;
- cfs_rwlock_t *g_lock = &kmxlnd_data.kmx_global_lock;
+ int count = 0;
+ cfs_list_t *zombies = &kmxlnd_data.kmx_conn_zombies;
+ spinlock_t *g_conn_lock = &kmxlnd_data.kmx_conn_lock;
+ rwlock_t *g_lock = &kmxlnd_data.kmx_global_lock;
- /* cleanup any zombies */
- cfs_spin_lock(g_conn_lock);
- while (!cfs_list_empty(zombies)) {
- kmx_conn_t *conn = NULL;
+ /* cleanup any zombies */
+ spin_lock(g_conn_lock);
+ while (!cfs_list_empty(zombies)) {
+ kmx_conn_t *conn = NULL;
- conn = cfs_list_entry(zombies->next, kmx_conn_t, mxk_zombie);
- cfs_list_del_init(&conn->mxk_zombie);
- cfs_spin_unlock(g_conn_lock);
+ conn = cfs_list_entry(zombies->next, kmx_conn_t, mxk_zombie);
+ cfs_list_del_init(&conn->mxk_zombie);
+ spin_unlock(g_conn_lock);
- cfs_write_lock(g_lock);
- mxlnd_conn_free_locked(conn);
- cfs_write_unlock(g_lock);
+ write_lock(g_lock);
+ mxlnd_conn_free_locked(conn);
+ write_unlock(g_lock);
- count++;
- cfs_spin_lock(g_conn_lock);
- }
- cfs_spin_unlock(g_conn_lock);
- CDEBUG(D_NET, "%s: freed %d zombies\n", __func__, count);
- return count;
+ count++;
+ spin_lock(g_conn_lock);
+ }
+ spin_unlock(g_conn_lock);
+ CDEBUG(D_NET, "%s: freed %d zombies\n", __func__, count);
+ return count;
}
/**
int
mxlnd_connd(void *arg)
{
- long id = (long) arg;
+ long id = (long) arg;
- cfs_daemonize("mxlnd_connd");
+ CDEBUG(D_NET, "connd starting\n");
- CDEBUG(D_NET, "connd starting\n");
+ while (!(atomic_read(&kmxlnd_data.kmx_shutdown))) {
+ int ret = 0;
+ kmx_connparams_t *cp = NULL;
+ spinlock_t *g_conn_lock = &kmxlnd_data.kmx_conn_lock;
+ cfs_list_t *conn_reqs = &kmxlnd_data.kmx_conn_reqs;
- while (!(cfs_atomic_read(&kmxlnd_data.kmx_shutdown))) {
- int ret = 0;
- kmx_connparams_t *cp = NULL;
- cfs_spinlock_t *g_conn_lock = &kmxlnd_data.kmx_conn_lock;
- cfs_list_t *conn_reqs = &kmxlnd_data.kmx_conn_reqs;
+ ret = down_interruptible(&kmxlnd_data.kmx_conn_sem);
- ret = cfs_down_interruptible(&kmxlnd_data.kmx_conn_sem);
-
- if (cfs_atomic_read(&kmxlnd_data.kmx_shutdown))
- break;
+ if (atomic_read(&kmxlnd_data.kmx_shutdown))
+ break;
if (ret != 0)
continue;
ret = mxlnd_abort_msgs();
ret += mxlnd_free_conn_zombies();
- cfs_spin_lock(g_conn_lock);
- if (cfs_list_empty(conn_reqs)) {
- if (ret == 0)
- CNETERR("connd woke up but did not "
- "find a kmx_connparams_t or zombie conn\n");
- cfs_spin_unlock(g_conn_lock);
- continue;
- }
- cp = cfs_list_entry(conn_reqs->next, kmx_connparams_t,
- mxr_list);
- cfs_list_del_init(&cp->mxr_list);
- cfs_spin_unlock(g_conn_lock);
+ spin_lock(g_conn_lock);
+ if (cfs_list_empty(conn_reqs)) {
+ if (ret == 0)
+ CNETERR("connd woke up but did not find a "
+ "kmx_connparams_t or zombie conn\n");
+ spin_unlock(g_conn_lock);
+ continue;
+ }
+ cp = cfs_list_entry(conn_reqs->next, kmx_connparams_t,
+ mxr_list);
+ cfs_list_del_init(&cp->mxr_list);
+ spin_unlock(g_conn_lock);
switch (MXLND_MSG_TYPE(cp->mxr_match)) {
case MXLND_MSG_CONN_REQ:
int
mxlnd_timeoutd(void *arg)
{
- int i = 0;
- long id = (long) arg;
- unsigned long now = 0;
- unsigned long next = 0;
- unsigned long delay = CFS_HZ;
- kmx_peer_t *peer = NULL;
- kmx_peer_t *temp = NULL;
- kmx_conn_t *conn = NULL;
- cfs_rwlock_t *g_lock = &kmxlnd_data.kmx_global_lock;
-
- cfs_daemonize("mxlnd_timeoutd");
+ int i = 0;
+ long id = (long) arg;
+ unsigned long now = 0;
+ unsigned long next = 0;
+ unsigned long delay = msecs_to_jiffies(MSEC_PER_SEC);
+ kmx_peer_t *peer = NULL;
+ kmx_peer_t *temp = NULL;
+ kmx_conn_t *conn = NULL;
+ rwlock_t *g_lock = &kmxlnd_data.kmx_global_lock;
CDEBUG(D_NET, "timeoutd starting\n");
- while (!(cfs_atomic_read(&kmxlnd_data.kmx_shutdown))) {
+ while (!(atomic_read(&kmxlnd_data.kmx_shutdown))) {
now = jiffies;
/* if the next timeout has not arrived, go back to sleep */
}
/* try to progress peers' txs */
- cfs_write_lock(g_lock);
+ write_lock(g_lock);
for (i = 0; i < MXLND_HASH_SIZE; i++) {
cfs_list_t *peers = &kmxlnd_data.kmx_peers[i];
* not against the removal of temp */
cfs_list_for_each_entry_safe(peer, temp, peers,
mxp_list) {
- if (cfs_atomic_read(&kmxlnd_data.kmx_shutdown))
+ if (atomic_read(&kmxlnd_data.kmx_shutdown))
break;
mxlnd_peer_addref(peer); /* add ref... */
conn = peer->mxp_conn;
continue;
}
- if ((conn->mxk_status == MXLND_CONN_READY ||
- conn->mxk_status == MXLND_CONN_FAIL) &&
- cfs_time_after(now,
- conn->mxk_last_tx +
- CFS_HZ)) {
- cfs_write_unlock(g_lock);
- mxlnd_check_sends(peer);
- cfs_write_lock(g_lock);
- }
- mxlnd_conn_decref(conn); /* until here */
- mxlnd_peer_decref(peer); /* ...to here */
- }
- }
- cfs_write_unlock(g_lock);
+ if ((conn->mxk_status == MXLND_CONN_READY ||
+ conn->mxk_status == MXLND_CONN_FAIL) &&
+ cfs_time_after(now,
+ conn->mxk_last_tx +
+ msecs_to_jiffies(MSEC_PER_SEC))) {
+ write_unlock(g_lock);
+ mxlnd_check_sends(peer);
+ write_lock(g_lock);
+ }
+ mxlnd_conn_decref(conn); /* until here */
+ mxlnd_peer_decref(peer); /* ...to here */
+ }
+ }
+ write_unlock(g_lock);
mxlnd_sleep(delay);
}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff