void
ksocknal_peer_failed(struct ksock_peer_ni *peer_ni)
{
- int notify = 0;
+ bool notify = false;
time64_t last_alive = 0;
/* There has been a connection failure or comms error; but I'll only
list_empty(&peer_ni->ksnp_conns) &&
peer_ni->ksnp_accepting == 0 &&
ksocknal_find_connecting_route_locked(peer_ni) == NULL) {
- notify = 1;
+ notify = true;
last_alive = peer_ni->ksnp_last_alive;
}
void
ksocknal_terminate_conn(struct ksock_conn *conn)
{
- /* This gets called by the reaper (guaranteed thread context) to
- * disengage the socket from its callbacks and close it.
- * ksnc_refcount will eventually hit zero, and then the reaper will
- * destroy it. */
+ /* This gets called by the reaper (guaranteed thread context) to
+ * disengage the socket from its callbacks and close it.
+ * ksnc_refcount will eventually hit zero, and then the reaper will
+ * destroy it.
+ */
struct ksock_peer_ni *peer_ni = conn->ksnc_peer;
struct ksock_sched *sched = conn->ksnc_scheduler;
- int failed = 0;
+ bool failed = false;
- LASSERT(conn->ksnc_closing);
+ LASSERT(conn->ksnc_closing);
- /* wake up the scheduler to "send" all remaining packets to /dev/null */
+ /* wake up the scheduler to "send" all remaining packets to /dev/null */
spin_lock_bh(&sched->kss_lock);
- /* a closing conn is always ready to tx */
- conn->ksnc_tx_ready = 1;
+ /* a closing conn is always ready to tx */
+ conn->ksnc_tx_ready = 1;
- if (!conn->ksnc_tx_scheduled &&
+ if (!conn->ksnc_tx_scheduled &&
!list_empty(&conn->ksnc_tx_queue)) {
list_add_tail(&conn->ksnc_tx_list,
- &sched->kss_tx_conns);
- conn->ksnc_tx_scheduled = 1;
- /* extra ref for scheduler */
+ &sched->kss_tx_conns);
+ conn->ksnc_tx_scheduled = 1;
+ /* extra ref for scheduler */
ksocknal_conn_addref(conn);
wake_up (&sched->kss_waitq);
/* serialise with callbacks */
write_lock_bh(&ksocknal_data.ksnd_global_lock);
- ksocknal_lib_reset_callback(conn->ksnc_sock, conn);
+ ksocknal_lib_reset_callback(conn->ksnc_sock, conn);
- /* OK, so this conn may not be completely disengaged from its
- * scheduler yet, but it _has_ committed to terminate... */
- conn->ksnc_scheduler->kss_nconns--;
+ /* OK, so this conn may not be completely disengaged from its
+ * scheduler yet, but it _has_ committed to terminate...
+ */
+ conn->ksnc_scheduler->kss_nconns--;
- if (peer_ni->ksnp_error != 0) {
- /* peer_ni's last conn closed in error */
+ if (peer_ni->ksnp_error != 0) {
+ /* peer_ni's last conn closed in error */
LASSERT(list_empty(&peer_ni->ksnp_conns));
- failed = 1;
- peer_ni->ksnp_error = 0; /* avoid multiple notifications */
- }
+ failed = true;
+ peer_ni->ksnp_error = 0; /* avoid multiple notifications */
+ }
write_unlock_bh(&ksocknal_data.ksnd_global_lock);
- if (failed)
- ksocknal_peer_failed(peer_ni);
+ if (failed)
+ ksocknal_peer_failed(peer_ni);
- /* The socket is closed on the final put; either here, or in
- * ksocknal_{send,recv}msg(). Since we set up the linger2 option
- * when the connection was established, this will close the socket
- * immediately, aborting anything buffered in it. Any hung
- * zero-copy transmits will therefore complete in finite time. */
- ksocknal_connsock_decref(conn);
+ /* The socket is closed on the final put; either here, or in
+ * ksocknal_{send,recv}msg(). Since we set up the linger2 option
+ * when the connection was established, this will close the socket
+ * immediately, aborting anything buffered in it. Any hung
+ * zero-copy transmits will therefore complete in finite time.
+ */
+ ksocknal_connsock_decref(conn);
}
void
for (i = 0; i < net->ksnn_ninterfaces; i++) {
char *ifnam = &net->ksnn_interfaces[i].ksni_name[0];
char *colon = strchr(ifnam, ':');
- int found = 0;
+ bool found = false;
struct ksock_net *tmp;
int j;
*colon = 0;
list_for_each_entry(tmp, &ksocknal_data.ksnd_nets,
- ksnn_list) {
+ ksnn_list) {
for (j = 0; !found && j < tmp->ksnn_ninterfaces; j++) {
char *ifnam2 = &tmp->ksnn_interfaces[j].\
- ksni_name[0];
+ ksni_name[0];
char *colon2 = strchr(ifnam2, ':');
if (colon2 != NULL)
spin_lock_bh(&sched->kss_lock);
while (!ksocknal_data.ksnd_shuttingdown) {
- int did_something = 0;
+ bool did_something = false;
/* Ensure I progress everything semi-fairly */
ksocknal_conn_decref(conn);
}
- did_something = 1;
+ did_something = true;
}
if (!list_empty(&sched->kss_tx_conns)) {
ksocknal_conn_decref(conn);
}
- did_something = 1;
+ did_something = true;
}
if (!did_something || /* nothing to do */
need_resched()) { /* hogging CPU? */
return 0;
}
-static int
+static bool
ksocknal_connect(struct ksock_route *route)
{
LIST_HEAD(zombies);
struct ksock_peer_ni *peer_ni = route->ksnr_peer;
- int type;
- int wanted;
- struct socket *sock;
+ int type;
+ int wanted;
+ struct socket *sock;
time64_t deadline;
- int retry_later = 0;
- int rc = 0;
+ bool retry_later = false;
+ int rc = 0;
deadline = ktime_get_seconds() + ksocknal_timeout();
write_lock_bh(&ksocknal_data.ksnd_global_lock);
- LASSERT (route->ksnr_scheduled);
- LASSERT (!route->ksnr_connecting);
+ LASSERT(route->ksnr_scheduled);
+ LASSERT(!route->ksnr_connecting);
- route->ksnr_connecting = 1;
+ route->ksnr_connecting = 1;
for (;;) {
wanted = ksocknal_route_mask() & ~route->ksnr_connected;
* route got connected while queued */
if (peer_ni->ksnp_closing || route->ksnr_deleted ||
wanted == 0) {
- retry_later = 0;
+ retry_later = false;
break;
}
CDEBUG(D_NET,
"peer_ni %s(%d) already connecting to me, retry later.\n",
libcfs_nid2str(peer_ni->ksnp_id.nid), peer_ni->ksnp_accepting);
- retry_later = 1;
+ retry_later = true;
}
if (retry_later) /* needs reschedule */
write_lock_bh(&ksocknal_data.ksnd_global_lock);
}
- route->ksnr_scheduled = 0;
- route->ksnr_connecting = 0;
+ route->ksnr_scheduled = 0;
+ route->ksnr_connecting = 0;
- if (retry_later) {
- /* re-queue for attention; this frees me up to handle
- * the peer_ni's incoming connection request */
+ if (retry_later) {
+ /* re-queue for attention; this frees me up to handle
+ * the peer_ni's incoming connection request
+ */
- if (rc == EALREADY ||
- (rc == 0 && peer_ni->ksnp_accepting > 0)) {
- /* We want to introduce a delay before next
- * attempt to connect if we lost conn race,
- * but the race is resolved quickly usually,
- * so min_reconnectms should be good heuristic */
+ if (rc == EALREADY ||
+ (rc == 0 && peer_ni->ksnp_accepting > 0)) {
+ /* We want to introduce a delay before next
+ * attempt to connect if we lost conn race, but
+ * the race is resolved quickly usually, so
+ * min_reconnectms should be good heuristic
+ */
route->ksnr_retry_interval = *ksocknal_tunables.ksnd_min_reconnectms / 1000;
route->ksnr_timeout = ktime_get_seconds() +
- route->ksnr_retry_interval;
- }
+ route->ksnr_retry_interval;
+ }
- ksocknal_launch_connection_locked(route);
- }
+ ksocknal_launch_connection_locked(route);
+ }
write_unlock_bh(&ksocknal_data.ksnd_global_lock);
- return retry_later;
+ return retry_later;
failed:
write_lock_bh(&ksocknal_data.ksnd_global_lock);
- route->ksnr_scheduled = 0;
- route->ksnr_connecting = 0;
+ route->ksnr_scheduled = 0;
+ route->ksnr_connecting = 0;
/* This is a retry rather than a new connection */
route->ksnr_retry_interval *= 2;
route->ksnr_timeout = ktime_get_seconds() + route->ksnr_retry_interval;
if (!list_empty(&peer_ni->ksnp_tx_queue) &&
- peer_ni->ksnp_accepting == 0 &&
- ksocknal_find_connecting_route_locked(peer_ni) == NULL) {
+ peer_ni->ksnp_accepting == 0 &&
+ ksocknal_find_connecting_route_locked(peer_ni) == NULL) {
struct ksock_conn *conn;
- /* ksnp_tx_queue is queued on a conn on successful
- * connection for V1.x and V2.x */
+ /* ksnp_tx_queue is queued on a conn on successful
+ * connection for V1.x and V2.x
+ */
if (!list_empty(&peer_ni->ksnp_conns)) {
conn = list_entry(peer_ni->ksnp_conns.next,
struct ksock_conn, ksnc_list);
- LASSERT (conn->ksnc_proto == &ksocknal_protocol_v3x);
- }
+ LASSERT(conn->ksnc_proto == &ksocknal_protocol_v3x);
+ }
- /* take all the blocked packets while I've got the lock and
- * complete below... */
+ /* take all the blocked packets while I've got the lock and
+ * complete below...
+ */
list_splice_init(&peer_ni->ksnp_tx_queue, &zombies);
- }
+ }
write_unlock_bh(&ksocknal_data.ksnd_global_lock);
struct ksock_route *route = NULL;
time64_t sec = ktime_get_real_seconds();
long timeout = MAX_SCHEDULE_TIMEOUT;
- int dropped_lock = 0;
+ bool dropped_lock = false;
if (ksocknal_connd_check_stop(sec, &timeout)) {
/* wakeup another one to check stop */
break;
}
- if (ksocknal_connd_check_start(sec, &timeout)) {
- /* created new thread */
- dropped_lock = 1;
- }
+ if (ksocknal_connd_check_start(sec, &timeout)) {
+ /* created new thread */
+ dropped_lock = true;
+ }
if (!list_empty(&ksocknal_data.ksnd_connd_connreqs)) {
- /* Connection accepted by the listener */
+ /* Connection accepted by the listener */
cr = list_entry(ksocknal_data.ksnd_connd_connreqs.next,
struct ksock_connreq, ksncr_list);
list_del(&cr->ksncr_list);
spin_unlock_bh(connd_lock);
- dropped_lock = 1;
+ dropped_lock = true;
ksocknal_create_conn(cr->ksncr_ni, NULL,
cr->ksncr_sock, SOCKLND_CONN_NONE);
LIBCFS_FREE(cr, sizeof(*cr));
spin_lock_bh(connd_lock);
- }
+ }
- /* Only handle an outgoing connection request if there
- * is a thread left to handle incoming connections and
- * create new connd */
- if (ksocknal_data.ksnd_connd_connecting + SOCKNAL_CONND_RESV <
- ksocknal_data.ksnd_connd_running) {
- route = ksocknal_connd_get_route_locked(&timeout);
- }
- if (route != NULL) {
+ /* Only handle an outgoing connection request if there
+ * is a thread left to handle incoming connections and
+ * create new connd
+ */
+ if (ksocknal_data.ksnd_connd_connecting + SOCKNAL_CONND_RESV <
+ ksocknal_data.ksnd_connd_running) {
+ route = ksocknal_connd_get_route_locked(&timeout);
+ }
+ if (route != NULL) {
list_del(&route->ksnr_connd_list);
- ksocknal_data.ksnd_connd_connecting++;
+ ksocknal_data.ksnd_connd_connecting++;
spin_unlock_bh(connd_lock);
- dropped_lock = 1;
+ dropped_lock = true;
if (ksocknal_connect(route)) {
/* consecutive retry */
cons_retry = 0;
}
- ksocknal_route_decref(route);
+ ksocknal_route_decref(route);
spin_lock_bh(connd_lock);
ksocknal_data.ksnd_connd_connecting--;
/* Nothing to do for 'timeout' */
set_current_state(TASK_INTERRUPTIBLE);
- add_wait_queue_exclusive(&ksocknal_data.ksnd_connd_waitq, &wait);
+ add_wait_queue_exclusive(&ksocknal_data.ksnd_connd_waitq,
+ &wait);
spin_unlock_bh(connd_lock);
schedule_timeout(timeout);
git://git.whamcloud.com / fs / lustre-release.git / commitdiff