Lines Matching +full:tx +full:- +full:ts +full:- +full:routes
1 // SPDX-License-Identifier: GPL-2.0-or-later
12 * Corey Minyard <wf-rch!minyard@relay.EU.net>
13 * Florian La Roche, <flla@stud.uni-sb.de>
25 * sk->inuse=1 and was trying to connect
51 * Alan Cox : sk->keepopen now seems to work
53 * Alan Cox : Fixed assorted sk->rqueue->next errors
63 * Alan Cox : FIN with no memory -> CRASH
113 * Alan Cox : Changed the semantics of sk->socket to
164 * Matt Day : poll()->select() match BSD precisely on error
166 * Marc Tamsky : Various sk->prot->retransmits and
167 * sk->retransmits misupdating fixed.
172 * Alan Cox : Look up device on a retransmit - routes may
214 * waiting for final ack in three-way handshake.
341 val--; in tcp_enter_memory_pressure()
356 jiffies_to_msecs(jiffies - val)); in tcp_leave_memory_pressure()
387 while (--retrans) { in retrans_to_secs()
399 u32 rate = READ_ONCE(tp->rate_delivered); in tcp_compute_delivery_rate()
400 u32 intv = READ_ONCE(tp->rate_interval_us); in tcp_compute_delivery_rate()
404 rate64 = (u64)rate * tp->mss_cache * USEC_PER_SEC; in tcp_compute_delivery_rate()
410 /* Address-family independent initialization for a tcp_sock.
420 tp->out_of_order_queue = RB_ROOT; in tcp_init_sock()
421 sk->tcp_rtx_queue = RB_ROOT; in tcp_init_sock()
423 INIT_LIST_HEAD(&tp->tsq_node); in tcp_init_sock()
424 INIT_LIST_HEAD(&tp->tsorted_sent_queue); in tcp_init_sock()
426 icsk->icsk_rto = TCP_TIMEOUT_INIT; in tcp_init_sock()
427 icsk->icsk_rto_min = TCP_RTO_MIN; in tcp_init_sock()
428 icsk->icsk_delack_max = TCP_DELACK_MAX; in tcp_init_sock()
429 tp->mdev_us = jiffies_to_usecs(TCP_TIMEOUT_INIT); in tcp_init_sock()
430 minmax_reset(&tp->rtt_min, tcp_jiffies32, ~0U); in tcp_init_sock()
433 * initial SYN frame in their delayed-ACK and congestion control in tcp_init_sock()
435 * efficiently to them. -DaveM in tcp_init_sock()
437 tp->snd_cwnd = TCP_INIT_CWND; in tcp_init_sock()
440 tp->app_limited = ~0U; in tcp_init_sock()
441 tp->rate_app_limited = 1; in tcp_init_sock()
443 /* See draft-stevens-tcpca-spec-01 for discussion of the in tcp_init_sock()
446 tp->snd_ssthresh = TCP_INFINITE_SSTHRESH; in tcp_init_sock()
447 tp->snd_cwnd_clamp = ~0; in tcp_init_sock()
448 tp->mss_cache = TCP_MSS_DEFAULT; in tcp_init_sock()
450 tp->reordering = READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_reordering); in tcp_init_sock()
453 tp->tsoffset = 0; in tcp_init_sock()
454 tp->rack.reo_wnd_steps = 1; in tcp_init_sock()
456 sk->sk_write_space = sk_stream_write_space; in tcp_init_sock()
459 icsk->icsk_sync_mss = tcp_sync_mss; in tcp_init_sock()
461 WRITE_ONCE(sk->sk_sndbuf, READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_wmem[1])); in tcp_init_sock()
462 WRITE_ONCE(sk->sk_rcvbuf, READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_rmem[1])); in tcp_init_sock()
465 sk->sk_route_forced_caps = NETIF_F_GSO; in tcp_init_sock()
467 icsk->nata_retries_enabled = 0; in tcp_init_sock()
468 icsk->nata_retries_type = NATA_NA; in tcp_init_sock()
469 icsk->nata_syn_rto = TCP_TIMEOUT_INIT; in tcp_init_sock()
470 icsk->nata_data_rto = TCP_TIMEOUT_INIT; in tcp_init_sock()
471 icsk->nata_data_retries = 0; in tcp_init_sock()
484 sock_tx_timestamp(sk, tsflags, &shinfo->tx_flags); in tcp_tx_timestamp()
486 tcb->txstamp_ack = 1; in tcp_tx_timestamp()
488 shinfo->tskey = TCP_SKB_CB(skb)->seq + skb->len - 1; in tcp_tx_timestamp()
495 int avail = READ_ONCE(tp->rcv_nxt) - READ_ONCE(tp->copied_seq); in tcp_stream_is_readable()
502 if (tcp_receive_window(tp) <= inet_csk(sk)->icsk_ack.rcv_mss) in tcp_stream_is_readable()
505 if (sk->sk_prot->stream_memory_read) in tcp_stream_is_readable()
506 return sk->sk_prot->stream_memory_read(sk); in tcp_stream_is_readable()
520 struct sock *sk = sock->sk; in tcp_poll()
549 * Check-me. in tcp_poll()
554 * in state CLOSE_WAIT. One solution is evident --- to set EPOLLHUP in tcp_poll()
560 * why EPOLLHUP is incompatible with EPOLLOUT. --ANK in tcp_poll()
563 * blocking on fresh not-connected or disconnected socket. --ANK in tcp_poll()
565 shutdown = READ_ONCE(sk->sk_shutdown); in tcp_poll()
573 (state != TCP_SYN_RECV || rcu_access_pointer(tp->fastopen_rsk))) { in tcp_poll()
576 if (READ_ONCE(tp->urg_seq) == READ_ONCE(tp->copied_seq) && in tcp_poll()
578 tp->urg_data) in tcp_poll()
589 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags); in tcp_poll()
603 if (tp->urg_data & TCP_URG_VALID) in tcp_poll()
605 } else if (state == TCP_SYN_SENT && inet_sk(sk)->defer_connect) { in tcp_poll()
614 if (sk->sk_err || !skb_queue_empty_lockless(&sk->sk_error_queue)) in tcp_poll()
629 if (sk->sk_state == TCP_LISTEN) in tcp_ioctl()
630 return -EINVAL; in tcp_ioctl()
637 answ = tp->urg_data && in tcp_ioctl()
638 READ_ONCE(tp->urg_seq) == READ_ONCE(tp->copied_seq); in tcp_ioctl()
641 if (sk->sk_state == TCP_LISTEN) in tcp_ioctl()
642 return -EINVAL; in tcp_ioctl()
644 if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) in tcp_ioctl()
647 answ = READ_ONCE(tp->write_seq) - tp->snd_una; in tcp_ioctl()
650 if (sk->sk_state == TCP_LISTEN) in tcp_ioctl()
651 return -EINVAL; in tcp_ioctl()
653 if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) in tcp_ioctl()
656 answ = READ_ONCE(tp->write_seq) - in tcp_ioctl()
657 READ_ONCE(tp->snd_nxt); in tcp_ioctl()
660 return -ENOIOCTLCMD; in tcp_ioctl()
669 TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_PSH; in tcp_mark_push()
670 tp->pushed_seq = tp->write_seq; in tcp_mark_push()
675 return after(tp->write_seq, tp->pushed_seq + (tp->max_window >> 1)); in forced_push()
683 skb->csum = 0; in skb_entail()
684 tcb->seq = tcb->end_seq = tp->write_seq; in skb_entail()
685 tcb->tcp_flags = TCPHDR_ACK; in skb_entail()
686 tcb->sacked = 0; in skb_entail()
689 sk_wmem_queued_add(sk, skb->truesize); in skb_entail()
690 sk_mem_charge(sk, skb->truesize); in skb_entail()
691 if (tp->nonagle & TCP_NAGLE_PUSH) in skb_entail()
692 tp->nonagle &= ~TCP_NAGLE_PUSH; in skb_entail()
700 tp->snd_up = tp->write_seq; in tcp_mark_urg()
705 * Because TX completion will happen shortly, it gives a chance
711 * or if TX completion was delayed after we processed ACK packet.
716 return skb->len < size_goal && in tcp_should_autocork()
717 READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_autocorking) && in tcp_should_autocork()
719 refcount_read(&sk->sk_wmem_alloc) > skb->truesize; in tcp_should_autocork()
739 if (!test_bit(TSQ_THROTTLED, &sk->sk_tsq_flags)) { in tcp_push()
741 set_bit(TSQ_THROTTLED, &sk->sk_tsq_flags); in tcp_push()
743 /* It is possible TX completion already happened in tcp_push()
746 if (refcount_read(&sk->sk_wmem_alloc) > skb->truesize) in tcp_push()
759 struct tcp_splice_state *tss = rd_desc->arg.data; in tcp_splice_data_recv()
762 ret = skb_splice_bits(skb, skb->sk, offset, tss->pipe, in tcp_splice_data_recv()
763 min(rd_desc->count, len), tss->flags); in tcp_splice_data_recv()
765 rd_desc->count -= ret; in tcp_splice_data_recv()
774 .count = tss->len, in __tcp_splice_read()
781 * tcp_splice_read - splice data from TCP socket to a pipe
796 struct sock *sk = sock->sk; in tcp_splice_read()
811 return -ESPIPE; in tcp_splice_read()
817 timeo = sock_rcvtimeo(sk, sock->file->f_flags & O_NONBLOCK); in tcp_splice_read()
827 if (sk->sk_err) { in tcp_splice_read()
831 if (sk->sk_shutdown & RCV_SHUTDOWN) in tcp_splice_read()
833 if (sk->sk_state == TCP_CLOSE) { in tcp_splice_read()
838 ret = -ENOTCONN; in tcp_splice_read()
842 ret = -EAGAIN; in tcp_splice_read()
849 if (!skb_queue_empty(&sk->sk_receive_queue)) in tcp_splice_read()
858 tss.len -= ret; in tcp_splice_read()
866 if (sk->sk_err || sk->sk_state == TCP_CLOSE || in tcp_splice_read()
867 (sk->sk_shutdown & RCV_SHUTDOWN) || in tcp_splice_read()
887 skb = sk->sk_tx_skb_cache; in sk_stream_alloc_skb()
889 skb->truesize = SKB_TRUESIZE(skb_end_offset(skb)); in sk_stream_alloc_skb()
890 sk->sk_tx_skb_cache = NULL; in sk_stream_alloc_skb()
892 INIT_LIST_HEAD(&skb->tcp_tsorted_anchor); in sk_stream_alloc_skb()
893 skb_shinfo(skb)->tx_flags = 0; in sk_stream_alloc_skb()
898 /* The TCP header must be at least 32-bit aligned. */ in sk_stream_alloc_skb()
904 skb = alloc_skb_fclone(size + sk->sk_prot->max_header, gfp); in sk_stream_alloc_skb()
910 sk_forced_mem_schedule(sk, skb->truesize); in sk_stream_alloc_skb()
912 mem_scheduled = sk_wmem_schedule(sk, skb->truesize); in sk_stream_alloc_skb()
915 skb_reserve(skb, sk->sk_prot->max_header); in sk_stream_alloc_skb()
920 skb->reserved_tailroom = skb->end - skb->tail - size; in sk_stream_alloc_skb()
921 INIT_LIST_HEAD(&skb->tcp_tsorted_anchor); in sk_stream_alloc_skb()
926 sk->sk_prot->enter_memory_pressure(sk); in sk_stream_alloc_skb()
942 new_size_goal = sk->sk_gso_max_size - 1 - MAX_TCP_HEADER; in tcp_xmit_size_goal()
946 size_goal = tp->gso_segs * mss_now; in tcp_xmit_size_goal()
949 tp->gso_segs = min_t(u16, new_size_goal / mss_now, in tcp_xmit_size_goal()
950 sk->sk_gso_max_segs); in tcp_xmit_size_goal()
951 size_goal = tp->gso_segs * mss_now; in tcp_xmit_size_goal()
975 if (skb && TCP_SKB_CB(skb)->seq == TCP_SKB_CB(skb)->end_seq) { in tcp_remove_empty_skb()
995 return -EINVAL; in do_tcp_sendpages()
1001 if (((1 << sk->sk_state) & ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)) && in do_tcp_sendpages()
1013 err = -EPIPE; in do_tcp_sendpages()
1014 if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN)) in do_tcp_sendpages()
1022 if (!skb || (copy = size_goal - skb->len) <= 0 || in do_tcp_sendpages()
1028 skb = sk_stream_alloc_skb(sk, 0, sk->sk_allocation, in do_tcp_sendpages()
1034 skb->decrypted = !!(flags & MSG_SENDPAGE_DECRYPTED); in do_tcp_sendpages()
1043 i = skb_shinfo(skb)->nr_frags; in do_tcp_sendpages()
1053 skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy); in do_tcp_sendpages()
1060 skb_shinfo(skb)->tx_flags |= SKBTX_SHARED_FRAG; in do_tcp_sendpages()
1062 skb->len += copy; in do_tcp_sendpages()
1063 skb->data_len += copy; in do_tcp_sendpages()
1064 skb->truesize += copy; in do_tcp_sendpages()
1067 skb->ip_summed = CHECKSUM_PARTIAL; in do_tcp_sendpages()
1068 WRITE_ONCE(tp->write_seq, tp->write_seq + copy); in do_tcp_sendpages()
1069 TCP_SKB_CB(skb)->end_seq += copy; in do_tcp_sendpages()
1073 TCP_SKB_CB(skb)->tcp_flags &= ~TCPHDR_PSH; in do_tcp_sendpages()
1077 size -= copy; in do_tcp_sendpages()
1081 if (skb->len < size_goal || (flags & MSG_OOB)) in do_tcp_sendpages()
1092 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags); in do_tcp_sendpages()
1105 tcp_tx_timestamp(sk, sk->sk_tsflags); in do_tcp_sendpages()
1107 tcp_push(sk, flags, mss_now, tp->nonagle, size_goal); in do_tcp_sendpages()
1117 if (unlikely(tcp_rtx_and_write_queues_empty(sk) && err == -EAGAIN)) { in do_tcp_sendpages()
1118 sk->sk_write_space(sk); in do_tcp_sendpages()
1128 if (!(sk->sk_route_caps & NETIF_F_SG)) in tcp_sendpage_locked()
1131 tcp_rate_check_app_limited(sk); /* is sending application-limited? */ in tcp_sendpage_locked()
1152 if (tp->fastopen_req) { in tcp_free_fastopen_req()
1153 kfree(tp->fastopen_req); in tcp_free_fastopen_req()
1154 tp->fastopen_req = NULL; in tcp_free_fastopen_req()
1164 struct sockaddr *uaddr = msg->msg_name; in tcp_sendmsg_fastopen()
1167 if (!(READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_fastopen) & in tcp_sendmsg_fastopen()
1169 (uaddr && msg->msg_namelen >= sizeof(uaddr->sa_family) && in tcp_sendmsg_fastopen()
1170 uaddr->sa_family == AF_UNSPEC)) in tcp_sendmsg_fastopen()
1171 return -EOPNOTSUPP; in tcp_sendmsg_fastopen()
1172 if (tp->fastopen_req) in tcp_sendmsg_fastopen()
1173 return -EALREADY; /* Another Fast Open is in progress */ in tcp_sendmsg_fastopen()
1175 tp->fastopen_req = kzalloc(sizeof(struct tcp_fastopen_request), in tcp_sendmsg_fastopen()
1176 sk->sk_allocation); in tcp_sendmsg_fastopen()
1177 if (unlikely(!tp->fastopen_req)) in tcp_sendmsg_fastopen()
1178 return -ENOBUFS; in tcp_sendmsg_fastopen()
1179 tp->fastopen_req->data = msg; in tcp_sendmsg_fastopen()
1180 tp->fastopen_req->size = size; in tcp_sendmsg_fastopen()
1181 tp->fastopen_req->uarg = uarg; in tcp_sendmsg_fastopen()
1183 if (inet->defer_connect) { in tcp_sendmsg_fastopen()
1188 inet->inet_dport = 0; in tcp_sendmsg_fastopen()
1189 sk->sk_route_caps = 0; in tcp_sendmsg_fastopen()
1192 flags = (msg->msg_flags & MSG_DONTWAIT) ? O_NONBLOCK : 0; in tcp_sendmsg_fastopen()
1193 err = __inet_stream_connect(sk->sk_socket, uaddr, in tcp_sendmsg_fastopen()
1194 msg->msg_namelen, flags, 1); in tcp_sendmsg_fastopen()
1198 if (tp->fastopen_req) { in tcp_sendmsg_fastopen()
1199 *copied = tp->fastopen_req->copied; in tcp_sendmsg_fastopen()
1201 inet->defer_connect = 0; in tcp_sendmsg_fastopen()
1218 flags = msg->msg_flags; in tcp_sendmsg_locked()
1224 err = -ENOBUFS; in tcp_sendmsg_locked()
1228 zc = sk->sk_route_caps & NETIF_F_SG; in tcp_sendmsg_locked()
1230 uarg->zerocopy = 0; in tcp_sendmsg_locked()
1233 if (unlikely(flags & MSG_FASTOPEN || inet_sk(sk)->defer_connect) && in tcp_sendmsg_locked()
1234 !tp->repair) { in tcp_sendmsg_locked()
1236 if (err == -EINPROGRESS && copied_syn > 0) in tcp_sendmsg_locked()
1244 tcp_rate_check_app_limited(sk); /* is sending application-limited? */ in tcp_sendmsg_locked()
1250 if (((1 << sk->sk_state) & ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)) && in tcp_sendmsg_locked()
1257 if (unlikely(tp->repair)) { in tcp_sendmsg_locked()
1258 if (tp->repair_queue == TCP_RECV_QUEUE) { in tcp_sendmsg_locked()
1263 err = -EINVAL; in tcp_sendmsg_locked()
1264 if (tp->repair_queue == TCP_NO_QUEUE) in tcp_sendmsg_locked()
1271 if (msg->msg_controllen) { in tcp_sendmsg_locked()
1274 err = -EINVAL; in tcp_sendmsg_locked()
1288 err = -EPIPE; in tcp_sendmsg_locked()
1289 if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN)) in tcp_sendmsg_locked()
1297 copy = size_goal - skb->len; in tcp_sendmsg_locked()
1312 skb = sk_stream_alloc_skb(sk, 0, sk->sk_allocation, in tcp_sendmsg_locked()
1318 skb->ip_summed = CHECKSUM_PARTIAL; in tcp_sendmsg_locked()
1327 if (tp->repair) in tcp_sendmsg_locked()
1328 TCP_SKB_CB(skb)->sacked |= TCPCB_REPAIRED; in tcp_sendmsg_locked()
1339 err = skb_add_data_nocache(sk, skb, &msg->msg_iter, copy); in tcp_sendmsg_locked()
1344 int i = skb_shinfo(skb)->nr_frags; in tcp_sendmsg_locked()
1350 if (!skb_can_coalesce(skb, i, pfrag->page, in tcp_sendmsg_locked()
1351 pfrag->offset)) { in tcp_sendmsg_locked()
1359 copy = min_t(int, copy, pfrag->size - pfrag->offset); in tcp_sendmsg_locked()
1364 err = skb_copy_to_page_nocache(sk, &msg->msg_iter, skb, in tcp_sendmsg_locked()
1365 pfrag->page, in tcp_sendmsg_locked()
1366 pfrag->offset, in tcp_sendmsg_locked()
1373 skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy); in tcp_sendmsg_locked()
1375 skb_fill_page_desc(skb, i, pfrag->page, in tcp_sendmsg_locked()
1376 pfrag->offset, copy); in tcp_sendmsg_locked()
1377 page_ref_inc(pfrag->page); in tcp_sendmsg_locked()
1379 pfrag->offset += copy; in tcp_sendmsg_locked()
1385 if (err == -EMSGSIZE || err == -EEXIST) { in tcp_sendmsg_locked()
1395 TCP_SKB_CB(skb)->tcp_flags &= ~TCPHDR_PSH; in tcp_sendmsg_locked()
1397 WRITE_ONCE(tp->write_seq, tp->write_seq + copy); in tcp_sendmsg_locked()
1398 TCP_SKB_CB(skb)->end_seq += copy; in tcp_sendmsg_locked()
1404 TCP_SKB_CB(skb)->eor = 1; in tcp_sendmsg_locked()
1408 if (skb->len < size_goal || (flags & MSG_OOB) || unlikely(tp->repair)) in tcp_sendmsg_locked()
1419 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags); in tcp_sendmsg_locked()
1434 tcp_push(sk, flags, mss_now, tp->nonagle, size_goal); in tcp_sendmsg_locked()
1451 if (unlikely(tcp_rtx_and_write_queues_empty(sk) && err == -EAGAIN)) { in tcp_sendmsg_locked()
1452 sk->sk_write_space(sk); in tcp_sendmsg_locked()
1481 if (sock_flag(sk, SOCK_URGINLINE) || !tp->urg_data || in tcp_recv_urg()
1482 tp->urg_data == TCP_URG_READ) in tcp_recv_urg()
1483 return -EINVAL; /* Yes this is right ! */ in tcp_recv_urg()
1485 if (sk->sk_state == TCP_CLOSE && !sock_flag(sk, SOCK_DONE)) in tcp_recv_urg()
1486 return -ENOTCONN; in tcp_recv_urg()
1488 if (tp->urg_data & TCP_URG_VALID) { in tcp_recv_urg()
1490 char c = tp->urg_data; in tcp_recv_urg()
1493 tp->urg_data = TCP_URG_READ; in tcp_recv_urg()
1496 msg->msg_flags |= MSG_OOB; in tcp_recv_urg()
1503 msg->msg_flags |= MSG_TRUNC; in tcp_recv_urg()
1505 return err ? -EFAULT : len; in tcp_recv_urg()
1508 if (sk->sk_state == TCP_CLOSE || (sk->sk_shutdown & RCV_SHUTDOWN)) in tcp_recv_urg()
1515 * Mike <pall@rz.uni-karlsruhe.de> in tcp_recv_urg()
1517 return -EAGAIN; in tcp_recv_urg()
1525 /* XXX -- need to support SO_PEEK_OFF */ in tcp_peek_sndq()
1527 skb_rbtree_walk(skb, &sk->tcp_rtx_queue) { in tcp_peek_sndq()
1528 err = skb_copy_datagram_msg(skb, 0, msg, skb->len); in tcp_peek_sndq()
1531 copied += skb->len; in tcp_peek_sndq()
1534 skb_queue_walk(&sk->sk_write_queue, skb) { in tcp_peek_sndq()
1535 err = skb_copy_datagram_msg(skb, 0, msg, skb->len); in tcp_peek_sndq()
1539 copied += skb->len; in tcp_peek_sndq()
1556 struct sk_buff *skb = skb_peek(&sk->sk_receive_queue); in tcp_cleanup_rbuf()
1558 WARN(skb && !before(tp->copied_seq, TCP_SKB_CB(skb)->end_seq), in tcp_cleanup_rbuf()
1560 tp->copied_seq, TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt); in tcp_cleanup_rbuf()
1564 __u16 rcv_mss = icsk->icsk_ack.rcv_mss; in tcp_cleanup_rbuf()
1569 if (/* Once-per-two-segments ACK was not sent by tcp_input.c */ in tcp_cleanup_rbuf()
1570 tp->rcv_nxt - tp->rcv_wup > rcv_mss || in tcp_cleanup_rbuf()
1578 ((icsk->icsk_ack.pending & ICSK_ACK_PUSHED2) || in tcp_cleanup_rbuf()
1579 ((icsk->icsk_ack.pending & ICSK_ACK_PUSHED) && in tcp_cleanup_rbuf()
1581 !atomic_read(&sk->sk_rmem_alloc))) in tcp_cleanup_rbuf()
1585 /* We send an ACK if we can now advertise a non-zero window in tcp_cleanup_rbuf()
1591 if (copied > 0 && !time_to_ack && !(sk->sk_shutdown & RCV_SHUTDOWN)) { in tcp_cleanup_rbuf()
1595 if (2*rcv_window_now <= tp->window_clamp) { in tcp_cleanup_rbuf()
1616 while ((skb = skb_peek(&sk->sk_receive_queue)) != NULL) { in tcp_recv_skb()
1617 offset = seq - TCP_SKB_CB(skb)->seq; in tcp_recv_skb()
1618 if (unlikely(TCP_SKB_CB(skb)->tcp_flags & TCPHDR_SYN)) { in tcp_recv_skb()
1620 offset--; in tcp_recv_skb()
1622 if (offset < skb->len || (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)) { in tcp_recv_skb()
1640 * - It is assumed that the socket was locked by the caller.
1641 * - The routine does not block.
1642 * - At present, there is no support for reading OOB data
1651 u32 seq = tp->copied_seq; in tcp_read_sock()
1655 if (sk->sk_state == TCP_LISTEN) in tcp_read_sock()
1656 return -ENOTCONN; in tcp_read_sock()
1658 if (offset < skb->len) { in tcp_read_sock()
1662 len = skb->len - offset; in tcp_read_sock()
1664 if (tp->urg_data) { in tcp_read_sock()
1665 u32 urg_offset = tp->urg_seq - seq; in tcp_read_sock()
1688 skb = tcp_recv_skb(sk, seq - 1, &offset); in tcp_read_sock()
1694 if (offset + 1 != skb->len) in tcp_read_sock()
1697 if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN) { in tcp_read_sock()
1703 if (!desc->count) in tcp_read_sock()
1705 WRITE_ONCE(tp->copied_seq, seq); in tcp_read_sock()
1707 WRITE_ONCE(tp->copied_seq, seq); in tcp_read_sock()
1722 return tcp_inq(sock->sk); in tcp_peek_len()
1731 if (sk->sk_userlocks & SOCK_RCVBUF_LOCK) in tcp_set_rcvlowat()
1732 cap = sk->sk_rcvbuf >> 1; in tcp_set_rcvlowat()
1734 cap = READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_rmem[2]) >> 1; in tcp_set_rcvlowat()
1736 WRITE_ONCE(sk->sk_rcvlowat, val ? : 1); in tcp_set_rcvlowat()
1741 if (sk->sk_userlocks & SOCK_RCVBUF_LOCK) in tcp_set_rcvlowat()
1745 if (val > sk->sk_rcvbuf) { in tcp_set_rcvlowat()
1746 WRITE_ONCE(sk->sk_rcvbuf, val); in tcp_set_rcvlowat()
1747 tcp_sk(sk)->window_clamp = tcp_win_from_space(sk, val); in tcp_set_rcvlowat()
1760 if (vma->vm_flags & (VM_WRITE | VM_EXEC)) in tcp_mmap()
1761 return -EPERM; in tcp_mmap()
1762 vma->vm_flags &= ~(VM_MAYWRITE | VM_MAYEXEC); in tcp_mmap()
1765 vma->vm_flags |= VM_MIXEDMAP; in tcp_mmap()
1767 vma->vm_ops = &tcp_vm_ops; in tcp_mmap()
1777 if (unlikely(offset_skb >= skb->len)) in skb_advance_to_frag()
1780 offset_skb -= skb_headlen(skb); in skb_advance_to_frag()
1784 frag = skb_shinfo(skb)->frags; in skb_advance_to_frag()
1790 offset_skb -= skb_frag_size(frag); in skb_advance_to_frag()
1806 if (PageCompound(page) || page->mapping) in can_map_frag()
1831 unsigned long copy_address = (unsigned long)zc->copybuf_address; in tcp_copy_straggler_data()
1836 if (copy_address != zc->copybuf_address) in tcp_copy_straggler_data()
1837 return -EINVAL; in tcp_copy_straggler_data()
1846 zc->recv_skip_hint -= copylen; in tcp_copy_straggler_data()
1858 u32 offset, copylen = min_t(u32, copybuf_len, zc->recv_skip_hint); in tcp_zerocopy_handle_leftover_data()
1864 offset = *seq - TCP_SKB_CB(skb)->seq; in tcp_zerocopy_handle_leftover_data()
1868 zc->copybuf_len = tcp_copy_straggler_data(zc, skb, copylen, &offset, in tcp_zerocopy_handle_leftover_data()
1870 return zc->copybuf_len < 0 ? 0 : copylen; in tcp_zerocopy_handle_leftover_data()
1886 bytes_mapped = PAGE_SIZE * (pages_to_map - pages_remaining); in tcp_zerocopy_vm_insert_batch()
1897 *length_with_pending -= bytes_not_mapped; in tcp_zerocopy_vm_insert_batch()
1898 zc->recv_skip_hint += bytes_not_mapped; in tcp_zerocopy_vm_insert_batch()
1907 unsigned long address = (unsigned long)zc->address; in tcp_zerocopy_receive()
1908 s32 copybuf_len = zc->copybuf_len; in tcp_zerocopy_receive()
1917 u32 seq = tp->copied_seq; in tcp_zerocopy_receive()
1921 zc->copybuf_len = 0; in tcp_zerocopy_receive()
1923 if (address & (PAGE_SIZE - 1) || address != zc->address) in tcp_zerocopy_receive()
1924 return -EINVAL; in tcp_zerocopy_receive()
1926 if (sk->sk_state == TCP_LISTEN) in tcp_zerocopy_receive()
1927 return -ENOTCONN; in tcp_zerocopy_receive()
1931 mmap_read_lock(current->mm); in tcp_zerocopy_receive()
1933 vma = find_vma(current->mm, address); in tcp_zerocopy_receive()
1934 if (!vma || vma->vm_start > address || vma->vm_ops != &tcp_vm_ops) { in tcp_zerocopy_receive()
1935 mmap_read_unlock(current->mm); in tcp_zerocopy_receive()
1936 return -EINVAL; in tcp_zerocopy_receive()
1938 vma_len = min_t(unsigned long, zc->length, vma->vm_end - address); in tcp_zerocopy_receive()
1940 aligned_len = avail_len & ~(PAGE_SIZE - 1); in tcp_zerocopy_receive()
1943 zc->length = aligned_len; in tcp_zerocopy_receive()
1944 zc->recv_skip_hint = 0; in tcp_zerocopy_receive()
1946 zc->length = avail_len; in tcp_zerocopy_receive()
1947 zc->recv_skip_hint = avail_len; in tcp_zerocopy_receive()
1951 while (length + PAGE_SIZE <= zc->length) { in tcp_zerocopy_receive()
1954 if (zc->recv_skip_hint < PAGE_SIZE) { in tcp_zerocopy_receive()
1969 if (zc->recv_skip_hint > 0) in tcp_zerocopy_receive()
1971 skb = skb->next; in tcp_zerocopy_receive()
1972 offset = seq - TCP_SKB_CB(skb)->seq; in tcp_zerocopy_receive()
1976 zc->recv_skip_hint = skb->len - offset; in tcp_zerocopy_receive()
1983 zc->recv_skip_hint); in tcp_zerocopy_receive()
1985 zc->recv_skip_hint = mappable_offset; in tcp_zerocopy_receive()
1991 zc->recv_skip_hint -= PAGE_SIZE; in tcp_zerocopy_receive()
2008 mmap_read_unlock(current->mm); in tcp_zerocopy_receive()
2015 WRITE_ONCE(tp->copied_seq, seq); in tcp_zerocopy_receive()
2022 if (length == zc->length) in tcp_zerocopy_receive()
2023 zc->recv_skip_hint = 0; in tcp_zerocopy_receive()
2025 if (!zc->recv_skip_hint && sock_flag(sk, SOCK_DONE)) in tcp_zerocopy_receive()
2026 ret = -EIO; in tcp_zerocopy_receive()
2028 zc->length = length; in tcp_zerocopy_receive()
2036 if (skb->tstamp) in tcp_update_recv_tstamps()
2037 tss->ts[0] = ktime_to_timespec64(skb->tstamp); in tcp_update_recv_tstamps()
2039 tss->ts[0] = (struct timespec64) {0}; in tcp_update_recv_tstamps()
2041 if (skb_hwtstamps(skb)->hwtstamp) in tcp_update_recv_tstamps()
2042 tss->ts[2] = ktime_to_timespec64(skb_hwtstamps(skb)->hwtstamp); in tcp_update_recv_tstamps()
2044 tss->ts[2] = (struct timespec64) {0}; in tcp_update_recv_tstamps()
2054 if (tss->ts[0].tv_sec || tss->ts[0].tv_nsec) { in tcp_recv_timestamp()
2059 .tv_sec = tss->ts[0].tv_sec, in tcp_recv_timestamp()
2060 .tv_nsec = tss->ts[0].tv_nsec, in tcp_recv_timestamp()
2066 .tv_sec = tss->ts[0].tv_sec, in tcp_recv_timestamp()
2067 .tv_nsec = tss->ts[0].tv_nsec, in tcp_recv_timestamp()
2075 .tv_sec = tss->ts[0].tv_sec, in tcp_recv_timestamp()
2076 .tv_usec = tss->ts[0].tv_nsec / 1000, in tcp_recv_timestamp()
2082 .tv_sec = tss->ts[0].tv_sec, in tcp_recv_timestamp()
2083 .tv_usec = tss->ts[0].tv_nsec / 1000, in tcp_recv_timestamp()
2091 if (sk->sk_tsflags & SOF_TIMESTAMPING_SOFTWARE) in tcp_recv_timestamp()
2094 tss->ts[0] = (struct timespec64) {0}; in tcp_recv_timestamp()
2097 if (tss->ts[2].tv_sec || tss->ts[2].tv_nsec) { in tcp_recv_timestamp()
2098 if (sk->sk_tsflags & SOF_TIMESTAMPING_RAW_HARDWARE) in tcp_recv_timestamp()
2101 tss->ts[2] = (struct timespec64) {0}; in tcp_recv_timestamp()
2105 tss->ts[1] = (struct timespec64) {0}; in tcp_recv_timestamp()
2116 u32 copied_seq = READ_ONCE(tp->copied_seq); in tcp_inq_hint()
2117 u32 rcv_nxt = READ_ONCE(tp->rcv_nxt); in tcp_inq_hint()
2120 inq = rcv_nxt - copied_seq; in tcp_inq_hint()
2121 if (unlikely(inq < 0 || copied_seq != READ_ONCE(tp->copied_seq))) { in tcp_inq_hint()
2123 inq = tp->rcv_nxt - tp->copied_seq; in tcp_inq_hint()
2126 /* After receiving a FIN, tell the user-space to continue reading in tcp_inq_hint()
2127 * by returning a non-zero inq. in tcp_inq_hint()
2138 * tricks with *seq access order and skb->users are not required.
2161 if (sk_can_busy_loop(sk) && skb_queue_empty_lockless(&sk->sk_receive_queue) && in tcp_recvmsg()
2162 (sk->sk_state == TCP_ESTABLISHED)) in tcp_recvmsg()
2167 err = -ENOTCONN; in tcp_recvmsg()
2168 if (sk->sk_state == TCP_LISTEN) in tcp_recvmsg()
2171 cmsg_flags = tp->recvmsg_inq ? 1 : 0; in tcp_recvmsg()
2178 if (unlikely(tp->repair)) { in tcp_recvmsg()
2179 err = -EPERM; in tcp_recvmsg()
2183 if (tp->repair_queue == TCP_SEND_QUEUE) in tcp_recvmsg()
2186 err = -EINVAL; in tcp_recvmsg()
2187 if (tp->repair_queue == TCP_NO_QUEUE) in tcp_recvmsg()
2190 /* 'common' recv queue MSG_PEEK-ing */ in tcp_recvmsg()
2193 seq = &tp->copied_seq; in tcp_recvmsg()
2195 peek_seq = tp->copied_seq; in tcp_recvmsg()
2205 if (tp->urg_data && tp->urg_seq == *seq) { in tcp_recvmsg()
2209 copied = timeo ? sock_intr_errno(timeo) : -EAGAIN; in tcp_recvmsg()
2216 last = skb_peek_tail(&sk->sk_receive_queue); in tcp_recvmsg()
2217 skb_queue_walk(&sk->sk_receive_queue, skb) { in tcp_recvmsg()
2222 if (WARN(before(*seq, TCP_SKB_CB(skb)->seq), in tcp_recvmsg()
2224 *seq, TCP_SKB_CB(skb)->seq, tp->rcv_nxt, in tcp_recvmsg()
2228 offset = *seq - TCP_SKB_CB(skb)->seq; in tcp_recvmsg()
2229 if (unlikely(TCP_SKB_CB(skb)->tcp_flags & TCPHDR_SYN)) { in tcp_recvmsg()
2231 offset--; in tcp_recvmsg()
2233 if (offset < skb->len) in tcp_recvmsg()
2235 if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN) in tcp_recvmsg()
2239 *seq, TCP_SKB_CB(skb)->seq, tp->rcv_nxt, flags); in tcp_recvmsg()
2244 if (copied >= target && !READ_ONCE(sk->sk_backlog.tail)) in tcp_recvmsg()
2248 if (sk->sk_err || in tcp_recvmsg()
2249 sk->sk_state == TCP_CLOSE || in tcp_recvmsg()
2250 (sk->sk_shutdown & RCV_SHUTDOWN) || in tcp_recvmsg()
2258 if (sk->sk_err) { in tcp_recvmsg()
2263 if (sk->sk_shutdown & RCV_SHUTDOWN) in tcp_recvmsg()
2266 if (sk->sk_state == TCP_CLOSE) { in tcp_recvmsg()
2270 copied = -ENOTCONN; in tcp_recvmsg()
2275 copied = -EAGAIN; in tcp_recvmsg()
2296 (peek_seq - copied - urg_hole != tp->copied_seq)) { in tcp_recvmsg()
2298 current->comm, in tcp_recvmsg()
2300 peek_seq = tp->copied_seq; in tcp_recvmsg()
2306 used = skb->len - offset; in tcp_recvmsg()
2311 if (tp->urg_data) { in tcp_recvmsg()
2312 u32 urg_offset = tp->urg_seq - *seq; in tcp_recvmsg()
2319 used--; in tcp_recvmsg()
2333 copied = -EFAULT; in tcp_recvmsg()
2340 len -= used; in tcp_recvmsg()
2345 if (tp->urg_data && after(tp->copied_seq, tp->urg_seq)) { in tcp_recvmsg()
2346 tp->urg_data = 0; in tcp_recvmsg()
2350 if (TCP_SKB_CB(skb)->has_rxtstamp) { in tcp_recvmsg()
2355 if (used + offset < skb->len) in tcp_recvmsg()
2358 if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN) in tcp_recvmsg()
2373 * on connected socket. I was just happy when found this 8) --ANK in tcp_recvmsg()
2408 int oldstate = sk->sk_state; in tcp_set_state()
2444 sk->sk_prot->unhash(sk); in tcp_set_state()
2445 if (inet_csk(sk)->icsk_bind_hash && in tcp_set_state()
2446 !(sk->sk_userlocks & SOCK_BINDPORT_LOCK)) in tcp_set_state()
2487 int next = (int)new_state[sk->sk_state]; in tcp_close_state()
2510 if ((1 << sk->sk_state) & in tcp_shutdown()
2556 net_info_ratelimited("out of memory -- consider tuning tcp_mem\n"); in tcp_check_oom()
2566 WRITE_ONCE(sk->sk_shutdown, SHUTDOWN_MASK); in __tcp_close()
2568 if (sk->sk_state == TCP_LISTEN) { in __tcp_close()
2578 * descriptor close, not protocol-sourced closes, because the in __tcp_close()
2581 while ((skb = __skb_dequeue(&sk->sk_receive_queue)) != NULL) { in __tcp_close()
2582 u32 len = TCP_SKB_CB(skb)->end_seq - TCP_SKB_CB(skb)->seq; in __tcp_close()
2584 if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN) in __tcp_close()
2585 len--; in __tcp_close()
2592 /* If socket has been already reset (e.g. in tcp_reset()) - kill it. */ in __tcp_close()
2593 if (sk->sk_state == TCP_CLOSE) in __tcp_close()
2600 * advertise a zero window, then kill -9 the FTP client, wheee... in __tcp_close()
2603 if (unlikely(tcp_sk(sk)->repair)) { in __tcp_close()
2604 sk->sk_prot->disconnect(sk, 0); in __tcp_close()
2609 tcp_send_active_reset(sk, sk->sk_allocation); in __tcp_close()
2610 } else if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) { in __tcp_close()
2612 sk->sk_prot->disconnect(sk, 0); in __tcp_close()
2619 /* RED-PEN. Formally speaking, we have broken TCP state in __tcp_close()
2622 * TCP_ESTABLISHED -> TCP_FIN_WAIT1 in __tcp_close()
2623 * TCP_SYN_RECV -> TCP_FIN_WAIT1 (it is difficult) in __tcp_close()
2624 * TCP_CLOSE_WAIT -> TCP_LAST_ACK in __tcp_close()
2630 * if Linux state is FIN-WAIT-1, but FIN is still not sent. in __tcp_close()
2633 * we enter time-wait state, when it is not required really in __tcp_close()
2638 * --ANK in __tcp_close()
2639 * XXX (TFO) - To start off we don't support SYN+ACK+FIN in __tcp_close()
2641 * probably need API support or TCP_CORK SYN-ACK until in __tcp_close()
2650 state = sk->sk_state; in __tcp_close()
2662 if (state != TCP_CLOSE && sk->sk_state == TCP_CLOSE) in __tcp_close()
2669 * our end. If they send after that then tough - BUT: long enough in __tcp_close()
2670 * that we won't make the old 4*rto = almost no time - whoops in __tcp_close()
2676 * linger2 option. --ANK in __tcp_close()
2679 if (sk->sk_state == TCP_FIN_WAIT2) { in __tcp_close()
2681 if (tp->linger2 < 0) { in __tcp_close()
2691 tmo - TCP_TIMEWAIT_LEN); in __tcp_close()
2698 if (sk->sk_state != TCP_CLOSE) { in __tcp_close()
2711 if (sk->sk_state == TCP_CLOSE) { in __tcp_close()
2714 req = rcu_dereference_protected(tcp_sk(sk)->fastopen_rsk, in __tcp_close()
2716 /* We could get here with a non-NULL req if the socket is in __tcp_close()
2736 if (!sk->sk_net_refcnt) in tcp_close()
2753 struct rb_node *p = rb_first(&sk->tcp_rtx_queue); in tcp_rtx_queue_purge()
2755 tcp_sk(sk)->highest_sack = NULL; in tcp_rtx_queue_purge()
2761 * list_del(&skb->tcp_tsorted_anchor) in tcp_rtx_queue_purge()
2773 while ((skb = __skb_dequeue(&sk->sk_write_queue)) != NULL) { in tcp_write_queue_purge()
2778 skb = sk->sk_tx_skb_cache; in tcp_write_queue_purge()
2781 sk->sk_tx_skb_cache = NULL; in tcp_write_queue_purge()
2783 INIT_LIST_HEAD(&tcp_sk(sk)->tsorted_sent_queue); in tcp_write_queue_purge()
2786 tcp_sk(sk)->packets_out = 0; in tcp_write_queue_purge()
2787 inet_csk(sk)->icsk_backoff = 0; in tcp_write_queue_purge()
2795 int old_state = sk->sk_state; in tcp_disconnect()
2801 if (sk->sk_wait_pending) in tcp_disconnect()
2802 return -EBUSY; in tcp_disconnect()
2810 } else if (unlikely(tp->repair)) { in tcp_disconnect()
2811 sk->sk_err = ECONNABORTED; in tcp_disconnect()
2813 (tp->snd_nxt != tp->write_seq && in tcp_disconnect()
2819 sk->sk_err = ECONNRESET; in tcp_disconnect()
2821 sk->sk_err = ECONNRESET; in tcp_disconnect()
2824 __skb_queue_purge(&sk->sk_receive_queue); in tcp_disconnect()
2825 if (sk->sk_rx_skb_cache) { in tcp_disconnect()
2826 __kfree_skb(sk->sk_rx_skb_cache); in tcp_disconnect()
2827 sk->sk_rx_skb_cache = NULL; in tcp_disconnect()
2829 WRITE_ONCE(tp->copied_seq, tp->rcv_nxt); in tcp_disconnect()
2830 tp->urg_data = 0; in tcp_disconnect()
2833 skb_rbtree_purge(&tp->out_of_order_queue); in tcp_disconnect()
2835 inet->inet_dport = 0; in tcp_disconnect()
2837 if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK)) in tcp_disconnect()
2840 WRITE_ONCE(sk->sk_shutdown, 0); in tcp_disconnect()
2842 tp->srtt_us = 0; in tcp_disconnect()
2843 tp->mdev_us = jiffies_to_usecs(TCP_TIMEOUT_INIT); in tcp_disconnect()
2844 tp->rcv_rtt_last_tsecr = 0; in tcp_disconnect()
2846 seq = tp->write_seq + tp->max_window + 2; in tcp_disconnect()
2849 WRITE_ONCE(tp->write_seq, seq); in tcp_disconnect()
2851 icsk->icsk_backoff = 0; in tcp_disconnect()
2852 icsk->icsk_probes_out = 0; in tcp_disconnect()
2853 icsk->icsk_probes_tstamp = 0; in tcp_disconnect()
2854 icsk->icsk_rto = TCP_TIMEOUT_INIT; in tcp_disconnect()
2855 icsk->icsk_rto_min = TCP_RTO_MIN; in tcp_disconnect()
2856 icsk->icsk_delack_max = TCP_DELACK_MAX; in tcp_disconnect()
2858 icsk->nata_retries_enabled = 0; in tcp_disconnect()
2859 icsk->nata_retries_type = NATA_NA; in tcp_disconnect()
2860 icsk->nata_syn_rto = TCP_TIMEOUT_INIT; in tcp_disconnect()
2861 icsk->nata_data_rto = TCP_TIMEOUT_INIT; in tcp_disconnect()
2862 icsk->nata_data_retries = 0; in tcp_disconnect()
2864 tp->snd_ssthresh = TCP_INFINITE_SSTHRESH; in tcp_disconnect()
2865 tp->snd_cwnd = TCP_INIT_CWND; in tcp_disconnect()
2866 tp->snd_cwnd_cnt = 0; in tcp_disconnect()
2867 tp->is_cwnd_limited = 0; in tcp_disconnect()
2868 tp->max_packets_out = 0; in tcp_disconnect()
2869 tp->window_clamp = 0; in tcp_disconnect()
2870 tp->delivered = 0; in tcp_disconnect()
2871 tp->delivered_ce = 0; in tcp_disconnect()
2872 if (icsk->icsk_ca_ops->release) in tcp_disconnect()
2873 icsk->icsk_ca_ops->release(sk); in tcp_disconnect()
2874 memset(icsk->icsk_ca_priv, 0, sizeof(icsk->icsk_ca_priv)); in tcp_disconnect()
2875 icsk->icsk_ca_initialized = 0; in tcp_disconnect()
2877 tp->is_sack_reneg = 0; in tcp_disconnect()
2879 tp->total_retrans = 0; in tcp_disconnect()
2884 icsk->icsk_ack.rcv_mss = TCP_MIN_MSS; in tcp_disconnect()
2885 memset(&tp->rx_opt, 0, sizeof(tp->rx_opt)); in tcp_disconnect()
2887 dst_release(xchg((__force struct dst_entry **)&sk->sk_rx_dst, NULL)); in tcp_disconnect()
2889 tp->compressed_ack = 0; in tcp_disconnect()
2890 tp->segs_in = 0; in tcp_disconnect()
2891 tp->segs_out = 0; in tcp_disconnect()
2892 tp->bytes_sent = 0; in tcp_disconnect()
2893 tp->bytes_acked = 0; in tcp_disconnect()
2894 tp->bytes_received = 0; in tcp_disconnect()
2895 tp->bytes_retrans = 0; in tcp_disconnect()
2896 tp->data_segs_in = 0; in tcp_disconnect()
2897 tp->data_segs_out = 0; in tcp_disconnect()
2898 tp->duplicate_sack[0].start_seq = 0; in tcp_disconnect()
2899 tp->duplicate_sack[0].end_seq = 0; in tcp_disconnect()
2900 tp->dsack_dups = 0; in tcp_disconnect()
2901 tp->reord_seen = 0; in tcp_disconnect()
2902 tp->retrans_out = 0; in tcp_disconnect()
2903 tp->sacked_out = 0; in tcp_disconnect()
2904 tp->tlp_high_seq = 0; in tcp_disconnect()
2905 tp->last_oow_ack_time = 0; in tcp_disconnect()
2907 tp->app_limited = ~0U; in tcp_disconnect()
2908 tp->rate_app_limited = 1; in tcp_disconnect()
2909 tp->rack.mstamp = 0; in tcp_disconnect()
2910 tp->rack.advanced = 0; in tcp_disconnect()
2911 tp->rack.reo_wnd_steps = 1; in tcp_disconnect()
2912 tp->rack.last_delivered = 0; in tcp_disconnect()
2913 tp->rack.reo_wnd_persist = 0; in tcp_disconnect()
2914 tp->rack.dsack_seen = 0; in tcp_disconnect()
2915 tp->syn_data_acked = 0; in tcp_disconnect()
2916 tp->rx_opt.saw_tstamp = 0; in tcp_disconnect()
2917 tp->rx_opt.dsack = 0; in tcp_disconnect()
2918 tp->rx_opt.num_sacks = 0; in tcp_disconnect()
2919 tp->rcv_ooopack = 0; in tcp_disconnect()
2924 inet->defer_connect = 0; in tcp_disconnect()
2925 tp->fastopen_client_fail = 0; in tcp_disconnect()
2927 WARN_ON(inet->inet_num && !icsk->icsk_bind_hash); in tcp_disconnect()
2929 if (sk->sk_frag.page) { in tcp_disconnect()
2930 put_page(sk->sk_frag.page); in tcp_disconnect()
2931 sk->sk_frag.page = NULL; in tcp_disconnect()
2932 sk->sk_frag.offset = 0; in tcp_disconnect()
2935 sk->sk_error_report(sk); in tcp_disconnect()
2942 return ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN) && in tcp_can_repair_sock()
2943 (sk->sk_state != TCP_LISTEN); in tcp_can_repair_sock()
2950 if (!tp->repair) in tcp_repair_set_window()
2951 return -EPERM; in tcp_repair_set_window()
2954 return -EINVAL; in tcp_repair_set_window()
2957 return -EFAULT; in tcp_repair_set_window()
2960 return -EINVAL; in tcp_repair_set_window()
2962 if (after(opt.snd_wl1, tp->rcv_nxt + opt.rcv_wnd)) in tcp_repair_set_window()
2963 return -EINVAL; in tcp_repair_set_window()
2965 if (after(opt.rcv_wup, tp->rcv_nxt)) in tcp_repair_set_window()
2966 return -EINVAL; in tcp_repair_set_window()
2968 tp->snd_wl1 = opt.snd_wl1; in tcp_repair_set_window()
2969 tp->snd_wnd = opt.snd_wnd; in tcp_repair_set_window()
2970 tp->max_window = opt.max_window; in tcp_repair_set_window()
2972 tp->rcv_wnd = opt.rcv_wnd; in tcp_repair_set_window()
2973 tp->rcv_wup = opt.rcv_wup; in tcp_repair_set_window()
2987 return -EFAULT; in tcp_repair_options_est()
2990 len -= sizeof(opt); in tcp_repair_options_est()
2994 tp->rx_opt.mss_clamp = opt.opt_val; in tcp_repair_options_est()
3003 return -EFBIG; in tcp_repair_options_est()
3005 tp->rx_opt.snd_wscale = snd_wscale; in tcp_repair_options_est()
3006 tp->rx_opt.rcv_wscale = rcv_wscale; in tcp_repair_options_est()
3007 tp->rx_opt.wscale_ok = 1; in tcp_repair_options_est()
3012 return -EINVAL; in tcp_repair_options_est()
3014 tp->rx_opt.sack_ok |= TCP_SACK_SEEN; in tcp_repair_options_est()
3018 return -EINVAL; in tcp_repair_options_est()
3020 tp->rx_opt.tstamp_ok = 1; in tcp_repair_options_est()
3043 /* When set indicates to always queue non-full frames. Later the user clears
3057 tp->nonagle |= TCP_NAGLE_CORK; in __tcp_sock_set_cork()
3059 tp->nonagle &= ~TCP_NAGLE_CORK; in __tcp_sock_set_cork()
3060 if (tp->nonagle & TCP_NAGLE_OFF) in __tcp_sock_set_cork()
3061 tp->nonagle |= TCP_NAGLE_PUSH; in __tcp_sock_set_cork()
3083 tcp_sk(sk)->nonagle |= TCP_NAGLE_OFF|TCP_NAGLE_PUSH; in __tcp_sock_set_nodelay()
3086 tcp_sk(sk)->nonagle &= ~TCP_NAGLE_OFF; in __tcp_sock_set_nodelay()
3106 if ((1 << sk->sk_state) & (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT) && in __tcp_sock_set_quickack()
3108 inet_csk(sk)->icsk_ack.pending |= ICSK_ACK_PUSHED; in __tcp_sock_set_quickack()
3126 return -EINVAL; in tcp_sock_set_syncnt()
3129 WRITE_ONCE(inet_csk(sk)->icsk_syn_retries, val); in tcp_sock_set_syncnt()
3138 WRITE_ONCE(inet_csk(sk)->icsk_user_timeout, val); in tcp_sock_set_user_timeout()
3148 return -EINVAL; in tcp_sock_set_keepidle_locked()
3151 WRITE_ONCE(tp->keepalive_time, val * HZ); in tcp_sock_set_keepidle_locked()
3153 !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) { in tcp_sock_set_keepidle_locked()
3156 if (tp->keepalive_time > elapsed) in tcp_sock_set_keepidle_locked()
3157 elapsed = tp->keepalive_time - elapsed; in tcp_sock_set_keepidle_locked()
3180 return -EINVAL; in tcp_sock_set_keepintvl()
3183 WRITE_ONCE(tcp_sk(sk)->keepalive_intvl, val * HZ); in tcp_sock_set_keepintvl()
3192 return -EINVAL; in tcp_sock_set_keepcnt()
3196 WRITE_ONCE(tcp_sk(sk)->keepalive_probes, val); in tcp_sock_set_keepcnt()
3220 return -EINVAL; in do_tcp_setsockopt()
3223 min_t(long, TCP_CA_NAME_MAX-1, optlen)); in do_tcp_setsockopt()
3225 return -EFAULT; in do_tcp_setsockopt()
3230 ns_capable(sock_net(sk)->user_ns, in do_tcp_setsockopt()
3239 return -EINVAL; in do_tcp_setsockopt()
3242 min_t(long, TCP_ULP_NAME_MAX - 1, in do_tcp_setsockopt()
3245 return -EFAULT; in do_tcp_setsockopt()
3262 return -EINVAL; in do_tcp_setsockopt()
3265 return -EFAULT; in do_tcp_setsockopt()
3278 return -EINVAL; in do_tcp_setsockopt()
3281 return -EFAULT; in do_tcp_setsockopt()
3292 err = -EINVAL; in do_tcp_setsockopt()
3295 tp->rx_opt.user_mss = val; in do_tcp_setsockopt()
3304 err = -EINVAL; in do_tcp_setsockopt()
3306 tp->thin_lto = val; in do_tcp_setsockopt()
3311 err = -EINVAL; in do_tcp_setsockopt()
3316 err = -EPERM; in do_tcp_setsockopt()
3318 tp->repair = 1; in do_tcp_setsockopt()
3319 sk->sk_reuse = SK_FORCE_REUSE; in do_tcp_setsockopt()
3320 tp->repair_queue = TCP_NO_QUEUE; in do_tcp_setsockopt()
3322 tp->repair = 0; in do_tcp_setsockopt()
3323 sk->sk_reuse = SK_NO_REUSE; in do_tcp_setsockopt()
3326 tp->repair = 0; in do_tcp_setsockopt()
3327 sk->sk_reuse = SK_NO_REUSE; in do_tcp_setsockopt()
3329 err = -EINVAL; in do_tcp_setsockopt()
3334 if (!tp->repair) in do_tcp_setsockopt()
3335 err = -EPERM; in do_tcp_setsockopt()
3337 tp->repair_queue = val; in do_tcp_setsockopt()
3339 err = -EINVAL; in do_tcp_setsockopt()
3343 if (sk->sk_state != TCP_CLOSE) { in do_tcp_setsockopt()
3344 err = -EPERM; in do_tcp_setsockopt()
3345 } else if (tp->repair_queue == TCP_SEND_QUEUE) { in do_tcp_setsockopt()
3347 err = -EPERM; in do_tcp_setsockopt()
3349 WRITE_ONCE(tp->write_seq, val); in do_tcp_setsockopt()
3350 } else if (tp->repair_queue == TCP_RECV_QUEUE) { in do_tcp_setsockopt()
3351 if (tp->rcv_nxt != tp->copied_seq) { in do_tcp_setsockopt()
3352 err = -EPERM; in do_tcp_setsockopt()
3354 WRITE_ONCE(tp->rcv_nxt, val); in do_tcp_setsockopt()
3355 WRITE_ONCE(tp->copied_seq, val); in do_tcp_setsockopt()
3358 err = -EINVAL; in do_tcp_setsockopt()
3363 if (!tp->repair) in do_tcp_setsockopt()
3364 err = -EINVAL; in do_tcp_setsockopt()
3365 else if (sk->sk_state == TCP_ESTABLISHED && !tp->bytes_sent) in do_tcp_setsockopt()
3368 err = -EPERM; in do_tcp_setsockopt()
3380 err = -EINVAL; in do_tcp_setsockopt()
3382 WRITE_ONCE(tp->keepalive_intvl, val * HZ); in do_tcp_setsockopt()
3386 err = -EINVAL; in do_tcp_setsockopt()
3388 WRITE_ONCE(tp->keepalive_probes, val); in do_tcp_setsockopt()
3392 err = -EINVAL; in do_tcp_setsockopt()
3394 WRITE_ONCE(icsk->icsk_syn_retries, val); in do_tcp_setsockopt()
3400 err = -EINVAL; in do_tcp_setsockopt()
3402 tp->save_syn = val; in do_tcp_setsockopt()
3407 WRITE_ONCE(tp->linger2, -1); in do_tcp_setsockopt()
3409 WRITE_ONCE(tp->linger2, TCP_FIN_TIMEOUT_MAX); in do_tcp_setsockopt()
3411 WRITE_ONCE(tp->linger2, val * HZ); in do_tcp_setsockopt()
3416 WRITE_ONCE(icsk->icsk_accept_queue.rskq_defer_accept, in do_tcp_setsockopt()
3423 if (sk->sk_state != TCP_CLOSE) { in do_tcp_setsockopt()
3424 err = -EINVAL; in do_tcp_setsockopt()
3427 tp->window_clamp = 0; in do_tcp_setsockopt()
3429 tp->window_clamp = val < SOCK_MIN_RCVBUF / 2 ? in do_tcp_setsockopt()
3440 err = tp->af_specific->md5_parse(sk, optname, optval, optlen); in do_tcp_setsockopt()
3448 err = -EINVAL; in do_tcp_setsockopt()
3450 WRITE_ONCE(icsk->icsk_user_timeout, val); in do_tcp_setsockopt()
3454 if (val >= 0 && ((1 << sk->sk_state) & (TCPF_CLOSE | in do_tcp_setsockopt()
3460 err = -EINVAL; in do_tcp_setsockopt()
3465 err = -EINVAL; in do_tcp_setsockopt()
3466 } else if (READ_ONCE(net->ipv4.sysctl_tcp_fastopen) & in do_tcp_setsockopt()
3468 if (sk->sk_state == TCP_CLOSE) in do_tcp_setsockopt()
3469 tp->fastopen_connect = val; in do_tcp_setsockopt()
3471 err = -EINVAL; in do_tcp_setsockopt()
3473 err = -EOPNOTSUPP; in do_tcp_setsockopt()
3478 err = -EINVAL; in do_tcp_setsockopt()
3479 else if (!((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) in do_tcp_setsockopt()
3480 err = -EINVAL; in do_tcp_setsockopt()
3482 tp->fastopen_no_cookie = val; in do_tcp_setsockopt()
3485 if (!tp->repair) in do_tcp_setsockopt()
3486 err = -EPERM; in do_tcp_setsockopt()
3488 tp->tsoffset = val - tcp_time_stamp_raw(); in do_tcp_setsockopt()
3494 WRITE_ONCE(tp->notsent_lowat, val); in do_tcp_setsockopt()
3495 sk->sk_write_space(sk); in do_tcp_setsockopt()
3499 err = -EINVAL; in do_tcp_setsockopt()
3501 tp->recvmsg_inq = val; in do_tcp_setsockopt()
3506 WRITE_ONCE(tp->tcp_tx_delay, val); in do_tcp_setsockopt()
3519 err = -ENOPROTOOPT; in do_tcp_setsockopt()
3534 return READ_ONCE(icsk->icsk_af_ops)->setsockopt(sk, level, optname, in tcp_setsockopt()
3547 stats[i] = tp->chrono_stat[i - 1]; in tcp_get_info_chrono_stats()
3548 if (i == tp->chrono_type) in tcp_get_info_chrono_stats()
3549 stats[i] += tcp_jiffies32 - tp->chrono_start; in tcp_get_info_chrono_stats()
3554 info->tcpi_busy_time = total; in tcp_get_info_chrono_stats()
3555 info->tcpi_rwnd_limited = stats[TCP_CHRONO_RWND_LIMITED]; in tcp_get_info_chrono_stats()
3556 info->tcpi_sndbuf_limited = stats[TCP_CHRONO_SNDBUF_LIMITED]; in tcp_get_info_chrono_stats()
3570 if (sk->sk_type != SOCK_STREAM) in tcp_get_info()
3573 info->tcpi_state = inet_sk_state_load(sk); in tcp_get_info()
3576 rate = READ_ONCE(sk->sk_pacing_rate); in tcp_get_info()
3578 info->tcpi_pacing_rate = rate64; in tcp_get_info()
3580 rate = READ_ONCE(sk->sk_max_pacing_rate); in tcp_get_info()
3582 info->tcpi_max_pacing_rate = rate64; in tcp_get_info()
3584 info->tcpi_reordering = tp->reordering; in tcp_get_info()
3585 info->tcpi_snd_cwnd = tp->snd_cwnd; in tcp_get_info()
3587 if (info->tcpi_state == TCP_LISTEN) { in tcp_get_info()
3589 * tcpi_unacked -> Number of children ready for accept() in tcp_get_info()
3590 * tcpi_sacked -> max backlog in tcp_get_info()
3592 info->tcpi_unacked = READ_ONCE(sk->sk_ack_backlog); in tcp_get_info()
3593 info->tcpi_sacked = READ_ONCE(sk->sk_max_ack_backlog); in tcp_get_info()
3599 info->tcpi_ca_state = icsk->icsk_ca_state; in tcp_get_info()
3600 info->tcpi_retransmits = icsk->icsk_retransmits; in tcp_get_info()
3601 info->tcpi_probes = icsk->icsk_probes_out; in tcp_get_info()
3602 info->tcpi_backoff = icsk->icsk_backoff; in tcp_get_info()
3604 if (tp->rx_opt.tstamp_ok) in tcp_get_info()
3605 info->tcpi_options |= TCPI_OPT_TIMESTAMPS; in tcp_get_info()
3607 info->tcpi_options |= TCPI_OPT_SACK; in tcp_get_info()
3608 if (tp->rx_opt.wscale_ok) { in tcp_get_info()
3609 info->tcpi_options |= TCPI_OPT_WSCALE; in tcp_get_info()
3610 info->tcpi_snd_wscale = tp->rx_opt.snd_wscale; in tcp_get_info()
3611 info->tcpi_rcv_wscale = tp->rx_opt.rcv_wscale; in tcp_get_info()
3614 if (tp->ecn_flags & TCP_ECN_OK) in tcp_get_info()
3615 info->tcpi_options |= TCPI_OPT_ECN; in tcp_get_info()
3616 if (tp->ecn_flags & TCP_ECN_SEEN) in tcp_get_info()
3617 info->tcpi_options |= TCPI_OPT_ECN_SEEN; in tcp_get_info()
3618 if (tp->syn_data_acked) in tcp_get_info()
3619 info->tcpi_options |= TCPI_OPT_SYN_DATA; in tcp_get_info()
3621 info->tcpi_rto = jiffies_to_usecs(icsk->icsk_rto); in tcp_get_info()
3622 info->tcpi_ato = jiffies_to_usecs(icsk->icsk_ack.ato); in tcp_get_info()
3623 info->tcpi_snd_mss = tp->mss_cache; in tcp_get_info()
3624 info->tcpi_rcv_mss = icsk->icsk_ack.rcv_mss; in tcp_get_info()
3626 info->tcpi_unacked = tp->packets_out; in tcp_get_info()
3627 info->tcpi_sacked = tp->sacked_out; in tcp_get_info()
3629 info->tcpi_lost = tp->lost_out; in tcp_get_info()
3630 info->tcpi_retrans = tp->retrans_out; in tcp_get_info()
3633 info->tcpi_last_data_sent = jiffies_to_msecs(now - tp->lsndtime); in tcp_get_info()
3634 info->tcpi_last_data_recv = jiffies_to_msecs(now - icsk->icsk_ack.lrcvtime); in tcp_get_info()
3635 info->tcpi_last_ack_recv = jiffies_to_msecs(now - tp->rcv_tstamp); in tcp_get_info()
3637 info->tcpi_pmtu = icsk->icsk_pmtu_cookie; in tcp_get_info()
3638 info->tcpi_rcv_ssthresh = tp->rcv_ssthresh; in tcp_get_info()
3639 info->tcpi_rtt = tp->srtt_us >> 3; in tcp_get_info()
3640 info->tcpi_rttvar = tp->mdev_us >> 2; in tcp_get_info()
3641 info->tcpi_snd_ssthresh = tp->snd_ssthresh; in tcp_get_info()
3642 info->tcpi_advmss = tp->advmss; in tcp_get_info()
3644 info->tcpi_rcv_rtt = tp->rcv_rtt_est.rtt_us >> 3; in tcp_get_info()
3645 info->tcpi_rcv_space = tp->rcvq_space.space; in tcp_get_info()
3647 info->tcpi_total_retrans = tp->total_retrans; in tcp_get_info()
3649 info->tcpi_bytes_acked = tp->bytes_acked; in tcp_get_info()
3650 info->tcpi_bytes_received = tp->bytes_received; in tcp_get_info()
3651 info->tcpi_notsent_bytes = max_t(int, 0, tp->write_seq - tp->snd_nxt); in tcp_get_info()
3654 info->tcpi_segs_out = tp->segs_out; in tcp_get_info()
3655 info->tcpi_segs_in = tp->segs_in; in tcp_get_info()
3657 info->tcpi_min_rtt = tcp_min_rtt(tp); in tcp_get_info()
3658 info->tcpi_data_segs_in = tp->data_segs_in; in tcp_get_info()
3659 info->tcpi_data_segs_out = tp->data_segs_out; in tcp_get_info()
3661 info->tcpi_delivery_rate_app_limited = tp->rate_app_limited ? 1 : 0; in tcp_get_info()
3664 info->tcpi_delivery_rate = rate64; in tcp_get_info()
3665 info->tcpi_delivered = tp->delivered; in tcp_get_info()
3666 info->tcpi_delivered_ce = tp->delivered_ce; in tcp_get_info()
3667 info->tcpi_bytes_sent = tp->bytes_sent; in tcp_get_info()
3668 info->tcpi_bytes_retrans = tp->bytes_retrans; in tcp_get_info()
3669 info->tcpi_dsack_dups = tp->dsack_dups; in tcp_get_info()
3670 info->tcpi_reord_seen = tp->reord_seen; in tcp_get_info()
3671 info->tcpi_rcv_ooopack = tp->rcv_ooopack; in tcp_get_info()
3672 info->tcpi_snd_wnd = tp->snd_wnd; in tcp_get_info()
3673 info->tcpi_fastopen_client_fail = tp->fastopen_client_fail; in tcp_get_info()
3730 tp->data_segs_out, TCP_NLA_PAD); in tcp_get_timestamping_opt_stats()
3732 tp->total_retrans, TCP_NLA_PAD); in tcp_get_timestamping_opt_stats()
3734 rate = READ_ONCE(sk->sk_pacing_rate); in tcp_get_timestamping_opt_stats()
3741 nla_put_u32(stats, TCP_NLA_SND_CWND, tp->snd_cwnd); in tcp_get_timestamping_opt_stats()
3742 nla_put_u32(stats, TCP_NLA_REORDERING, tp->reordering); in tcp_get_timestamping_opt_stats()
3745 nla_put_u8(stats, TCP_NLA_RECUR_RETRANS, inet_csk(sk)->icsk_retransmits); in tcp_get_timestamping_opt_stats()
3746 nla_put_u8(stats, TCP_NLA_DELIVERY_RATE_APP_LMT, !!tp->rate_app_limited); in tcp_get_timestamping_opt_stats()
3747 nla_put_u32(stats, TCP_NLA_SND_SSTHRESH, tp->snd_ssthresh); in tcp_get_timestamping_opt_stats()
3748 nla_put_u32(stats, TCP_NLA_DELIVERED, tp->delivered); in tcp_get_timestamping_opt_stats()
3749 nla_put_u32(stats, TCP_NLA_DELIVERED_CE, tp->delivered_ce); in tcp_get_timestamping_opt_stats()
3751 nla_put_u32(stats, TCP_NLA_SNDQ_SIZE, tp->write_seq - tp->snd_una); in tcp_get_timestamping_opt_stats()
3752 nla_put_u8(stats, TCP_NLA_CA_STATE, inet_csk(sk)->icsk_ca_state); in tcp_get_timestamping_opt_stats()
3754 nla_put_u64_64bit(stats, TCP_NLA_BYTES_SENT, tp->bytes_sent, in tcp_get_timestamping_opt_stats()
3756 nla_put_u64_64bit(stats, TCP_NLA_BYTES_RETRANS, tp->bytes_retrans, in tcp_get_timestamping_opt_stats()
3758 nla_put_u32(stats, TCP_NLA_DSACK_DUPS, tp->dsack_dups); in tcp_get_timestamping_opt_stats()
3759 nla_put_u32(stats, TCP_NLA_REORD_SEEN, tp->reord_seen); in tcp_get_timestamping_opt_stats()
3760 nla_put_u32(stats, TCP_NLA_SRTT, tp->srtt_us >> 3); in tcp_get_timestamping_opt_stats()
3761 nla_put_u16(stats, TCP_NLA_TIMEOUT_REHASH, tp->timeout_rehash); in tcp_get_timestamping_opt_stats()
3763 max_t(int, 0, tp->write_seq - tp->snd_nxt)); in tcp_get_timestamping_opt_stats()
3764 nla_put_u64_64bit(stats, TCP_NLA_EDT, orig_skb->skb_mstamp_ns, in tcp_get_timestamping_opt_stats()
3779 return -EFAULT; in do_tcp_getsockopt()
3784 return -EINVAL; in do_tcp_getsockopt()
3788 val = tp->mss_cache; in do_tcp_getsockopt()
3789 if (tp->rx_opt.user_mss && in do_tcp_getsockopt()
3790 ((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) in do_tcp_getsockopt()
3791 val = tp->rx_opt.user_mss; in do_tcp_getsockopt()
3792 if (tp->repair) in do_tcp_getsockopt()
3793 val = tp->rx_opt.mss_clamp; in do_tcp_getsockopt()
3796 val = !!(tp->nonagle&TCP_NAGLE_OFF); in do_tcp_getsockopt()
3799 val = !!(tp->nonagle&TCP_NAGLE_CORK); in do_tcp_getsockopt()
3811 val = READ_ONCE(icsk->icsk_syn_retries) ? : in do_tcp_getsockopt()
3812 READ_ONCE(net->ipv4.sysctl_tcp_syn_retries); in do_tcp_getsockopt()
3815 val = READ_ONCE(tp->linger2); in do_tcp_getsockopt()
3817 val = (val ? : READ_ONCE(net->ipv4.sysctl_tcp_fin_timeout)) / HZ; in do_tcp_getsockopt()
3820 val = READ_ONCE(icsk->icsk_accept_queue.rskq_defer_accept); in do_tcp_getsockopt()
3825 val = tp->window_clamp; in do_tcp_getsockopt()
3831 return -EFAULT; in do_tcp_getsockopt()
3837 return -EFAULT; in do_tcp_getsockopt()
3839 return -EFAULT; in do_tcp_getsockopt()
3849 return -EFAULT; in do_tcp_getsockopt()
3851 ca_ops = icsk->icsk_ca_ops; in do_tcp_getsockopt()
3852 if (ca_ops && ca_ops->get_info) in do_tcp_getsockopt()
3853 sz = ca_ops->get_info(sk, ~0U, &attr, &info); in do_tcp_getsockopt()
3857 return -EFAULT; in do_tcp_getsockopt()
3859 return -EFAULT; in do_tcp_getsockopt()
3868 return -EFAULT; in do_tcp_getsockopt()
3871 return -EFAULT; in do_tcp_getsockopt()
3872 if (copy_to_user(optval, icsk->icsk_ca_ops->name, len)) in do_tcp_getsockopt()
3873 return -EFAULT; in do_tcp_getsockopt()
3878 return -EFAULT; in do_tcp_getsockopt()
3880 if (!icsk->icsk_ulp_ops) { in do_tcp_getsockopt()
3882 return -EFAULT; in do_tcp_getsockopt()
3886 return -EFAULT; in do_tcp_getsockopt()
3887 if (copy_to_user(optval, icsk->icsk_ulp_ops->name, len)) in do_tcp_getsockopt()
3888 return -EFAULT; in do_tcp_getsockopt()
3896 return -EFAULT; in do_tcp_getsockopt()
3902 return -EFAULT; in do_tcp_getsockopt()
3904 return -EFAULT; in do_tcp_getsockopt()
3908 val = tp->thin_lto; in do_tcp_getsockopt()
3916 val = tp->repair; in do_tcp_getsockopt()
3920 if (tp->repair) in do_tcp_getsockopt()
3921 val = tp->repair_queue; in do_tcp_getsockopt()
3923 return -EINVAL; in do_tcp_getsockopt()
3930 return -EFAULT; in do_tcp_getsockopt()
3933 return -EINVAL; in do_tcp_getsockopt()
3935 if (!tp->repair) in do_tcp_getsockopt()
3936 return -EPERM; in do_tcp_getsockopt()
3938 opt.snd_wl1 = tp->snd_wl1; in do_tcp_getsockopt()
3939 opt.snd_wnd = tp->snd_wnd; in do_tcp_getsockopt()
3940 opt.max_window = tp->max_window; in do_tcp_getsockopt()
3941 opt.rcv_wnd = tp->rcv_wnd; in do_tcp_getsockopt()
3942 opt.rcv_wup = tp->rcv_wup; in do_tcp_getsockopt()
3945 return -EFAULT; in do_tcp_getsockopt()
3949 if (tp->repair_queue == TCP_SEND_QUEUE) in do_tcp_getsockopt()
3950 val = tp->write_seq; in do_tcp_getsockopt()
3951 else if (tp->repair_queue == TCP_RECV_QUEUE) in do_tcp_getsockopt()
3952 val = tp->rcv_nxt; in do_tcp_getsockopt()
3954 return -EINVAL; in do_tcp_getsockopt()
3958 val = READ_ONCE(icsk->icsk_user_timeout); in do_tcp_getsockopt()
3962 val = READ_ONCE(icsk->icsk_accept_queue.fastopenq.max_qlen); in do_tcp_getsockopt()
3966 val = tp->fastopen_connect; in do_tcp_getsockopt()
3970 val = tp->fastopen_no_cookie; in do_tcp_getsockopt()
3974 val = READ_ONCE(tp->tcp_tx_delay); in do_tcp_getsockopt()
3978 val = tcp_time_stamp_raw() + tp->tsoffset; in do_tcp_getsockopt()
3981 val = READ_ONCE(tp->notsent_lowat); in do_tcp_getsockopt()
3984 val = tp->recvmsg_inq; in do_tcp_getsockopt()
3987 val = tp->save_syn; in do_tcp_getsockopt()
3991 return -EFAULT; in do_tcp_getsockopt()
3994 if (tp->saved_syn) { in do_tcp_getsockopt()
3995 if (len < tcp_saved_syn_len(tp->saved_syn)) { in do_tcp_getsockopt()
3996 if (put_user(tcp_saved_syn_len(tp->saved_syn), in do_tcp_getsockopt()
3999 return -EFAULT; in do_tcp_getsockopt()
4002 return -EINVAL; in do_tcp_getsockopt()
4004 len = tcp_saved_syn_len(tp->saved_syn); in do_tcp_getsockopt()
4007 return -EFAULT; in do_tcp_getsockopt()
4009 if (copy_to_user(optval, tp->saved_syn->data, len)) { in do_tcp_getsockopt()
4011 return -EFAULT; in do_tcp_getsockopt()
4019 return -EFAULT; in do_tcp_getsockopt()
4029 return -EFAULT; in do_tcp_getsockopt()
4032 return -EINVAL; in do_tcp_getsockopt()
4036 return -EFAULT; in do_tcp_getsockopt()
4039 return -EFAULT; in do_tcp_getsockopt()
4063 err = -EFAULT; in do_tcp_getsockopt()
4068 return -ENOPROTOOPT; in do_tcp_getsockopt()
4072 return -EFAULT; in do_tcp_getsockopt()
4074 return -EFAULT; in do_tcp_getsockopt()
4097 return READ_ONCE(icsk->icsk_af_ops)->getsockopt(sk, level, optname, in tcp_getsockopt()
4172 * tcp_get_md5sig_pool - get md5sig_pool for this user
4198 struct ahash_request *req = hp->md5_req; in tcp_md5_hash_skb_data()
4201 skb_headlen(skb) - header_len : 0; in tcp_md5_hash_skb_data()
4212 for (i = 0; i < shi->nr_frags; ++i) { in tcp_md5_hash_skb_data()
4213 const skb_frag_t *f = &shi->frags[i]; in tcp_md5_hash_skb_data()
4234 u8 keylen = READ_ONCE(key->keylen); /* paired with WRITE_ONCE() in tcp_md5_do_add */ in tcp_md5_hash_key()
4237 sg_init_one(&sg, key->key, keylen); in tcp_md5_hash_key()
4238 ahash_request_set_crypt(hp->md5_req, &sg, NULL, keylen); in tcp_md5_hash_key()
4240 /* We use data_race() because tcp_md5_do_add() might change key->key under us */ in tcp_md5_hash_key()
4241 return data_race(crypto_ahash_update(hp->md5_req)); in tcp_md5_hash_key()
4255 req = rcu_dereference_protected(tcp_sk(sk)->fastopen_rsk, 1); in tcp_done()
4257 if (sk->sk_state == TCP_SYN_SENT || sk->sk_state == TCP_SYN_RECV) in tcp_done()
4265 WRITE_ONCE(sk->sk_shutdown, SHUTDOWN_MASK); in tcp_done()
4268 sk->sk_state_change(sk); in tcp_done()
4277 if (sk->sk_state == TCP_NEW_SYN_RECV) { in tcp_abort()
4281 inet_csk_reqsk_queue_drop(req->rsk_listener, req); in tcp_abort()
4285 return -EOPNOTSUPP; in tcp_abort()
4295 if (sk->sk_state == TCP_LISTEN) { in tcp_abort()
4305 sk->sk_err = err; in tcp_abort()
4308 sk->sk_error_report(sk); in tcp_abort()
4309 if (tcp_need_reset(sk->sk_state)) in tcp_abort()
4418 /* Set per-socket limits to no more than 1/128 the pressure threshold */ in tcp_init()
4419 limit = nr_free_buffer_pages() << (PAGE_SHIFT - 7); in tcp_init()