Lines Matching defs:subflow
84 struct mptcp_subflow_context *subflow;
95 subflow = mptcp_subflow_ctx(ssock->sk);
96 list_add(&subflow->node, &msk->conn_list);
98 subflow->request_mptcp = 1;
99 subflow->subflow_id = msk->subflow_id++;
101 /* This is the first subflow, always with id 0 */
102 WRITE_ONCE(subflow->local_id, 0);
109 /* If the MPC handshake is not started, returns the first subflow,
358 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
368 /* try to fetch required memory from subflow */
378 MPTCP_SKB_CB(skb)->map_seq = mptcp_subflow_get_mapped_dsn(subflow);
496 static long mptcp_timeout_from_subflow(const struct mptcp_subflow_context *subflow)
498 const struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
500 return inet_csk(ssk)->icsk_pending && !subflow->stale_count ?
506 struct mptcp_subflow_context *subflow;
509 mptcp_for_each_subflow(mptcp_sk(sk), subflow)
510 tout = max(tout, mptcp_timeout_from_subflow(subflow));
537 struct mptcp_subflow_context *subflow;
539 mptcp_for_each_subflow(msk, subflow)
540 mptcp_subflow_send_ack(mptcp_subflow_tcp_sock(subflow));
569 struct mptcp_subflow_context *subflow;
577 mptcp_for_each_subflow(msk, subflow) {
578 struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
594 * at the subflow level and the msk lock was not held, so this
639 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
667 map_remaining = subflow->map_data_len -
668 mptcp_subflow_get_map_offset(subflow);
687 subflow->map_data_len = skb->len;
805 struct mptcp_subflow_context *subflow;
808 mptcp_for_each_subflow(msk, subflow)
809 if (__mptcp_subflow_error_report(sk, mptcp_subflow_tcp_sock(subflow)))
842 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
847 * subflow at msk destruction time, but we must avoid enqueuing
850 if (unlikely(subflow->disposable))
902 struct mptcp_subflow_context *tmp, *subflow;
905 list_for_each_entry_safe(subflow, tmp, join_list, node) {
906 struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
909 list_move_tail(&subflow->node, &msk->conn_list);
938 /* each subflow already holds a reference to the sk, and the
939 * workqueue is invoked by a subflow, so sk can't go away here.
949 struct mptcp_subflow_context *subflow;
953 mptcp_for_each_subflow(msk, subflow) {
954 if (READ_ONCE(subflow->data_avail))
955 return mptcp_subflow_tcp_sock(subflow);
1079 struct mptcp_subflow_context *subflow;
1083 mptcp_for_each_subflow(msk, subflow) {
1084 struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
1387 void mptcp_subflow_set_active(struct mptcp_subflow_context *subflow)
1389 if (!subflow->stale)
1392 subflow->stale = 0;
1393 MPTCP_INC_STATS(sock_net(mptcp_subflow_tcp_sock(subflow)), MPTCP_MIB_SUBFLOWRECOVER);
1396 bool mptcp_subflow_active(struct mptcp_subflow_context *subflow)
1398 if (unlikely(subflow->stale)) {
1399 u32 rcv_tstamp = READ_ONCE(tcp_sk(mptcp_subflow_tcp_sock(subflow))->rcv_tstamp);
1401 if (subflow->stale_rcv_tstamp == rcv_tstamp)
1404 mptcp_subflow_set_active(subflow);
1406 return __mptcp_subflow_active(subflow);
1414 * returns the subflow that will transmit the next DSS
1420 struct mptcp_subflow_context *subflow;
1428 /* pick the subflow with the lower wmem/wspace ratio */
1434 mptcp_for_each_subflow(msk, subflow) {
1435 trace_mptcp_subflow_get_send(subflow);
1436 ssk = mptcp_subflow_tcp_sock(subflow);
1437 if (!mptcp_subflow_active(subflow))
1440 tout = max(tout, mptcp_timeout_from_subflow(subflow));
1441 nr_active += !subflow->backup;
1442 pace = subflow->avg_pacing_rate;
1445 subflow->avg_pacing_rate = READ_ONCE(ssk->sk_pacing_rate);
1446 pace = subflow->avg_pacing_rate;
1452 if (linger_time < send_info[subflow->backup].linger_time) {
1453 send_info[subflow->backup].ssk = ssk;
1454 send_info[subflow->backup].linger_time = linger_time;
1459 /* pick the best backup if no other subflow is active */
1469 * otherwise do not use the picked, slower, subflow
1470 * We select the subflow with the shorter estimated time to flush
1472 * to check that subflow has a non empty cwin.
1483 subflow = mptcp_subflow_ctx(ssk);
1484 subflow->avg_pacing_rate = div_u64((u64)subflow->avg_pacing_rate * wmem +
1515 * that has been handed to the subflow for transmission
1586 struct mptcp_subflow_context *subflow;
1594 mptcp_for_each_subflow(msk, subflow) {
1595 if (READ_ONCE(subflow->scheduled)) {
1596 mptcp_subflow_set_scheduled(subflow, false);
1599 ssk = mptcp_subflow_tcp_sock(subflow);
1607 /* Need to lock the new subflow only if different
1629 /* at this point we held the socket lock for the last subflow we used */
1652 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
1655 /* check for a different subflow usage only after
1659 mptcp_subflow_set_scheduled(subflow, false);
1671 if (READ_ONCE(subflow->scheduled)) {
1672 mptcp_subflow_set_scheduled(subflow, false);
1679 mptcp_for_each_subflow(msk, subflow) {
1680 if (READ_ONCE(subflow->scheduled)) {
1681 xmit_ssk = mptcp_subflow_tcp_sock(subflow);
1683 mptcp_subflow_delegate(subflow,
1727 * first subflow right now. Otherwise we are in the defer_connect
1728 * path, and the first subflow must be already present.
1730 * fastopen attempt, no need to check for additional subflow status.
1960 struct mptcp_subflow_context *subflow;
1984 mptcp_for_each_subflow(msk, subflow) {
1989 tp = tcp_sk(mptcp_subflow_tcp_sock(subflow));
2029 * get drops at subflow level if skbs can't be moved to
2033 mptcp_for_each_subflow(msk, subflow) {
2037 ssk = mptcp_subflow_tcp_sock(subflow);
2279 /* Find an idle subflow. Return NULL if there is unacked data at tcp
2282 * A backup subflow is returned only if that is the only kind available.
2287 struct mptcp_subflow_context *subflow;
2290 mptcp_for_each_subflow(msk, subflow) {
2291 struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
2293 if (!__mptcp_subflow_active(subflow))
2299 min_stale_count = min_t(int, min_stale_count, subflow->stale_count);
2303 if (subflow->backup) {
2362 * clean completely the subflow status when the subflow reaches
2366 struct mptcp_subflow_context *subflow,
2371 /* The MPTCP code never wait on the subflow sockets, TCP-level
2375 mptcp_subflow_ctx_reset(subflow);
2381 /* subflow sockets can be either outgoing (connect) or incoming
2390 struct mptcp_subflow_context *subflow,
2396 /* If the first subflow moved to a close state before accept, e.g. due
2397 * to an incoming reset or listener shutdown, the subflow socket is
2413 list_del(&subflow->node);
2423 subflow->send_fastclose = 1;
2428 __mptcp_subflow_disconnect(ssk, subflow, flags);
2434 subflow->disposable = 1;
2442 kfree_rcu(subflow, rcu);
2444 /* otherwise tcp will dispose of the ssk and subflow ctx */
2483 struct mptcp_subflow_context *subflow)
2488 /* subflow aborted before reaching the fully_established status
2489 * attempt the creation of the next subflow
2491 mptcp_pm_subflow_check_next(mptcp_sk(sk), ssk, subflow);
2493 __mptcp_close_ssk(sk, ssk, subflow, MPTCP_CF_PUSH);
2503 struct mptcp_subflow_context *subflow, *tmp;
2508 mptcp_for_each_subflow_safe(msk, subflow, tmp) {
2509 struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
2518 mptcp_close_ssk(sk, ssk, subflow);
2535 struct mptcp_subflow_context *subflow, *tmp;
2543 mptcp_for_each_subflow_safe(msk, subflow, tmp) {
2544 struct sock *tcp_sk = mptcp_subflow_tcp_sock(subflow);
2585 struct mptcp_subflow_context *subflow;
2617 mptcp_for_each_subflow(msk, subflow) {
2618 if (READ_ONCE(subflow->scheduled)) {
2621 mptcp_subflow_set_scheduled(subflow, false);
2623 ssk = mptcp_subflow_tcp_sock(subflow);
2691 pr_debug("MP_FAIL doesn't respond, reset the subflow");
2701 struct mptcp_subflow_context *subflow, *tmp;
2705 mptcp_for_each_subflow_safe(msk, subflow, tmp)
2706 __mptcp_close_ssk(sk, mptcp_subflow_tcp_sock(subflow),
2707 subflow, MPTCP_CF_FASTCLOSE);
2870 pr_debug("Sending DATA_FIN on subflow %p", ssk);
2928 struct mptcp_subflow_context *subflow;
2944 mptcp_for_each_subflow(msk, subflow) {
2945 struct sock *tcp_sk = mptcp_subflow_tcp_sock(subflow);
3030 struct mptcp_subflow_context *subflow;
3057 mptcp_for_each_subflow(msk, subflow) {
3058 struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
3067 subflow->fail_tout = 0;
3156 /* msk->subflow is still intact, the following will not free the first
3157 * subflow
3241 struct mptcp_subflow_context *subflow;
3276 /* passive msk is created after the first/MPC subflow */
3287 /* The msk maintain a ref to each subflow in the connections list */
3289 subflow = mptcp_subflow_ctx(ssk);
3290 list_add(&subflow->node, &msk->conn_list);
3293 /* new mpc subflow takes ownership of the newly
3307 __mptcp_subflow_fully_established(msk, subflow, mp_opt);
3341 pr_debug("newsk=%p, subflow is mptcp=%d", newsk, sk_is_mptcp(newsk));
3343 struct mptcp_subflow_context *subflow;
3346 subflow = mptcp_subflow_ctx(newsk);
3347 new_mptcp_sock = subflow->conn;
3349 /* is_mptcp should be false if subflow->conn is missing, see
3371 struct mptcp_subflow_context *subflow, *tmp;
3377 mptcp_for_each_subflow_safe(msk, subflow, tmp)
3378 __mptcp_close_ssk(sk, mptcp_subflow_tcp_sock(subflow), subflow, flags);
3401 /* allow the following to close even the initial subflow */
3449 /* the following actions acquire the subflow socket lock
3454 * the subflow socket lock
3475 * On sk release avoid actions depending on the first subflow
3488 /* MP_JOIN client subflow must wait for 4th ack before sending any data:
3489 * TCP can't schedule delack timer before the subflow is fully established.
3516 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
3517 struct sock *sk = subflow->conn;
3566 struct mptcp_subflow_context *subflow;
3570 subflow = mptcp_subflow_ctx(ssk);
3571 sk = subflow->conn;
3574 pr_debug("msk=%p, token=%u", sk, subflow->token);
3576 subflow->map_seq = subflow->iasn;
3577 subflow->map_subflow_seq = 1;
3579 /* the socket is not connected yet, no msk/subflow ops can access/race
3582 WRITE_ONCE(msk->local_key, subflow->local_key);
3598 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
3599 struct mptcp_sock *msk = mptcp_sk(subflow->conn);
3603 pr_debug("msk=%p, subflow=%p", msk, subflow);
3607 subflow->reset_reason = MPTCP_RST_EMPTCP;
3611 /* active subflow, already present inside the conn_list */
3612 if (!list_empty(&subflow->node)) {
3629 list_add_tail(&subflow->node, &msk->conn_list);
3633 list_add_tail(&subflow->node, &msk->join_list);
3640 subflow->reset_reason = MPTCP_RST_EPROHIBIT;
3676 /* the first subflow is disconnected after close - see
3723 struct mptcp_subflow_context *subflow)
3725 subflow->request_mptcp = 0;
3731 struct mptcp_subflow_context *subflow;
3741 subflow = mptcp_subflow_ctx(ssk);
3747 mptcp_subflow_early_fallback(msk, subflow);
3749 if (subflow->request_mptcp && mptcp_token_new_connect(ssk)) {
3751 mptcp_subflow_early_fallback(msk, subflow);
3757 * acquired the subflow socket lock, too.
3909 * but no need to allocate the first subflow just to error out.
3924 struct mptcp_subflow_context *subflow;
3932 mptcp_for_each_subflow(msk, subflow) {
3933 struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
3939 /* Do late cleanup for the first subflow as necessary. Also
4050 struct mptcp_subflow_context *subflow;
4054 while ((subflow = mptcp_subflow_delegated_next(delegated)) != NULL) {
4055 struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
4059 mptcp_subflow_process_delegated(ssk, xchg(&subflow->delegated_status, 0));
4063 * In both case must dequeue the subflow here - on the same
4067 clear_bit(MPTCP_DELEGATE_SCHEDULED, &subflow->delegated_status);