Lines Matching defs:sc
63 #define SC_NODEF_ARGS(sc) sc->sc_node->nd_name, sc->sc_node->nd_num, \
64 &sc->sc_node->nd_ipv4_address, \
65 ntohs(sc->sc_node->nd_ipv4_port)
82 #define sclog(sc, fmt, args...) do { \
83 typeof(sc) __sc = (sc); \
84 mlog(ML_SOCKET, "[sc %p refs %d sock %p node %u page %p " \
129 static void o2net_sc_postpone_idle(struct o2net_sock_container *sc);
130 static void o2net_sc_reset_idle_timer(struct o2net_sock_container *sc);
159 struct o2net_sock_container *sc)
161 nst->st_sc = sc;
170 static inline void o2net_set_sock_timer(struct o2net_sock_container *sc)
172 sc->sc_tv_timer = ktime_get();
175 static inline void o2net_set_data_ready_time(struct o2net_sock_container *sc)
177 sc->sc_tv_data_ready = ktime_get();
180 static inline void o2net_set_advance_start_time(struct o2net_sock_container *sc)
182 sc->sc_tv_advance_start = ktime_get();
185 static inline void o2net_set_advance_stop_time(struct o2net_sock_container *sc)
187 sc->sc_tv_advance_stop = ktime_get();
190 static inline void o2net_set_func_start_time(struct o2net_sock_container *sc)
192 sc->sc_tv_func_start = ktime_get();
195 static inline void o2net_set_func_stop_time(struct o2net_sock_container *sc)
197 sc->sc_tv_func_stop = ktime_get();
216 static ktime_t o2net_get_func_run_time(struct o2net_sock_container *sc)
218 return ktime_sub(sc->sc_tv_func_stop, sc->sc_tv_func_start);
222 struct o2net_sock_container *sc)
224 sc->sc_tv_status_total = ktime_add(sc->sc_tv_status_total,
227 sc->sc_tv_send_total = ktime_add(sc->sc_tv_send_total,
230 sc->sc_tv_acquiry_total = ktime_add(sc->sc_tv_acquiry_total,
233 sc->sc_send_count++;
236 static void o2net_update_recv_stats(struct o2net_sock_container *sc)
238 sc->sc_tv_process_total = ktime_add(sc->sc_tv_process_total,
239 o2net_get_func_run_time(sc));
240 sc->sc_recv_count++;
247 # define o2net_update_recv_stats(sc)
379 struct o2net_sock_container *sc = container_of(kref,
381 BUG_ON(timer_pending(&sc->sc_idle_timeout));
383 sclog(sc, "releasing\n");
385 if (sc->sc_sock) {
386 sock_release(sc->sc_sock);
387 sc->sc_sock = NULL;
390 o2nm_undepend_item(&sc->sc_node->nd_item);
391 o2nm_node_put(sc->sc_node);
392 sc->sc_node = NULL;
394 o2net_debug_del_sc(sc);
396 if (sc->sc_page)
397 __free_page(sc->sc_page);
398 kfree(sc);
401 static void sc_put(struct o2net_sock_container *sc)
403 sclog(sc, "put\n");
404 kref_put(&sc->sc_kref, sc_kref_release);
406 static void sc_get(struct o2net_sock_container *sc)
408 sclog(sc, "get\n");
409 kref_get(&sc->sc_kref);
413 struct o2net_sock_container *sc, *ret = NULL;
418 sc = kzalloc(sizeof(*sc), GFP_NOFS);
419 if (sc == NULL || page == NULL)
422 kref_init(&sc->sc_kref);
424 sc->sc_node = node;
433 INIT_WORK(&sc->sc_connect_work, o2net_sc_connect_completed);
434 INIT_WORK(&sc->sc_rx_work, o2net_rx_until_empty);
435 INIT_WORK(&sc->sc_shutdown_work, o2net_shutdown_sc);
436 INIT_DELAYED_WORK(&sc->sc_keepalive_work, o2net_sc_send_keep_req);
438 timer_setup(&sc->sc_idle_timeout, o2net_idle_timer, 0);
440 sclog(sc, "alloced\n");
442 ret = sc;
443 sc->sc_page = page;
444 o2net_debug_add_sc(sc);
445 sc = NULL;
451 kfree(sc);
458 static void o2net_sc_queue_work(struct o2net_sock_container *sc,
461 sc_get(sc);
463 sc_put(sc);
465 static void o2net_sc_queue_delayed_work(struct o2net_sock_container *sc,
469 sc_get(sc);
471 sc_put(sc);
473 static void o2net_sc_cancel_delayed_work(struct o2net_sock_container *sc,
477 sc_put(sc);
488 struct o2net_sock_container *sc,
497 if (old_sc && !sc)
499 else if (!old_sc && sc)
503 * an non-null sc from being overwritten with another */
504 BUG_ON(sc && nn->nn_sc && nn->nn_sc != sc);
506 mlog_bug_on_msg(valid && !sc, "valid %u sc %p\n", valid, sc);
511 mlog(ML_CONN, "node %u sc: %p -> %p, valid %u -> %u, err %d -> %d\n",
512 o2net_num_from_nn(nn), nn->nn_sc, sc, nn->nn_sc_valid, valid,
515 nn->nn_sc = sc;
540 o2nm_this_node() > sc->sc_node->nd_num ?
542 SC_NODEF_ARGS(sc));
574 /* keep track of the nn's sc ref for the caller */
575 if ((old_sc == NULL) && sc)
576 sc_get(sc);
577 if (old_sc && (old_sc != sc)) {
587 struct o2net_sock_container *sc;
592 sc = sk->sk_user_data;
593 if (sc) {
594 sclog(sc, "data_ready hit\n");
595 o2net_set_data_ready_time(sc);
596 o2net_sc_queue_work(sc, &sc->sc_rx_work);
597 ready = sc->sc_data_ready;
610 struct o2net_sock_container *sc;
613 sc = sk->sk_user_data;
614 if (sc == NULL) {
619 sclog(sc, "state_change to %d\n", sk->sk_state);
621 state_change = sc->sc_state_change;
629 o2net_sc_queue_work(sc, &sc->sc_connect_work);
634 SC_NODEF_ARGS(sc), sk->sk_state);
635 o2net_sc_queue_work(sc, &sc->sc_shutdown_work);
649 struct o2net_sock_container *sc)
660 sk->sk_user_data = sc;
661 sc_get(sc);
663 sc->sc_data_ready = sk->sk_data_ready;
664 sc->sc_state_change = sk->sk_state_change;
668 mutex_init(&sc->sc_send_lock);
674 struct o2net_sock_container *sc)
679 if (sk->sk_user_data == sc) {
682 sk->sk_data_ready = sc->sc_data_ready;
683 sk->sk_state_change = sc->sc_state_change;
692 * with an sc and want to detach it from the nn if someone already hasn't beat
697 struct o2net_sock_container *sc,
701 if (nn->nn_sc == sc)
709 * sc detached from the nn. state_change will also trigger this callback
716 struct o2net_sock_container *sc =
719 struct o2net_node *nn = o2net_nn_from_num(sc->sc_node->nd_num);
721 sclog(sc, "shutting down\n");
724 if (o2net_unregister_callbacks(sc->sc_sock->sk, sc)) {
726 * races with pending sc work structs are harmless */
727 del_timer_sync(&sc->sc_idle_timeout);
728 o2net_sc_cancel_delayed_work(sc, &sc->sc_keepalive_work);
729 sc_put(sc);
730 kernel_sock_shutdown(sc->sc_sock, SHUT_RDWR);
735 o2net_ensure_shutdown(nn, sc, 0);
736 sc_put(sc);
932 static void o2net_sendpage(struct o2net_sock_container *sc,
935 struct o2net_node *nn = o2net_nn_from_num(sc->sc_node->nd_num);
945 mutex_lock(&sc->sc_send_lock);
946 ret = sock_sendmsg(sc->sc_sock, &msg);
947 mutex_unlock(&sc->sc_send_lock);
953 " returned EAGAIN\n", size, SC_NODEF_ARGS(sc));
958 " failed with %zd\n", size, SC_NODEF_ARGS(sc), ret);
959 o2net_ensure_shutdown(nn, sc, 0);
1001 struct o2net_sock_container *sc;
1006 if (!o2net_tx_can_proceed(o2net_nn_from_num(node), &sc, &ret))
1010 sc_put(sc);
1023 struct o2net_sock_container *sc = NULL;
1060 wait_event(nn->nn_sc_wq, o2net_tx_can_proceed(nn, &sc, &ret));
1064 o2net_set_nst_sock_container(&nst, sc);
1098 mutex_lock(&sc->sc_send_lock);
1099 ret = o2net_send_tcp_msg(sc->sc_sock, vec, veclen,
1101 mutex_unlock(&sc->sc_send_lock);
1112 o2net_update_send_stats(&nst, sc);
1124 o2net_debug_del_nst(&nst); /* must be before dropping sc and node */
1125 if (sc)
1126 sc_put(sc);
1170 static int o2net_process_message(struct o2net_sock_container *sc,
1173 struct o2net_node *nn = o2net_nn_from_num(sc->sc_node->nd_num);
1181 o2net_sc_postpone_idle(sc);
1192 o2net_sendpage(sc, o2net_keep_resp,
1224 o2net_set_func_start_time(sc);
1225 sc->sc_msg_key = be32_to_cpu(hdr->key);
1226 sc->sc_msg_type = be16_to_cpu(hdr->msg_type);
1230 o2net_set_func_stop_time(sc);
1232 o2net_update_recv_stats(sc);
1236 mutex_lock(&sc->sc_send_lock);
1237 ret = o2net_send_status_magic(sc->sc_sock, hdr, syserr,
1239 mutex_unlock(&sc->sc_send_lock);
1257 static int o2net_check_handshake(struct o2net_sock_container *sc)
1259 struct o2net_handshake *hand = page_address(sc->sc_page);
1260 struct o2net_node *nn = o2net_nn_from_num(sc->sc_node->nd_num);
1265 "Disconnecting.\n", SC_NODEF_ARGS(sc),
1270 o2net_ensure_shutdown(nn, sc, -ENOTCONN);
1283 "Disconnecting.\n", SC_NODEF_ARGS(sc),
1286 o2net_ensure_shutdown(nn, sc, -ENOTCONN);
1294 "Disconnecting.\n", SC_NODEF_ARGS(sc),
1297 o2net_ensure_shutdown(nn, sc, -ENOTCONN);
1305 "Disconnecting.\n", SC_NODEF_ARGS(sc),
1308 o2net_ensure_shutdown(nn, sc, -ENOTCONN);
1312 sc->sc_handshake_ok = 1;
1317 if (nn->nn_sc == sc) {
1318 o2net_sc_reset_idle_timer(sc);
1320 o2net_set_nn_state(nn, sc, 1, 0);
1325 sc->sc_page_off -= sizeof(struct o2net_handshake);
1326 if (sc->sc_page_off)
1327 memmove(hand, hand + 1, sc->sc_page_off);
1335 static int o2net_advance_rx(struct o2net_sock_container *sc)
1342 sclog(sc, "receiving\n");
1343 o2net_set_advance_start_time(sc);
1345 if (unlikely(sc->sc_handshake_ok == 0)) {
1346 if(sc->sc_page_off < sizeof(struct o2net_handshake)) {
1347 data = page_address(sc->sc_page) + sc->sc_page_off;
1348 datalen = sizeof(struct o2net_handshake) - sc->sc_page_off;
1349 ret = o2net_recv_tcp_msg(sc->sc_sock, data, datalen);
1351 sc->sc_page_off += ret;
1354 if (sc->sc_page_off == sizeof(struct o2net_handshake)) {
1355 o2net_check_handshake(sc);
1356 if (unlikely(sc->sc_handshake_ok == 0))
1363 if (sc->sc_page_off < sizeof(struct o2net_msg)) {
1364 data = page_address(sc->sc_page) + sc->sc_page_off;
1365 datalen = sizeof(struct o2net_msg) - sc->sc_page_off;
1366 ret = o2net_recv_tcp_msg(sc->sc_sock, data, datalen);
1368 sc->sc_page_off += ret;
1372 if (sc->sc_page_off == sizeof(struct o2net_msg)) {
1373 hdr = page_address(sc->sc_page);
1383 if (sc->sc_page_off < sizeof(struct o2net_msg)) {
1389 hdr = page_address(sc->sc_page);
1391 msglog(hdr, "at page_off %zu\n", sc->sc_page_off);
1394 if (sc->sc_page_off - sizeof(struct o2net_msg) < be16_to_cpu(hdr->data_len)) {
1396 data = page_address(sc->sc_page) + sc->sc_page_off;
1398 sc->sc_page_off;
1399 ret = o2net_recv_tcp_msg(sc->sc_sock, data, datalen);
1401 sc->sc_page_off += ret;
1406 if (sc->sc_page_off - sizeof(struct o2net_msg) == be16_to_cpu(hdr->data_len)) {
1410 ret = o2net_process_message(sc, hdr);
1413 sc->sc_page_off = 0;
1417 sclog(sc, "ret = %d\n", ret);
1418 o2net_set_advance_stop_time(sc);
1427 struct o2net_sock_container *sc =
1432 ret = o2net_advance_rx(sc);
1436 struct o2net_node *nn = o2net_nn_from_num(sc->sc_node->nd_num);
1437 sclog(sc, "saw error %d, closing\n", ret);
1439 o2net_ensure_shutdown(nn, sc, 0);
1442 sc_put(sc);
1459 * rx path will see the response and mark the sc valid */
1462 struct o2net_sock_container *sc =
1466 mlog(ML_MSG, "sc sending handshake with ver %llu id %llx\n",
1471 o2net_sendpage(sc, o2net_hand, sizeof(*o2net_hand));
1472 sc_put(sc);
1478 struct o2net_sock_container *sc =
1482 o2net_sendpage(sc, o2net_keep_req, sizeof(*o2net_keep_req));
1483 sc_put(sc);
1487 * we can't start this timer until we've got to the point in sc buildup
1491 struct o2net_sock_container *sc = from_timer(sc, t, sc_idle_timeout);
1492 struct o2net_node *nn = o2net_nn_from_num(sc->sc_node->nd_num);
1495 ktime_to_ms(sc->sc_tv_timer);
1502 SC_NODEF_ARGS(sc), msecs / 1000, msecs % 1000);
1513 o2net_sc_reset_idle_timer(sc);
1517 static void o2net_sc_reset_idle_timer(struct o2net_sock_container *sc)
1519 o2net_sc_cancel_delayed_work(sc, &sc->sc_keepalive_work);
1520 o2net_sc_queue_delayed_work(sc, &sc->sc_keepalive_work,
1522 o2net_set_sock_timer(sc);
1523 mod_timer(&sc->sc_idle_timeout,
1527 static void o2net_sc_postpone_idle(struct o2net_sock_container *sc)
1529 struct o2net_node *nn = o2net_nn_from_num(sc->sc_node->nd_num);
1539 if (timer_pending(&sc->sc_idle_timeout))
1540 o2net_sc_reset_idle_timer(sc);
1552 struct o2net_sock_container *sc = NULL;
1596 sc = sc_alloc(node);
1597 if (sc == NULL) {
1598 mlog(0, "couldn't allocate sc\n");
1608 sc->sc_sock = sock; /* freed by sc_kref_release */
1625 tcp_sock_set_nodelay(sc->sc_sock->sk);
1628 o2net_register_callbacks(sc->sc_sock->sk, sc);
1632 o2net_set_nn_state(nn, sc, 0, 0);
1639 ret = sc->sc_sock->ops->connect(sc->sc_sock,
1647 if (ret && sc) {
1649 " failed with errno %d\n", SC_NODEF_ARGS(sc), ret);
1652 o2net_ensure_shutdown(nn, sc, 0);
1654 if (sc)
1655 sc_put(sc);
1786 struct o2net_sock_container *sc = NULL;
1874 sc = sc_alloc(node);
1875 if (sc == NULL) {
1880 sc->sc_sock = new_sock;
1885 o2net_set_nn_state(nn, sc, 0, 0);
1888 o2net_register_callbacks(sc->sc_sock->sk, sc);
1889 o2net_sc_queue_work(sc, &sc->sc_rx_work);
1892 o2net_sendpage(sc, o2net_hand, sizeof(*o2net_hand));
1901 if (sc)
1902 sc_put(sc);