tools/testing/selftests/net/packetdrill/tcp_zerocopy_maxfrags.pkt

   1 // SPDX-License-Identifier: GPL-2.0
   2 // tcp_MAX_SKB_FRAGS test
   3 //
   4 // Verify that sending an iovec of tcp_MAX_SKB_FRAGS + 1 elements will
   5 // 1) fit in a single packet without zerocopy
   6 // 2) spill over into a second packet with zerocopy,
   7 //    because each iovec element becomes a frag
   8 // 3) the PSH bit is set on an skb when it runs out of fragments
   9
  10 `./defaults.sh`
  11
  12     0 socket(..., SOCK_STREAM, IPPROTO_TCP) = 3
  13    +0 setsockopt(3, SOL_SOCKET, SO_REUSEADDR, [1], 4) = 0
  14    +0 setsockopt(3, SOL_SOCKET, SO_ZEROCOPY, [1], 4) = 0
  15
  16    // Each pinned zerocopy page is fully accounted to skb->truesize.
  17    // This test generates a worst case packet with each frag storing
  18    // one byte, but increasing truesize with a page (64KB on PPC).
  19    +0 setsockopt(3, SOL_SOCKET, SO_SNDBUF, [2000000], 4) = 0
  20
  21    +0 bind(3, ..., ...) = 0
  22    +0 listen(3, 1) = 0
  23
  24    +0 < S 0:0(0) win 32792 <mss 1000,sackOK,nop,nop,nop,wscale 7>
  25    +0 > S. 0:0(0) ack 1 <mss 1460,nop,nop,sackOK,nop,wscale 8>
  26    +0 < . 1:1(0) ack 1 win 257
  27
  28    +0 accept(3, ..., ...) = 4
  29
  30    // send an iov of 18 elements: just becomes a linear skb
  31    +0 sendmsg(4, {msg_name(...)=...,
  32                   msg_iov(18)=[{..., 1}, {..., 1}, {..., 1}, {..., 1},
  33                                {..., 1}, {..., 1}, {..., 1}, {..., 1},
  34                                {..., 1}, {..., 1}, {..., 1}, {..., 1},
  35                                {..., 1}, {..., 1}, {..., 1}, {..., 1},
  36                                {..., 1}, {..., 1}],
  37                   msg_flags=0}, 0) = 18
  38
  39    +0 > P. 1:19(18) ack 1
  40    +0 < . 1:1(0) ack 19 win 257
  41
  42    // send a zerocopy iov of 18 elements:
  43    +1 sendmsg(4, {msg_name(...)=...,
  44                   msg_iov(18)=[{..., 1}, {..., 1}, {..., 1}, {..., 1},
  45                                {..., 1}, {..., 1}, {..., 1}, {..., 1},
  46                                {..., 1}, {..., 1}, {..., 1}, {..., 1},
  47                                {..., 1}, {..., 1}, {..., 1}, {..., 1},
  48                                {..., 1}, {..., 1}],
  49                   msg_flags=0}, MSG_ZEROCOPY) = 18
  50
  51    // verify that it is split in one skb of 17 frags + 1 of 1 frag
  52    // verify that both have the PSH bit set
  53    +0 > P. 19:36(17) ack 1
  54    +0 < . 1:1(0) ack 36 win 257
  55
  56    +0 > P. 36:37(1) ack 1
  57    +0 < . 1:1(0) ack 37 win 257
  58
  59    +1 recvmsg(4, {msg_name(...)=...,
  60                   msg_iov(1)=[{...,0}],
  61                   msg_flags=MSG_ERRQUEUE,
  62                   msg_control=[
  63                         {cmsg_level=CMSG_LEVEL_IP,
  64                          cmsg_type=CMSG_TYPE_RECVERR,
  65                          cmsg_data={ee_errno=0,
  66                                     ee_origin=SO_EE_ORIGIN_ZEROCOPY,
  67                                     ee_type=0,
  68                                     ee_code=SO_EE_CODE_ZEROCOPY_COPIED,
  69                                     ee_info=0,
  70                                     ee_data=0}}
  71                    ]}, MSG_ERRQUEUE) = 0
  72
  73    // send a zerocopy iov of 64 elements:
  74    +0 sendmsg(4, {msg_name(...)=...,
  75                   msg_iov(64)=[{..., 1}, {..., 1}, {..., 1}, {..., 1},
  76                                {..., 1}, {..., 1}, {..., 1}, {..., 1},
  77                                {..., 1}, {..., 1}, {..., 1}, {..., 1},
  78                                {..., 1}, {..., 1}, {..., 1}, {..., 1},
  79                                {..., 1}, {..., 1}, {..., 1}, {..., 1},
  80                                {..., 1}, {..., 1}, {..., 1}, {..., 1},
  81                                {..., 1}, {..., 1}, {..., 1}, {..., 1},
  82                                {..., 1}, {..., 1}, {..., 1}, {..., 1},
  83                                {..., 1}, {..., 1}, {..., 1}, {..., 1},
  84                                {..., 1}, {..., 1}, {..., 1}, {..., 1},
  85                                {..., 1}, {..., 1}, {..., 1}, {..., 1},
  86                                {..., 1}, {..., 1}, {..., 1}, {..., 1},
  87                                {..., 1}, {..., 1}, {..., 1}, {..., 1},
  88                                {..., 1}, {..., 1}, {..., 1}, {..., 1},
  89                                {..., 1}, {..., 1}, {..., 1}, {..., 1},
  90                                {..., 1}, {..., 1}, {..., 1}, {..., 1}],
  91                   msg_flags=0}, MSG_ZEROCOPY) = 64
  92
  93    // verify that it is split in skbs with 17 frags
  94    +0 > P. 37:54(17) ack 1
  95    +0 < . 1:1(0) ack 54 win 257
  96
  97    +0 > P. 54:71(17) ack 1
  98    +0 < . 1:1(0) ack 71 win 257
  99
 100    +0 > P. 71:88(17) ack 1
 101    +0 < . 1:1(0) ack 88 win 257
 102
 103    +0 > P. 88:101(13) ack 1
 104    +0 < . 1:1(0) ack 101 win 257
 105
 106    +1 recvmsg(4, {msg_name(...)=...,
 107                   msg_iov(1)=[{...,0}],
 108                   msg_flags=MSG_ERRQUEUE,
 109                   msg_control=[
 110                         {cmsg_level=CMSG_LEVEL_IP,
 111                          cmsg_type=CMSG_TYPE_RECVERR,
 112                          cmsg_data={ee_errno=0,
 113                                     ee_origin=SO_EE_ORIGIN_ZEROCOPY,
 114                                     ee_type=0,
 115                                     ee_code=SO_EE_CODE_ZEROCOPY_COPIED,
 116                                     ee_info=1,
 117                                     ee_data=1}}
 118                    ]}, MSG_ERRQUEUE) = 0