Lines Matching refs:sc
83 #define SC_NODEF_ARGS(sc) sc->sc_node->nd_name, sc->sc_node->nd_num, \
84 NIPQUAD(sc->sc_node->nd_ipv4_address), \
85 ntohs(sc->sc_node->nd_ipv4_port)
102 #define sclog(sc, fmt, args...) do { \
103 typeof(sc) __sc = (sc); \
104 mlog(ML_SOCKET, "[sc %p refs %d sock %p node %u page %p " \
148 static void o2net_sc_postpone_idle(struct o2net_sock_container *sc);
149 static void o2net_sc_reset_idle_timer(struct o2net_sock_container *sc);
287 struct o2net_sock_container *sc = container_of(kref,
289 BUG_ON(timer_pending(&sc->sc_idle_timeout));
291 sclog(sc, "releasing\n");
293 if (sc->sc_sock) {
294 sock_release(sc->sc_sock);
295 sc->sc_sock = NULL;
298 o2nm_node_put(sc->sc_node);
299 sc->sc_node = NULL;
301 kfree(sc);
304 static void sc_put(struct o2net_sock_container *sc)
306 sclog(sc, "put\n");
307 kref_put(&sc->sc_kref, sc_kref_release);
309 static void sc_get(struct o2net_sock_container *sc)
311 sclog(sc, "get\n");
312 kref_get(&sc->sc_kref);
316 struct o2net_sock_container *sc, *ret = NULL;
320 sc = kzalloc(sizeof(*sc), GFP_NOFS);
321 if (sc == NULL || page == NULL)
324 kref_init(&sc->sc_kref);
326 sc->sc_node = node;
328 INIT_WORK(&sc->sc_connect_work, o2net_sc_connect_completed);
329 INIT_WORK(&sc->sc_rx_work, o2net_rx_until_empty);
330 INIT_WORK(&sc->sc_shutdown_work, o2net_shutdown_sc);
331 INIT_DELAYED_WORK(&sc->sc_keepalive_work, o2net_sc_send_keep_req);
333 init_timer(&sc->sc_idle_timeout);
334 sc->sc_idle_timeout.function = o2net_idle_timer;
335 sc->sc_idle_timeout.data = (unsigned long)sc;
337 sclog(sc, "alloced\n");
339 ret = sc;
340 sc->sc_page = page;
341 sc = NULL;
347 kfree(sc);
354 static void o2net_sc_queue_work(struct o2net_sock_container *sc,
357 sc_get(sc);
359 sc_put(sc);
361 static void o2net_sc_queue_delayed_work(struct o2net_sock_container *sc,
365 sc_get(sc);
367 sc_put(sc);
369 static void o2net_sc_cancel_delayed_work(struct o2net_sock_container *sc,
373 sc_put(sc);
384 struct o2net_sock_container *sc,
393 if (old_sc && !sc)
395 else if (!old_sc && sc)
399 * an non-null sc from being overwritten with another */
400 BUG_ON(sc && nn->nn_sc && nn->nn_sc != sc);
402 mlog_bug_on_msg(valid && !sc, "valid %u sc %p\n", valid, sc);
409 mlog(ML_CONN, "node %u sc: %p -> %p, valid %u -> %u, err %d -> %d\n",
410 o2net_num_from_nn(nn), nn->nn_sc, sc, nn->nn_sc_valid, valid,
413 nn->nn_sc = sc;
442 o2nm_this_node() > sc->sc_node->nd_num ?
444 SC_NODEF_ARGS(sc));
456 msecs_to_jiffies(o2net_reconnect_delay(sc->sc_node)))
458 if (delay > msecs_to_jiffies(o2net_reconnect_delay(sc->sc_node)))
464 /* keep track of the nn's sc ref for the caller */
465 if ((old_sc == NULL) && sc)
466 sc_get(sc);
467 if (old_sc && (old_sc != sc)) {
480 struct o2net_sock_container *sc = sk->sk_user_data;
481 sclog(sc, "data_ready hit\n");
482 do_gettimeofday(&sc->sc_tv_data_ready);
483 o2net_sc_queue_work(sc, &sc->sc_rx_work);
484 ready = sc->sc_data_ready;
497 struct o2net_sock_container *sc;
500 sc = sk->sk_user_data;
501 if (sc == NULL) {
506 sclog(sc, "state_change to %d\n", sk->sk_state);
508 state_change = sc->sc_state_change;
516 o2net_sc_queue_work(sc, &sc->sc_connect_work);
519 o2net_sc_queue_work(sc, &sc->sc_shutdown_work);
533 struct o2net_sock_container *sc)
544 sk->sk_user_data = sc;
545 sc_get(sc);
547 sc->sc_data_ready = sk->sk_data_ready;
548 sc->sc_state_change = sk->sk_state_change;
552 mutex_init(&sc->sc_send_lock);
558 struct o2net_sock_container *sc)
563 if (sk->sk_user_data == sc) {
566 sk->sk_data_ready = sc->sc_data_ready;
567 sk->sk_state_change = sc->sc_state_change;
576 * with an sc and want to detach it from the nn if someone already hasn't beat
581 struct o2net_sock_container *sc,
585 if (nn->nn_sc == sc)
593 * sc detached from the nn. state_change will also trigger this callback
600 struct o2net_sock_container *sc =
603 struct o2net_node *nn = o2net_nn_from_num(sc->sc_node->nd_num);
605 sclog(sc, "shutting down\n");
608 if (o2net_unregister_callbacks(sc->sc_sock->sk, sc)) {
610 * races with pending sc work structs are harmless */
611 del_timer_sync(&sc->sc_idle_timeout);
612 o2net_sc_cancel_delayed_work(sc, &sc->sc_keepalive_work);
613 sc_put(sc);
614 sc->sc_sock->ops->shutdown(sc->sc_sock,
620 o2net_ensure_shutdown(nn, sc, 0);
621 sc_put(sc);
848 static void o2net_sendpage(struct o2net_sock_container *sc,
852 struct o2net_node *nn = o2net_nn_from_num(sc->sc_node->nd_num);
856 mutex_lock(&sc->sc_send_lock);
857 ret = sc->sc_sock->ops->sendpage(sc->sc_sock,
861 mutex_unlock(&sc->sc_send_lock);
864 " failed with %zd\n", size, SC_NODEF_ARGS(sc), ret);
865 o2net_ensure_shutdown(nn, sc, 0);
910 struct o2net_sock_container *sc = NULL;
941 o2net_tx_can_proceed(nn, &sc, &error));
976 mutex_lock(&sc->sc_send_lock);
977 ret = o2net_send_tcp_msg(sc->sc_sock, vec, veclen,
979 mutex_unlock(&sc->sc_send_lock);
999 if (sc)
1000 sc_put(sc);
1046 static int o2net_process_message(struct o2net_sock_container *sc,
1049 struct o2net_node *nn = o2net_nn_from_num(sc->sc_node->nd_num);
1057 o2net_sc_postpone_idle(sc);
1068 o2net_sendpage(sc, o2net_keep_resp,
1101 do_gettimeofday(&sc->sc_tv_func_start);
1102 sc->sc_msg_key = be32_to_cpu(hdr->key);
1103 sc->sc_msg_type = be16_to_cpu(hdr->msg_type);
1107 do_gettimeofday(&sc->sc_tv_func_stop);
1111 mutex_lock(&sc->sc_send_lock);
1112 ret = o2net_send_status_magic(sc->sc_sock, hdr, syserr,
1114 mutex_unlock(&sc->sc_send_lock);
1132 static int o2net_check_handshake(struct o2net_sock_container *sc)
1134 struct o2net_handshake *hand = page_address(sc->sc_page);
1135 struct o2net_node *nn = o2net_nn_from_num(sc->sc_node->nd_num);
1140 SC_NODEF_ARGS(sc),
1145 o2net_ensure_shutdown(nn, sc, -ENOTCONN);
1155 o2net_idle_timeout(sc->sc_node)) {
1158 SC_NODEF_ARGS(sc),
1160 o2net_idle_timeout(sc->sc_node));
1161 o2net_ensure_shutdown(nn, sc, -ENOTCONN);
1166 o2net_keepalive_delay(sc->sc_node)) {
1169 SC_NODEF_ARGS(sc),
1171 o2net_keepalive_delay(sc->sc_node));
1172 o2net_ensure_shutdown(nn, sc, -ENOTCONN);
1180 SC_NODEF_ARGS(sc),
1183 o2net_ensure_shutdown(nn, sc, -ENOTCONN);
1187 sc->sc_handshake_ok = 1;
1192 if (nn->nn_sc == sc) {
1193 o2net_sc_reset_idle_timer(sc);
1194 o2net_set_nn_state(nn, sc, 1, 0);
1199 sc->sc_page_off -= sizeof(struct o2net_handshake);
1200 if (sc->sc_page_off)
1201 memmove(hand, hand + 1, sc->sc_page_off);
1209 static int o2net_advance_rx(struct o2net_sock_container *sc)
1216 sclog(sc, "receiving\n");
1217 do_gettimeofday(&sc->sc_tv_advance_start);
1219 if (unlikely(sc->sc_handshake_ok == 0)) {
1220 if(sc->sc_page_off < sizeof(struct o2net_handshake)) {
1221 data = page_address(sc->sc_page) + sc->sc_page_off;
1222 datalen = sizeof(struct o2net_handshake) - sc->sc_page_off;
1223 ret = o2net_recv_tcp_msg(sc->sc_sock, data, datalen);
1225 sc->sc_page_off += ret;
1228 if (sc->sc_page_off == sizeof(struct o2net_handshake)) {
1229 o2net_check_handshake(sc);
1230 if (unlikely(sc->sc_handshake_ok == 0))
1237 if (sc->sc_page_off < sizeof(struct o2net_msg)) {
1238 data = page_address(sc->sc_page) + sc->sc_page_off;
1239 datalen = sizeof(struct o2net_msg) - sc->sc_page_off;
1240 ret = o2net_recv_tcp_msg(sc->sc_sock, data, datalen);
1242 sc->sc_page_off += ret;
1246 if (sc->sc_page_off == sizeof(struct o2net_msg)) {
1247 hdr = page_address(sc->sc_page);
1257 if (sc->sc_page_off < sizeof(struct o2net_msg)) {
1263 hdr = page_address(sc->sc_page);
1265 msglog(hdr, "at page_off %zu\n", sc->sc_page_off);
1268 if (sc->sc_page_off - sizeof(struct o2net_msg) < be16_to_cpu(hdr->data_len)) {
1270 data = page_address(sc->sc_page) + sc->sc_page_off;
1272 sc->sc_page_off;
1273 ret = o2net_recv_tcp_msg(sc->sc_sock, data, datalen);
1275 sc->sc_page_off += ret;
1280 if (sc->sc_page_off - sizeof(struct o2net_msg) == be16_to_cpu(hdr->data_len)) {
1284 ret = o2net_process_message(sc, hdr);
1287 sc->sc_page_off = 0;
1291 sclog(sc, "ret = %d\n", ret);
1292 do_gettimeofday(&sc->sc_tv_advance_stop);
1301 struct o2net_sock_container *sc =
1306 ret = o2net_advance_rx(sc);
1310 struct o2net_node *nn = o2net_nn_from_num(sc->sc_node->nd_num);
1311 sclog(sc, "saw error %d, closing\n", ret);
1313 o2net_ensure_shutdown(nn, sc, 0);
1316 sc_put(sc);
1359 * rx path will see the response and mark the sc valid */
1362 struct o2net_sock_container *sc =
1366 mlog(ML_MSG, "sc sending handshake with ver %llu id %llx\n",
1371 o2net_sendpage(sc, o2net_hand, sizeof(*o2net_hand));
1372 sc_put(sc);
1378 struct o2net_sock_container *sc =
1382 o2net_sendpage(sc, o2net_keep_req, sizeof(*o2net_keep_req));
1383 sc_put(sc);
1387 * we can't start this timer until we've got to the point in sc buildup
1391 struct o2net_sock_container *sc = (struct o2net_sock_container *)data;
1397 "seconds, shutting it down.\n", SC_NODEF_ARGS(sc),
1398 o2net_idle_timeout(sc->sc_node) / 1000,
1399 o2net_idle_timeout(sc->sc_node) % 1000);
1403 sc->sc_tv_timer.tv_sec, (long) sc->sc_tv_timer.tv_usec,
1405 sc->sc_tv_data_ready.tv_sec, (long) sc->sc_tv_data_ready.tv_usec,
1406 sc->sc_tv_advance_start.tv_sec,
1407 (long) sc->sc_tv_advance_start.tv_usec,
1408 sc->sc_tv_advance_stop.tv_sec,
1409 (long) sc->sc_tv_advance_stop.tv_usec,
1410 sc->sc_msg_key, sc->sc_msg_type,
1411 sc->sc_tv_func_start.tv_sec, (long) sc->sc_tv_func_start.tv_usec,
1412 sc->sc_tv_func_stop.tv_sec, (long) sc->sc_tv_func_stop.tv_usec);
1414 o2net_sc_queue_work(sc, &sc->sc_shutdown_work);
1417 static void o2net_sc_reset_idle_timer(struct o2net_sock_container *sc)
1419 o2net_sc_cancel_delayed_work(sc, &sc->sc_keepalive_work);
1420 o2net_sc_queue_delayed_work(sc, &sc->sc_keepalive_work,
1421 msecs_to_jiffies(o2net_keepalive_delay(sc->sc_node)));
1422 do_gettimeofday(&sc->sc_tv_timer);
1423 mod_timer(&sc->sc_idle_timeout,
1424 jiffies + msecs_to_jiffies(o2net_idle_timeout(sc->sc_node)));
1427 static void o2net_sc_postpone_idle(struct o2net_sock_container *sc)
1430 if (timer_pending(&sc->sc_idle_timeout))
1431 o2net_sc_reset_idle_timer(sc);
1443 struct o2net_sock_container *sc = NULL;
1475 sc = sc_alloc(node);
1476 if (sc == NULL) {
1477 mlog(0, "couldn't allocate sc\n");
1487 sc->sc_sock = sock; /* freed by sc_kref_release */
1503 ret = o2net_set_nodelay(sc->sc_sock);
1509 o2net_register_callbacks(sc->sc_sock->sk, sc);
1513 o2net_set_nn_state(nn, sc, 0, 0);
1520 ret = sc->sc_sock->ops->connect(sc->sc_sock,
1530 "with errno %d\n", SC_NODEF_ARGS(sc), ret);
1533 if (sc)
1534 o2net_ensure_shutdown(nn, sc, 0);
1536 if (sc)
1537 sc_put(sc);
1665 struct o2net_sock_container *sc = NULL;
1739 sc = sc_alloc(node);
1740 if (sc == NULL) {
1745 sc->sc_sock = new_sock;
1749 o2net_set_nn_state(nn, sc, 0, 0);
1752 o2net_register_callbacks(sc->sc_sock->sk, sc);
1753 o2net_sc_queue_work(sc, &sc->sc_rx_work);
1756 o2net_sendpage(sc, o2net_hand, sizeof(*o2net_hand));
1763 if (sc)
1764 sc_put(sc);