Lines Matching defs:tp
388 static u64 tcp_compute_delivery_rate(const struct tcp_sock *tp)
390 u32 rate = READ_ONCE(tp->rate_delivered);
391 u32 intv = READ_ONCE(tp->rate_interval_us);
395 rate64 = (u64)rate * tp->mss_cache * USEC_PER_SEC;
404 struct tcp_sock *tp = tcp_sk(sk);
406 if (tp->md5sig_info) {
409 kfree(rcu_replace_pointer(tp->md5sig_info, NULL, 1));
423 struct tcp_sock *tp = tcp_sk(sk);
426 tp->out_of_order_queue = RB_ROOT;
429 INIT_LIST_HEAD(&tp->tsq_node);
430 INIT_LIST_HEAD(&tp->tsorted_sent_queue);
440 tp->mdev_us = jiffies_to_usecs(TCP_TIMEOUT_INIT);
441 minmax_reset(&tp->rtt_min, tcp_jiffies32, ~0U);
448 tcp_snd_cwnd_set(tp, TCP_INIT_CWND);
451 tp->app_limited = ~0U;
452 tp->rate_app_limited = 1;
457 tp->snd_ssthresh = TCP_INFINITE_SSTHRESH;
458 tp->snd_cwnd_clamp = ~0;
459 tp->mss_cache = TCP_MSS_DEFAULT;
461 tp->reordering = READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_reordering);
464 tp->tsoffset = 0;
465 tp->rack.reo_wnd_steps = 1;
511 const struct tcp_sock *tp = tcp_sk(sk);
512 u32 notsent_bytes = READ_ONCE(tp->write_seq) - READ_ONCE(tp->snd_nxt);
514 return (notsent_bytes << wake) < tcp_notsent_lowat(tp);
536 const struct tcp_sock *tp = tcp_sk(sk);
588 (state != TCP_SYN_RECV || rcu_access_pointer(tp->fastopen_rsk))) {
590 u16 urg_data = READ_ONCE(tp->urg_data);
593 READ_ONCE(tp->urg_seq) == READ_ONCE(tp->copied_seq) &&
641 struct tcp_sock *tp = tcp_sk(sk);
655 answ = READ_ONCE(tp->urg_data) &&
656 READ_ONCE(tp->urg_seq) == READ_ONCE(tp->copied_seq);
665 answ = READ_ONCE(tp->write_seq) - tp->snd_una;
674 answ = READ_ONCE(tp->write_seq) -
675 READ_ONCE(tp->snd_nxt);
685 void tcp_mark_push(struct tcp_sock *tp, struct sk_buff *skb)
688 tp->pushed_seq = tp->write_seq;
691 static inline bool forced_push(const struct tcp_sock *tp)
693 return after(tp->write_seq, tp->pushed_seq + (tp->max_window >> 1));
698 struct tcp_sock *tp = tcp_sk(sk);
701 tcb->seq = tcb->end_seq = tp->write_seq;
708 if (tp->nonagle & TCP_NAGLE_PUSH)
709 tp->nonagle &= ~TCP_NAGLE_PUSH;
714 static inline void tcp_mark_urg(struct tcp_sock *tp, int flags)
717 tp->snd_up = tp->write_seq;
743 struct tcp_sock *tp = tcp_sk(sk);
749 if (!(flags & MSG_MORE) || forced_push(tp))
750 tcp_mark_push(tp, skb);
752 tcp_mark_urg(tp, flags);
960 struct tcp_sock *tp = tcp_sk(sk);
967 new_size_goal = tcp_bound_to_half_wnd(tp, sk->sk_gso_max_size);
970 size_goal = tp->gso_segs * mss_now;
973 tp->gso_segs = min_t(u16, new_size_goal / mss_now,
975 size_goal = tp->gso_segs * mss_now;
1043 void tcp_free_fastopen_req(struct tcp_sock *tp)
1045 if (tp->fastopen_req) {
1046 kfree(tp->fastopen_req);
1047 tp->fastopen_req = NULL;
1054 struct tcp_sock *tp = tcp_sk(sk);
1064 if (tp->fastopen_req)
1067 tp->fastopen_req = kzalloc_obj(struct tcp_fastopen_request,
1069 if (unlikely(!tp->fastopen_req))
1071 tp->fastopen_req->data = msg;
1072 tp->fastopen_req->size = size;
1073 tp->fastopen_req->uarg = uarg;
1090 if (tp->fastopen_req) {
1091 *copied = tp->fastopen_req->copied;
1092 tcp_free_fastopen_req(tp);
1101 struct tcp_sock *tp = tcp_sk(sk);
1104 tp->write_seq - tp->snd_nxt < tp->mss_cache &&
1108 tcp_packets_in_flight(tp) < tcp_snd_cwnd(tp) &&
1110 tp->lost_out <= tp->retrans_out)
1111 tp->app_limited =
1112 (tp->delivered + tcp_packets_in_flight(tp)) ? : 1;
1119 struct tcp_sock *tp = tcp_sk(sk);
1179 !tp->repair) {
1202 if (unlikely(tp->repair)) {
1203 if (tp->repair_queue == TCP_RECV_QUEUE) {
1209 if (tp->repair_queue == TCP_NO_QUEUE)
1273 if (tp->repair)
1292 tcp_mark_push(tp, skb);
1342 tcp_mark_push(tp, skb);
1359 tcp_mark_push(tp, skb);
1376 WRITE_ONCE(tp->write_seq, tp->write_seq + copy);
1387 if (skb->len < size_goal || (flags & MSG_OOB) || unlikely(tp->repair))
1390 if (forced_push(tp)) {
1391 tcp_mark_push(tp, skb);
1414 tcp_push(sk, flags, mss_now, tp->nonagle, size_goal);
1461 struct tcp_sock *tp = tcp_sk(sk);
1469 tcp_push(sk, 0, mss_now, tp->nonagle, size_goal);
1480 struct tcp_sock *tp = tcp_sk(sk);
1483 if (sock_flag(sk, SOCK_URGINLINE) || !tp->urg_data ||
1484 tp->urg_data == TCP_URG_READ)
1490 if (tp->urg_data & TCP_URG_VALID) {
1492 char c = tp->urg_data;
1495 WRITE_ONCE(tp->urg_data, TCP_URG_READ);
1553 struct tcp_sock *tp = tcp_sk(sk);
1560 tp->rcv_nxt - tp->rcv_wup > icsk->icsk_ack.rcv_mss ||
1582 __u32 rcv_window_now = tcp_receive_window(tp);
1585 if (2*rcv_window_now <= tp->window_clamp) {
1598 tcp_mstamp_refresh(tp);
1606 struct tcp_sock *tp = tcp_sk(sk);
1608 WARN(skb && !before(tp->copied_seq, TCP_SKB_CB(skb)->end_seq),
1610 tp->copied_seq, TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt);
1667 struct tcp_sock *tp = tcp_sk(sk);
1681 if (unlikely(tp->urg_data)) {
1682 u32 urg_offset = tp->urg_seq - seq;
1786 struct tcp_sock *tp = tcp_sk(sk);
1787 u32 seq = tp->copied_seq;
1813 WRITE_ONCE(tp->copied_seq, seq);
1831 struct tcp_sock *tp = tcp_sk(sk);
1851 if (tp->window_clamp && tp->window_clamp < val)
1852 WRITE_ONCE(tp->window_clamp, val);
2205 struct tcp_sock *tp = tcp_sk(sk);
2210 u32 seq = tp->copied_seq;
2329 WRITE_ONCE(tp->copied_seq, seq);
2417 const struct tcp_sock *tp = tcp_sk(sk);
2418 u32 copied_seq = READ_ONCE(tp->copied_seq);
2419 u32 rcv_nxt = READ_ONCE(tp->rcv_nxt);
2423 if (unlikely(inq < 0 || copied_seq != READ_ONCE(tp->copied_seq))) {
2425 inq = tp->rcv_nxt - tp->copied_seq;
2661 struct tcp_sock *tp = tcp_sk(sk);
2678 if (tp->recvmsg_inq)
2686 if (unlikely(tp->repair)) {
2691 if (tp->repair_queue == TCP_SEND_QUEUE)
2695 if (tp->repair_queue == TCP_NO_QUEUE)
2701 seq = &tp->copied_seq;
2704 peek_seq = tp->copied_seq + peek_offset;
2714 if (unlikely(tp->urg_data) && tp->urg_seq == *seq) {
2733 *seq, TCP_SKB_CB(skb)->seq, tp->rcv_nxt,
2748 *seq, TCP_SKB_CB(skb)->seq, tp->rcv_nxt, flags);
2804 (peek_seq - peek_offset - copied - urg_hole != tp->copied_seq)) {
2808 peek_seq = tp->copied_seq + peek_offset;
2819 if (unlikely(tp->urg_data)) {
2820 u32 urg_offset = tp->urg_seq - *seq;
2885 if (unlikely(tp->urg_data) && after(tp->copied_seq, tp->urg_seq)) {
2886 WRITE_ONCE(tp->urg_data, 0);
3257 struct tcp_sock *tp = tcp_sk(sk);
3258 if (READ_ONCE(tp->linger2) < 0) {
3366 struct tcp_sock *tp = tcp_sk(sk);
3377 } else if (unlikely(tp->repair)) {
3382 } else if (tp->snd_nxt != tp->write_seq &&
3395 WRITE_ONCE(tp->copied_seq, tp->rcv_nxt);
3396 WRITE_ONCE(tp->urg_data, 0);
3400 skb_rbtree_purge(&tp->out_of_order_queue);
3408 tp->srtt_us = 0;
3409 tp->mdev_us = jiffies_to_usecs(TCP_TIMEOUT_INIT);
3410 tp->rcv_rtt_last_tsecr = 0;
3412 seq = tp->write_seq + tp->max_window + 2;
3415 WRITE_ONCE(tp->write_seq, seq);
3423 WRITE_ONCE(tp->snd_ssthresh, TCP_INFINITE_SSTHRESH);
3424 tcp_snd_cwnd_set(tp, TCP_INIT_CWND);
3425 tp->snd_cwnd_cnt = 0;
3426 tp->is_cwnd_limited = 0;
3427 tp->max_packets_out = 0;
3428 tp->window_clamp = 0;
3429 tp->delivered = 0;
3430 tp->delivered_ce = 0;
3431 tp->accecn_fail_mode = 0;
3432 tp->saw_accecn_opt = TCP_ACCECN_OPT_NOT_SEEN;
3433 tcp_accecn_init_counters(tp);
3434 tp->prev_ecnfield = 0;
3435 tp->accecn_opt_tstamp = 0;
3436 tp->pkts_acked_ewma = 0;
3442 tp->is_sack_reneg = 0;
3443 tcp_clear_retrans(tp);
3444 tp->total_retrans = 0;
3450 memset(&tp->rx_opt, 0, sizeof(tp->rx_opt));
3453 tcp_saved_syn_free(tp);
3454 tp->compressed_ack = 0;
3455 tp->segs_in = 0;
3456 tp->segs_out = 0;
3457 tp->bytes_sent = 0;
3458 tp->bytes_acked = 0;
3459 tp->bytes_received = 0;
3460 tp->bytes_retrans = 0;
3461 tp->data_segs_in = 0;
3462 tp->data_segs_out = 0;
3463 tp->duplicate_sack[0].start_seq = 0;
3464 tp->duplicate_sack[0].end_seq = 0;
3465 tp->dsack_dups = 0;
3466 tp->reord_seen = 0;
3467 tp->retrans_out = 0;
3468 tp->sacked_out = 0;
3469 tp->tlp_high_seq = 0;
3470 tp->last_oow_ack_time = 0;
3471 tp->plb_rehash = 0;
3473 tp->app_limited = ~0U;
3474 tp->rate_app_limited = 1;
3475 tp->rack.mstamp = 0;
3476 tp->rack.advanced = 0;
3477 tp->rack.reo_wnd_steps = 1;
3478 tp->rack.last_delivered = 0;
3479 tp->rack.reo_wnd_persist = 0;
3480 tp->rack.dsack_seen = 0;
3481 tp->syn_data_acked = 0;
3482 tp->syn_fastopen_child = 0;
3483 tp->rx_opt.saw_tstamp = 0;
3484 tp->rx_opt.dsack = 0;
3485 tp->rx_opt.num_sacks = 0;
3486 tp->rcv_ooopack = 0;
3490 req = rcu_dereference_protected(tp->fastopen_rsk,
3494 tcp_free_fastopen_req(tp);
3496 tp->fastopen_client_fail = 0;
3515 static int tcp_repair_set_window(struct tcp_sock *tp, sockptr_t optbuf, int len)
3519 if (!tp->repair)
3531 if (after(opt.snd_wl1, tp->rcv_nxt + opt.rcv_wnd))
3534 if (after(opt.rcv_wup, tp->rcv_nxt))
3537 tp->snd_wl1 = opt.snd_wl1;
3538 tp->snd_wnd = opt.snd_wnd;
3539 tp->max_window = opt.max_window;
3541 tp->rcv_wnd = opt.rcv_wnd;
3542 tp->rcv_wup = opt.rcv_wup;
3543 tp->rcv_mwnd_seq = opt.rcv_wup + opt.rcv_wnd;
3551 struct tcp_sock *tp = tcp_sk(sk);
3564 tp->rx_opt.mss_clamp = opt.opt_val;
3575 tp->rx_opt.snd_wscale = snd_wscale;
3576 tp->rx_opt.rcv_wscale = rcv_wscale;
3577 tp->rx_opt.wscale_ok = 1;
3584 tp->rx_opt.sack_ok |= TCP_SACK_SEEN;
3590 tp->rx_opt.tstamp_ok = 1;
3602 struct tcp_sock *tp = tcp_sk(sk);
3603 s32 delta = (val - tp->tcp_tx_delay) << 3;
3613 /* If we change tcp_tx_delay on a live flow, adjust tp->srtt_us,
3614 * tp->rtt_min, icsk_rto and sk->sk_pacing_rate.
3618 s64 srtt = (s64)tp->srtt_us + delta;
3620 WRITE_ONCE(tp->srtt_us,
3626 minmax_reset(&tp->rtt_min, tcp_jiffies32, ~0U);
3643 struct tcp_sock *tp = tcp_sk(sk);
3646 tp->nonagle |= TCP_NAGLE_CORK;
3648 tp->nonagle &= ~TCP_NAGLE_CORK;
3649 if (tp->nonagle & TCP_NAGLE_OFF)
3650 tp->nonagle |= TCP_NAGLE_PUSH;
3737 struct tcp_sock *tp = tcp_sk(sk);
3743 WRITE_ONCE(tp->keepalive_time, val * HZ);
3746 u32 elapsed = keepalive_time_elapsed(tp);
3748 if (tp->keepalive_time > elapsed)
3749 elapsed = tp->keepalive_time - elapsed;
3793 struct tcp_sock *tp = tcp_sk(sk);
3798 WRITE_ONCE(tp->window_clamp, 0);
3802 old_window_clamp = tp->window_clamp;
3808 WRITE_ONCE(tp->window_clamp, new_window_clamp);
3816 new_rcv_ssthresh = min(tp->rcv_wnd, new_window_clamp);
3817 tp->rcv_ssthresh = max(new_rcv_ssthresh, tp->rcv_ssthresh);
3841 struct tcp_sock *tp = tcp_sk(sk);
3928 WRITE_ONCE(tp->linger2, -1);
3930 WRITE_ONCE(tp->linger2, TCP_FIN_TIMEOUT_MAX);
3932 WRITE_ONCE(tp->linger2, val * HZ);
3976 tp->thin_lto = val;
3988 tp->repair = 1;
3990 tp->repair_queue = TCP_NO_QUEUE;
3992 tp->repair = 0;
3996 tp->repair = 0;
4004 if (!tp->repair)
4007 tp->repair_queue = val;
4015 } else if (tp->repair_queue == TCP_SEND_QUEUE) {
4019 WRITE_ONCE(tp->write_seq, val);
4020 } else if (tp->repair_queue == TCP_RECV_QUEUE) {
4021 if (tp->rcv_nxt != tp->copied_seq) {
4024 WRITE_ONCE(tp->rcv_nxt, val);
4025 WRITE_ONCE(tp->copied_seq, val);
4033 if (!tp->repair)
4035 else if (sk->sk_state == TCP_ESTABLISHED && !tp->bytes_sent)
4053 tp->save_syn = val;
4084 if (tp->repair)
4089 err = tp->af_specific->ao_parse(sk, optname, optval, optlen);
4096 err = tp->af_specific->md5_parse(sk, optname, optval, optlen);
4115 tp->fastopen_connect = val;
4128 tp->fastopen_no_cookie = val;
4131 if (!tp->repair) {
4139 tp->tcp_usec_ts = val & 1;
4140 WRITE_ONCE(tp->tsoffset, val - tcp_clock_ts(tp->tcp_usec_ts));
4143 err = tcp_repair_set_window(tp, optval, optlen);
4146 WRITE_ONCE(tp->notsent_lowat, val);
4153 tp->recvmsg_inq = val;
4156 /* tp->srtt_us is u32, and is shifted by 3 */
4162 WRITE_ONCE(tp->tcp_tx_delay, val);
4185 static void tcp_get_info_chrono_stats(const struct tcp_sock *tp,
4196 cur = READ_ONCE(tp->chrono_type);
4198 stats[i] = READ_ONCE(tp->chrono_stat[i - 1]);
4200 stats[i] += tcp_jiffies32 - READ_ONCE(tp->chrono_start);
4213 const struct tcp_sock *tp = tcp_sk(sk); /* iff sk_type == SOCK_STREAM */
4238 info->tcpi_reordering = tp->reordering;
4239 info->tcpi_snd_cwnd = tcp_snd_cwnd(tp);
4258 if (tp->rx_opt.tstamp_ok)
4260 if (tcp_is_sack(tp))
4262 if (tp->rx_opt.wscale_ok) {
4264 info->tcpi_snd_wscale = tp->rx_opt.snd_wscale;
4265 info->tcpi_rcv_wscale = tp->rx_opt.rcv_wscale;
4268 if (tcp_ecn_mode_any(tp))
4270 if (tp->ecn_flags & TCP_ECN_SEEN)
4272 if (tp->syn_data_acked)
4274 if (tp->tcp_usec_ts)
4276 if (tp->syn_fastopen_child)
4282 info->tcpi_snd_mss = tp->mss_cache;
4285 info->tcpi_unacked = tp->packets_out;
4286 info->tcpi_sacked = tp->sacked_out;
4288 info->tcpi_lost = tp->lost_out;
4289 info->tcpi_retrans = tp->retrans_out;
4292 info->tcpi_last_data_sent = jiffies_to_msecs(now - tp->lsndtime);
4294 info->tcpi_last_ack_recv = jiffies_to_msecs(now - tp->rcv_tstamp);
4297 info->tcpi_rcv_ssthresh = tp->rcv_ssthresh;
4298 info->tcpi_rtt = tp->srtt_us >> 3;
4299 info->tcpi_rttvar = tp->mdev_us >> 2;
4300 info->tcpi_snd_ssthresh = tp->snd_ssthresh;
4301 info->tcpi_advmss = tp->advmss;
4303 info->tcpi_rcv_rtt = tp->rcv_rtt_est.rtt_us >> 3;
4304 info->tcpi_rcv_space = tp->rcvq_space.space;
4306 info->tcpi_total_retrans = tp->total_retrans;
4308 info->tcpi_bytes_acked = tp->bytes_acked;
4309 info->tcpi_bytes_received = tp->bytes_received;
4310 info->tcpi_notsent_bytes = max_t(int, 0, tp->write_seq - tp->snd_nxt);
4311 tcp_get_info_chrono_stats(tp, info);
4313 info->tcpi_segs_out = tp->segs_out;
4316 info->tcpi_segs_in = READ_ONCE(tp->segs_in);
4317 info->tcpi_data_segs_in = READ_ONCE(tp->data_segs_in);
4319 info->tcpi_min_rtt = tcp_min_rtt(tp);
4320 info->tcpi_data_segs_out = tp->data_segs_out;
4322 info->tcpi_delivery_rate_app_limited = tp->rate_app_limited ? 1 : 0;
4323 rate64 = tcp_compute_delivery_rate(tp);
4326 info->tcpi_delivered = tp->delivered;
4327 info->tcpi_delivered_ce = tp->delivered_ce;
4328 info->tcpi_bytes_sent = tp->bytes_sent;
4329 info->tcpi_bytes_retrans = tp->bytes_retrans;
4330 info->tcpi_dsack_dups = tp->dsack_dups;
4331 info->tcpi_reord_seen = tp->reord_seen;
4332 info->tcpi_rcv_ooopack = tp->rcv_ooopack;
4333 info->tcpi_snd_wnd = tp->snd_wnd;
4334 info->tcpi_rcv_wnd = tp->rcv_wnd;
4335 info->tcpi_rehash = tp->plb_rehash + tp->timeout_rehash;
4336 info->tcpi_fastopen_client_fail = tp->fastopen_client_fail;
4338 info->tcpi_total_rto = tp->total_rto;
4339 info->tcpi_total_rto_recoveries = tp->total_rto_recoveries;
4340 info->tcpi_total_rto_time = tp->total_rto_time;
4341 if (tp->rto_stamp)
4342 info->tcpi_total_rto_time += tcp_clock_ms() - tp->rto_stamp;
4344 if (tcp_ecn_disabled(tp))
4346 else if (tcp_ecn_mode_rfc3168(tp))
4348 else if (tcp_ecn_mode_accecn(tp))
4350 else if (tcp_ecn_mode_pending(tp))
4352 info->tcpi_accecn_fail_mode = tp->accecn_fail_mode;
4353 info->tcpi_accecn_opt_seen = tp->saw_accecn_opt;
4354 info->tcpi_received_ce = tp->received_ce;
4355 info->tcpi_delivered_e1_bytes = tp->delivered_ecn_bytes[ect1_idx];
4356 info->tcpi_delivered_e0_bytes = tp->delivered_ecn_bytes[ect0_idx];
4357 info->tcpi_delivered_ce_bytes = tp->delivered_ecn_bytes[ce_idx];
4358 info->tcpi_received_e1_bytes = tp->received_ecn_bytes[ect1_idx];
4359 info->tcpi_received_e0_bytes = tp->received_ecn_bytes[ect0_idx];
4360 info->tcpi_received_ce_bytes = tp->received_ecn_bytes[ce_idx];
4414 const struct tcp_sock *tp = tcp_sk(sk);
4424 tcp_get_info_chrono_stats(tp, &info);
4432 READ_ONCE(tp->data_segs_out), TCP_NLA_PAD);
4434 READ_ONCE(tp->total_retrans), TCP_NLA_PAD);
4440 rate64 = tcp_compute_delivery_rate(tp);
4443 nla_put_u32(stats, TCP_NLA_SND_CWND, READ_ONCE(tp->snd_cwnd));
4444 nla_put_u32(stats, TCP_NLA_REORDERING, READ_ONCE(tp->reordering));
4445 nla_put_u32(stats, TCP_NLA_MIN_RTT, data_race(tcp_min_rtt(tp)));
4449 nla_put_u8(stats, TCP_NLA_DELIVERY_RATE_APP_LMT, data_race(!!tp->rate_app_limited));
4450 nla_put_u32(stats, TCP_NLA_SND_SSTHRESH, READ_ONCE(tp->snd_ssthresh));
4451 nla_put_u32(stats, TCP_NLA_DELIVERED, READ_ONCE(tp->delivered));
4452 nla_put_u32(stats, TCP_NLA_DELIVERED_CE, READ_ONCE(tp->delivered_ce));
4456 READ_ONCE(tp->write_seq) - READ_ONCE(tp->snd_una)));
4459 nla_put_u64_64bit(stats, TCP_NLA_BYTES_SENT, READ_ONCE(tp->bytes_sent),
4462 READ_ONCE(tp->bytes_retrans), TCP_NLA_PAD);
4463 nla_put_u32(stats, TCP_NLA_DSACK_DUPS, READ_ONCE(tp->dsack_dups));
4464 nla_put_u32(stats, TCP_NLA_REORD_SEEN, READ_ONCE(tp->reord_seen));
4465 nla_put_u32(stats, TCP_NLA_SRTT, READ_ONCE(tp->srtt_us) >> 3);
4467 READ_ONCE(tp->timeout_rehash));
4470 READ_ONCE(tp->write_seq) - READ_ONCE(tp->snd_nxt)));
4478 READ_ONCE(tp->plb_rehash) + READ_ONCE(tp->timeout_rehash));
4486 struct tcp_sock *tp = tcp_sk(sk);
4501 val = tp->mss_cache;
4502 user_mss = READ_ONCE(tp->rx_opt.user_mss);
4506 if (tp->repair)
4507 val = tp->rx_opt.mss_clamp;
4510 val = !!(tp->nonagle&TCP_NAGLE_OFF);
4513 val = !!(tp->nonagle&TCP_NAGLE_CORK);
4516 val = keepalive_time_when(tp) / HZ;
4519 val = keepalive_intvl_when(tp) / HZ;
4522 val = keepalive_probes(tp);
4529 val = READ_ONCE(tp->linger2);
4539 val = READ_ONCE(tp->window_clamp);
4633 val = tp->thin_lto;
4641 val = tp->repair;
4645 if (tp->repair)
4646 val = tp->repair_queue;
4660 if (!tp->repair)
4663 opt.snd_wl1 = tp->snd_wl1;
4664 opt.snd_wnd = tp->snd_wnd;
4665 opt.max_window = tp->max_window;
4666 opt.rcv_wnd = tp->rcv_wnd;
4667 opt.rcv_wup = tp->rcv_wup;
4674 if (tp->repair_queue == TCP_SEND_QUEUE)
4675 val = tp->write_seq;
4676 else if (tp->repair_queue == TCP_RECV_QUEUE)
4677 val = tp->rcv_nxt;
4691 val = tp->fastopen_connect;
4695 val = tp->fastopen_no_cookie;
4699 val = READ_ONCE(tp->tcp_tx_delay);
4703 val = tcp_clock_ts(tp->tcp_usec_ts) + READ_ONCE(tp->tsoffset);
4704 if (tp->tcp_usec_ts)
4710 val = READ_ONCE(tp->notsent_lowat);
4713 val = tp->recvmsg_inq;
4716 val = tp->save_syn;
4723 if (tp->saved_syn) {
4724 if (len < tcp_saved_syn_len(tp->saved_syn)) {
4725 len = tcp_saved_syn_len(tp->saved_syn);
4733 len = tcp_saved_syn_len(tp->saved_syn);
4738 if (copy_to_sockptr(optval, tp->saved_syn->data, len)) {
4742 tcp_saved_syn_free(tp);
4933 const struct tcp_sock *tp = tcp_sk(sk);
4951 tp->af_specific->calc_md5_hash(newhash, key, NULL, skb);