From e64458ff08b6c66ab055ce6907a8bd60119a7c4d Mon Sep 17 00:00:00 2001 From: Lucas Manning Date: Tue, 7 Jun 2022 10:33:35 -0700 Subject: [PATCH] Remove VectorisedView everywhere. PiperOrigin-RevId: 453471156 --- .buildkite/pipeline.yaml | 2 +- pkg/buffer/buffer.go | 9 + pkg/buffer/view.go | 10 + pkg/sentry/mm/BUILD | 1 - pkg/sentry/socket/unix/transport/BUILD | 2 +- pkg/sentry/socket/unix/transport/queue.go | 3 +- pkg/sentry/socket/unix/transport/unix.go | 5 +- pkg/tcpip/BUILD | 1 - pkg/tcpip/adapters/gonet/BUILD | 1 - pkg/tcpip/adapters/gonet/gonet.go | 3 +- pkg/tcpip/buffer/BUILD | 24 - pkg/tcpip/buffer/view.go | 315 --------- pkg/tcpip/buffer/view_test.go | 629 ------------------ pkg/tcpip/buffer/view_unsafe.go | 22 - pkg/tcpip/checker/BUILD | 2 +- pkg/tcpip/checker/checker.go | 8 +- pkg/tcpip/header/BUILD | 5 +- pkg/tcpip/header/checksum.go | 13 - pkg/tcpip/header/checksum_test.go | 36 +- pkg/tcpip/header/ipv6_extension_headers.go | 16 +- .../header/ipv6_extension_headers_test.go | 114 ++-- pkg/tcpip/header/parse/BUILD | 1 - pkg/tcpip/header/parse/parse.go | 19 +- pkg/tcpip/link/ethernet/BUILD | 1 - pkg/tcpip/link/ethernet/ethernet_test.go | 3 +- pkg/tcpip/link/fdbased/endpoint.go | 4 +- pkg/tcpip/link/fdbased/endpoint_test.go | 2 +- pkg/tcpip/link/sniffer/pcap.go | 2 +- pkg/tcpip/network/BUILD | 1 - pkg/tcpip/network/arp/BUILD | 1 - pkg/tcpip/network/arp/arp.go | 3 +- .../network/internal/fragmentation/BUILD | 1 - .../fragmentation/fragmentation_test.go | 2 +- pkg/tcpip/network/ipv4/BUILD | 1 - pkg/tcpip/network/ipv4/icmp.go | 2 +- pkg/tcpip/network/ipv4/ipv4.go | 11 +- pkg/tcpip/network/ipv4/ipv4_test.go | 2 +- pkg/tcpip/network/ipv6/BUILD | 1 - pkg/tcpip/network/ipv6/icmp.go | 4 +- pkg/tcpip/network/ipv6/ipv6.go | 37 +- pkg/tcpip/network/ipv6/ipv6_test.go | 4 +- pkg/tcpip/network/multicast_group_test.go | 5 +- pkg/tcpip/stack/BUILD | 4 +- pkg/tcpip/stack/conntrack_test.go | 4 +- pkg/tcpip/stack/forwarding_test.go | 43 +- pkg/tcpip/stack/iptables_targets.go | 2 +- pkg/tcpip/stack/ndp_test.go | 8 +- pkg/tcpip/stack/nic.go | 9 +- pkg/tcpip/stack/nic_test.go | 10 +- pkg/tcpip/stack/packet_buffer.go | 101 +-- pkg/tcpip/stack/packet_buffer_test.go | 93 +-- pkg/tcpip/stack/registration.go | 5 +- pkg/tcpip/stack/stack.go | 10 +- pkg/tcpip/stack/stack_test.go | 64 +- pkg/tcpip/stack/transport_demuxer_test.go | 10 +- pkg/tcpip/stack/transport_test.go | 22 +- pkg/tcpip/tests/integration/BUILD | 7 +- pkg/tcpip/tests/integration/iptables_test.go | 148 ++--- .../tests/integration/link_resolution_test.go | 4 +- pkg/tcpip/tests/integration/loopback_test.go | 8 +- pkg/tcpip/tests/integration/route_test.go | 17 +- pkg/tcpip/tests/utils/BUILD | 2 +- pkg/tcpip/tests/utils/utils.go | 14 +- pkg/tcpip/transport/icmp/BUILD | 2 - pkg/tcpip/transport/icmp/protocol.go | 3 +- pkg/tcpip/transport/packet/BUILD | 3 +- pkg/tcpip/transport/packet/endpoint.go | 10 +- pkg/tcpip/transport/raw/BUILD | 2 - pkg/tcpip/transport/tcp/BUILD | 2 - pkg/tcpip/transport/tcp/protocol.go | 3 +- pkg/tcpip/transport/udp/BUILD | 2 - pkg/tcpip/transport/udp/protocol.go | 3 +- test/packetimpact/testbench/BUILD | 2 +- test/packetimpact/testbench/layers.go | 12 +- test/packetimpact/tests/BUILD | 3 - 75 files changed, 415 insertions(+), 1545 deletions(-) delete mode 100644 pkg/tcpip/buffer/BUILD delete mode 100644 pkg/tcpip/buffer/view.go delete mode 100644 pkg/tcpip/buffer/view_test.go delete mode 100644 pkg/tcpip/buffer/view_unsafe.go diff --git a/.buildkite/pipeline.yaml b/.buildkite/pipeline.yaml index d03be4e63..8a27b0d83 100644 --- a/.buildkite/pipeline.yaml +++ b/.buildkite/pipeline.yaml @@ -28,7 +28,6 @@ _templates: PACKAGES: > ./pkg/tcpip ./pkg/tcpip/adapters/gonet - ./pkg/tcpip/buffer ./pkg/tcpip/header ./pkg/tcpip/link/channel ./pkg/tcpip/network/ipv4 @@ -37,6 +36,7 @@ _templates: ./pkg/tcpip/transport/icmp ./pkg/tcpip/transport/tcp ./pkg/tcpip/transport/udp + ./pkg/buffer ./pkg/waiter env: # Force a clean checkout every time to avoid reuse of files between runs. diff --git a/pkg/buffer/buffer.go b/pkg/buffer/buffer.go index 5b77a6a3f..84d112547 100644 --- a/pkg/buffer/buffer.go +++ b/pkg/buffer/buffer.go @@ -18,6 +18,8 @@ // well as the ability to grow via either prepend or append, as well as shrink. package buffer +import "bytes" + // buffer encapsulates a queueable byte buffer. // // +stateify savable @@ -103,3 +105,10 @@ func (b *buffer) WriteMove(n int) { func (b *buffer) WriteSlice() []byte { return b.data[b.write:] } + +// Reader returns a bytes.Reader for v. +func (b *buffer) Reader() bytes.Reader { + var r bytes.Reader + r.Reset(b.ReadSlice()) + return r +} diff --git a/pkg/buffer/view.go b/pkg/buffer/view.go index d9f0de11c..cc0cddfbf 100644 --- a/pkg/buffer/view.go +++ b/pkg/buffer/view.go @@ -15,6 +15,7 @@ package buffer import ( + "bytes" "fmt" "io" ) @@ -611,3 +612,12 @@ func (x Range) Len() int { } return l } + +// Readers returns a bytes.Reader for each of bufs's underlying buffers. +func (v *View) Readers() []bytes.Reader { + readers := make([]bytes.Reader, 0, v.data.Len()) + for buf := v.data.Front(); buf != nil; buf = buf.Next() { + readers = append(readers, buf.Reader()) + } + return readers +} diff --git a/pkg/sentry/mm/BUILD b/pkg/sentry/mm/BUILD index 8fa6821dd..55561fb42 100644 --- a/pkg/sentry/mm/BUILD +++ b/pkg/sentry/mm/BUILD @@ -194,7 +194,6 @@ go_library( "//pkg/sentry/usage", "//pkg/sync", "//pkg/sync/locking", - "//pkg/tcpip/buffer", "//pkg/usermem", ], ) diff --git a/pkg/sentry/socket/unix/transport/BUILD b/pkg/sentry/socket/unix/transport/BUILD index df0a7f163..f3bcc48cb 100644 --- a/pkg/sentry/socket/unix/transport/BUILD +++ b/pkg/sentry/socket/unix/transport/BUILD @@ -94,6 +94,7 @@ go_library( deps = [ "//pkg/abi/linux", "//pkg/atomicbitops", + "//pkg/buffer", "//pkg/context", "//pkg/errors/linuxerr", "//pkg/fdnotifier", @@ -109,7 +110,6 @@ go_library( "//pkg/sync/locking", "//pkg/syserr", "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/unet", "//pkg/waiter", "@org_golang_x_sys//unix:go_default_library", diff --git a/pkg/sentry/socket/unix/transport/queue.go b/pkg/sentry/socket/unix/transport/queue.go index 3482aef8a..5d811a9d1 100644 --- a/pkg/sentry/socket/unix/transport/queue.go +++ b/pkg/sentry/socket/unix/transport/queue.go @@ -18,7 +18,6 @@ import ( "gvisor.dev/gvisor/pkg/context" "gvisor.dev/gvisor/pkg/syserr" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/waiter" ) @@ -167,7 +166,7 @@ func (q *queue) Enqueue(ctx context.Context, data [][]byte, c ControlMessages, f notify = q.dataList.Front() == nil q.used += l q.dataList.PushBack(&message{ - Data: buffer.View(v), + Data: v, Control: c, Address: from, }) diff --git a/pkg/sentry/socket/unix/transport/unix.go b/pkg/sentry/socket/unix/transport/unix.go index 87bb7eb35..cb22e7b1d 100644 --- a/pkg/sentry/socket/unix/transport/unix.go +++ b/pkg/sentry/socket/unix/transport/unix.go @@ -22,7 +22,6 @@ import ( "gvisor.dev/gvisor/pkg/log" "gvisor.dev/gvisor/pkg/syserr" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/waiter" ) @@ -282,7 +281,7 @@ type message struct { messageEntry // Data is the Message payload. - Data buffer.View + Data []byte // Control is auxiliary control message data that goes along with the // data. @@ -314,7 +313,7 @@ func (m *message) Peek() *message { // // Preconditions: n <= m.Length(). func (m *message) Truncate(n int64) { - m.Data.CapLength(int(n)) + m.Data = m.Data[:n] } // A Receiver can be used to receive Messages. diff --git a/pkg/tcpip/BUILD b/pkg/tcpip/BUILD index 0444000d2..9e69c4c88 100644 --- a/pkg/tcpip/BUILD +++ b/pkg/tcpip/BUILD @@ -32,7 +32,6 @@ go_library( deps = [ "//pkg/atomicbitops", "//pkg/sync", - "//pkg/tcpip/buffer", "//pkg/waiter", ], ) diff --git a/pkg/tcpip/adapters/gonet/BUILD b/pkg/tcpip/adapters/gonet/BUILD index a984f1712..3e1c2ddc6 100644 --- a/pkg/tcpip/adapters/gonet/BUILD +++ b/pkg/tcpip/adapters/gonet/BUILD @@ -9,7 +9,6 @@ go_library( deps = [ "//pkg/sync", "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/stack", "//pkg/tcpip/transport/tcp", "//pkg/tcpip/transport/udp", diff --git a/pkg/tcpip/adapters/gonet/gonet.go b/pkg/tcpip/adapters/gonet/gonet.go index 8e9b041dc..a93f51b8f 100644 --- a/pkg/tcpip/adapters/gonet/gonet.go +++ b/pkg/tcpip/adapters/gonet/gonet.go @@ -26,7 +26,6 @@ import ( "gvisor.dev/gvisor/pkg/sync" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/stack" "gvisor.dev/gvisor/pkg/tcpip/transport/tcp" "gvisor.dev/gvisor/pkg/tcpip/transport/udp" @@ -240,7 +239,7 @@ type TCPConn struct { // read contains bytes that have been read from the endpoint, // but haven't yet been returned. - read buffer.View + read []byte } // NewTCPConn creates a new TCPConn. diff --git a/pkg/tcpip/buffer/BUILD b/pkg/tcpip/buffer/BUILD deleted file mode 100644 index ce4062a81..000000000 --- a/pkg/tcpip/buffer/BUILD +++ /dev/null @@ -1,24 +0,0 @@ -load("//tools:defs.bzl", "go_library", "go_test") - -package(licenses = ["notice"]) - -go_library( - name = "buffer", - srcs = [ - "view.go", - "view_unsafe.go", - ], - visibility = ["//visibility:public"], -) - -go_test( - name = "buffer_x_test", - size = "small", - srcs = [ - "view_test.go", - ], - deps = [ - ":buffer", - "//pkg/tcpip", - ], -) diff --git a/pkg/tcpip/buffer/view.go b/pkg/tcpip/buffer/view.go deleted file mode 100644 index f4a30effd..000000000 --- a/pkg/tcpip/buffer/view.go +++ /dev/null @@ -1,315 +0,0 @@ -// Copyright 2018 The gVisor Authors. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -// Package buffer provides the implementation of a buffer view. -package buffer - -import ( - "bytes" - "fmt" - "io" -) - -// View is a slice of a buffer, with convenience methods. -type View []byte - -// NewView allocates a new buffer and returns an initialized view that covers -// the whole buffer. -func NewView(size int) View { - return make(View, size) -} - -// NewViewFromBytes allocates a new buffer and copies in the given bytes. -func NewViewFromBytes(b []byte) View { - return append(View(nil), b...) -} - -// TrimFront removes the first "count" bytes from the visible section of the -// buffer. -func (v *View) TrimFront(count int) { - *v = (*v)[count:] -} - -// CapLength irreversibly reduces the length of the visible section of the -// buffer to the value specified. -func (v *View) CapLength(length int) { - // We also set the slice cap because if we don't, one would be able to - // expand the view back to include the region just excluded. We want to - // prevent that to avoid potential data leak if we have uninitialized - // data in excluded region. - *v = (*v)[:length:length] -} - -// Reader returns a bytes.Reader for v. -func (v *View) Reader() bytes.Reader { - var r bytes.Reader - r.Reset(*v) - return r -} - -// ToVectorisedView returns a VectorisedView containing the receiver. -func (v View) ToVectorisedView() VectorisedView { - if len(v) == 0 { - return VectorisedView{} - } - return NewVectorisedView(len(v), []View{v}) -} - -// IsEmpty returns whether v is of length zero. -func (v View) IsEmpty() bool { - return len(v) == 0 -} - -// Size returns the length of v. -func (v View) Size() int { - return len(v) -} - -// VectorisedView is a vectorised version of View using non contiguous memory. -// It supports all the convenience methods supported by View. -// -// +stateify savable -type VectorisedView struct { - views []View - size int -} - -// NewVectorisedView creates a new vectorised view from an already-allocated -// slice of View and sets its size. -func NewVectorisedView(size int, views []View) VectorisedView { - return VectorisedView{views: views, size: size} -} - -// TrimFront removes the first "count" bytes of the vectorised view. It panics -// if count > vv.Size(). -func (vv *VectorisedView) TrimFront(count int) { - for count > 0 && len(vv.views) > 0 { - if count < len(vv.views[0]) { - vv.size -= count - vv.views[0].TrimFront(count) - return - } - count -= len(vv.views[0]) - vv.removeFirst() - } -} - -// Read implements io.Reader. -func (vv *VectorisedView) Read(b []byte) (copied int, err error) { - count := len(b) - for count > 0 && len(vv.views) > 0 { - if count < len(vv.views[0]) { - vv.size -= count - copy(b[copied:], vv.views[0][:count]) - vv.views[0].TrimFront(count) - copied += count - return copied, nil - } - count -= len(vv.views[0]) - copy(b[copied:], vv.views[0]) - copied += len(vv.views[0]) - vv.removeFirst() - } - if copied == 0 { - return 0, io.EOF - } - return copied, nil -} - -// ReadToVV reads up to n bytes from vv to dstVV and removes them from vv. It -// returns the number of bytes copied. -func (vv *VectorisedView) ReadToVV(dstVV *VectorisedView, count int) (copied int) { - for count > 0 && len(vv.views) > 0 { - if count < len(vv.views[0]) { - vv.size -= count - dstVV.AppendView(vv.views[0][:count]) - vv.views[0].TrimFront(count) - copied += count - return - } - count -= len(vv.views[0]) - dstVV.AppendView(vv.views[0]) - copied += len(vv.views[0]) - vv.removeFirst() - } - return copied -} - -// ReadTo reads up to count bytes from vv to dst. It also removes them from vv -// unless peek is true. -func (vv *VectorisedView) ReadTo(dst io.Writer, peek bool) (int, error) { - var err error - done := 0 - for _, v := range vv.Views() { - var n int - n, err = dst.Write(v) - done += n - if err != nil { - break - } - if n != len(v) { - panic(fmt.Sprintf("io.Writer.Write succeeded with incomplete write: %d != %d", n, len(v))) - } - } - if !peek { - vv.TrimFront(done) - } - return done, err -} - -// CapLength irreversibly reduces the length of the vectorised view. -func (vv *VectorisedView) CapLength(length int) { - if length < 0 { - length = 0 - } - if vv.size < length { - return - } - vv.size = length - for i := range vv.views { - v := &vv.views[i] - if len(*v) >= length { - if length == 0 { - vv.views = vv.views[:i] - } else { - v.CapLength(length) - vv.views = vv.views[:i+1] - } - return - } - length -= len(*v) - } -} - -// Clone returns a clone of this VectorisedView. -// If the buffer argument is large enough to contain all the Views of this -// VectorisedView, the method will avoid allocations and use the buffer to -// store the Views of the clone. -func (vv VectorisedView) Clone(buffer []View) VectorisedView { - return VectorisedView{views: append(buffer[:0], vv.views...), size: vv.size} -} - -// PullUp returns the first "count" bytes of the vectorised view. If those -// bytes aren't already contiguous inside the vectorised view, PullUp will -// reallocate as needed to make them contiguous. PullUp fails and returns false -// when count > vv.Size(). -func (vv *VectorisedView) PullUp(count int) (View, bool) { - if len(vv.views) == 0 { - return nil, count == 0 - } - if count <= len(vv.views[0]) { - return vv.views[0][:count], true - } - if count > vv.size { - return nil, false - } - - newFirst := NewView(count) - i := 0 - for offset := 0; offset < count; i++ { - copy(newFirst[offset:], vv.views[i]) - if count-offset < len(vv.views[i]) { - vv.views[i].TrimFront(count - offset) - break - } - offset += len(vv.views[i]) - vv.views[i] = nil - } - // We're guaranteed that i > 0, since count is too large for the first - // view. - vv.views[i-1] = newFirst - vv.views = vv.views[i-1:] - return newFirst, true -} - -// Size returns the size in bytes of the entire content stored in the -// vectorised view. -func (vv *VectorisedView) Size() int { - return vv.size -} - -// MemSize returns the estimation size of the vv in memory, including backing -// buffer data. -func (vv *VectorisedView) MemSize() int { - var size int - for _, v := range vv.views { - size += cap(v) - } - return size + cap(vv.views)*viewStructSize + vectorisedViewStructSize -} - -// ToView returns a single view containing the content of the vectorised view. -// -// If the vectorised view contains a single view, that view will be returned -// directly. -func (vv *VectorisedView) ToView() View { - if len(vv.views) == 1 { - return vv.views[0] - } - return vv.ToOwnedView() -} - -// ToOwnedView returns a single view containing the content of the vectorised -// view that vv does not own. -func (vv *VectorisedView) ToOwnedView() View { - u := make([]byte, 0, vv.size) - for _, v := range vv.views { - u = append(u, v...) - } - return u -} - -// Views returns the slice containing the all views. -func (vv *VectorisedView) Views() []View { - return vv.views -} - -// Append appends the views in a vectorised view to this vectorised view. -func (vv *VectorisedView) Append(vv2 VectorisedView) { - vv.views = append(vv.views, vv2.views...) - vv.size += vv2.size -} - -// AppendView appends the given view into this vectorised view. -func (vv *VectorisedView) AppendView(v View) { - if len(v) == 0 { - return - } - vv.views = append(vv.views, v) - vv.size += len(v) -} - -// AppendViews appends views to vv. -func (vv *VectorisedView) AppendViews(views []View) { - vv.views = append(vv.views, views...) - for _, v := range views { - vv.size += len(v) - } -} - -// Readers returns a bytes.Reader for each of vv's views. -func (vv *VectorisedView) Readers() []bytes.Reader { - readers := make([]bytes.Reader, 0, len(vv.views)) - for _, v := range vv.views { - readers = append(readers, v.Reader()) - } - return readers -} - -// removeFirst panics when len(vv.views) < 1. -func (vv *VectorisedView) removeFirst() { - vv.size -= len(vv.views[0]) - vv.views[0] = nil - vv.views = vv.views[1:] -} diff --git a/pkg/tcpip/buffer/view_test.go b/pkg/tcpip/buffer/view_test.go deleted file mode 100644 index d296d9c2b..000000000 --- a/pkg/tcpip/buffer/view_test.go +++ /dev/null @@ -1,629 +0,0 @@ -// Copyright 2018 The gVisor Authors. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -// Package buffer_test contains tests for the buffer.VectorisedView type. -package buffer_test - -import ( - "bytes" - "io" - "reflect" - "testing" - "unsafe" - - "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" -) - -// copy returns a deep-copy of the vectorised view. -func copyVV(vv buffer.VectorisedView) buffer.VectorisedView { - views := make([]buffer.View, 0, len(vv.Views())) - for _, v := range vv.Views() { - views = append(views, append(buffer.View(nil), v...)) - } - return buffer.NewVectorisedView(vv.Size(), views) -} - -// vv is an helper to build buffer.VectorisedView from different strings. -func vv(size int, pieces ...string) buffer.VectorisedView { - views := make([]buffer.View, len(pieces)) - for i, p := range pieces { - views[i] = []byte(p) - } - - return buffer.NewVectorisedView(size, views) -} - -// v returns a buffer.View containing piece. -func v(piece string) buffer.View { - return buffer.View(piece) -} - -var capLengthTestCases = []struct { - comment string - in buffer.VectorisedView - length int - want buffer.VectorisedView -}{ - { - comment: "Simple case", - in: vv(2, "12"), - length: 1, - want: vv(1, "1"), - }, - { - comment: "Case spanning across two Views", - in: vv(4, "123", "4"), - length: 2, - want: vv(2, "12"), - }, - { - comment: "Corner case with negative length", - in: vv(1, "1"), - length: -1, - want: vv(0), - }, - { - comment: "Corner case with length = 0", - in: vv(3, "12", "3"), - length: 0, - want: vv(0), - }, - { - comment: "Corner case with length = size", - in: vv(1, "1"), - length: 1, - want: vv(1, "1"), - }, - { - comment: "Corner case with length > size", - in: vv(1, "1"), - length: 2, - want: vv(1, "1"), - }, -} - -func TestCapLength(t *testing.T) { - for _, c := range capLengthTestCases { - orig := copyVV(c.in) - c.in.CapLength(c.length) - if !reflect.DeepEqual(c.in, c.want) { - t.Errorf("Test \"%s\" failed when calling CapLength(%d) on %v. Got %v. Want %v", - c.comment, c.length, orig, c.in, c.want) - } - } -} - -var trimFrontTestCases = []struct { - comment string - in buffer.VectorisedView - count int - want buffer.VectorisedView -}{ - { - comment: "Simple case", - in: vv(2, "12"), - count: 1, - want: vv(1, "2"), - }, - { - comment: "Case where we trim an entire View", - in: vv(2, "1", "2"), - count: 1, - want: vv(1, "2"), - }, - { - comment: "Case spanning across two Views", - in: vv(3, "1", "23"), - count: 2, - want: vv(1, "3"), - }, - { - comment: "Case with one empty Views", - in: vv(3, "1", "", "23"), - count: 2, - want: vv(1, "3"), - }, - { - comment: "Corner case with negative count", - in: vv(1, "1"), - count: -1, - want: vv(1, "1"), - }, - { - comment: " Corner case with count = 0", - in: vv(1, "1"), - count: 0, - want: vv(1, "1"), - }, - { - comment: "Corner case with count = size", - in: vv(1, "1"), - count: 1, - want: vv(0), - }, - { - comment: "Corner case with count > size", - in: vv(1, "1"), - count: 2, - want: vv(0), - }, -} - -func TestTrimFront(t *testing.T) { - for _, c := range trimFrontTestCases { - orig := copyVV(c.in) - c.in.TrimFront(c.count) - if !reflect.DeepEqual(c.in, c.want) { - t.Errorf("Test \"%s\" failed when calling TrimFront(%d) on %v. Got %v. Want %v", - c.comment, c.count, orig, c.in, c.want) - } - } -} - -var toViewCases = []struct { - comment string - in buffer.VectorisedView - want buffer.View -}{ - { - comment: "Simple case", - in: vv(2, "12"), - want: []byte("12"), - }, - { - comment: "Case with multiple views", - in: vv(2, "1", "2"), - want: []byte("12"), - }, - { - comment: "Empty case", - in: vv(0), - want: []byte(""), - }, -} - -func TestToView(t *testing.T) { - for _, c := range toViewCases { - got := c.in.ToView() - if !reflect.DeepEqual(got, c.want) { - t.Errorf("Test \"%s\" failed when calling ToView() on %v. Got %v. Want %v", - c.comment, c.in, got, c.want) - } - } -} - -var toCloneCases = []struct { - comment string - inView buffer.VectorisedView - inBuffer []buffer.View -}{ - { - comment: "Simple case", - inView: vv(1, "1"), - inBuffer: make([]buffer.View, 1), - }, - { - comment: "Case with multiple views", - inView: vv(2, "1", "2"), - inBuffer: make([]buffer.View, 2), - }, - { - comment: "Case with buffer too small", - inView: vv(2, "1", "2"), - inBuffer: make([]buffer.View, 1), - }, - { - comment: "Case with buffer larger than needed", - inView: vv(1, "1"), - inBuffer: make([]buffer.View, 2), - }, - { - comment: "Case with nil buffer", - inView: vv(1, "1"), - inBuffer: nil, - }, -} - -func TestToClone(t *testing.T) { - for _, c := range toCloneCases { - t.Run(c.comment, func(t *testing.T) { - got := c.inView.Clone(c.inBuffer) - if !reflect.DeepEqual(got, c.inView) { - t.Fatalf("got (%+v).Clone(%+v) = %+v, want = %+v", - c.inView, c.inBuffer, got, c.inView) - } - }) - } -} - -type readToTestCases struct { - comment string - vv buffer.VectorisedView - bytesToRead int - wantBytes string - leftVV buffer.VectorisedView -} - -func createReadToTestCases() []readToTestCases { - return []readToTestCases{ - { - comment: "large VV, short read", - vv: vv(30, "012345678901234567890123456789"), - bytesToRead: 10, - wantBytes: "0123456789", - leftVV: vv(20, "01234567890123456789"), - }, - { - comment: "largeVV, multiple views, short read", - vv: vv(13, "123", "345", "567", "8910"), - bytesToRead: 6, - wantBytes: "123345", - leftVV: vv(7, "567", "8910"), - }, - { - comment: "smallVV (multiple views), large read", - vv: vv(3, "1", "2", "3"), - bytesToRead: 10, - wantBytes: "123", - leftVV: vv(0, ""), - }, - { - comment: "smallVV (single view), large read", - vv: vv(1, "1"), - bytesToRead: 10, - wantBytes: "1", - leftVV: vv(0, ""), - }, - { - comment: "emptyVV, large read", - vv: vv(0, ""), - bytesToRead: 10, - wantBytes: "", - leftVV: vv(0, ""), - }, - } -} - -func TestVVReadToVV(t *testing.T) { - for _, tc := range createReadToTestCases() { - t.Run(tc.comment, func(t *testing.T) { - var readTo buffer.VectorisedView - inSize := tc.vv.Size() - copied := tc.vv.ReadToVV(&readTo, tc.bytesToRead) - if got, want := copied, len(tc.wantBytes); got != want { - t.Errorf("incorrect number of bytes copied returned in ReadToVV got: %d, want: %d, tc: %+v", got, want, tc) - } - if got, want := string(readTo.ToView()), tc.wantBytes; got != want { - t.Errorf("unexpected content in readTo got: %s, want: %s", got, want) - } - if got, want := tc.vv.Size(), inSize-copied; got != want { - t.Errorf("test VV has incorrect size after reading got: %d, want: %d, tc.vv: %+v", got, want, tc.vv) - } - if got, want := string(tc.vv.ToView()), string(tc.leftVV.ToView()); got != want { - t.Errorf("unexpected data left in vv after read got: %+v, want: %+v", got, want) - } - }) - } -} - -func TestVVReadTo(t *testing.T) { - for _, tc := range createReadToTestCases() { - t.Run(tc.comment, func(t *testing.T) { - b := make([]byte, tc.bytesToRead) - dst := tcpip.SliceWriter(b) - origSize := tc.vv.Size() - copied, err := tc.vv.ReadTo(&dst, false /* peek */) - if err != nil && err != io.ErrShortWrite { - t.Errorf("got ReadTo(&dst, false) = (_, %s); want nil or io.ErrShortWrite", err) - } - if got, want := copied, len(tc.wantBytes); got != want { - t.Errorf("got ReadTo(&dst, false) = (%d, _); want %d", got, want) - } - if got, want := string(b[:copied]), tc.wantBytes; got != want { - t.Errorf("got dst = %q, want %q", got, want) - } - if got, want := tc.vv.Size(), origSize-copied; got != want { - t.Errorf("got after-read tc.vv.Size() = %d, want %d", got, want) - } - if got, want := string(tc.vv.ToView()), string(tc.leftVV.ToView()); got != want { - t.Errorf("got after-read data in tc.vv = %q, want %q", got, want) - } - }) - } -} - -func TestVVReadToPeek(t *testing.T) { - for _, tc := range createReadToTestCases() { - t.Run(tc.comment, func(t *testing.T) { - b := make([]byte, tc.bytesToRead) - dst := tcpip.SliceWriter(b) - origSize := tc.vv.Size() - origData := string(tc.vv.ToView()) - copied, err := tc.vv.ReadTo(&dst, true /* peek */) - if err != nil && err != io.ErrShortWrite { - t.Errorf("got ReadTo(&dst, true) = (_, %s); want nil or io.ErrShortWrite", err) - } - if got, want := copied, len(tc.wantBytes); got != want { - t.Errorf("got ReadTo(&dst, true) = (%d, _); want %d", got, want) - } - if got, want := string(b[:copied]), tc.wantBytes; got != want { - t.Errorf("got dst = %q, want %q", got, want) - } - // Expect tc.vv is unchanged. - if got, want := tc.vv.Size(), origSize; got != want { - t.Errorf("got after-read tc.vv.Size() = %d, want %d", got, want) - } - if got, want := string(tc.vv.ToView()), origData; got != want { - t.Errorf("got after-read data in tc.vv = %q, want %q", got, want) - } - }) - } -} - -func TestVVRead(t *testing.T) { - testCases := []struct { - comment string - vv buffer.VectorisedView - bytesToRead int - readBytes string - leftBytes string - wantError bool - }{ - { - comment: "large VV, short read", - vv: vv(30, "012345678901234567890123456789"), - bytesToRead: 10, - readBytes: "0123456789", - leftBytes: "01234567890123456789", - }, - { - comment: "largeVV, multiple buffers, short read", - vv: vv(13, "123", "345", "567", "8910"), - bytesToRead: 6, - readBytes: "123345", - leftBytes: "5678910", - }, - { - comment: "smallVV, large read", - vv: vv(3, "1", "2", "3"), - bytesToRead: 10, - readBytes: "123", - leftBytes: "", - }, - { - comment: "smallVV, large read", - vv: vv(1, "1"), - bytesToRead: 10, - readBytes: "1", - leftBytes: "", - }, - { - comment: "emptyVV, large read", - vv: vv(0, ""), - bytesToRead: 10, - readBytes: "", - wantError: true, - }, - } - - for _, tc := range testCases { - t.Run(tc.comment, func(t *testing.T) { - readTo := buffer.NewView(tc.bytesToRead) - inSize := tc.vv.Size() - copied, err := tc.vv.Read(readTo) - if !tc.wantError && err != nil { - t.Fatalf("unexpected error in tc.vv.Read(..) = %s", err) - } - readTo = readTo[:copied] - if got, want := copied, len(tc.readBytes); got != want { - t.Errorf("incorrect number of bytes copied returned in ReadToVV got: %d, want: %d, tc.vv: %+v", got, want, tc.vv) - } - if got, want := string(readTo), tc.readBytes; got != want { - t.Errorf("unexpected data in readTo got: %s, want: %s", got, want) - } - if got, want := tc.vv.Size(), inSize-copied; got != want { - t.Errorf("test VV has incorrect size after reading got: %d, want: %d, tc.vv: %+v", got, want, tc.vv) - } - if got, want := string(tc.vv.ToView()), tc.leftBytes; got != want { - t.Errorf("vv has incorrect data after Read got: %s, want: %s", got, want) - } - }) - } -} - -var pullUpTestCases = []struct { - comment string - in buffer.VectorisedView - count int - want []byte - result buffer.VectorisedView - ok bool -}{ - { - comment: "simple case", - in: vv(2, "12"), - count: 1, - want: []byte("1"), - result: vv(2, "12"), - ok: true, - }, - { - comment: "entire View", - in: vv(2, "1", "2"), - count: 1, - want: []byte("1"), - result: vv(2, "1", "2"), - ok: true, - }, - { - comment: "spanning across two Views", - in: vv(3, "1", "23"), - count: 2, - want: []byte("12"), - result: vv(3, "12", "3"), - ok: true, - }, - { - comment: "spanning across all Views", - in: vv(5, "1", "23", "45"), - count: 5, - want: []byte("12345"), - result: vv(5, "12345"), - ok: true, - }, - { - comment: "count = 0", - in: vv(1, "1"), - count: 0, - want: []byte{}, - result: vv(1, "1"), - ok: true, - }, - { - comment: "count = size", - in: vv(1, "1"), - count: 1, - want: []byte("1"), - result: vv(1, "1"), - ok: true, - }, - { - comment: "count too large", - in: vv(3, "1", "23"), - count: 4, - want: nil, - result: vv(3, "1", "23"), - ok: false, - }, - { - comment: "empty vv", - in: vv(0, ""), - count: 1, - want: nil, - result: vv(0, ""), - ok: false, - }, - { - comment: "empty vv, count = 0", - in: vv(0, ""), - count: 0, - want: nil, - result: vv(0, ""), - ok: true, - }, - { - comment: "empty views", - in: vv(3, "", "1", "", "23"), - count: 2, - want: []byte("12"), - result: vv(3, "12", "3"), - ok: true, - }, -} - -func TestPullUp(t *testing.T) { - for _, c := range pullUpTestCases { - got, ok := c.in.PullUp(c.count) - - // Is the return value right? - if ok != c.ok { - t.Errorf("Test %q failed when calling PullUp(%d) on %v. Got an ok of %t. Want %t", - c.comment, c.count, c.in, ok, c.ok) - } - if bytes.Compare(got, buffer.View(c.want)) != 0 { - t.Errorf("Test %q failed when calling PullUp(%d) on %v. Got %v. Want %v", - c.comment, c.count, c.in, got, c.want) - } - - // Is the underlying structure right? - if !reflect.DeepEqual(c.in, c.result) { - t.Errorf("Test %q failed when calling PullUp(%d). Got vv with structure %v. Wanted %v", - c.comment, c.count, c.in, c.result) - } - } -} - -func TestToVectorisedView(t *testing.T) { - testCases := []struct { - in buffer.View - want buffer.VectorisedView - }{ - {nil, buffer.VectorisedView{}}, - {buffer.View{}, buffer.VectorisedView{}}, - {buffer.View{'a'}, buffer.NewVectorisedView(1, []buffer.View{{'a'}})}, - } - for _, tc := range testCases { - if got, want := tc.in.ToVectorisedView(), tc.want; !reflect.DeepEqual(got, want) { - t.Errorf("(%v).ToVectorisedView failed got: %+v, want: %+v", tc.in, got, want) - } - } -} - -func TestAppendView(t *testing.T) { - testCases := []struct { - vv buffer.VectorisedView - in buffer.View - want buffer.VectorisedView - }{ - {vv(0), nil, vv(0)}, - {vv(0), v(""), vv(0)}, - {vv(4, "abcd"), nil, vv(4, "abcd")}, - {vv(4, "abcd"), v(""), vv(4, "abcd")}, - {vv(4, "abcd"), v("e"), vv(5, "abcd", "e")}, - } - for _, tc := range testCases { - tc.vv.AppendView(tc.in) - if got, want := tc.vv, tc.want; !reflect.DeepEqual(got, want) { - t.Errorf("(%v).ToVectorisedView failed got: %+v, want: %+v", tc.in, got, want) - } - } -} - -func TestAppendViews(t *testing.T) { - testCases := []struct { - vv buffer.VectorisedView - in []buffer.View - want buffer.VectorisedView - }{ - {vv(0), nil, vv(0)}, - {vv(0), []buffer.View{}, vv(0)}, - {vv(0), []buffer.View{v("")}, vv(0, "")}, - {vv(4, "abcd"), nil, vv(4, "abcd")}, - {vv(4, "abcd"), []buffer.View{}, vv(4, "abcd")}, - {vv(4, "abcd"), []buffer.View{v("")}, vv(4, "abcd", "")}, - {vv(4, "abcd"), []buffer.View{v("")}, vv(4, "abcd", "")}, - {vv(4, "abcd"), []buffer.View{v("e")}, vv(5, "abcd", "e")}, - {vv(4, "abcd"), []buffer.View{v("e"), v("fg")}, vv(7, "abcd", "e", "fg")}, - {vv(4, "abcd"), []buffer.View{v(""), v("fg")}, vv(6, "abcd", "", "fg")}, - } - for _, tc := range testCases { - tc.vv.AppendViews(tc.in) - if got, want := tc.vv, tc.want; !reflect.DeepEqual(got, want) { - t.Errorf("(%v).ToVectorisedView failed got: %+v, want: %+v", tc.in, got, want) - } - } -} - -func TestMemSize(t *testing.T) { - const perViewCap = 128 - views := make([]buffer.View, 2, 32) - views[0] = make(buffer.View, 10, perViewCap) - views[1] = make(buffer.View, 20, perViewCap) - vv := buffer.NewVectorisedView(30, views) - want := int(unsafe.Sizeof(vv)) + cap(views)*int(unsafe.Sizeof(views)) + 2*perViewCap - if got := vv.MemSize(); got != want { - t.Errorf("vv.MemSize() = %d, want %d", got, want) - } -} diff --git a/pkg/tcpip/buffer/view_unsafe.go b/pkg/tcpip/buffer/view_unsafe.go deleted file mode 100644 index 75ccd40f8..000000000 --- a/pkg/tcpip/buffer/view_unsafe.go +++ /dev/null @@ -1,22 +0,0 @@ -// Copyright 2021 The gVisor Authors. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package buffer - -import "unsafe" - -const ( - vectorisedViewStructSize = int(unsafe.Sizeof(VectorisedView{})) - viewStructSize = int(unsafe.Sizeof(View{})) -) diff --git a/pkg/tcpip/checker/BUILD b/pkg/tcpip/checker/BUILD index c984470e6..a36bc2c52 100644 --- a/pkg/tcpip/checker/BUILD +++ b/pkg/tcpip/checker/BUILD @@ -8,8 +8,8 @@ go_library( srcs = ["checker.go"], visibility = ["//visibility:public"], deps = [ + "//pkg/buffer", "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/header", "//pkg/tcpip/seqnum", "@com_github_google_go_cmp//cmp:go_default_library", diff --git a/pkg/tcpip/checker/checker.go b/pkg/tcpip/checker/checker.go index e718e5f66..e2e72f499 100644 --- a/pkg/tcpip/checker/checker.go +++ b/pkg/tcpip/checker/checker.go @@ -23,8 +23,8 @@ import ( "time" "github.com/google/go-cmp/cmp" + "gvisor.dev/gvisor/pkg/buffer" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/header" "gvisor.dev/gvisor/pkg/tcpip/seqnum" ) @@ -1546,7 +1546,7 @@ func IPv6WithExtHdr(t *testing.T, b []byte, checkers ...NetworkChecker) { payloadIterator := header.MakeIPv6PayloadIterator( header.IPv6ExtensionHeaderIdentifier(ipv6.NextHeader()), - buffer.View(ipv6.Payload()).ToVectorisedView(), + buffer.NewWithData(ipv6.Payload()), ) var rawPayloadHeader header.IPv6RawPayloadHeader @@ -1570,7 +1570,7 @@ func IPv6WithExtHdr(t *testing.T, b []byte, checkers ...NetworkChecker) { networkHeader := ipv6HeaderWithExtHdr{ IPv6: ipv6, transport: tcpip.TransportProtocolNumber(rawPayloadHeader.Identifier), - payload: rawPayloadHeader.Buf.ToView(), + payload: rawPayloadHeader.Buf.Flatten(), } for _, checker := range checkers { @@ -1594,7 +1594,7 @@ func IPv6ExtHdr(headers ...IPv6ExtHdrChecker) NetworkChecker { payloadIterator := header.MakeIPv6PayloadIterator( header.IPv6ExtensionHeaderIdentifier(extHdrs.IPv6.NextHeader()), - buffer.View(extHdrs.IPv6.Payload()).ToVectorisedView(), + buffer.NewWithData(extHdrs.IPv6.Payload()), ) for _, check := range headers { diff --git a/pkg/tcpip/header/BUILD b/pkg/tcpip/header/BUILD index f8adecac3..8cddf9d74 100644 --- a/pkg/tcpip/header/BUILD +++ b/pkg/tcpip/header/BUILD @@ -32,7 +32,6 @@ go_library( deps = [ "//pkg/buffer", "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/seqnum", "@com_github_google_btree//:go_default_library", ], @@ -51,9 +50,9 @@ go_test( ], deps = [ ":header", + "//pkg/buffer", "//pkg/rand", "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/prependable", "//pkg/tcpip/testutil", "@com_github_google_go_cmp//cmp:go_default_library", @@ -71,8 +70,8 @@ go_test( ], library = ":header", deps = [ + "//pkg/buffer", "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/testutil", "@com_github_google_go_cmp//cmp:go_default_library", ], diff --git a/pkg/tcpip/header/checksum.go b/pkg/tcpip/header/checksum.go index 8ccb29944..eb9efdac1 100644 --- a/pkg/tcpip/header/checksum.go +++ b/pkg/tcpip/header/checksum.go @@ -22,7 +22,6 @@ import ( "gvisor.dev/gvisor/pkg/buffer" "gvisor.dev/gvisor/pkg/tcpip" - tcpipbuffer "gvisor.dev/gvisor/pkg/tcpip/buffer" ) // ChecksumSize is the size of a checksum. @@ -193,18 +192,6 @@ func Checksum(buf []byte, initial uint16) uint16 { return s } -// ChecksumVV calculates the checksum (as defined in RFC 1071) of the bytes in -// the given VectorizedView. -// -// The initial checksum must have been computed on an even number of bytes. -func ChecksumVV(vv tcpipbuffer.VectorisedView, initial uint16) uint16 { - var c Checksumer - for _, v := range vv.Views() { - c.Add([]byte(v)) - } - return ChecksumCombine(initial, c.Checksum()) -} - // ChecksumBuffer calculates the checksum (as defined in RFC 1071) of the // bytes in the given Buffer. // diff --git a/pkg/tcpip/header/checksum_test.go b/pkg/tcpip/header/checksum_test.go index 70158297c..8fff52084 100644 --- a/pkg/tcpip/header/checksum_test.go +++ b/pkg/tcpip/header/checksum_test.go @@ -23,8 +23,8 @@ import ( "sync" "testing" + "gvisor.dev/gvisor/pkg/buffer" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/header" ) @@ -63,8 +63,8 @@ func TestChecksumer(t *testing.T) { { name: "TwoEvenViews", data: [][]byte{ - buffer.NewViewFromBytes([]byte{98, 1, 9, 0}), - buffer.NewViewFromBytes([]byte{9, 0, 5, 4}), + []byte{98, 1, 9, 0}, + []byte{9, 0, 5, 4}, }, want: 30981, }, @@ -206,18 +206,16 @@ func TestICMPv4Checksum(t *testing.T) { if _, err := rnd.Read(buf); err != nil { t.Fatalf("rnd.Read failed: %v", err) } - vv := buffer.NewVectorisedView(len(buf), []buffer.View{ - buffer.NewViewFromBytes(buf[:5]), - buffer.NewViewFromBytes(buf[5:]), - }) + b := buffer.NewWithData(buf[:5]) + b.AppendOwned(buf[5:]) - want := header.Checksum(vv.ToView(), 0) + want := header.Checksum(b.Flatten(), 0) want = ^header.Checksum(h, want) h.SetChecksum(want) testICMPChecksum(t, h.Checksum, func() uint16 { - return header.ICMPv4Checksum(h, header.ChecksumVV(vv, 0)) - }, want, fmt.Sprintf("header: {% x} data {% x}", h, vv.ToView())) + return header.ICMPv4Checksum(h, header.ChecksumBuffer(b, 0)) + }, want, fmt.Sprintf("header: {% x} data {% x}", h, b.Flatten())) } func TestICMPv6Checksum(t *testing.T) { @@ -233,17 +231,15 @@ func TestICMPv6Checksum(t *testing.T) { if _, err := rnd.Read(buf); err != nil { t.Fatalf("rnd.Read failed: %v", err) } - vv := buffer.NewVectorisedView(len(buf), []buffer.View{ - buffer.NewViewFromBytes(buf[:7]), - buffer.NewViewFromBytes(buf[7:10]), - buffer.NewViewFromBytes(buf[10:]), - }) + b := buffer.NewWithData(buf[:7]) + b.AppendOwned(buf[7:10]) + b.AppendOwned(buf[10:]) dst := header.IPv6Loopback src := header.IPv6Loopback - want := header.PseudoHeaderChecksum(header.ICMPv6ProtocolNumber, src, dst, uint16(len(h)+vv.Size())) - want = header.Checksum(vv.ToView(), want) + want := header.PseudoHeaderChecksum(header.ICMPv6ProtocolNumber, src, dst, uint16(len(h)+int(b.Size()))) + want = header.Checksum(b.Flatten(), want) want = ^header.Checksum(h, want) h.SetChecksum(want) @@ -252,10 +248,10 @@ func TestICMPv6Checksum(t *testing.T) { Header: h, Src: src, Dst: dst, - PayloadCsum: header.ChecksumVV(vv, 0), - PayloadLen: vv.Size(), + PayloadCsum: header.ChecksumBuffer(b, 0), + PayloadLen: int(b.Size()), }) - }, want, fmt.Sprintf("header: {% x} data {% x}", h, vv.ToView())) + }, want, fmt.Sprintf("header: {% x} data {% x}", h, b.Flatten())) } func randomAddress(size int) tcpip.Address { diff --git a/pkg/tcpip/header/ipv6_extension_headers.go b/pkg/tcpip/header/ipv6_extension_headers.go index f18981332..50b469e17 100644 --- a/pkg/tcpip/header/ipv6_extension_headers.go +++ b/pkg/tcpip/header/ipv6_extension_headers.go @@ -23,8 +23,8 @@ import ( "io" "math" + "gvisor.dev/gvisor/pkg/buffer" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" ) // IPv6ExtensionHeaderIdentifier is an IPv6 extension header identifier. @@ -161,7 +161,7 @@ type IPv6PayloadHeader interface { // header. type IPv6RawPayloadHeader struct { Identifier IPv6ExtensionHeaderIdentifier - Buf buffer.VectorisedView + Buf buffer.Buffer } // isIPv6PayloadHeader implements IPv6PayloadHeader.isIPv6PayloadHeader. @@ -469,7 +469,7 @@ type IPv6PayloadIterator struct { // reader is an io.Reader over payload. reader bufio.Reader - payload buffer.VectorisedView + payload buffer.Buffer // Indicates to the iterator that it should return the remaining payload as a // raw payload on the next call to Next. @@ -501,7 +501,7 @@ func (i IPv6PayloadIterator) ParseOffset() uint32 { // MakeIPv6PayloadIterator returns an iterator over the IPv6 payload containing // extension headers, or a raw payload if the payload cannot be parsed. -func MakeIPv6PayloadIterator(nextHdrIdentifier IPv6ExtensionHeaderIdentifier, payload buffer.VectorisedView) IPv6PayloadIterator { +func MakeIPv6PayloadIterator(nextHdrIdentifier IPv6ExtensionHeaderIdentifier, payload buffer.Buffer) IPv6PayloadIterator { readers := payload.Readers() readerPs := make([]io.Reader, 0, len(readers)) for i := range readers { @@ -510,7 +510,7 @@ func MakeIPv6PayloadIterator(nextHdrIdentifier IPv6ExtensionHeaderIdentifier, pa return IPv6PayloadIterator{ nextHdrIdentifier: nextHdrIdentifier, - payload: payload.Clone(nil), + payload: payload.Clone(), // We need a buffer of size 1 for calls to bufio.Reader.ReadByte. reader: *bufio.NewReaderSize(io.MultiReader(readerPs...), 1), nextOffset: IPv6FixedHeaderSize, @@ -525,7 +525,7 @@ func MakeIPv6PayloadIterator(nextHdrIdentifier IPv6ExtensionHeaderIdentifier, pa func (i *IPv6PayloadIterator) AsRawHeader(consume bool) IPv6RawPayloadHeader { identifier := i.nextHdrIdentifier - var buf buffer.VectorisedView + var buf buffer.Buffer if consume { // Since we consume the iterator, we return the payload as is. buf = i.payload @@ -537,7 +537,7 @@ func (i *IPv6PayloadIterator) AsRawHeader(consume bool) IPv6RawPayloadHeader { nextOffset: i.nextOffset, } } else { - buf = i.payload.Clone(nil) + buf = i.payload.Clone() } return IPv6RawPayloadHeader{Identifier: identifier, Buf: buf} @@ -675,7 +675,7 @@ func (i *IPv6PayloadIterator) nextHeaderData(fragmentHdr bool, bytes []byte) (IP } n, err := io.ReadFull(&i.reader, bytes) - i.payload.TrimFront(n) + i.payload.TrimFront(int64(n)) if err != nil { return 0, nil, fmt.Errorf("read %d out of %d extension header data bytes (length = %d) for header with id = %d: %w", n, bytesLen, length, i.nextHdrIdentifier, err) } diff --git a/pkg/tcpip/header/ipv6_extension_headers_test.go b/pkg/tcpip/header/ipv6_extension_headers_test.go index 65adc6250..dc80e76b0 100644 --- a/pkg/tcpip/header/ipv6_extension_headers_test.go +++ b/pkg/tcpip/header/ipv6_extension_headers_test.go @@ -21,8 +21,8 @@ import ( "testing" "github.com/google/go-cmp/cmp" + "gvisor.dev/gvisor/pkg/buffer" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" ) // Equal returns true of a and b are equivalent. @@ -34,7 +34,7 @@ import ( // Needed to use cmp.Equal on IPv6RawPayloadHeader as it contains unexported // fields. func (a IPv6RawPayloadHeader) Equal(b IPv6RawPayloadHeader) bool { - return a.Identifier == b.Identifier && bytes.Equal(a.Buf.ToView(), b.Buf.ToView()) + return a.Identifier == b.Identifier && bytes.Equal(a.Buf.Flatten(), b.Buf.Flatten()) } // Equal returns true of a and b are equivalent. @@ -490,23 +490,19 @@ func TestIPv6FragmentExtHdr(t *testing.T) { } } -func makeVectorisedViewFromByteBuffers(bs ...[]byte) buffer.VectorisedView { - size := 0 - var vs []buffer.View - +func makeBufferFromByteBuffers(bs ...[]byte) buffer.Buffer { + buf := buffer.Buffer{} for _, b := range bs { - vs = append(vs, buffer.View(b)) - size += len(b) + buf.AppendOwned(b) } - - return buffer.NewVectorisedView(size, vs) + return buf } func TestIPv6ExtHdrIterErr(t *testing.T) { tests := []struct { name string firstNextHdr IPv6ExtensionHeaderIdentifier - payload buffer.VectorisedView + payload buffer.Buffer err error }{ { @@ -516,7 +512,7 @@ func TestIPv6ExtHdrIterErr(t *testing.T) { { name: "Upper layer only with data", firstNextHdr: 255, - payload: makeVectorisedViewFromByteBuffers([]byte{1, 2, 3, 4}), + payload: buffer.NewWithData([]byte{1, 2, 3, 4}), }, { name: "No next header", @@ -525,83 +521,83 @@ func TestIPv6ExtHdrIterErr(t *testing.T) { { name: "No next header with data", firstNextHdr: IPv6NoNextHeaderIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{1, 2, 3, 4}), + payload: buffer.NewWithData([]byte{1, 2, 3, 4}), }, { name: "Valid single hop by hop", firstNextHdr: IPv6HopByHopOptionsExtHdrIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{255, 0, 1, 4, 1, 2, 3, 4}), + payload: buffer.NewWithData([]byte{255, 0, 1, 4, 1, 2, 3, 4}), }, { name: "Hop by hop too small", firstNextHdr: IPv6HopByHopOptionsExtHdrIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{255, 0, 1, 4, 1, 2, 3}), + payload: buffer.NewWithData([]byte{255, 0, 1, 4, 1, 2, 3}), err: io.ErrUnexpectedEOF, }, { name: "Valid single fragment", firstNextHdr: IPv6FragmentExtHdrIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{255, 0, 68, 9, 128, 4, 2, 1}), + payload: buffer.NewWithData([]byte{255, 0, 68, 9, 128, 4, 2, 1}), }, { name: "Fragment too small", firstNextHdr: IPv6FragmentExtHdrIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{255, 0, 68, 9, 128, 4, 2}), + payload: buffer.NewWithData([]byte{255, 0, 68, 9, 128, 4, 2}), err: io.ErrUnexpectedEOF, }, { name: "Valid single destination", firstNextHdr: IPv6DestinationOptionsExtHdrIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{255, 0, 1, 4, 1, 2, 3, 4}), + payload: buffer.NewWithData([]byte{255, 0, 1, 4, 1, 2, 3, 4}), }, { name: "Destination too small", firstNextHdr: IPv6DestinationOptionsExtHdrIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{255, 0, 1, 4, 1, 2, 3}), + payload: buffer.NewWithData([]byte{255, 0, 1, 4, 1, 2, 3}), err: io.ErrUnexpectedEOF, }, { name: "Valid single routing", firstNextHdr: IPv6RoutingExtHdrIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{255, 0, 1, 2, 3, 4, 5, 6}), + payload: buffer.NewWithData([]byte{255, 0, 1, 2, 3, 4, 5, 6}), }, { name: "Valid single routing across views", firstNextHdr: IPv6RoutingExtHdrIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{255, 0, 1, 2}, []byte{3, 4, 5, 6}), + payload: makeBufferFromByteBuffers([]byte{255, 0, 1, 2}, []byte{3, 4, 5, 6}), }, { name: "Routing too small with zero length field", firstNextHdr: IPv6RoutingExtHdrIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{255, 0, 1, 2, 3, 4, 5}), + payload: buffer.NewWithData([]byte{255, 0, 1, 2, 3, 4, 5}), err: io.ErrUnexpectedEOF, }, { name: "Valid routing with non-zero length field", firstNextHdr: IPv6RoutingExtHdrIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{255, 1, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7, 8}), + payload: buffer.NewWithData([]byte{255, 1, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7, 8}), }, { name: "Valid routing with non-zero length field across views", firstNextHdr: IPv6RoutingExtHdrIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{255, 1, 1, 2, 3, 4, 5, 6}, []byte{1, 2, 3, 4, 5, 6, 7, 8}), + payload: makeBufferFromByteBuffers([]byte{255, 1, 1, 2, 3, 4, 5, 6}, []byte{1, 2, 3, 4, 5, 6, 7, 8}), }, { name: "Routing too small with non-zero length field", firstNextHdr: IPv6RoutingExtHdrIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{255, 1, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7}), + payload: buffer.NewWithData([]byte{255, 1, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7}), err: io.ErrUnexpectedEOF, }, { name: "Routing too small with non-zero length field across views", firstNextHdr: IPv6RoutingExtHdrIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{255, 1, 1, 2, 3, 4, 5, 6}, []byte{1, 2, 3, 4, 5, 6, 7}), + payload: makeBufferFromByteBuffers([]byte{255, 1, 1, 2, 3, 4, 5, 6}, []byte{1, 2, 3, 4, 5, 6, 7}), err: io.ErrUnexpectedEOF, }, { name: "Mixed", firstNextHdr: IPv6HopByHopOptionsExtHdrIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{ + payload: buffer.NewWithData([]byte{ // Hop By Hop Options extension header. uint8(IPv6FragmentExtHdrIdentifier), 0, 1, 4, 1, 2, 3, 4, @@ -623,7 +619,7 @@ func TestIPv6ExtHdrIterErr(t *testing.T) { { name: "Mixed without upper layer data", firstNextHdr: IPv6HopByHopOptionsExtHdrIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{ + payload: buffer.NewWithData([]byte{ // Hop By Hop Options extension header. uint8(IPv6FragmentExtHdrIdentifier), 0, 1, 4, 1, 2, 3, 4, @@ -642,7 +638,7 @@ func TestIPv6ExtHdrIterErr(t *testing.T) { { name: "Mixed without upper layer data but last ext hdr too small", firstNextHdr: IPv6HopByHopOptionsExtHdrIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{ + payload: buffer.NewWithData([]byte{ // Hop By Hop Options extension header. uint8(IPv6FragmentExtHdrIdentifier), 0, 1, 4, 1, 2, 3, 4, @@ -691,12 +687,12 @@ func TestIPv6ExtHdrIterErr(t *testing.T) { } func TestIPv6ExtHdrIter(t *testing.T) { - routingExtHdrWithUpperLayerData := buffer.View([]byte{255, 0, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4}) - upperLayerData := buffer.View([]byte{1, 2, 3, 4}) + routingExtHdrWithUpperLayerData := []byte{255, 0, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4} + upperLayerData := []byte{1, 2, 3, 4} tests := []struct { name string firstNextHdr IPv6ExtensionHeaderIdentifier - payload buffer.VectorisedView + payload buffer.Buffer expected []IPv6PayloadHeader }{ // With a non-atomic fragment that is not the first fragment, the payload @@ -705,7 +701,7 @@ func TestIPv6ExtHdrIter(t *testing.T) { { name: "hopbyhop - fragment (not first) - routing - upper", firstNextHdr: IPv6HopByHopOptionsExtHdrIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{ + payload: buffer.NewWithData([]byte{ // Hop By Hop extension header. uint8(IPv6FragmentExtHdrIdentifier), 0, 1, 4, 1, 2, 3, 4, @@ -729,14 +725,14 @@ func TestIPv6ExtHdrIter(t *testing.T) { IPv6FragmentExtHdr([6]byte{68, 9, 128, 4, 2, 1}), IPv6RawPayloadHeader{ Identifier: IPv6RoutingExtHdrIdentifier, - Buf: routingExtHdrWithUpperLayerData.ToVectorisedView(), + Buf: buffer.NewWithData(routingExtHdrWithUpperLayerData), }, }, }, { name: "hopbyhop - fragment (first) - routing - upper", firstNextHdr: IPv6HopByHopOptionsExtHdrIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{ + payload: buffer.NewWithData([]byte{ // Hop By Hop extension header. uint8(IPv6FragmentExtHdrIdentifier), 0, 1, 4, 1, 2, 3, 4, @@ -757,14 +753,14 @@ func TestIPv6ExtHdrIter(t *testing.T) { IPv6RoutingExtHdr([]byte{1, 2, 3, 4, 5, 6}), IPv6RawPayloadHeader{ Identifier: 255, - Buf: upperLayerData.ToVectorisedView(), + Buf: buffer.NewWithData(upperLayerData), }, }, }, { name: "fragment - routing - upper (across views)", firstNextHdr: IPv6FragmentExtHdrIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{ + payload: makeBufferFromByteBuffers([]byte{ // Fragment extension header. uint8(IPv6RoutingExtHdrIdentifier), 0, 68, 9, 128, 4, 2, 1, @@ -778,7 +774,7 @@ func TestIPv6ExtHdrIter(t *testing.T) { IPv6FragmentExtHdr([6]byte{68, 9, 128, 4, 2, 1}), IPv6RawPayloadHeader{ Identifier: IPv6RoutingExtHdrIdentifier, - Buf: routingExtHdrWithUpperLayerData.ToVectorisedView(), + Buf: buffer.NewWithData(routingExtHdrWithUpperLayerData), }, }, }, @@ -788,7 +784,7 @@ func TestIPv6ExtHdrIter(t *testing.T) { { name: "atomic fragment - routing - destination - upper", firstNextHdr: IPv6FragmentExtHdrIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{ + payload: buffer.NewWithData([]byte{ // Fragment extension header. // // Reserved bits are 1 which should not affect anything. @@ -809,14 +805,14 @@ func TestIPv6ExtHdrIter(t *testing.T) { IPv6DestinationOptionsExtHdr{ipv6OptionsExtHdr: []byte{1, 4, 1, 2, 3, 4}}, IPv6RawPayloadHeader{ Identifier: 255, - Buf: upperLayerData.ToVectorisedView(), + Buf: buffer.NewWithData(upperLayerData), }, }, }, { name: "atomic fragment - routing - upper (across views)", firstNextHdr: IPv6FragmentExtHdrIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{ + payload: makeBufferFromByteBuffers([]byte{ // Fragment extension header. // // Reserved bits are 1 which should not affect anything. @@ -832,14 +828,14 @@ func TestIPv6ExtHdrIter(t *testing.T) { IPv6RoutingExtHdr([]byte{1, 2, 3, 4, 5, 6}), IPv6RawPayloadHeader{ Identifier: 255, - Buf: makeVectorisedViewFromByteBuffers(upperLayerData[:2], upperLayerData[2:]), + Buf: makeBufferFromByteBuffers(upperLayerData[:2], upperLayerData[2:]), }, }, }, { name: "atomic fragment - destination - no next header", firstNextHdr: IPv6FragmentExtHdrIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{ + payload: buffer.NewWithData([]byte{ // Fragment extension header. // // Res (Reserved) bits are 1 which should not affect anything. @@ -859,7 +855,7 @@ func TestIPv6ExtHdrIter(t *testing.T) { { name: "routing - atomic fragment - no next header", firstNextHdr: IPv6RoutingExtHdrIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{ + payload: buffer.NewWithData([]byte{ // Routing extension header. uint8(IPv6FragmentExtHdrIdentifier), 0, 1, 2, 3, 4, 5, 6, @@ -879,7 +875,7 @@ func TestIPv6ExtHdrIter(t *testing.T) { { name: "routing - atomic fragment - no next header (across views)", firstNextHdr: IPv6RoutingExtHdrIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{ + payload: makeBufferFromByteBuffers([]byte{ // Routing extension header. uint8(IPv6FragmentExtHdrIdentifier), 0, 1, 2, 3, 4, 5, 6, @@ -899,7 +895,7 @@ func TestIPv6ExtHdrIter(t *testing.T) { { name: "hopbyhop - routing - fragment - no next header", firstNextHdr: IPv6HopByHopOptionsExtHdrIdentifier, - payload: makeVectorisedViewFromByteBuffers([]byte{ + payload: buffer.NewWithData([]byte{ // Hop By Hop Options extension header. uint8(IPv6RoutingExtHdrIdentifier), 0, 1, 4, 1, 2, 3, 4, @@ -920,7 +916,7 @@ func TestIPv6ExtHdrIter(t *testing.T) { IPv6FragmentExtHdr([6]byte{1, 6, 128, 4, 2, 1}), IPv6RawPayloadHeader{ Identifier: IPv6NoNextHeaderIdentifier, - Buf: upperLayerData.ToVectorisedView(), + Buf: buffer.NewWithData(upperLayerData), }, }, }, @@ -929,55 +925,55 @@ func TestIPv6ExtHdrIter(t *testing.T) { { name: "TCP raw payload", firstNextHdr: IPv6ExtensionHeaderIdentifier(TCPProtocolNumber), - payload: makeVectorisedViewFromByteBuffers(upperLayerData), + payload: buffer.NewWithData(upperLayerData), expected: []IPv6PayloadHeader{IPv6RawPayloadHeader{ Identifier: IPv6ExtensionHeaderIdentifier(TCPProtocolNumber), - Buf: upperLayerData.ToVectorisedView(), + Buf: buffer.NewWithData(upperLayerData), }}, }, { name: "UDP raw payload", firstNextHdr: IPv6ExtensionHeaderIdentifier(UDPProtocolNumber), - payload: makeVectorisedViewFromByteBuffers(upperLayerData), + payload: buffer.NewWithData(upperLayerData), expected: []IPv6PayloadHeader{IPv6RawPayloadHeader{ Identifier: IPv6ExtensionHeaderIdentifier(UDPProtocolNumber), - Buf: upperLayerData.ToVectorisedView(), + Buf: buffer.NewWithData(upperLayerData), }}, }, { name: "ICMPv4 raw payload", firstNextHdr: IPv6ExtensionHeaderIdentifier(ICMPv4ProtocolNumber), - payload: makeVectorisedViewFromByteBuffers(upperLayerData), + payload: buffer.NewWithData(upperLayerData), expected: []IPv6PayloadHeader{IPv6RawPayloadHeader{ Identifier: IPv6ExtensionHeaderIdentifier(ICMPv4ProtocolNumber), - Buf: upperLayerData.ToVectorisedView(), + Buf: buffer.NewWithData(upperLayerData), }}, }, { name: "ICMPv6 raw payload", firstNextHdr: IPv6ExtensionHeaderIdentifier(ICMPv6ProtocolNumber), - payload: makeVectorisedViewFromByteBuffers(upperLayerData), + payload: buffer.NewWithData(upperLayerData), expected: []IPv6PayloadHeader{IPv6RawPayloadHeader{ Identifier: IPv6ExtensionHeaderIdentifier(ICMPv6ProtocolNumber), - Buf: upperLayerData.ToVectorisedView(), + Buf: buffer.NewWithData(upperLayerData), }}, }, { name: "Unknwon next header raw payload", firstNextHdr: 255, - payload: makeVectorisedViewFromByteBuffers(upperLayerData), + payload: buffer.NewWithData(upperLayerData), expected: []IPv6PayloadHeader{IPv6RawPayloadHeader{ Identifier: 255, - Buf: upperLayerData.ToVectorisedView(), + Buf: buffer.NewWithData(upperLayerData), }}, }, { name: "Unknwon next header raw payload (across views)", firstNextHdr: 255, - payload: makeVectorisedViewFromByteBuffers(upperLayerData[:2], upperLayerData[2:]), + payload: makeBufferFromByteBuffers(upperLayerData[:2], upperLayerData[2:]), expected: []IPv6PayloadHeader{IPv6RawPayloadHeader{ Identifier: 255, - Buf: makeVectorisedViewFromByteBuffers(upperLayerData[:2], upperLayerData[2:]), + Buf: makeBufferFromByteBuffers(upperLayerData[:2], upperLayerData[2:]), }}, }, } diff --git a/pkg/tcpip/header/parse/BUILD b/pkg/tcpip/header/parse/BUILD index 2adee9288..279307716 100644 --- a/pkg/tcpip/header/parse/BUILD +++ b/pkg/tcpip/header/parse/BUILD @@ -8,7 +8,6 @@ go_library( visibility = ["//visibility:public"], deps = [ "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/header", "//pkg/tcpip/stack", ], diff --git a/pkg/tcpip/header/parse/parse.go b/pkg/tcpip/header/parse/parse.go index c4ac9372f..6dada8c36 100644 --- a/pkg/tcpip/header/parse/parse.go +++ b/pkg/tcpip/header/parse/parse.go @@ -19,7 +19,6 @@ import ( "fmt" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/header" "gvisor.dev/gvisor/pkg/tcpip/stack" ) @@ -84,15 +83,13 @@ func IPv6(pkt *stack.PacketBuffer) (proto tcpip.TransportProtocolNumber, fragID // - Any IPv6 header bytes after the first 40 (i.e. extensions). // - The transport header, if present. // - Any other payload data. - views := [8]buffer.View{} - dataVV := buffer.NewVectorisedView(0, views[:0]) - dataVV.AppendViews(pkt.Data().Views()) - dataVV.TrimFront(header.IPv6MinimumSize) - it := header.MakeIPv6PayloadIterator(header.IPv6ExtensionHeaderIdentifier(ipHdr.NextHeader()), dataVV) + dataBuf := pkt.Data().AsBuffer() + dataBuf.TrimFront(header.IPv6MinimumSize) + it := header.MakeIPv6PayloadIterator(header.IPv6ExtensionHeaderIdentifier(ipHdr.NextHeader()), dataBuf) // Iterate over the IPv6 extensions to find their length. var nextHdr tcpip.TransportProtocolNumber - var extensionsSize int + var extensionsSize int64 traverseExtensions: for { @@ -104,7 +101,7 @@ traverseExtensions: // If we exhaust the extension list, the entire packet is the IPv6 header // and (possibly) extensions. if done { - extensionsSize = dataVV.Size() + extensionsSize = dataBuf.Size() break } @@ -126,12 +123,12 @@ traverseExtensions: fragMore = extHdr.More() } rawPayload := it.AsRawHeader(true /* consume */) - extensionsSize = dataVV.Size() - rawPayload.Buf.Size() + extensionsSize = dataBuf.Size() - rawPayload.Buf.Size() break traverseExtensions case header.IPv6RawPayloadHeader: // We've found the payload after any extensions. - extensionsSize = dataVV.Size() - extHdr.Buf.Size() + extensionsSize = dataBuf.Size() - extHdr.Buf.Size() nextHdr = tcpip.TransportProtocolNumber(extHdr.Identifier) break traverseExtensions @@ -141,7 +138,7 @@ traverseExtensions: } // Put the IPv6 header with extensions in pkt.NetworkHeader(). - hdr, ok = pkt.NetworkHeader().Consume(header.IPv6MinimumSize + extensionsSize) + hdr, ok = pkt.NetworkHeader().Consume(header.IPv6MinimumSize + int(extensionsSize)) if !ok { panic(fmt.Sprintf("pkt.Data should have at least %d bytes, but only has %d.", header.IPv6MinimumSize+extensionsSize, pkt.Data().Size())) } diff --git a/pkg/tcpip/link/ethernet/BUILD b/pkg/tcpip/link/ethernet/BUILD index 99abc8346..85d66db85 100644 --- a/pkg/tcpip/link/ethernet/BUILD +++ b/pkg/tcpip/link/ethernet/BUILD @@ -24,7 +24,6 @@ go_test( "//pkg/refs", "//pkg/refsvfs2", "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/header", "//pkg/tcpip/link/channel", "//pkg/tcpip/stack", diff --git a/pkg/tcpip/link/ethernet/ethernet_test.go b/pkg/tcpip/link/ethernet/ethernet_test.go index 8bb8540a1..33d1f69cc 100644 --- a/pkg/tcpip/link/ethernet/ethernet_test.go +++ b/pkg/tcpip/link/ethernet/ethernet_test.go @@ -23,7 +23,6 @@ import ( "gvisor.dev/gvisor/pkg/refs" "gvisor.dev/gvisor/pkg/refsvfs2" "gvisor.dev/gvisor/pkg/tcpip" - tcpipbuffer "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/header" "gvisor.dev/gvisor/pkg/tcpip/link/channel" "gvisor.dev/gvisor/pkg/tcpip/link/ethernet" @@ -143,7 +142,7 @@ func TestWritePacketToRemoteAddHeader(t *testing.T) { // TODO(b/230896518): Remove tcpipbuffer once WritePacketToRemote API is // changed. - if err := s.WritePacketToRemote(nicID, remoteLinkAddr, netProto, tcpipbuffer.VectorisedView{}); err != nil { + if err := s.WritePacketToRemote(nicID, remoteLinkAddr, netProto, buffer.Buffer{}); err != nil { t.Fatalf("s.WritePacketToRemote(%d, %s, _): %s", nicID, remoteLinkAddr, err) } diff --git a/pkg/tcpip/link/fdbased/endpoint.go b/pkg/tcpip/link/fdbased/endpoint.go index be8417526..a3fa225d7 100644 --- a/pkg/tcpip/link/fdbased/endpoint.go +++ b/pkg/tcpip/link/fdbased/endpoint.go @@ -530,7 +530,7 @@ func (e *endpoint) writePacket(pkt *stack.PacketBuffer) tcpip.Error { vnetHdrBuf = vnetHdr.marshal() } - views := pkt.Views() + views := pkt.Slices() numIovecs := len(views) if len(vnetHdrBuf) != 0 { numIovecs++ @@ -601,7 +601,7 @@ func (e *endpoint) sendBatch(batchFDInfo fdInfo, pkts []*stack.PacketBuffer) (in vnetHdrBuf = vnetHdr.marshal() } - views := pkt.Views() + views := pkt.Slices() numIovecs := len(views) if len(vnetHdrBuf) != 0 { numIovecs++ diff --git a/pkg/tcpip/link/fdbased/endpoint_test.go b/pkg/tcpip/link/fdbased/endpoint_test.go index c0c0d5cd8..6a0100efa 100644 --- a/pkg/tcpip/link/fdbased/endpoint_test.go +++ b/pkg/tcpip/link/fdbased/endpoint_test.go @@ -627,7 +627,7 @@ func TestDispatchPacketFormat(t *testing.T) { t.Fatalf("len(sink.pkts) = %d, want %d", got, want) } pkt := sink.pkts[0] - if got, want := pkt.LinkHeader().View().Size(), header.EthernetMinimumSize; got != want { + if got, want := len(pkt.LinkHeader().View()), header.EthernetMinimumSize; got != want { t.Errorf("pkt.LinkHeader().View().Size() = %d, want %d", got, want) } if got, want := pkt.Data().Size(), 4; got != want { diff --git a/pkg/tcpip/link/sniffer/pcap.go b/pkg/tcpip/link/sniffer/pcap.go index d3edede63..efcb4f684 100644 --- a/pkg/tcpip/link/sniffer/pcap.go +++ b/pkg/tcpip/link/sniffer/pcap.go @@ -66,7 +66,7 @@ func (p *pcapPacket) MarshalBinary() ([]byte, error) { binary.BigEndian.PutUint32(b[8:12], uint32(captureLen)) binary.BigEndian.PutUint32(b[12:16], uint32(packetSize)) w := tcpip.SliceWriter(b[16:]) - for _, v := range p.packet.Views() { + for _, v := range p.packet.Slices() { if captureLen == 0 { break } diff --git a/pkg/tcpip/network/BUILD b/pkg/tcpip/network/BUILD index 6efb9ca66..9f8ff52bf 100644 --- a/pkg/tcpip/network/BUILD +++ b/pkg/tcpip/network/BUILD @@ -16,7 +16,6 @@ go_test( "//pkg/refsvfs2", "//pkg/sync", "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/checker", "//pkg/tcpip/faketime", "//pkg/tcpip/header", diff --git a/pkg/tcpip/network/arp/BUILD b/pkg/tcpip/network/arp/BUILD index 8b30a0446..095f0c81f 100644 --- a/pkg/tcpip/network/arp/BUILD +++ b/pkg/tcpip/network/arp/BUILD @@ -13,7 +13,6 @@ go_library( "//pkg/atomicbitops", "//pkg/sync", "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/header", "//pkg/tcpip/header/parse", "//pkg/tcpip/network/internal/ip", diff --git a/pkg/tcpip/network/arp/arp.go b/pkg/tcpip/network/arp/arp.go index 65721a8f2..217755b72 100644 --- a/pkg/tcpip/network/arp/arp.go +++ b/pkg/tcpip/network/arp/arp.go @@ -24,7 +24,6 @@ import ( "gvisor.dev/gvisor/pkg/atomicbitops" "gvisor.dev/gvisor/pkg/sync" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/header" "gvisor.dev/gvisor/pkg/tcpip/header/parse" "gvisor.dev/gvisor/pkg/tcpip/network/internal/ip" @@ -267,7 +266,7 @@ type protocol struct { func (p *protocol) Number() tcpip.NetworkProtocolNumber { return ProtocolNumber } func (p *protocol) MinimumPacketSize() int { return header.ARPSize } -func (*protocol) ParseAddresses(buffer.View) (src, dst tcpip.Address) { +func (*protocol) ParseAddresses([]byte) (src, dst tcpip.Address) { return "", "" } diff --git a/pkg/tcpip/network/internal/fragmentation/BUILD b/pkg/tcpip/network/internal/fragmentation/BUILD index 4d1caff18..ddd64e586 100644 --- a/pkg/tcpip/network/internal/fragmentation/BUILD +++ b/pkg/tcpip/network/internal/fragmentation/BUILD @@ -31,7 +31,6 @@ go_library( "//pkg/log", "//pkg/sync", "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/header", "//pkg/tcpip/stack", ], diff --git a/pkg/tcpip/network/internal/fragmentation/fragmentation_test.go b/pkg/tcpip/network/internal/fragmentation/fragmentation_test.go index 48a697229..c80728a84 100644 --- a/pkg/tcpip/network/internal/fragmentation/fragmentation_test.go +++ b/pkg/tcpip/network/internal/fragmentation/fragmentation_test.go @@ -550,7 +550,7 @@ func TestPacketFragmenter(t *testing.T) { if got := fragPkt.AvailableHeaderBytes(); got != reserve { t.Errorf("(fragment #%d) got fragPkt.AvailableHeaderBytes() = %d, want = %d", i, got, reserve) } - if got := fragPkt.TransportHeader().View().Size(); got != 0 { + if got := len(fragPkt.TransportHeader().View()); got != 0 { t.Errorf("(fragment #%d) got fragPkt.TransportHeader().View().Size() = %d, want = 0", i, got) } fragBuf := fragPkt.Data().AsBuffer() diff --git a/pkg/tcpip/network/ipv4/BUILD b/pkg/tcpip/network/ipv4/BUILD index 83a1c2a6f..eedb62cef 100644 --- a/pkg/tcpip/network/ipv4/BUILD +++ b/pkg/tcpip/network/ipv4/BUILD @@ -16,7 +16,6 @@ go_library( "//pkg/buffer", "//pkg/sync", "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/header", "//pkg/tcpip/header/parse", "//pkg/tcpip/network/hash", diff --git a/pkg/tcpip/network/ipv4/icmp.go b/pkg/tcpip/network/ipv4/icmp.go index e6ae12ed7..ef939a053 100644 --- a/pkg/tcpip/network/ipv4/icmp.go +++ b/pkg/tcpip/network/ipv4/icmp.go @@ -629,7 +629,7 @@ func (p *protocol) returnError(reason icmpReason, pkt *stack.PacketBuffer, deliv return nil } - payloadLen := len(origIPHdr) + transportHeader.Size() + pkt.Data().Size() + payloadLen := len(origIPHdr) + len(transportHeader) + pkt.Data().Size() if payloadLen > available { payloadLen = available } diff --git a/pkg/tcpip/network/ipv4/ipv4.go b/pkg/tcpip/network/ipv4/ipv4.go index 75cc8f135..ad3ab738a 100644 --- a/pkg/tcpip/network/ipv4/ipv4.go +++ b/pkg/tcpip/network/ipv4/ipv4.go @@ -24,7 +24,6 @@ import ( "gvisor.dev/gvisor/pkg/atomicbitops" "gvisor.dev/gvisor/pkg/sync" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/header" "gvisor.dev/gvisor/pkg/tcpip/header/parse" "gvisor.dev/gvisor/pkg/tcpip/network/hash" @@ -527,7 +526,7 @@ func (e *endpoint) writePacketPostRouting(r *stack.Route, pkt *stack.PacketBuffe stats := e.stats.ip - networkMTU, err := calculateNetworkMTU(e.nic.MTU(), uint32(pkt.NetworkHeader().View().Size())) + networkMTU, err := calculateNetworkMTU(e.nic.MTU(), uint32(len(pkt.NetworkHeader().View()))) if err != nil { stats.OutgoingPacketErrors.Increment() return err @@ -1125,7 +1124,7 @@ func (e *endpoint) deliverPacketLocally(h header.IPv4, pkt *stack.PacketBuffer, } if h.More() || h.FragmentOffset() != 0 { - if pkt.Data().Size()+pkt.TransportHeader().View().Size() == 0 { + if pkt.Data().Size()+len(pkt.TransportHeader().View()) == 0 { // Drop the packet as it's marked as a fragment but has // no payload. stats.ip.MalformedPacketsReceived.Increment() @@ -1448,7 +1447,7 @@ func (p *protocol) MinimumPacketSize() int { // ParseAddresses implements stack.NetworkProtocol. // TODO(b/230896518): Remove buffer.View once stack.NetworkProtocol is changed // to use pkg/buffer.Buffer. -func (*protocol) ParseAddresses(v buffer.View) (src, dst tcpip.Address) { +func (*protocol) ParseAddresses(v []byte) (src, dst tcpip.Address) { h := header.IPv4(v) return h.SourceAddress(), h.DestinationAddress() } @@ -1637,7 +1636,7 @@ func (p *protocol) parseAndValidate(pkt *stack.PacketBuffer) (header.IPv4, bool) h := header.IPv4(pkt.NetworkHeader().View()) // Do not include the link header's size when calculating the size of the IP // packet. - if !h.IsValid(pkt.Size() - pkt.LinkHeader().View().Size()) { + if !h.IsValid(pkt.Size() - len(pkt.LinkHeader().View())) { return nil, false } @@ -1740,7 +1739,7 @@ func calculateNetworkMTU(linkMTU, networkHeaderSize uint32) (uint32, tcpip.Error } func packetMustBeFragmented(pkt *stack.PacketBuffer, networkMTU uint32) bool { - payload := pkt.TransportHeader().View().Size() + pkt.Data().Size() + payload := len(pkt.TransportHeader().View()) + pkt.Data().Size() return pkt.GSOOptions.Type == stack.GSONone && uint32(payload) > networkMTU } diff --git a/pkg/tcpip/network/ipv4/ipv4_test.go b/pkg/tcpip/network/ipv4/ipv4_test.go index a476d184e..b067d1199 100644 --- a/pkg/tcpip/network/ipv4/ipv4_test.go +++ b/pkg/tcpip/network/ipv4/ipv4_test.go @@ -3920,7 +3920,7 @@ func TestIcmpRateLimit(t *testing.T) { p := e.Read() if round >= icmpBurst { if p != nil { - t.Errorf("got packet %x in round %d, expected ICMP rate limit to stop it", p.Data().Views(), round) + t.Errorf("got packet %x in round %d, expected ICMP rate limit to stop it", p.Data().Slices(), round) p.DecRef() } return diff --git a/pkg/tcpip/network/ipv6/BUILD b/pkg/tcpip/network/ipv6/BUILD index 1de8698b3..de912f224 100644 --- a/pkg/tcpip/network/ipv6/BUILD +++ b/pkg/tcpip/network/ipv6/BUILD @@ -18,7 +18,6 @@ go_library( "//pkg/buffer", "//pkg/sync", "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/header", "//pkg/tcpip/header/parse", "//pkg/tcpip/network/hash", diff --git a/pkg/tcpip/network/ipv6/icmp.go b/pkg/tcpip/network/ipv6/icmp.go index 529e834cc..4590c978d 100644 --- a/pkg/tcpip/network/ipv6/icmp.go +++ b/pkg/tcpip/network/ipv6/icmp.go @@ -275,7 +275,7 @@ func isMLDValid(pkt *stack.PacketBuffer, iph header.IPv6, routerAlert *header.IP if routerAlert == nil || routerAlert.Value != header.IPv6RouterAlertMLD { return false } - if pkt.TransportHeader().View().Size() < header.ICMPv6HeaderSize+header.MLDMinimumSize { + if len(pkt.TransportHeader().View()) < header.ICMPv6HeaderSize+header.MLDMinimumSize { return false } if iph.HopLimit() != header.MLDHopLimit { @@ -1161,7 +1161,7 @@ func (p *protocol) returnError(reason icmpReason, pkt *stack.PacketBuffer, deliv if available < header.IPv6MinimumSize { return nil } - payloadLen := network.Size() + transport.Size() + pkt.Data().Size() + payloadLen := len(network) + len(transport) + pkt.Data().Size() if payloadLen > available { payloadLen = available } diff --git a/pkg/tcpip/network/ipv6/ipv6.go b/pkg/tcpip/network/ipv6/ipv6.go index 7d8e739ef..fe6469da5 100644 --- a/pkg/tcpip/network/ipv6/ipv6.go +++ b/pkg/tcpip/network/ipv6/ipv6.go @@ -25,9 +25,9 @@ import ( "time" "gvisor.dev/gvisor/pkg/atomicbitops" + "gvisor.dev/gvisor/pkg/buffer" "gvisor.dev/gvisor/pkg/sync" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/header" "gvisor.dev/gvisor/pkg/tcpip/header/parse" "gvisor.dev/gvisor/pkg/tcpip/network/hash" @@ -717,7 +717,7 @@ func addIPHeader(srcAddr, dstAddr tcpip.Address, pkt *stack.PacketBuffer, params } func packetMustBeFragmented(pkt *stack.PacketBuffer, networkMTU uint32) bool { - payload := pkt.TransportHeader().View().Size() + pkt.Data().Size() + payload := len(pkt.TransportHeader().View()) + pkt.Data().Size() return pkt.GSOOptions.Type == stack.GSONone && uint32(payload) > networkMTU } @@ -742,7 +742,7 @@ func (e *endpoint) handleFragments(r *stack.Route, networkMTU uint32, pkt *stack return 0, 1, &tcpip.ErrMessageTooLong{} } - if fragmentPayloadLen < uint32(pkt.TransportHeader().View().Size()) { + if fragmentPayloadLen < uint32(len(pkt.TransportHeader().View())) { // As per RFC 8200 Section 4.5, the Transport Header is expected to be small // enough to fit in the first fragment. return 0, 1, &tcpip.ErrMessageTooLong{} @@ -822,7 +822,7 @@ func (e *endpoint) writePacket(r *stack.Route, pkt *stack.PacketBuffer, protocol } stats := e.stats.ip - networkMTU, err := calculateNetworkMTU(e.nic.MTU(), uint32(pkt.NetworkHeader().View().Size())) + networkMTU, err := calculateNetworkMTU(e.nic.MTU(), uint32(len(pkt.NetworkHeader().View()))) if err != nil { stats.OutgoingPacketErrors.Increment() return err @@ -1319,10 +1319,11 @@ func (e *endpoint) processExtensionHeaders(h header.IPv6, pkt *stack.PacketBuffe // - Any IPv6 header bytes after the first 40 (i.e. extensions). // - The transport header, if present. // - Any other payload data. - vv := pkt.NetworkHeader().View()[header.IPv6MinimumSize:].ToVectorisedView() - vv.AppendView(pkt.TransportHeader().View()) - vv.AppendViews(pkt.Data().Views()) - it := header.MakeIPv6PayloadIterator(header.IPv6ExtensionHeaderIdentifier(h.NextHeader()), vv) + buf := buffer.NewWithData(pkt.NetworkHeader().View()[header.IPv6MinimumSize:]) + buf.AppendOwned(pkt.TransportHeader().View()) + dataBuf := pkt.Data().AsBuffer() + buf.Merge(&dataBuf) + it := header.MakeIPv6PayloadIterator(header.IPv6ExtensionHeaderIdentifier(h.NextHeader()), buf) var ( hasFragmentHeader bool @@ -1558,7 +1559,7 @@ func (e *endpoint) processExtensionHeaders(h header.IPv6, pkt *stack.PacketBuffe // Parameter Problem, Code 0, message should be sent to the source of // the fragment, pointing to the Fragment Offset field of the fragment // packet. - lengthAfterReassembly := int(start) + fragmentPayloadLen + lengthAfterReassembly := int(start) + int(fragmentPayloadLen) if lengthAfterReassembly > header.IPv6MaximumPayloadSize { stats.MalformedPacketsReceived.Increment() stats.MalformedFragmentsReceived.Increment() @@ -1599,11 +1600,7 @@ func (e *endpoint) processExtensionHeaders(h header.IPv6, pkt *stack.PacketBuffe // have more extension headers in the reassembled payload, as per RFC // 8200 section 4.5. We also use the NextHeader value from the first // fragment. - data := pkt.Data() - // TODO(b/230896518): Create a pkg/buffer once MakeIPv6PayloadIterator - // API has been changed. - dataVV := buffer.NewVectorisedView(data.Size(), data.Views()) - it = header.MakeIPv6PayloadIterator(header.IPv6ExtensionHeaderIdentifier(proto), dataVV) + it = header.MakeIPv6PayloadIterator(header.IPv6ExtensionHeaderIdentifier(proto), pkt.Data().AsBuffer()) } case header.IPv6DestinationOptionsExtHdr: @@ -1657,14 +1654,14 @@ func (e *endpoint) processExtensionHeaders(h header.IPv6, pkt *stack.PacketBuffe // Calculate the number of octets parsed from data. We want to consume all // the data except the unparsed portion located at the end, whose size is // extHdr.Buf.Size(). - trim := pkt.Data().Size() - extHdr.Buf.Size() + trim := pkt.Data().Size() - int(extHdr.Buf.Size()) // For unfragmented packets, extHdr still contains the transport header. // Consume that too. // // For reassembled fragments, pkt.TransportHeader is unset, so this is a // no-op and pkt.Data begins with the transport header. - trim += pkt.TransportHeader().View().Size() + trim += len(pkt.TransportHeader().View()) if _, ok := pkt.Data().Consume(trim); !ok { stats.MalformedPacketsReceived.Increment() @@ -1674,7 +1671,7 @@ func (e *endpoint) processExtensionHeaders(h header.IPv6, pkt *stack.PacketBuffe proto := tcpip.TransportProtocolNumber(extHdr.Identifier) // If the packet was reassembled from a fragment, it will not have a // transport header set yet. - if pkt.TransportHeader().View().IsEmpty() { + if len(pkt.TransportHeader().View()) == 0 { e.protocol.parseTransport(pkt, proto) } @@ -2155,7 +2152,7 @@ func (p *protocol) MinimumPacketSize() int { } // ParseAddresses implements stack.NetworkProtocol. -func (*protocol) ParseAddresses(v buffer.View) (src, dst tcpip.Address) { +func (*protocol) ParseAddresses(v []byte) (src, dst tcpip.Address) { h := header.IPv6(v) return h.SourceAddress(), h.DestinationAddress() } @@ -2404,7 +2401,7 @@ func (p *protocol) parseAndValidate(pkt *stack.PacketBuffer) (header.IPv6, bool) h := header.IPv6(pkt.NetworkHeader().View()) // Do not include the link header's size when calculating the size of the IP // packet. - if !h.IsValid(pkt.Size() - pkt.LinkHeader().View().Size()) { + if !h.IsValid(pkt.Size() - len(pkt.LinkHeader().View())) { return nil, false } @@ -2604,7 +2601,7 @@ func NewProtocol(s *stack.Stack) stack.NetworkProtocol { } func calculateFragmentReserve(pkt *stack.PacketBuffer) int { - return pkt.AvailableHeaderBytes() + pkt.NetworkHeader().View().Size() + header.IPv6FragmentHeaderSize + return pkt.AvailableHeaderBytes() + len(pkt.NetworkHeader().View()) + header.IPv6FragmentHeaderSize } // hashRoute calculates a hash value for the given route. It uses the source & diff --git a/pkg/tcpip/network/ipv6/ipv6_test.go b/pkg/tcpip/network/ipv6/ipv6_test.go index 17900cff6..11ff88fdb 100644 --- a/pkg/tcpip/network/ipv6/ipv6_test.go +++ b/pkg/tcpip/network/ipv6/ipv6_test.go @@ -173,7 +173,7 @@ func compareFragments(packets []*stack.PacketBuffer, sourcePacket *stack.PacketB return fmt.Errorf("fragment #%d: IP packet is invalid:\n%s", i, hex.Dump(fragmentIPHeaders)) } - fragmentIPHeadersLength := fragment.NetworkHeader().View().Size() + fragmentIPHeadersLength := len(fragment.NetworkHeader().View()) if fragmentIPHeadersLength != sourceIPHeadersLen { return fmt.Errorf("fragment #%d: got fragmentIPHeadersLength = %d, want = %d", i, fragmentIPHeadersLength, sourceIPHeadersLen) } @@ -3764,7 +3764,7 @@ func TestIcmpRateLimit(t *testing.T) { p := e.Read() if round >= icmpBurst { if p != nil { - t.Errorf("got packet %x in round %d, expected ICMP rate limit to stop it", p.Data().Views(), round) + t.Errorf("got packet %x in round %d, expected ICMP rate limit to stop it", p.Data().Slices(), round) p.DecRef() } return diff --git a/pkg/tcpip/network/multicast_group_test.go b/pkg/tcpip/network/multicast_group_test.go index a4d7b1f6c..c8bd24bff 100644 --- a/pkg/tcpip/network/multicast_group_test.go +++ b/pkg/tcpip/network/multicast_group_test.go @@ -23,7 +23,6 @@ import ( "gvisor.dev/gvisor/pkg/buffer" "gvisor.dev/gvisor/pkg/refsvfs2" "gvisor.dev/gvisor/pkg/tcpip" - tcpipbuffer "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/checker" "gvisor.dev/gvisor/pkg/tcpip/faketime" "gvisor.dev/gvisor/pkg/tcpip/header" @@ -1079,7 +1078,7 @@ func TestMGPWithNICLifecycle(t *testing.T) { ipv6HeaderIter := header.MakeIPv6PayloadIterator( header.IPv6ExtensionHeaderIdentifier(ipv6.NextHeader()), - tcpipbuffer.View(ipv6.Payload()).ToVectorisedView(), + buffer.NewWithData(ipv6.Payload()), ) var transport header.IPv6RawPayloadHeader @@ -1100,7 +1099,7 @@ func TestMGPWithNICLifecycle(t *testing.T) { if got := tcpip.TransportProtocolNumber(transport.Identifier); got != header.ICMPv6ProtocolNumber { t.Fatalf("got ipv6.NextHeader() = %d, want = %d", got, header.ICMPv6ProtocolNumber) } - icmpv6 := header.ICMPv6(transport.Buf.ToView()) + icmpv6 := header.ICMPv6(transport.Buf.Flatten()) if got := icmpv6.Type(); got != header.ICMPv6MulticastListenerReport && got != header.ICMPv6MulticastListenerDone { t.Fatalf("got icmpv6.Type() = %d, want = %d or %d", got, header.ICMPv6MulticastListenerReport, header.ICMPv6MulticastListenerDone) } diff --git a/pkg/tcpip/stack/BUILD b/pkg/tcpip/stack/BUILD index 1519155bb..d399c12c3 100644 --- a/pkg/tcpip/stack/BUILD +++ b/pkg/tcpip/stack/BUILD @@ -83,7 +83,6 @@ go_library( "//pkg/sleep", "//pkg/sync", "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/hash/jenkins", "//pkg/tcpip/header", "//pkg/tcpip/internal/tcp", @@ -109,10 +108,10 @@ go_test( shard_count = most_shards, deps = [ ":stack", + "//pkg/buffer", "//pkg/rand", "//pkg/sync", "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/checker", "//pkg/tcpip/faketime", "//pkg/tcpip/header", @@ -150,7 +149,6 @@ go_test( "//pkg/buffer", "//pkg/sync", "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/faketime", "//pkg/tcpip/header", "//pkg/tcpip/seqnum", diff --git a/pkg/tcpip/stack/conntrack_test.go b/pkg/tcpip/stack/conntrack_test.go index ecb867582..5f2d637b1 100644 --- a/pkg/tcpip/stack/conntrack_test.go +++ b/pkg/tcpip/stack/conntrack_test.go @@ -17,8 +17,8 @@ package stack import ( "testing" + "gvisor.dev/gvisor/pkg/buffer" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/faketime" "gvisor.dev/gvisor/pkg/tcpip/header" "gvisor.dev/gvisor/pkg/tcpip/seqnum" @@ -323,7 +323,7 @@ func genTCPPacket(opts genTCPOpts) *PacketBuffer { packetLen := header.IPv4MinimumSize + uint16(tcpHdrSize) pkt := NewPacketBuffer(PacketBufferOptions{ ReserveHeaderBytes: int(packetLen), - Data: buffer.NewVectorisedView(len(opts.data), []buffer.View{opts.data}), + Payload: buffer.NewWithData(opts.data), }) pkt.NetworkProtocolNumber = header.IPv4ProtocolNumber pkt.TransportProtocolNumber = header.TCPProtocolNumber diff --git a/pkg/tcpip/stack/forwarding_test.go b/pkg/tcpip/stack/forwarding_test.go index e41b638b7..239f1f431 100644 --- a/pkg/tcpip/stack/forwarding_test.go +++ b/pkg/tcpip/stack/forwarding_test.go @@ -20,9 +20,9 @@ import ( "testing" "time" + "gvisor.dev/gvisor/pkg/buffer" "gvisor.dev/gvisor/pkg/sync" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/faketime" "gvisor.dev/gvisor/pkg/tcpip/header" ) @@ -102,10 +102,9 @@ func (f *fwdTestNetworkEndpoint) HandlePacket(pkt *PacketBuffer) { } defer r.Release() - vv := buffer.NewVectorisedView(pkt.Size(), pkt.Views()) pkt = NewPacketBuffer(PacketBufferOptions{ ReserveHeaderBytes: int(r.MaxHeaderLength()), - Data: vv.ToView().ToVectorisedView(), + Payload: pkt.Buffer(), }) // TODO(gvisor.dev/issue/1085) Decrease the TTL field in forwarded packets. _ = r.WriteHeaderIncludedPacket(pkt) @@ -178,7 +177,7 @@ func (*fwdTestNetworkProtocol) MinimumPacketSize() int { return fwdTestNetHeaderLen } -func (*fwdTestNetworkProtocol) ParseAddresses(v buffer.View) (src, dst tcpip.Address) { +func (*fwdTestNetworkProtocol) ParseAddresses(v []byte) (src, dst tcpip.Address) { return tcpip.Address(v[srcAddrOffset : srcAddrOffset+1]), tcpip.Address(v[dstAddrOffset : dstAddrOffset+1]) } @@ -424,10 +423,10 @@ func TestForwardingWithStaticResolver(t *testing.T) { // Inject an inbound packet to address 3 on NIC 1, and see if it is // forwarded to NIC 2. - buf := buffer.NewView(30) + buf := make([]byte, 30) buf[dstAddrOffset] = 3 ep1.InjectInbound(fwdTestNetNumber, NewPacketBuffer(PacketBufferOptions{ - Data: buf.ToVectorisedView(), + Payload: buffer.NewWithData(buf), })) var p *PacketBuffer @@ -468,10 +467,10 @@ func TestForwardingWithFakeResolver(t *testing.T) { // Inject an inbound packet to address 3 on NIC 1, and see if it is // forwarded to NIC 2. - buf := buffer.NewView(30) + buf := make([]byte, 30) buf[dstAddrOffset] = 3 ep1.InjectInbound(fwdTestNetNumber, NewPacketBuffer(PacketBufferOptions{ - Data: buf.ToVectorisedView(), + Payload: buffer.NewWithData(buf), })) var p *PacketBuffer @@ -502,10 +501,10 @@ func TestForwardingWithNoResolver(t *testing.T) { // inject an inbound packet to address 3 on NIC 1, and see if it is // forwarded to NIC 2. - buf := buffer.NewView(30) + buf := make([]byte, 30) buf[dstAddrOffset] = 3 ep1.InjectInbound(fwdTestNetNumber, NewPacketBuffer(PacketBufferOptions{ - Data: buf.ToVectorisedView(), + Payload: buffer.NewWithData(buf), })) clock.Advance(proto.addrResolveDelay) @@ -530,10 +529,10 @@ func TestForwardingResolutionFailsForQueuedPackets(t *testing.T) { // These packets will all be enqueued in the packet queue to wait for link // address resolution. for i := 0; i < numPackets; i++ { - buf := buffer.NewView(30) + buf := make([]byte, 30) buf[dstAddrOffset] = 3 ep1.InjectInbound(fwdTestNetNumber, NewPacketBuffer(PacketBufferOptions{ - Data: buf.ToVectorisedView(), + Payload: buffer.NewWithData(buf), })) } @@ -571,18 +570,18 @@ func TestForwardingWithFakeResolverPartialTimeout(t *testing.T) { // Inject an inbound packet to address 4 on NIC 1. This packet should // not be forwarded. - buf := buffer.NewView(30) + buf := make([]byte, 30) buf[dstAddrOffset] = 4 ep1.InjectInbound(fwdTestNetNumber, NewPacketBuffer(PacketBufferOptions{ - Data: buf.ToVectorisedView(), + Payload: buffer.NewWithData(buf), })) // Inject an inbound packet to address 3 on NIC 1, and see if it is // forwarded to NIC 2. - buf = buffer.NewView(30) + buf = make([]byte, 30) buf[dstAddrOffset] = 3 ep1.InjectInbound(fwdTestNetNumber, NewPacketBuffer(PacketBufferOptions{ - Data: buf.ToVectorisedView(), + Payload: buffer.NewWithData(buf), })) var p *PacketBuffer @@ -627,10 +626,10 @@ func TestForwardingWithFakeResolverTwoPackets(t *testing.T) { // Inject two inbound packets to address 3 on NIC 1. for i := 0; i < 2; i++ { - buf := buffer.NewView(30) + buf := make([]byte, 30) buf[dstAddrOffset] = 3 ep1.InjectInbound(fwdTestNetNumber, NewPacketBuffer(PacketBufferOptions{ - Data: buf.ToVectorisedView(), + Payload: buffer.NewWithData(buf), })) } @@ -678,12 +677,12 @@ func TestForwardingWithFakeResolverManyPackets(t *testing.T) { for i := 0; i < maxPendingPacketsPerResolution+5; i++ { // Inject inbound 'maxPendingPacketsPerResolution + 5' packets on NIC 1. - buf := buffer.NewView(30) + buf := make([]byte, 30) buf[dstAddrOffset] = 3 // Set the packet sequence number. binary.BigEndian.PutUint16(buf[fwdTestNetHeaderLen:], uint16(i)) ep1.InjectInbound(fwdTestNetNumber, NewPacketBuffer(PacketBufferOptions{ - Data: buf.ToVectorisedView(), + Payload: buffer.NewWithData(buf), })) } @@ -745,10 +744,10 @@ func TestForwardingWithFakeResolverManyResolutions(t *testing.T) { // Inject inbound 'maxPendingResolutions + 5' packets on NIC 1. // Each packet has a different destination address (3 to // maxPendingResolutions + 7). - buf := buffer.NewView(30) + buf := make([]byte, 30) buf[dstAddrOffset] = byte(3 + i) ep1.InjectInbound(fwdTestNetNumber, NewPacketBuffer(PacketBufferOptions{ - Data: buf.ToVectorisedView(), + Payload: buffer.NewWithData(buf), })) } diff --git a/pkg/tcpip/stack/iptables_targets.go b/pkg/tcpip/stack/iptables_targets.go index 1af3418e2..cd10746a7 100644 --- a/pkg/tcpip/stack/iptables_targets.go +++ b/pkg/tcpip/stack/iptables_targets.go @@ -303,7 +303,7 @@ func snatAction(pkt *PacketBuffer, hook Hook, r *Route, port uint16, address tcp func natAction(pkt *PacketBuffer, hook Hook, r *Route, portsOrIdents portOrIdentRange, address tcpip.Address, dnat bool) (RuleVerdict, int) { // Drop the packet if network and transport header are not set. - if pkt.NetworkHeader().View().IsEmpty() || pkt.TransportHeader().View().IsEmpty() { + if len(pkt.NetworkHeader().View()) == 0 || len(pkt.TransportHeader().View()) == 0 { return RuleDrop, 0 } diff --git a/pkg/tcpip/stack/ndp_test.go b/pkg/tcpip/stack/ndp_test.go index 7feb49f8e..5ec8150d9 100644 --- a/pkg/tcpip/stack/ndp_test.go +++ b/pkg/tcpip/stack/ndp_test.go @@ -23,9 +23,9 @@ import ( "time" "github.com/google/go-cmp/cmp" + "gvisor.dev/gvisor/pkg/buffer" cryptorand "gvisor.dev/gvisor/pkg/rand" "gvisor.dev/gvisor/pkg/tcpip" - tcpipbuffer "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/checker" "gvisor.dev/gvisor/pkg/tcpip/faketime" "gvisor.dev/gvisor/pkg/tcpip/header" @@ -671,7 +671,7 @@ func rxNDPSolicit(e *channel.Endpoint, tgt tcpip.Address) { SrcAddr: header.IPv6Any, DstAddr: snmc, }) - e.InjectInbound(header.IPv6ProtocolNumber, stack.NewPacketBuffer(stack.PacketBufferOptions{Data: tcpipbuffer.NewViewFromBytes(hdr.View()).ToVectorisedView()})) + e.InjectInbound(header.IPv6ProtocolNumber, stack.NewPacketBuffer(stack.PacketBufferOptions{Payload: buffer.NewWithData(hdr.View())})) } // TestDADFail tests to make sure that the DAD process fails if another node is @@ -723,7 +723,7 @@ func TestDADFail(t *testing.T) { SrcAddr: tgt, DstAddr: header.IPv6AllNodesMulticastAddress, }) - e.InjectInbound(header.IPv6ProtocolNumber, stack.NewPacketBuffer(stack.PacketBufferOptions{Data: tcpipbuffer.NewViewFromBytes(hdr.View()).ToVectorisedView()})) + e.InjectInbound(header.IPv6ProtocolNumber, stack.NewPacketBuffer(stack.PacketBufferOptions{Payload: buffer.NewWithData(hdr.View())})) }, getStat: func(s tcpip.ICMPv6ReceivedPacketStats) *tcpip.StatCounter { return s.NeighborAdvert @@ -1110,7 +1110,7 @@ func raBuf(ip tcpip.Address, rl uint16, managedAddress, otherConfigurations bool }) return stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: tcpipbuffer.NewViewFromBytes(hdr.View()).ToVectorisedView(), + Payload: buffer.NewWithData(hdr.View()), }) } diff --git a/pkg/tcpip/stack/nic.go b/pkg/tcpip/stack/nic.go index c805f74f5..889320477 100644 --- a/pkg/tcpip/stack/nic.go +++ b/pkg/tcpip/stack/nic.go @@ -19,6 +19,7 @@ import ( "reflect" "gvisor.dev/gvisor/pkg/atomicbitops" + "gvisor.dev/gvisor/pkg/buffer" "gvisor.dev/gvisor/pkg/sync" "gvisor.dev/gvisor/pkg/tcpip" "gvisor.dev/gvisor/pkg/tcpip/header" @@ -765,12 +766,12 @@ func (n *nic) DeliverLinkPacket(protocol tcpip.NetworkProtocolNumber, pkt *Packe // overlapping slices (e.g. by passing a shallow copy of pkt to the packet // endpoint). packetEPPkt = NewPacketBuffer(PacketBufferOptions{ - Data: PayloadSince(pkt.LinkHeader()).ToVectorisedView(), + Payload: buffer.NewWithData(PayloadSince(pkt.LinkHeader())), }) // If a link header was populated in the original packet buffer, then // populate it in the packet buffer we provide to packet endpoints as // packet endpoints inspect link headers. - packetEPPkt.LinkHeader().Consume(pkt.LinkHeader().View().Size()) + packetEPPkt.LinkHeader().Consume(len(pkt.LinkHeader().View())) if incoming { packetEPPkt.PktType = tcpip.PacketHost @@ -811,7 +812,7 @@ func (n *nic) DeliverTransportPacket(protocol tcpip.TransportProtocolNumber, pkt transProto := state.proto - if pkt.TransportHeader().View().IsEmpty() { + if len(pkt.TransportHeader().View()) == 0 { n.stats.malformedL4RcvdPackets.Increment() return TransportPacketHandled } @@ -894,7 +895,7 @@ func (n *nic) DeliverRawPacket(protocol tcpip.TransportProtocolNumber, pkt *Pack // For ICMPv4 only we validate the header length for compatibility with // raw(7) ICMP_FILTER. The same check is made in Linux here: // https://github.com/torvalds/linux/blob/70585216/net/ipv4/raw.c#L189. - if protocol == header.ICMPv4ProtocolNumber && pkt.TransportHeader().View().Size()+pkt.Data().Size() < header.ICMPv4MinimumSize { + if protocol == header.ICMPv4ProtocolNumber && len(pkt.TransportHeader().View())+pkt.Data().Size() < header.ICMPv4MinimumSize { return } n.stack.demux.deliverRawPacket(protocol, pkt) diff --git a/pkg/tcpip/stack/nic_test.go b/pkg/tcpip/stack/nic_test.go index f42a32af7..90c017243 100644 --- a/pkg/tcpip/stack/nic_test.go +++ b/pkg/tcpip/stack/nic_test.go @@ -19,8 +19,8 @@ import ( "testing" "gvisor.dev/gvisor/pkg/atomicbitops" + "gvisor.dev/gvisor/pkg/buffer" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/header" "gvisor.dev/gvisor/pkg/tcpip/testutil" ) @@ -123,7 +123,7 @@ func (*testIPv6Protocol) MinimumPacketSize() int { } // ParseAddresses implements NetworkProtocol.ParseAddresses. -func (*testIPv6Protocol) ParseAddresses(v buffer.View) (src, dst tcpip.Address) { +func (*testIPv6Protocol) ParseAddresses(v []byte) (src, dst tcpip.Address) { h := header.IPv6(v) return h.SourceAddress(), h.DestinationAddress() } @@ -184,7 +184,7 @@ func TestDisabledRxStatsWhenNICDisabled(t *testing.T) { } nic.DeliverNetworkPacket(0, NewPacketBuffer(PacketBufferOptions{ - Data: buffer.View([]byte{1, 2, 3, 4}).ToVectorisedView(), + Payload: buffer.NewWithData([]byte{1, 2, 3, 4}), })) if got := nic.stats.local.DisabledRx.Packets.Value(); got != 1 { @@ -209,7 +209,7 @@ func TestPacketWithUnknownNetworkProtocolNumber(t *testing.T) { // IPv4 isn't recognized since we haven't initialized the NIC with an IPv4 // endpoint. nic.DeliverNetworkPacket(header.IPv4ProtocolNumber, NewPacketBuffer(PacketBufferOptions{ - Data: buffer.View([]byte{1, 2, 3, 4}).ToVectorisedView(), + Payload: buffer.NewWithData([]byte{1, 2, 3, 4}), })) var count uint64 if got, ok := nic.stats.local.UnknownL3ProtocolRcvdPacketCounts.Get(uint64(header.IPv4ProtocolNumber)); ok { @@ -229,7 +229,7 @@ func TestPacketWithUnknownTransportProtocolNumber(t *testing.T) { // UDP isn't recognized since we haven't initialized the NIC with a UDP // protocol. nic.DeliverTransportPacket(header.UDPProtocolNumber, NewPacketBuffer(PacketBufferOptions{ - Data: buffer.View([]byte{1, 2, 3, 4}).ToVectorisedView(), + Payload: buffer.NewWithData([]byte{1, 2, 3, 4}), })) var count uint64 if got, ok := nic.stats.local.UnknownL4ProtocolRcvdPacketCounts.Get(uint64(header.UDPProtocolNumber)); ok { diff --git a/pkg/tcpip/stack/packet_buffer.go b/pkg/tcpip/stack/packet_buffer.go index dd7eff877..d1613c6c1 100644 --- a/pkg/tcpip/stack/packet_buffer.go +++ b/pkg/tcpip/stack/packet_buffer.go @@ -20,7 +20,6 @@ import ( "gvisor.dev/gvisor/pkg/buffer" "gvisor.dev/gvisor/pkg/sync" "gvisor.dev/gvisor/pkg/tcpip" - tcpipbuffer "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/header" ) @@ -41,20 +40,13 @@ var pkPool = sync.Pool{ } // PacketBufferOptions specifies options for PacketBuffer creation. -// TODO(b/230896518): Convert PacketBufferOptions.Data to be a buffer.Buffer -// instead of a VectorisedView and remove Payload. type PacketBufferOptions struct { // ReserveHeaderBytes is the number of bytes to reserve for headers. Total // number of bytes pushed onto the headers must not exceed this value. ReserveHeaderBytes int - // Data is the initial unparsed data for the new packet. If set, it will be - // owned by the new packet. If Data is set, Payload must be unset. - // Deprecated: Use Payload instead. - Data tcpipbuffer.VectorisedView - // Payload is the initial unparsed data for the new packet. If set, it will - // be owned by the new packet. If Payload is set, Data must be unset. + // be owned by the new packet. Payload buffer.Buffer // IsForwardedPacket identifies that the PacketBuffer being created is for a @@ -185,14 +177,8 @@ func NewPacketBuffer(opts PacketBufferOptions) *PacketBuffer { pk.reserved = opts.ReserveHeaderBytes } if opts.Payload.Size() > 0 { - if len(opts.Data.Views()) != 0 { - panic("opts.Data must not be set if using Payload") - } pk.buf.Merge(&opts.Payload) } - for _, v := range opts.Data.Views() { - pk.buf.AppendOwned(v) - } pk.NetworkPacketInfo.IsForwardedPacket = opts.IsForwardedPacket pk.onRelease = opts.OnRelease pk.InitRefs() @@ -287,17 +273,6 @@ func (pk *PacketBuffer) Data() PacketData { return PacketData{pk: pk} } -// Views returns the underlying storage of the whole packet. -// TODO(b/230896518): Remove this. -func (pk *PacketBuffer) Views() []tcpipbuffer.View { - var views []tcpipbuffer.View - offset := pk.headerOffset() - pk.buf.SubApply(offset, int(pk.buf.Size())-offset, func(v []byte) { - views = append(views, v) - }) - return views -} - // Slices returns the underlying storage of the whole packet. func (pk *PacketBuffer) Slices() [][]byte { var views [][]byte @@ -327,7 +302,7 @@ func (pk *PacketBuffer) dataOffset() int { return pk.reserved + pk.consumed } -func (pk *PacketBuffer) push(typ headerType, size int) tcpipbuffer.View { +func (pk *PacketBuffer) push(typ headerType, size int) []byte { h := &pk.headers[typ] if h.length > 0 { panic(fmt.Sprintf("push(%s, %d) called after previous push", typ, size)) @@ -341,7 +316,7 @@ func (pk *PacketBuffer) push(typ headerType, size int) tcpipbuffer.View { return pk.headerView(typ) } -func (pk *PacketBuffer) consume(typ headerType, size int) (v tcpipbuffer.View, consumed bool) { +func (pk *PacketBuffer) consume(typ headerType, size int) (v []byte, consumed bool) { h := &pk.headers[typ] if h.length > 0 { panic(fmt.Sprintf("consume must not be called twice: type %s", typ)) @@ -355,7 +330,7 @@ func (pk *PacketBuffer) consume(typ headerType, size int) (v tcpipbuffer.View, c return pk.headerView(typ), true } -func (pk *PacketBuffer) headerView(typ headerType) tcpipbuffer.View { +func (pk *PacketBuffer) headerView(typ headerType) []byte { h := &pk.headers[typ] if h.length == 0 { return nil @@ -441,12 +416,12 @@ func (pk *PacketBuffer) CloneToInbound() *PacketBuffer { func (pk *PacketBuffer) DeepCopyForForwarding(reservedHeaderBytes int) *PacketBuffer { newPk := NewPacketBuffer(PacketBufferOptions{ ReserveHeaderBytes: reservedHeaderBytes, - Data: PayloadSince(pk.NetworkHeader()).ToVectorisedView(), + Payload: buffer.NewWithData(PayloadSince(pk.NetworkHeader())), IsForwardedPacket: true, }) { - consumeBytes := pk.NetworkHeader().View().Size() + consumeBytes := len(pk.NetworkHeader().View()) if _, consumed := newPk.NetworkHeader().Consume(consumeBytes); !consumed { panic(fmt.Sprintf("expected to consume network header %d bytes from new packet", consumeBytes)) } @@ -454,7 +429,7 @@ func (pk *PacketBuffer) DeepCopyForForwarding(reservedHeaderBytes int) *PacketBu } { - consumeBytes := pk.TransportHeader().View().Size() + consumeBytes := len(pk.TransportHeader().View()) if _, consumed := newPk.TransportHeader().Consume(consumeBytes); !consumed { panic(fmt.Sprintf("expected to consume transport header %d bytes from new packet", consumeBytes)) } @@ -485,14 +460,14 @@ type PacketHeader struct { } // View returns the underlying storage of h. -func (h PacketHeader) View() tcpipbuffer.View { +func (h PacketHeader) View() []byte { return h.pk.headerView(h.typ) } // Push pushes size bytes in the front of its residing packet, and returns the // backing storage. Callers may only call one of Push or Consume once on each // header in the lifetime of the underlying packet. -func (h PacketHeader) Push(size int) tcpipbuffer.View { +func (h PacketHeader) Push(size int) []byte { return h.pk.push(h.typ, size) } @@ -501,7 +476,7 @@ func (h PacketHeader) Push(size int) tcpipbuffer.View { // size, consumed will be false, and the state of h will not be affected. // Callers may only call one of Push or Consume once on each header in the // lifetime of the underlying packet. -func (h PacketHeader) Consume(size int) (v tcpipbuffer.View, consumed bool) { +func (h PacketHeader) Consume(size int) (v []byte, consumed bool) { return h.pk.consume(h.typ, size) } @@ -514,13 +489,13 @@ type PacketData struct { // PullUp returns a contiguous view of size bytes from the beginning of d. // Callers should not write to or keep the view for later use. -func (d PacketData) PullUp(size int) (tcpipbuffer.View, bool) { +func (d PacketData) PullUp(size int) ([]byte, bool) { return d.pk.buf.PullUp(d.pk.dataOffset(), size) } // Consume is the same as PullUp except that is additionally consumes the // returned bytes. Subsequent PullUp or Consume will not return these bytes. -func (d PacketData) Consume(size int) (tcpipbuffer.View, bool) { +func (d PacketData) Consume(size int) ([]byte, bool) { v, ok := d.PullUp(size) if ok { d.pk.consumed += size @@ -533,7 +508,7 @@ func (d PacketData) Consume(size int) (tcpipbuffer.View, bool) { func (d PacketData) ReadTo(dst io.Writer, peek bool) (int, error) { var err error done := 0 - for _, v := range d.Views() { + for _, v := range d.Slices() { var n int n, err = dst.Write(v) done += n @@ -561,10 +536,10 @@ func (d PacketData) CapLength(length int) { } } -// Views returns the underlying storage of d in a slice of Views. Caller should +// Slices returns the underlying storage of d in a slice of Views. Caller should // not modify the returned slice. -func (d PacketData) Views() []tcpipbuffer.View { - var views []tcpipbuffer.View +func (d PacketData) Slices() [][]byte { + var views [][]byte offset := d.pk.dataOffset() d.pk.buf.SubApply(offset, int(d.pk.buf.Size())-offset, func(v []byte) { views = append(views, v) @@ -582,7 +557,7 @@ func (d PacketData) AsBuffer() buffer.Buffer { } // AppendView appends v into d, taking the ownership of v. -func (d PacketData) AppendView(v tcpipbuffer.View) { +func (d PacketData) AppendView(v []byte) { d.pk.buf.AppendOwned(v) } @@ -598,27 +573,6 @@ func MergeFragment(dst, frag *PacketBuffer) { dst.buf.Merge(&frag.buf) } -// ReadFromVV moves at most count bytes from the beginning of srcVV to the end -// of d and returns the number of bytes moved. -func (d PacketData) ReadFromVV(srcVV *tcpipbuffer.VectorisedView, count int) int { - done := 0 - for _, v := range srcVV.Views() { - if len(v) < count { - count -= len(v) - done += len(v) - d.pk.buf.AppendOwned(v) - } else { - v = v[:count] - count -= len(v) - done += len(v) - d.pk.buf.Append(v) - break - } - } - srcVV.TrimFront(done) - return done -} - // ReadFromBuffer moves at most count bytes from the beginning of src to the end // of d and returns the number of bytes moved. func (d PacketData) ReadFromBuffer(src *buffer.Buffer, count int) int { @@ -650,7 +604,7 @@ func (d PacketData) Merge(oth PacketData) { // of d. func (d PacketData) ReadFrom(src PacketData, count int) { done := 0 - for _, v := range src.Views() { + for _, v := range src.Slices() { if len(v) < count { count -= len(v) done += len(v) @@ -691,19 +645,6 @@ func (d PacketData) AsRange() Range { } } -// ExtractVV returns a VectorisedView of d. This method has the semantic to -// destruct the underlying packet, hence the packet cannot be used again. -// -// This method exists for compatibility between PacketBuffer and VectorisedView. -// It may be removed later and should be used with care. -func (d PacketData) ExtractVV() tcpipbuffer.VectorisedView { - var vv tcpipbuffer.VectorisedView - d.pk.buf.SubApply(d.pk.dataOffset(), d.pk.Size(), func(v []byte) { - vv.AppendView(v) - }) - return vv -} - // Range represents a contiguous subportion of a PacketBuffer. type Range struct { pk *PacketBuffer @@ -745,9 +686,9 @@ func (r Range) Capped(max int) Range { // AsView returns the backing storage of r if possible. It will allocate a new // View if r spans multiple pieces internally. Caller should not write to the // returned View in any way. -func (r Range) AsView() tcpipbuffer.View { +func (r Range) AsView() []byte { var allocated bool - var v tcpipbuffer.View + var v []byte r.iterate(func(b []byte) { if v == nil { // v has not been assigned, allowing first view to be returned. @@ -797,7 +738,7 @@ func (r Range) iterate(fn func([]byte)) { // // The returned View is owned by the caller - its backing buffer is separate // from the packet header's underlying packet buffer. -func PayloadSince(h PacketHeader) tcpipbuffer.View { +func PayloadSince(h PacketHeader) []byte { offset := h.pk.headerOffset() for i := headerType(0); i < h.typ; i++ { offset += h.pk.headers[i].length diff --git a/pkg/tcpip/stack/packet_buffer_test.go b/pkg/tcpip/stack/packet_buffer_test.go index a142bf96b..233fa166e 100644 --- a/pkg/tcpip/stack/packet_buffer_test.go +++ b/pkg/tcpip/stack/packet_buffer_test.go @@ -19,7 +19,6 @@ import ( "testing" "gvisor.dev/gvisor/pkg/buffer" - tcpipbuffer "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/header" ) @@ -78,7 +77,7 @@ func TestPacketHeaderPush(t *testing.T) { ReserveHeaderBytes: test.reserved, // Make a copy of data to make sure our truth data won't be taint by // PacketBuffer. - Data: tcpipbuffer.NewViewFromBytes(test.data).ToVectorisedView(), + Payload: buffer.NewWithData(test.data), }) allHdrSize := len(test.link) + len(test.network) + len(test.transport) @@ -86,7 +85,7 @@ func TestPacketHeaderPush(t *testing.T) { // Check the initial values for packet. checkInitialPacketBuffer(t, pk, PacketBufferOptions{ ReserveHeaderBytes: test.reserved, - Data: tcpipbuffer.View(test.data).ToVectorisedView(), + Payload: buffer.NewWithData(test.data), }) // Push headers. @@ -150,12 +149,12 @@ func TestPacketHeaderConsume(t *testing.T) { pk := NewPacketBuffer(PacketBufferOptions{ // Make a copy of data to make sure our truth data won't be taint by // PacketBuffer. - Data: tcpipbuffer.NewViewFromBytes(test.data).ToVectorisedView(), + Payload: buffer.NewWithData(test.data), }) // Check the initial values for packet. checkInitialPacketBuffer(t, pk, PacketBufferOptions{ - Data: tcpipbuffer.View(test.data).ToVectorisedView(), + Payload: buffer.NewWithData(test.data), }) // Consume headers. @@ -207,7 +206,7 @@ func TestPacketHeaderConsumeDataTooShort(t *testing.T) { pk := NewPacketBuffer(PacketBufferOptions{ // Make a copy of data to make sure our truth data won't be taint by // PacketBuffer. - Data: tcpipbuffer.NewViewFromBytes(data).ToVectorisedView(), + Payload: buffer.NewWithData(data), }) // Consume should fail if pkt.Data is too short. @@ -223,7 +222,7 @@ func TestPacketHeaderConsumeDataTooShort(t *testing.T) { // Check packet should look the same as initial packet. checkInitialPacketBuffer(t, pk, PacketBufferOptions{ - Data: tcpipbuffer.View(data).ToVectorisedView(), + Payload: buffer.NewWithData(data), }) } @@ -240,7 +239,7 @@ func TestPacketHeaderPushConsumeMixed(t *testing.T) { initData = append(initData, data...) pk := NewPacketBuffer(PacketBufferOptions{ ReserveHeaderBytes: len(link), - Data: tcpipbuffer.NewViewFromBytes(initData).ToVectorisedView(), + Payload: buffer.NewWithData(initData), }) // 1. Consume network header @@ -268,7 +267,7 @@ func TestPacketHeaderPushConsumeMixedTooLong(t *testing.T) { initData := concatViews(network, data) pk := NewPacketBuffer(PacketBufferOptions{ ReserveHeaderBytes: len(link), - Data: tcpipbuffer.NewViewFromBytes(initData).ToVectorisedView(), + Payload: buffer.NewWithData(initData), }) // 1. Push link header @@ -317,7 +316,7 @@ func TestPacketHeaderConsumeCalledAtMostOnce(t *testing.T) { const headerSize = 10 pk := NewPacketBuffer(PacketBufferOptions{ - Data: makeView(headerSize * int(numHeaderType)).ToVectorisedView(), + Payload: buffer.NewWithData(make([]byte, headerSize*int(numHeaderType))), }) for _, h := range []PacketHeader{ @@ -374,7 +373,7 @@ func TestPacketHeaderConsumeThenPushPanics(t *testing.T) { const headerSize = 10 pk := NewPacketBuffer(PacketBufferOptions{ - Data: makeView(headerSize * int(numHeaderType)).ToVectorisedView(), + Payload: buffer.NewWithData(make([]byte, headerSize*int(numHeaderType))), }) for _, h := range []PacketHeader{ @@ -402,7 +401,7 @@ func TestPacketBufferData(t *testing.T) { name: "inbound packet", makePkt: func(*testing.T) *PacketBuffer { pkt := NewPacketBuffer(PacketBufferOptions{ - Data: vv("aabbbbccccccDATA"), + Payload: buf("aabbbbccccccDATA"), }) pkt.LinkHeader().Consume(2) pkt.NetworkHeader().Consume(4) @@ -416,7 +415,7 @@ func TestPacketBufferData(t *testing.T) { makePkt: func(*testing.T) *PacketBuffer { pkt := NewPacketBuffer(PacketBufferOptions{ ReserveHeaderBytes: 12, - Data: vv("DATA"), + Payload: buf("DATA"), }) copy(pkt.TransportHeader().Push(6), []byte("cccccc")) copy(pkt.NetworkHeader().Push(4), []byte("bbbb")) @@ -495,42 +494,11 @@ func TestPacketBufferData(t *testing.T) { s := "APPEND" pkt := tc.makePkt(t) - pkt.Data().AppendView(tcpipbuffer.View(s)) + pkt.Data().AppendView([]byte(s)) checkData(t, pkt, []byte(tc.data+s)) }) - // ReadFromVV - t.Run("ReadFromVV", func(t *testing.T) { - for _, n := range []int{0, 1, 2, 7, 10, 14, 20} { - t.Run(fmt.Sprintf("%dbytes", n), func(t *testing.T) { - s := "TO READ" - srcVV := vv(s, s) - s += s - - pkt := tc.makePkt(t) - pkt.Data().ReadFromVV(&srcVV, n) - - if n < len(s) { - s = s[:n] - } - checkData(t, pkt, []byte(tc.data+s)) - }) - } - }) - - // ExtractVV - t.Run("ExtractVV", func(t *testing.T) { - pkt := tc.makePkt(t) - extractedVV := pkt.Data().ExtractVV() - - got := extractedVV.ToOwnedView() - want := []byte(tc.data) - if !bytes.Equal(got, want) { - t.Errorf("pkt.Data().ExtractVV().ToOwnedView() = %q, want %q", got, want) - } - }) - t.Run("AppendRange", func(t *testing.T) { pkt1 := tc.makePkt(t) pkt2 := tc.makePkt(t) @@ -605,10 +573,10 @@ func TestPacketBufferData(t *testing.T) { } type packetContents struct { - link tcpipbuffer.View - network tcpipbuffer.View - transport tcpipbuffer.View - data tcpipbuffer.View + link []byte + network []byte + transport []byte + data []byte } func checkPacketContents(t *testing.T, prefix string, pk *PacketBuffer, want packetContents) { @@ -620,8 +588,8 @@ func checkPacketContents(t *testing.T, prefix string, pk *PacketBuffer, want pac // Data. checkData(t, pk, want.data) // Whole packet. - checkViewEqual(t, prefix+"pk.Views()", - concatViews(pk.Views()...), + checkViewEqual(t, prefix+"pk.Slices()", + concatViews(pk.Slices()...), concatViews(want.link, want.network, want.transport, want.data)) // PayloadSince. checkViewEqual(t, prefix+"PayloadSince(LinkHeader)", @@ -647,7 +615,7 @@ func checkInitialPacketBuffer(t *testing.T, pk *PacketBuffer, opts PacketBufferO if got, want := pk.HeaderSize(), 0; got != want { t.Errorf("Initial pk.HeaderSize() = %d, want %d", got, want) } - data := opts.Data.ToView() + data := opts.Payload.Flatten() if got, want := pk.Size(), len(data); got != want { t.Errorf("Initial pk.Size() = %d, want %d", got, want) } @@ -661,7 +629,7 @@ func checkPacketHeader(t *testing.T, name string, h PacketHeader, want []byte) { checkViewEqual(t, name+".View()", h.View(), want) } -func checkViewEqual(t *testing.T, what string, got, want tcpipbuffer.View) { +func checkViewEqual(t *testing.T, what string, got, want []byte) { t.Helper() if !bytes.Equal(got, want) { t.Errorf("%s = %x, want %x", what, got, want) @@ -670,7 +638,7 @@ func checkViewEqual(t *testing.T, what string, got, want tcpipbuffer.View) { func checkData(t *testing.T, pkt *PacketBuffer, want []byte) { t.Helper() - if got := concatViews(pkt.Data().Views()...); !bytes.Equal(got, want) { + if got := concatViews(pkt.Data().Slices()...); !bytes.Equal(got, want) { t.Errorf("pkt.Data().Views() = 0x%x, want 0x%x", got, want) } if got := pkt.Data().Size(); got != len(want) { @@ -721,24 +689,21 @@ func checkRange(t *testing.T, r Range, data []byte) { } } -func vv(pieces ...string) tcpipbuffer.VectorisedView { - var views []tcpipbuffer.View - var size int +func buf(pieces ...string) buffer.Buffer { + b := buffer.Buffer{} for _, p := range pieces { - v := tcpipbuffer.View([]byte(p)) - size += len(v) - views = append(views, v) + b.AppendOwned([]byte(p)) } - return tcpipbuffer.NewVectorisedView(size, views) + return b } -func makeView(size int) tcpipbuffer.View { +func makeView(size int) []byte { b := byte(size) return bytes.Repeat([]byte{b}, size) } -func concatViews(views ...tcpipbuffer.View) tcpipbuffer.View { - var all tcpipbuffer.View +func concatViews(views ...[]byte) []byte { + var all []byte for _, v := range views { all = append(all, v...) } diff --git a/pkg/tcpip/stack/registration.go b/pkg/tcpip/stack/registration.go index f3b22f206..a08d1c899 100644 --- a/pkg/tcpip/stack/registration.go +++ b/pkg/tcpip/stack/registration.go @@ -19,7 +19,6 @@ import ( "time" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/header" "gvisor.dev/gvisor/pkg/waiter" ) @@ -198,7 +197,7 @@ type TransportProtocol interface { // ParsePorts returns the source and destination ports stored in a // packet of this protocol. - ParsePorts(v buffer.View) (src, dst uint16, err tcpip.Error) + ParsePorts(v []byte) (src, dst uint16, err tcpip.Error) // HandleUnknownDestinationPacket handles packets targeted at this // protocol that don't match any existing endpoint. For example, @@ -726,7 +725,7 @@ type NetworkProtocol interface { // ParseAddresses returns the source and destination addresses stored in a // packet of this protocol. - ParseAddresses(v buffer.View) (src, dst tcpip.Address) + ParseAddresses(v []byte) (src, dst tcpip.Address) // NewEndpoint creates a new endpoint of this protocol. NewEndpoint(nic NetworkInterface, dispatcher TransportDispatcher) NetworkEndpoint diff --git a/pkg/tcpip/stack/stack.go b/pkg/tcpip/stack/stack.go index 67659f57f..7836934da 100644 --- a/pkg/tcpip/stack/stack.go +++ b/pkg/tcpip/stack/stack.go @@ -29,10 +29,10 @@ import ( "golang.org/x/time/rate" "gvisor.dev/gvisor/pkg/atomicbitops" + "gvisor.dev/gvisor/pkg/buffer" cryptorand "gvisor.dev/gvisor/pkg/rand" "gvisor.dev/gvisor/pkg/sync" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/header" "gvisor.dev/gvisor/pkg/tcpip/ports" "gvisor.dev/gvisor/pkg/waiter" @@ -1757,7 +1757,7 @@ func (s *Stack) unregisterPacketEndpointLocked(nicID tcpip.NICID, netProto tcpip // WritePacketToRemote writes a payload on the specified NIC using the provided // network protocol and remote link address. -func (s *Stack) WritePacketToRemote(nicID tcpip.NICID, remote tcpip.LinkAddress, netProto tcpip.NetworkProtocolNumber, payload buffer.VectorisedView) tcpip.Error { +func (s *Stack) WritePacketToRemote(nicID tcpip.NICID, remote tcpip.LinkAddress, netProto tcpip.NetworkProtocolNumber, payload buffer.Buffer) tcpip.Error { s.mu.Lock() nic, ok := s.nics[nicID] s.mu.Unlock() @@ -1766,7 +1766,7 @@ func (s *Stack) WritePacketToRemote(nicID tcpip.NICID, remote tcpip.LinkAddress, } pkt := NewPacketBuffer(PacketBufferOptions{ ReserveHeaderBytes: int(nic.MaxHeaderLength()), - Data: payload, + Payload: payload, }) defer pkt.DecRef() pkt.NetworkProtocolNumber = netProto @@ -1775,7 +1775,7 @@ func (s *Stack) WritePacketToRemote(nicID tcpip.NICID, remote tcpip.LinkAddress, // WriteRawPacket writes data directly to the specified NIC without adding any // headers. -func (s *Stack) WriteRawPacket(nicID tcpip.NICID, proto tcpip.NetworkProtocolNumber, payload buffer.VectorisedView) tcpip.Error { +func (s *Stack) WriteRawPacket(nicID tcpip.NICID, proto tcpip.NetworkProtocolNumber, payload buffer.Buffer) tcpip.Error { s.mu.RLock() nic, ok := s.nics[nicID] s.mu.RUnlock() @@ -1784,7 +1784,7 @@ func (s *Stack) WriteRawPacket(nicID tcpip.NICID, proto tcpip.NetworkProtocolNum } pkt := NewPacketBuffer(PacketBufferOptions{ - Data: payload, + Payload: payload, }) defer pkt.DecRef() pkt.NetworkProtocolNumber = proto diff --git a/pkg/tcpip/stack/stack_test.go b/pkg/tcpip/stack/stack_test.go index bf7acbffa..f04c93557 100644 --- a/pkg/tcpip/stack/stack_test.go +++ b/pkg/tcpip/stack/stack_test.go @@ -28,10 +28,10 @@ import ( "github.com/google/go-cmp/cmp" "github.com/google/go-cmp/cmp/cmpopts" + "gvisor.dev/gvisor/pkg/buffer" "gvisor.dev/gvisor/pkg/rand" "gvisor.dev/gvisor/pkg/sync" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/faketime" "gvisor.dev/gvisor/pkg/tcpip/header" "gvisor.dev/gvisor/pkg/tcpip/link/channel" @@ -258,7 +258,7 @@ func (f *fakeNetworkProtocol) PacketCount(intfAddr byte) int { return f.packetCount[int(intfAddr)%len(f.packetCount)] } -func (*fakeNetworkProtocol) ParseAddresses(v buffer.View) (src, dst tcpip.Address) { +func (*fakeNetworkProtocol) ParseAddresses(v []byte) (src, dst tcpip.Address) { return tcpip.Address(v[srcAddrOffset : srcAddrOffset+1]), tcpip.Address(v[dstAddrOffset : dstAddrOffset+1]) } @@ -428,12 +428,12 @@ func TestNetworkReceive(t *testing.T) { fakeNet := s.NetworkProtocolInstance(fakeNetNumber).(*fakeNetworkProtocol) - buf := buffer.NewView(30) + buf := make([]byte, 30) // Make sure packet with wrong address is not delivered. buf[dstAddrOffset] = 3 ep.InjectInbound(fakeNetNumber, stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: buf.ToVectorisedView(), + Payload: buffer.NewWithData(buf), })) if fakeNet.packetCount[1] != 0 { t.Errorf("packetCount[1] = %d, want %d", fakeNet.packetCount[1], 0) @@ -445,7 +445,7 @@ func TestNetworkReceive(t *testing.T) { // Make sure packet is delivered to first endpoint. buf[dstAddrOffset] = 1 ep.InjectInbound(fakeNetNumber, stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: buf.ToVectorisedView(), + Payload: buffer.NewWithData(buf), })) if fakeNet.packetCount[1] != 1 { t.Errorf("packetCount[1] = %d, want %d", fakeNet.packetCount[1], 1) @@ -457,7 +457,7 @@ func TestNetworkReceive(t *testing.T) { // Make sure packet is delivered to second endpoint. buf[dstAddrOffset] = 2 ep.InjectInbound(fakeNetNumber, stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: buf.ToVectorisedView(), + Payload: buffer.NewWithData(buf), })) if fakeNet.packetCount[1] != 1 { t.Errorf("packetCount[1] = %d, want %d", fakeNet.packetCount[1], 1) @@ -468,7 +468,7 @@ func TestNetworkReceive(t *testing.T) { // Make sure packet is not delivered if protocol number is wrong. ep.InjectInbound(fakeNetNumber-1, stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: buf.ToVectorisedView(), + Payload: buffer.NewWithData(buf), })) if fakeNet.packetCount[1] != 1 { t.Errorf("packetCount[1] = %d, want %d", fakeNet.packetCount[1], 1) @@ -478,9 +478,9 @@ func TestNetworkReceive(t *testing.T) { } // Make sure packet that is too small is dropped. - buf.CapLength(2) + buf = buf[:2] ep.InjectInbound(fakeNetNumber, stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: buf.ToVectorisedView(), + Payload: buffer.NewWithData(buf), })) if fakeNet.packetCount[1] != 1 { t.Errorf("packetCount[1] = %d, want %d", fakeNet.packetCount[1], 1) @@ -490,7 +490,7 @@ func TestNetworkReceive(t *testing.T) { } } -func sendTo(s *stack.Stack, addr tcpip.Address, payload buffer.View) tcpip.Error { +func sendTo(s *stack.Stack, addr tcpip.Address, payload []byte) tcpip.Error { r, err := s.FindRoute(0, "", addr, fakeNetNumber, false /* multicastLoop */) if err != nil { return err @@ -499,14 +499,14 @@ func sendTo(s *stack.Stack, addr tcpip.Address, payload buffer.View) tcpip.Error return send(r, payload) } -func send(r *stack.Route, payload buffer.View) tcpip.Error { +func send(r *stack.Route, payload []byte) tcpip.Error { return r.WritePacket(stack.NetworkHeaderParams{Protocol: fakeTransNumber, TTL: 123, TOS: stack.DefaultTOS}, stack.NewPacketBuffer(stack.PacketBufferOptions{ ReserveHeaderBytes: int(r.MaxHeaderLength()), - Data: payload.ToVectorisedView(), + Payload: buffer.NewWithData(payload), })) } -func testSendTo(t *testing.T, s *stack.Stack, addr tcpip.Address, ep *channel.Endpoint, payload buffer.View) { +func testSendTo(t *testing.T, s *stack.Stack, addr tcpip.Address, ep *channel.Endpoint, payload []byte) { t.Helper() ep.Drain() if err := sendTo(s, addr, payload); err != nil { @@ -517,7 +517,7 @@ func testSendTo(t *testing.T, s *stack.Stack, addr tcpip.Address, ep *channel.En } } -func testSend(t *testing.T, r *stack.Route, ep *channel.Endpoint, payload buffer.View) { +func testSend(t *testing.T, r *stack.Route, ep *channel.Endpoint, payload []byte) { t.Helper() ep.Drain() if err := send(r, payload); err != nil { @@ -528,38 +528,38 @@ func testSend(t *testing.T, r *stack.Route, ep *channel.Endpoint, payload buffer } } -func testFailingSend(t *testing.T, r *stack.Route, payload buffer.View, wantErr tcpip.Error) { +func testFailingSend(t *testing.T, r *stack.Route, payload []byte, wantErr tcpip.Error) { t.Helper() if gotErr := send(r, payload); gotErr != wantErr { t.Errorf("send failed: got = %s, want = %s ", gotErr, wantErr) } } -func testFailingSendTo(t *testing.T, s *stack.Stack, addr tcpip.Address, payload buffer.View, wantErr tcpip.Error) { +func testFailingSendTo(t *testing.T, s *stack.Stack, addr tcpip.Address, payload []byte, wantErr tcpip.Error) { t.Helper() if gotErr := sendTo(s, addr, payload); gotErr != wantErr { t.Errorf("sendto failed: got = %s, want = %s ", gotErr, wantErr) } } -func testRecv(t *testing.T, fakeNet *fakeNetworkProtocol, localAddrByte byte, ep *channel.Endpoint, buf buffer.View) { +func testRecv(t *testing.T, fakeNet *fakeNetworkProtocol, localAddrByte byte, ep *channel.Endpoint, buf []byte) { t.Helper() // testRecvInternal injects one packet, and we expect to receive it. want := fakeNet.PacketCount(localAddrByte) + 1 testRecvInternal(t, fakeNet, localAddrByte, ep, buf, want) } -func testFailingRecv(t *testing.T, fakeNet *fakeNetworkProtocol, localAddrByte byte, ep *channel.Endpoint, buf buffer.View) { +func testFailingRecv(t *testing.T, fakeNet *fakeNetworkProtocol, localAddrByte byte, ep *channel.Endpoint, buf []byte) { t.Helper() // testRecvInternal injects one packet, and we do NOT expect to receive it. want := fakeNet.PacketCount(localAddrByte) testRecvInternal(t, fakeNet, localAddrByte, ep, buf, want) } -func testRecvInternal(t *testing.T, fakeNet *fakeNetworkProtocol, localAddrByte byte, ep *channel.Endpoint, buf buffer.View, want int) { +func testRecvInternal(t *testing.T, fakeNet *fakeNetworkProtocol, localAddrByte byte, ep *channel.Endpoint, buf []byte, want int) { t.Helper() ep.InjectInbound(fakeNetNumber, stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: buf.ToVectorisedView(), + Payload: buffer.NewWithData(buf), })) if got := fakeNet.PacketCount(localAddrByte); got != want { t.Errorf("receive packet count: got = %d, want %d", got, want) @@ -1047,7 +1047,7 @@ func TestRouteWithDownNIC(t *testing.T) { t.FailNow() } - buf := buffer.View([]byte{1}) + buf := []byte{1} testSend(t, r1, ep1, buf) testSend(t, r2, ep2, buf) @@ -1224,7 +1224,7 @@ func TestAddressRemoval(t *testing.T) { fakeNet := s.NetworkProtocolInstance(fakeNetNumber).(*fakeNetworkProtocol) - buf := buffer.NewView(30) + buf := make([]byte, 30) // Send and receive packets, and verify they are received. buf[dstAddrOffset] = localAddrByte @@ -1259,7 +1259,7 @@ func TestAddressRemovalWithRouteHeld(t *testing.T) { t.Fatalf("CreateNIC failed: %v", err) } fakeNet := s.NetworkProtocolInstance(fakeNetNumber).(*fakeNetworkProtocol) - buf := buffer.NewView(30) + buf := make([]byte, 30) protocolAddr := tcpip.ProtocolAddress{ Protocol: fakeNetNumber, @@ -1369,7 +1369,7 @@ func TestEndpointExpiration(t *testing.T) { } fakeNet := s.NetworkProtocolInstance(fakeNetNumber).(*fakeNetworkProtocol) - buf := buffer.NewView(30) + buf := make([]byte, 30) buf[dstAddrOffset] = localAddrByte if promiscuous { @@ -1535,7 +1535,7 @@ func TestPromiscuousMode(t *testing.T) { fakeNet := s.NetworkProtocolInstance(fakeNetNumber).(*fakeNetworkProtocol) - buf := buffer.NewView(30) + buf := make([]byte, 30) // Write a packet, and check that it doesn't get delivered as we don't // have a matching endpoint. @@ -1657,7 +1657,7 @@ func TestExternalSendWithHandleLocal(t *testing.T) { TOS: stack.DefaultTOS, }, stack.NewPacketBuffer(stack.PacketBufferOptions{ ReserveHeaderBytes: int(r.MaxHeaderLength()), - Data: buffer.NewView(10).ToVectorisedView(), + Payload: buffer.NewWithData(make([]byte, 10)), })); err != nil { t.Fatalf("r.WritePacket(nil, _, _): %s", err) } @@ -2429,9 +2429,9 @@ func TestNICStats(t *testing.T) { nicStats := s.NICInfo()[nicid].Stats // Inbound packet. - rxBuffer := buffer.NewView(nic.rxByteCount) + rxBuffer := make([]byte, nic.rxByteCount) ep.InjectInbound(fakeNetNumber, stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: rxBuffer.ToVectorisedView(), + Payload: buffer.NewWithData(rxBuffer), })) if got, want := nicStats.Rx.Packets.Value(), uint64(1); got != want { t.Errorf("got Rx.Packets.Value() = %d, want = %d", got, want) @@ -2443,7 +2443,7 @@ func TestNICStats(t *testing.T) { rxBytesTotal += nic.rxByteCount // Outbound packet. - txBuffer := buffer.NewView(nic.txByteCount) + txBuffer := make([]byte, nic.txByteCount) actualTxLength := nic.txByteCount + fakeNetHeaderLen if err := sendTo(s, nic.addr, txBuffer); err != nil { t.Fatal("sendTo failed: ", err) @@ -4649,7 +4649,7 @@ func TestFindRouteWithForwarding(t *testing.T) { // Sending a packet should always go through NIC2 since we only install a // route to test.netCfg.remoteAddr through NIC2. - data := buffer.View([]byte{1, 2, 3, 4}) + data := []byte{1, 2, 3, 4} if err := send(r, data); err != nil { t.Fatalf("send(_, _): %s", err) } @@ -5023,7 +5023,7 @@ func TestWritePacketToRemote(t *testing.T) { } for _, test := range tests { t.Run(test.name, func(t *testing.T) { - if err := s.WritePacketToRemote(nicID, linkAddr2, test.protocol, buffer.View(test.payload).ToVectorisedView()); err != nil { + if err := s.WritePacketToRemote(nicID, linkAddr2, test.protocol, buffer.NewWithData(test.payload)); err != nil { t.Fatalf("s.WritePacketToRemote(_, _, _, _) = %s", err) } @@ -5045,7 +5045,7 @@ func TestWritePacketToRemote(t *testing.T) { } t.Run("InvalidNICID", func(t *testing.T) { - err := s.WritePacketToRemote(234, linkAddr2, header.IPv4ProtocolNumber, buffer.View([]byte{1}).ToVectorisedView()) + err := s.WritePacketToRemote(234, linkAddr2, header.IPv4ProtocolNumber, buffer.NewWithData([]byte{1})) if _, ok := err.(*tcpip.ErrUnknownDevice); !ok { t.Fatalf("s.WritePacketToRemote(_, _, _, _) = %s, want = %s", err, &tcpip.ErrUnknownDevice{}) } diff --git a/pkg/tcpip/stack/transport_demuxer_test.go b/pkg/tcpip/stack/transport_demuxer_test.go index bf31fc790..9461c90f0 100644 --- a/pkg/tcpip/stack/transport_demuxer_test.go +++ b/pkg/tcpip/stack/transport_demuxer_test.go @@ -21,8 +21,8 @@ import ( "strconv" "testing" + "gvisor.dev/gvisor/pkg/buffer" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/header" "gvisor.dev/gvisor/pkg/tcpip/link/channel" "gvisor.dev/gvisor/pkg/tcpip/network/ipv4" @@ -106,7 +106,7 @@ func newPayload() []byte { } func (c *testContext) sendV4Packet(payload []byte, h *headers, linkEpID tcpip.NICID) { - buf := buffer.NewView(header.UDPMinimumSize + header.IPv4MinimumSize + len(payload)) + buf := make([]byte, header.UDPMinimumSize+header.IPv4MinimumSize+len(payload)) payloadStart := len(buf) - len(payload) copy(buf[payloadStart:], payload) @@ -139,14 +139,14 @@ func (c *testContext) sendV4Packet(payload []byte, h *headers, linkEpID tcpip.NI // Inject packet. pkt := stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: buf.ToVectorisedView(), + Payload: buffer.NewWithData(buf), }) c.linkEps[linkEpID].InjectInbound(ipv4.ProtocolNumber, pkt) } func (c *testContext) sendV6Packet(payload []byte, h *headers, linkEpID tcpip.NICID) { // Allocate a buffer for data and headers. - buf := buffer.NewView(header.UDPMinimumSize + header.IPv6MinimumSize + len(payload)) + buf := make([]byte, header.UDPMinimumSize+header.IPv6MinimumSize+len(payload)) copy(buf[len(buf)-len(payload):], payload) // Initialize the IP header. @@ -176,7 +176,7 @@ func (c *testContext) sendV6Packet(payload []byte, h *headers, linkEpID tcpip.NI // Inject packet. pkt := stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: buf.ToVectorisedView(), + Payload: buffer.NewWithData(buf), }) c.linkEps[linkEpID].InjectInbound(ipv6.ProtocolNumber, pkt) } diff --git a/pkg/tcpip/stack/transport_test.go b/pkg/tcpip/stack/transport_test.go index 13c2afb77..b99624154 100644 --- a/pkg/tcpip/stack/transport_test.go +++ b/pkg/tcpip/stack/transport_test.go @@ -19,8 +19,8 @@ import ( "io" "testing" + "gvisor.dev/gvisor/pkg/buffer" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/link/channel" "gvisor.dev/gvisor/pkg/tcpip/ports" "gvisor.dev/gvisor/pkg/tcpip/stack" @@ -105,7 +105,7 @@ func (f *fakeTransportEndpoint) Write(p tcpip.Payloader, opts tcpip.WriteOptions pkt := stack.NewPacketBuffer(stack.PacketBufferOptions{ ReserveHeaderBytes: int(f.route.MaxHeaderLength()) + fakeTransHeaderLen, - Data: buffer.View(v).ToVectorisedView(), + Payload: buffer.NewWithData(v), }) _ = pkt.TransportHeader().Push(fakeTransHeaderLen) if err := f.route.WritePacket(stack.NetworkHeaderParams{Protocol: fakeTransNumber, TTL: 123, TOS: stack.DefaultTOS}, pkt); err != nil { @@ -294,7 +294,7 @@ func (*fakeTransportProtocol) MinimumPacketSize() int { return fakeTransHeaderLen } -func (*fakeTransportProtocol) ParsePorts(buffer.View) (src, dst uint16, err tcpip.Error) { +func (*fakeTransportProtocol) ParsePorts([]byte) (src, dst uint16, err tcpip.Error) { return 0, 0, nil } @@ -393,13 +393,13 @@ func TestTransportReceive(t *testing.T) { fakeTrans := s.TransportProtocolInstance(fakeTransNumber).(*fakeTransportProtocol) // Create buffer that will hold the packet. - buf := buffer.NewView(30) + buf := make([]byte, 30) // Make sure packet with wrong protocol is not delivered. buf[0] = 1 buf[2] = 0 linkEP.InjectInbound(fakeNetNumber, stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: buf.ToVectorisedView(), + Payload: buffer.NewWithData(buf), })) if fakeTrans.packetCount != 0 { t.Errorf("packetCount = %d, want %d", fakeTrans.packetCount, 0) @@ -410,7 +410,7 @@ func TestTransportReceive(t *testing.T) { buf[1] = 3 buf[2] = byte(fakeTransNumber) linkEP.InjectInbound(fakeNetNumber, stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: buf.ToVectorisedView(), + Payload: buffer.NewWithData(buf), })) if fakeTrans.packetCount != 0 { t.Errorf("packetCount = %d, want %d", fakeTrans.packetCount, 0) @@ -421,7 +421,7 @@ func TestTransportReceive(t *testing.T) { buf[1] = 2 buf[2] = byte(fakeTransNumber) linkEP.InjectInbound(fakeNetNumber, stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: buf.ToVectorisedView(), + Payload: buffer.NewWithData(buf), })) if fakeTrans.packetCount != 1 { t.Errorf("packetCount = %d, want %d", fakeTrans.packetCount, 1) @@ -471,7 +471,7 @@ func TestTransportControlReceive(t *testing.T) { fakeTrans := s.TransportProtocolInstance(fakeTransNumber).(*fakeTransportProtocol) // Create buffer that will hold the control packet. - buf := buffer.NewView(2*fakeNetHeaderLen + 30) + buf := make([]byte, 2*fakeNetHeaderLen+30) // Outer packet contains the control protocol number. buf[0] = 1 @@ -483,7 +483,7 @@ func TestTransportControlReceive(t *testing.T) { buf[fakeNetHeaderLen+1] = 1 buf[fakeNetHeaderLen+2] = 0 linkEP.InjectInbound(fakeNetNumber, stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: buf.ToVectorisedView(), + Payload: buffer.NewWithData(buf), })) if fakeTrans.controlCount != 0 { t.Errorf("controlCount = %d, want %d", fakeTrans.controlCount, 0) @@ -494,7 +494,7 @@ func TestTransportControlReceive(t *testing.T) { buf[fakeNetHeaderLen+1] = 1 buf[fakeNetHeaderLen+2] = byte(fakeTransNumber) linkEP.InjectInbound(fakeNetNumber, stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: buf.ToVectorisedView(), + Payload: buffer.NewWithData(buf), })) if fakeTrans.controlCount != 0 { t.Errorf("controlCount = %d, want %d", fakeTrans.controlCount, 0) @@ -505,7 +505,7 @@ func TestTransportControlReceive(t *testing.T) { buf[fakeNetHeaderLen+1] = 1 buf[fakeNetHeaderLen+2] = byte(fakeTransNumber) linkEP.InjectInbound(fakeNetNumber, stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: buf.ToVectorisedView(), + Payload: buffer.NewWithData(buf), })) if fakeTrans.controlCount != 1 { t.Errorf("controlCount = %d, want %d", fakeTrans.controlCount, 1) diff --git a/pkg/tcpip/tests/integration/BUILD b/pkg/tcpip/tests/integration/BUILD index f7f8c6086..af10d9dbe 100644 --- a/pkg/tcpip/tests/integration/BUILD +++ b/pkg/tcpip/tests/integration/BUILD @@ -29,8 +29,8 @@ go_test( size = "small", srcs = ["iptables_test.go"], deps = [ + "//pkg/buffer", "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/checker", "//pkg/tcpip/header", "//pkg/tcpip/link/channel", @@ -55,8 +55,8 @@ go_test( size = "small", srcs = ["link_resolution_test.go"], deps = [ + "//pkg/buffer", "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/checker", "//pkg/tcpip/faketime", "//pkg/tcpip/header", @@ -82,8 +82,8 @@ go_test( size = "small", srcs = ["loopback_test.go"], deps = [ + "//pkg/buffer", "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/checker", "//pkg/tcpip/header", "//pkg/tcpip/link/channel", @@ -131,7 +131,6 @@ go_test( srcs = ["route_test.go"], deps = [ "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/checker", "//pkg/tcpip/header", "//pkg/tcpip/link/channel", diff --git a/pkg/tcpip/tests/integration/iptables_test.go b/pkg/tcpip/tests/integration/iptables_test.go index b86aeba7f..8d7fb1318 100644 --- a/pkg/tcpip/tests/integration/iptables_test.go +++ b/pkg/tcpip/tests/integration/iptables_test.go @@ -21,8 +21,8 @@ import ( "testing" "github.com/google/go-cmp/cmp" + "gvisor.dev/gvisor/pkg/buffer" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/checker" "gvisor.dev/gvisor/pkg/tcpip/header" "gvisor.dev/gvisor/pkg/tcpip/link/channel" @@ -119,8 +119,8 @@ func genPacketV6() *stack.PacketBuffer { SrcAddr: srcAddrV6, DstAddr: dstAddrV6, }) - vv := buffer.NewViewFromBytes(hdr.View()).ToVectorisedView() - return stack.NewPacketBuffer(stack.PacketBufferOptions{Data: vv}) + buf := buffer.NewWithData(hdr.View()) + return stack.NewPacketBuffer(stack.PacketBufferOptions{Payload: buf}) } func genPacketV4() *stack.PacketBuffer { @@ -140,8 +140,8 @@ func genPacketV4() *stack.PacketBuffer { }) ip.SetChecksum(0) ip.SetChecksum(^ip.CalculateChecksum()) - vv := buffer.NewViewFromBytes(hdr.View()).ToVectorisedView() - return stack.NewPacketBuffer(stack.PacketBufferOptions{Data: vv}) + buf := buffer.NewWithData(hdr.View()) + return stack.NewPacketBuffer(stack.PacketBufferOptions{Payload: buf}) } func TestIPTablesStatsForInput(t *testing.T) { @@ -380,7 +380,7 @@ func TestIPTableWritePackets(t *testing.T) { dropPackets = 3 ) - udpHdr := func(hdr buffer.View, srcAddr, dstAddr tcpip.Address, srcPort, dstPort uint16) { + udpHdr := func(hdr []byte, srcAddr, dstAddr tcpip.Address, srcPort, dstPort uint16) { u := header.UDP(hdr) u.Encode(&header.UDPFields{ SrcPort: srcPort, @@ -1369,7 +1369,7 @@ var ( func TestNATEcho(t *testing.T) { const ident = 1 - v4EchoPkt := func(srcAddr, dstAddr tcpip.Address, reply bool) buffer.View { + v4EchoPkt := func(srcAddr, dstAddr tcpip.Address, reply bool) []byte { icmpType := header.ICMPv4Echo if reply { icmpType = header.ICMPv4EchoReply @@ -1378,7 +1378,7 @@ func TestNATEcho(t *testing.T) { return icmpv4Packet(srcAddr, dstAddr, icmpType, ident) } - checkV4EchoPkt := func(t *testing.T, v buffer.View, srcAddr, dstAddr tcpip.Address, reply bool) { + checkV4EchoPkt := func(t *testing.T, v []byte, srcAddr, dstAddr tcpip.Address, reply bool) { t.Helper() icmpType := header.ICMPv4Echo @@ -1396,7 +1396,7 @@ func TestNATEcho(t *testing.T) { ) } - v6EchoPkt := func(srcAddr, dstAddr tcpip.Address, reply bool) buffer.View { + v6EchoPkt := func(srcAddr, dstAddr tcpip.Address, reply bool) []byte { icmpType := header.ICMPv6EchoRequest if reply { icmpType = header.ICMPv6EchoReply @@ -1405,7 +1405,7 @@ func TestNATEcho(t *testing.T) { return icmpv6Packet(srcAddr, dstAddr, icmpType, ident) } - checkV6EchoPkt := func(t *testing.T, v buffer.View, srcAddr, dstAddr tcpip.Address, reply bool) { + checkV6EchoPkt := func(t *testing.T, v []byte, srcAddr, dstAddr tcpip.Address, reply bool) { t.Helper() icmpType := header.ICMPv6EchoRequest @@ -1433,8 +1433,8 @@ func TestNATEcho(t *testing.T) { name string netProto tcpip.NetworkProtocolNumber transProto tcpip.TransportProtocolNumber - echoPkt func(srcAddr, dstAddr tcpip.Address, reply bool) buffer.View - checkEchoPkt func(t *testing.T, v buffer.View, srcAddr, dstAddr tcpip.Address, reply bool) + echoPkt func(srcAddr, dstAddr tcpip.Address, reply bool) []byte + checkEchoPkt func(t *testing.T, v []byte, srcAddr, dstAddr tcpip.Address, reply bool) natTypes []natTypeTest }{ @@ -1528,7 +1528,7 @@ func TestNATEcho(t *testing.T) { // Send and check the Echo Request. { ep2.InjectInbound(test.netProto, stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: test.echoPkt(natTypeTest.requestSrc, natTypeTest.requestDst, false /* reply */).ToVectorisedView(), + Payload: buffer.NewWithData(test.echoPkt(natTypeTest.requestSrc, natTypeTest.requestDst, false /* reply */)), })) pkt := ep1.Read() if pkt == nil { @@ -1545,7 +1545,7 @@ func TestNATEcho(t *testing.T) { // Send and check the Echo Reply. { ep1.InjectInbound(test.netProto, stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: test.echoPkt(natTypeTest.expectedRequestDst, natTypeTest.expectedRequestSrc, true /* reply */).ToVectorisedView(), + Payload: buffer.NewWithData(test.echoPkt(natTypeTest.expectedRequestDst, natTypeTest.expectedRequestSrc, true /* reply */)), })) pkt := ep2.Read() if pkt == nil { @@ -2009,7 +2009,7 @@ func TestNAT(t *testing.T) { } } -func encodeIPv4Header(v buffer.View, totalLen int, transProto tcpip.TransportProtocolNumber, srcAddr, dstAddr tcpip.Address) { +func encodeIPv4Header(v []byte, totalLen int, transProto tcpip.TransportProtocolNumber, srcAddr, dstAddr tcpip.Address) { ip := header.IPv4(v) ip.Encode(&header.IPv4Fields{ TotalLength: uint16(totalLen), @@ -2021,7 +2021,7 @@ func encodeIPv4Header(v buffer.View, totalLen int, transProto tcpip.TransportPro ip.SetChecksum(^ip.CalculateChecksum()) } -func encodeIPv6Header(v buffer.View, payloadLen int, transProto tcpip.TransportProtocolNumber, srcAddr, dstAddr tcpip.Address) { +func encodeIPv6Header(v []byte, payloadLen int, transProto tcpip.TransportProtocolNumber, srcAddr, dstAddr tcpip.Address) { ip := header.IPv6(v) ip.Encode(&header.IPv6Fields{ PayloadLength: uint16(payloadLen), @@ -2032,7 +2032,7 @@ func encodeIPv6Header(v buffer.View, payloadLen int, transProto tcpip.TransportP }) } -func udpv4Packet(srcAddr, dstAddr tcpip.Address, srcPort, dstPort uint16, dataSize int) buffer.View { +func udpv4Packet(srcAddr, dstAddr tcpip.Address, srcPort, dstPort uint16, dataSize int) []byte { udpSize := header.UDPMinimumSize + dataSize hdr := prependable.New(header.IPv4MinimumSize + udpSize) udp := header.UDP(hdr.Prepend(udpSize)) @@ -2056,7 +2056,7 @@ func udpv4Packet(srcAddr, dstAddr tcpip.Address, srcPort, dstPort uint16, dataSi return hdr.View() } -func tcpv4Packet(srcAddr, dstAddr tcpip.Address, srcPort, dstPort uint16, dataSize int) buffer.View { +func tcpv4Packet(srcAddr, dstAddr tcpip.Address, srcPort, dstPort uint16, dataSize int) []byte { tcpSize := header.TCPMinimumSize + dataSize hdr := prependable.New(header.IPv4MinimumSize + tcpSize) tcp := header.TCP(hdr.Prepend(tcpSize)) @@ -2080,7 +2080,7 @@ func tcpv4Packet(srcAddr, dstAddr tcpip.Address, srcPort, dstPort uint16, dataSi return hdr.View() } -func icmpv4Packet(srcAddr, dstAddr tcpip.Address, icmpType header.ICMPv4Type, ident uint16) buffer.View { +func icmpv4Packet(srcAddr, dstAddr tcpip.Address, icmpType header.ICMPv4Type, ident uint16) []byte { hdr := prependable.New(header.IPv4MinimumSize + header.ICMPv4MinimumSize) icmp := header.ICMPv4(hdr.Prepend(header.ICMPv4MinimumSize)) icmp.SetType(icmpType) @@ -2097,7 +2097,7 @@ func icmpv4Packet(srcAddr, dstAddr tcpip.Address, icmpType header.ICMPv4Type, id return hdr.View() } -func udpv6Packet(srcAddr, dstAddr tcpip.Address, srcPort, dstPort uint16, dataSize int) buffer.View { +func udpv6Packet(srcAddr, dstAddr tcpip.Address, srcPort, dstPort uint16, dataSize int) []byte { udpSize := header.UDPMinimumSize + dataSize hdr := prependable.New(header.IPv6MinimumSize + udpSize) udp := header.UDP(hdr.Prepend(udpSize)) @@ -2121,7 +2121,7 @@ func udpv6Packet(srcAddr, dstAddr tcpip.Address, srcPort, dstPort uint16, dataSi return hdr.View() } -func tcpv6Packet(srcAddr, dstAddr tcpip.Address, srcPort, dstPort uint16, dataSize int) buffer.View { +func tcpv6Packet(srcAddr, dstAddr tcpip.Address, srcPort, dstPort uint16, dataSize int) []byte { tcpSize := header.TCPMinimumSize + dataSize hdr := prependable.New(header.IPv6MinimumSize + tcpSize) tcp := header.TCP(hdr.Prepend(tcpSize)) @@ -2145,7 +2145,7 @@ func tcpv6Packet(srcAddr, dstAddr tcpip.Address, srcPort, dstPort uint16, dataSi return hdr.View() } -func icmpv6Packet(srcAddr, dstAddr tcpip.Address, icmpType header.ICMPv6Type, ident uint16) buffer.View { +func icmpv6Packet(srcAddr, dstAddr tcpip.Address, icmpType header.ICMPv6Type, ident uint16) []byte { hdr := prependable.New(header.IPv6MinimumSize + header.ICMPv6MinimumSize) icmp := header.ICMPv6(hdr.Prepend(header.ICMPv6MinimumSize)) icmp.SetType(icmpType) @@ -2182,17 +2182,17 @@ func TestNATICMPError(t *testing.T) { type transportTypeTest struct { name string proto tcpip.TransportProtocolNumber - buf buffer.View - checkNATed func(*testing.T, buffer.View) + buf []byte + checkNATed func(*testing.T, []byte) } tests := []struct { name string netProto tcpip.NetworkProtocolNumber host1Addr tcpip.Address - icmpError func(*testing.T, buffer.View, uint8) buffer.View - decrementTTL func(buffer.View) - checkNATedError func(*testing.T, buffer.View, buffer.View, uint8) + icmpError func(*testing.T, []byte, uint8) []byte + decrementTTL func([]byte) + checkNATedError func(*testing.T, []byte, []byte, uint8) transportTypes []transportTypeTest icmpTypes []icmpTypeTest @@ -2201,7 +2201,7 @@ func TestNATICMPError(t *testing.T) { name: "IPv4", netProto: ipv4.ProtocolNumber, host1Addr: utils.Host1IPv4Addr.AddressWithPrefix.Address, - icmpError: func(t *testing.T, original buffer.View, icmpType uint8) buffer.View { + icmpError: func(t *testing.T, original []byte, icmpType uint8) []byte { hdr := prependable.New(header.IPv4MinimumSize + header.ICMPv4MinimumSize + len(original)) if n := copy(hdr.Prepend(len(original)), original); n != len(original) { t.Fatalf("got copy(...) = %d, want = %d", n, len(original)) @@ -2219,13 +2219,13 @@ func TestNATICMPError(t *testing.T) { ) return hdr.View() }, - decrementTTL: func(v buffer.View) { + decrementTTL: func(v []byte) { ip := header.IPv4(v) ip.SetTTL(ip.TTL() - 1) ip.SetChecksum(0) ip.SetChecksum(^ip.CalculateChecksum()) }, - checkNATedError: func(t *testing.T, v buffer.View, original buffer.View, icmpType uint8) { + checkNATedError: func(t *testing.T, v []byte, original []byte, icmpType uint8) { checker.IPv4(t, v, checker.SrcAddr(utils.RouterNIC2IPv4Addr.AddressWithPrefix.Address), checker.DstAddr(utils.Host2IPv4Addr.AddressWithPrefix.Address), @@ -2240,10 +2240,10 @@ func TestNATICMPError(t *testing.T) { { name: "UDP", proto: header.UDPProtocolNumber, - buf: func() buffer.View { + buf: func() []byte { return udpv4Packet(utils.Host2IPv4Addr.AddressWithPrefix.Address, utils.RouterNIC2IPv4Addr.AddressWithPrefix.Address, srcPort, dstPort, dataSize) }(), - checkNATed: func(t *testing.T, v buffer.View) { + checkNATed: func(t *testing.T, v []byte) { checker.IPv4(t, v, checker.SrcAddr(utils.RouterNIC1IPv4Addr.AddressWithPrefix.Address), checker.DstAddr(utils.Host1IPv4Addr.AddressWithPrefix.Address), @@ -2257,10 +2257,10 @@ func TestNATICMPError(t *testing.T) { { name: "TCP", proto: header.TCPProtocolNumber, - buf: func() buffer.View { + buf: func() []byte { return tcpv4Packet(utils.Host2IPv4Addr.AddressWithPrefix.Address, utils.RouterNIC2IPv4Addr.AddressWithPrefix.Address, srcPort, dstPort, dataSize) }(), - checkNATed: func(t *testing.T, v buffer.View) { + checkNATed: func(t *testing.T, v []byte) { checker.IPv4(t, v, checker.SrcAddr(utils.RouterNIC1IPv4Addr.AddressWithPrefix.Address), checker.DstAddr(utils.Host1IPv4Addr.AddressWithPrefix.Address), @@ -2304,7 +2304,7 @@ func TestNATICMPError(t *testing.T) { name: "IPv6", netProto: ipv6.ProtocolNumber, host1Addr: utils.Host1IPv6Addr.AddressWithPrefix.Address, - icmpError: func(t *testing.T, original buffer.View, icmpType uint8) buffer.View { + icmpError: func(t *testing.T, original []byte, icmpType uint8) []byte { payloadLen := header.ICMPv6MinimumSize + len(original) hdr := prependable.New(header.IPv6MinimumSize + payloadLen) icmp := header.ICMPv6(hdr.Prepend(payloadLen)) @@ -2327,11 +2327,11 @@ func TestNATICMPError(t *testing.T) { ) return hdr.View() }, - decrementTTL: func(v buffer.View) { + decrementTTL: func(v []byte) { ip := header.IPv6(v) ip.SetHopLimit(ip.HopLimit() - 1) }, - checkNATedError: func(t *testing.T, v buffer.View, original buffer.View, icmpType uint8) { + checkNATedError: func(t *testing.T, v []byte, original []byte, icmpType uint8) { checker.IPv6(t, v, checker.SrcAddr(utils.RouterNIC2IPv6Addr.AddressWithPrefix.Address), checker.DstAddr(utils.Host2IPv6Addr.AddressWithPrefix.Address), @@ -2345,10 +2345,10 @@ func TestNATICMPError(t *testing.T) { { name: "UDP", proto: header.UDPProtocolNumber, - buf: func() buffer.View { + buf: func() []byte { return udpv6Packet(utils.Host2IPv6Addr.AddressWithPrefix.Address, utils.RouterNIC2IPv6Addr.AddressWithPrefix.Address, srcPort, dstPort, dataSize) }(), - checkNATed: func(t *testing.T, v buffer.View) { + checkNATed: func(t *testing.T, v []byte) { checker.IPv6(t, v, checker.SrcAddr(utils.RouterNIC1IPv6Addr.AddressWithPrefix.Address), checker.DstAddr(utils.Host1IPv6Addr.AddressWithPrefix.Address), @@ -2362,10 +2362,10 @@ func TestNATICMPError(t *testing.T) { { name: "TCP", proto: header.TCPProtocolNumber, - buf: func() buffer.View { + buf: func() []byte { return tcpv6Packet(utils.Host2IPv6Addr.AddressWithPrefix.Address, utils.RouterNIC2IPv6Addr.AddressWithPrefix.Address, srcPort, dstPort, dataSize) }(), - checkNATed: func(t *testing.T, v buffer.View) { + checkNATed: func(t *testing.T, v []byte) { checker.IPv6(t, v, checker.SrcAddr(utils.RouterNIC1IPv6Addr.AddressWithPrefix.Address), checker.DstAddr(utils.Host1IPv6Addr.AddressWithPrefix.Address), @@ -2511,7 +2511,7 @@ func TestNATICMPError(t *testing.T) { buf := transportType.buf ep2.InjectInbound(test.netProto, stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: append(buffer.View(nil), buf...).ToVectorisedView(), + Payload: buffer.NewWithData(append([]byte{}, buf...)), })) { @@ -2530,7 +2530,7 @@ func TestNATICMPError(t *testing.T) { buf = buf[:len(buf)-trimTest.trimLen] ep1.InjectInbound(test.netProto, stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: test.icmpError(t, pktView, icmpType.val).ToVectorisedView(), + Payload: buffer.NewWithData(test.icmpError(t, pktView, icmpType.val)), })) } @@ -2609,8 +2609,8 @@ func TestSNATHandlePortOrIdentConflicts(t *testing.T) { type transportTypeTest struct { name string proto tcpip.TransportProtocolNumber - buf func(tcpip.Address, uint16) buffer.View - checkNATed func(*testing.T, buffer.View, uint16, bool, portOrIdentRange) + buf func(tcpip.Address, uint16) []byte + checkNATed func(*testing.T, []byte, uint16, bool, portOrIdentRange) srcPortOrIdentRanges []srcPortOrIdentRangeTest } @@ -2649,10 +2649,10 @@ func TestSNATHandlePortOrIdentConflicts(t *testing.T) { { name: "UDP", proto: header.UDPProtocolNumber, - buf: func(srcAddr tcpip.Address, srcPort uint16) buffer.View { + buf: func(srcAddr tcpip.Address, srcPort uint16) []byte { return udpv4Packet(srcAddr, utils.Host1IPv4Addr.AddressWithPrefix.Address, srcPort, dstPort, 0 /* dataSize */) }, - checkNATed: func(t *testing.T, v buffer.View, originalSrcPort uint16, firstPacket bool, expectedRange portOrIdentRange) { + checkNATed: func(t *testing.T, v []byte, originalSrcPort uint16, firstPacket bool, expectedRange portOrIdentRange) { checker.IPv4(t, v, checker.SrcAddr(utils.RouterNIC1IPv4Addr.AddressWithPrefix.Address), checker.DstAddr(utils.Host1IPv4Addr.AddressWithPrefix.Address), @@ -2670,10 +2670,10 @@ func TestSNATHandlePortOrIdentConflicts(t *testing.T) { { name: "TCP", proto: header.TCPProtocolNumber, - buf: func(srcAddr tcpip.Address, srcPort uint16) buffer.View { + buf: func(srcAddr tcpip.Address, srcPort uint16) []byte { return tcpv4Packet(srcAddr, utils.Host1IPv4Addr.AddressWithPrefix.Address, srcPort, dstPort, 0 /* dataSize */) }, - checkNATed: func(t *testing.T, v buffer.View, originalSrcPort uint16, firstPacket bool, expectedRange portOrIdentRange) { + checkNATed: func(t *testing.T, v []byte, originalSrcPort uint16, firstPacket bool, expectedRange portOrIdentRange) { checker.IPv4(t, v, checker.SrcAddr(utils.RouterNIC1IPv4Addr.AddressWithPrefix.Address), checker.DstAddr(utils.Host1IPv4Addr.AddressWithPrefix.Address), @@ -2691,10 +2691,10 @@ func TestSNATHandlePortOrIdentConflicts(t *testing.T) { { name: "ICMP Echo", proto: header.ICMPv4ProtocolNumber, - buf: func(srcAddr tcpip.Address, ident uint16) buffer.View { + buf: func(srcAddr tcpip.Address, ident uint16) []byte { return icmpv4Packet(srcAddr, utils.Host1IPv4Addr.AddressWithPrefix.Address, header.ICMPv4Echo, ident) }, - checkNATed: func(t *testing.T, v buffer.View, originalIdent uint16, firstPacket bool, expectedRange portOrIdentRange) { + checkNATed: func(t *testing.T, v []byte, originalIdent uint16, firstPacket bool, expectedRange portOrIdentRange) { checker.IPv4(t, v, checker.SrcAddr(utils.RouterNIC1IPv4Addr.AddressWithPrefix.Address), checker.DstAddr(utils.Host1IPv4Addr.AddressWithPrefix.Address), @@ -2725,10 +2725,10 @@ func TestSNATHandlePortOrIdentConflicts(t *testing.T) { { name: "UDP", proto: header.UDPProtocolNumber, - buf: func(srcAddr tcpip.Address, srcPort uint16) buffer.View { + buf: func(srcAddr tcpip.Address, srcPort uint16) []byte { return udpv6Packet(srcAddr, utils.Host1IPv6Addr.AddressWithPrefix.Address, srcPort, dstPort, 0 /* dataSize */) }, - checkNATed: func(t *testing.T, v buffer.View, originalSrcPort uint16, firstPacket bool, expectedRange portOrIdentRange) { + checkNATed: func(t *testing.T, v []byte, originalSrcPort uint16, firstPacket bool, expectedRange portOrIdentRange) { checker.IPv6(t, v, checker.SrcAddr(utils.RouterNIC1IPv6Addr.AddressWithPrefix.Address), checker.DstAddr(utils.Host1IPv6Addr.AddressWithPrefix.Address), @@ -2746,10 +2746,10 @@ func TestSNATHandlePortOrIdentConflicts(t *testing.T) { { name: "TCP", proto: header.TCPProtocolNumber, - buf: func(srcAddr tcpip.Address, srcPort uint16) buffer.View { + buf: func(srcAddr tcpip.Address, srcPort uint16) []byte { return tcpv6Packet(srcAddr, utils.Host1IPv6Addr.AddressWithPrefix.Address, srcPort, dstPort, 0 /* dataSize */) }, - checkNATed: func(t *testing.T, v buffer.View, originalSrcPort uint16, firstPacket bool, expectedRange portOrIdentRange) { + checkNATed: func(t *testing.T, v []byte, originalSrcPort uint16, firstPacket bool, expectedRange portOrIdentRange) { checker.IPv6(t, v, checker.SrcAddr(utils.RouterNIC1IPv6Addr.AddressWithPrefix.Address), checker.DstAddr(utils.Host1IPv6Addr.AddressWithPrefix.Address), @@ -2767,10 +2767,10 @@ func TestSNATHandlePortOrIdentConflicts(t *testing.T) { { name: "ICMP Echo", proto: header.ICMPv6ProtocolNumber, - buf: func(srcAddr tcpip.Address, ident uint16) buffer.View { + buf: func(srcAddr tcpip.Address, ident uint16) []byte { return icmpv6Packet(srcAddr, utils.Host1IPv6Addr.AddressWithPrefix.Address, header.ICMPv6EchoRequest, ident) }, - checkNATed: func(t *testing.T, v buffer.View, originalIdent uint16, firstPacket bool, expectedRange portOrIdentRange) { + checkNATed: func(t *testing.T, v []byte, originalIdent uint16, firstPacket bool, expectedRange portOrIdentRange) { checker.IPv6(t, v, checker.SrcAddr(utils.RouterNIC1IPv6Addr.AddressWithPrefix.Address), checker.DstAddr(utils.Host1IPv6Addr.AddressWithPrefix.Address), @@ -2878,7 +2878,7 @@ func TestSNATHandlePortOrIdentConflicts(t *testing.T) { for i, srcAddr := range test.srcAddrs { t.Run(fmt.Sprintf("Packet#%d", i), func(t *testing.T) { ep2.InjectInbound(test.netProto, stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: transportType.buf(srcAddr, srcPortOrIdent).ToVectorisedView(), + Payload: buffer.NewWithData(transportType.buf(srcAddr, srcPortOrIdent)), })) pkt := ep1.Read() @@ -3057,7 +3057,7 @@ func TestRejectWith(t *testing.T) { matcher stack.Matcher errorICMPDstAddr tcpip.Address - errorICMPPayload buffer.View + errorICMPPayload []byte } type rejectWithVal struct { @@ -3066,19 +3066,19 @@ func TestRejectWith(t *testing.T) { errorICMPCode uint8 } - rxICMPv4EchoRequest := func(dst tcpip.Address) buffer.View { + rxICMPv4EchoRequest := func(dst tcpip.Address) []byte { return utils.ICMPv4Echo(utils.Host1IPv4Addr.AddressWithPrefix.Address, dst, ttl, header.ICMPv4Echo) } - rxICMPv6EchoRequest := func(dst tcpip.Address) buffer.View { + rxICMPv6EchoRequest := func(dst tcpip.Address) []byte { return utils.ICMPv6Echo(utils.Host1IPv6Addr.AddressWithPrefix.Address, dst, ttl, header.ICMPv6EchoRequest) } tests := []struct { name string netProto tcpip.NetworkProtocolNumber - rxICMPEchoRequest func(tcpip.Address) buffer.View - icmpChecker func(*testing.T, buffer.View, tcpip.Address, uint8, uint8, buffer.View) + rxICMPEchoRequest func(tcpip.Address) []byte + icmpChecker func(*testing.T, []byte, tcpip.Address, uint8, uint8, []byte) natHooks []natHook @@ -3091,7 +3091,7 @@ func TestRejectWith(t *testing.T) { netProto: header.IPv4ProtocolNumber, rxICMPEchoRequest: rxICMPv4EchoRequest, - icmpChecker: func(t *testing.T, v buffer.View, dstAddr tcpip.Address, icmpType, icmpCode uint8, origPayload buffer.View) { + icmpChecker: func(t *testing.T, v []byte, dstAddr tcpip.Address, icmpType, icmpCode uint8, origPayload []byte) { t.Helper() checker.IPv4(t, v, @@ -3178,7 +3178,7 @@ func TestRejectWith(t *testing.T) { netProto: header.IPv6ProtocolNumber, rxICMPEchoRequest: rxICMPv6EchoRequest, - icmpChecker: func(t *testing.T, v buffer.View, dstAddr tcpip.Address, icmpType, icmpCode uint8, origPayload buffer.View) { + icmpChecker: func(t *testing.T, v []byte, dstAddr tcpip.Address, icmpType, icmpCode uint8, origPayload []byte) { t.Helper() checker.IPv6(t, v, @@ -3280,7 +3280,7 @@ func TestRejectWith(t *testing.T) { func() { pkt := stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: test.rxICMPEchoRequest(natHook.dstAddr).ToVectorisedView(), + Payload: buffer.NewWithData(test.rxICMPEchoRequest(natHook.dstAddr)), }) defer pkt.DecRef() ep1.InjectInbound(test.netProto, pkt) @@ -3411,8 +3411,8 @@ func genTCP4(offset int8) *stack.PacketBuffer { ip.SetChecksum(0) ip.SetChecksum(^ip.CalculateChecksum()) - vv := buffer.NewViewFromBytes(hdr.View()).ToVectorisedView() - return stack.NewPacketBuffer(stack.PacketBufferOptions{Data: vv}) + buf := buffer.NewWithData(append([]byte{}, hdr.View()...)) + return stack.NewPacketBuffer(stack.PacketBufferOptions{Payload: buf}) } func genTCP6(offset int8) *stack.PacketBuffer { @@ -3437,8 +3437,8 @@ func genTCP6(offset int8) *stack.PacketBuffer { DstAddr: dstAddrV6, }) - vv := buffer.NewViewFromBytes(hdr.View()).ToVectorisedView() - return stack.NewPacketBuffer(stack.PacketBufferOptions{Data: vv}) + buf := buffer.NewWithData(append([]byte{}, hdr.View()...)) + return stack.NewPacketBuffer(stack.PacketBufferOptions{Payload: buf}) } func genUDP4(offset int8) *stack.PacketBuffer { @@ -3468,8 +3468,8 @@ func genUDP4(offset int8) *stack.PacketBuffer { ip.SetChecksum(0) ip.SetChecksum(^ip.CalculateChecksum()) - vv := buffer.NewViewFromBytes(hdr.View()).ToVectorisedView() - return stack.NewPacketBuffer(stack.PacketBufferOptions{Data: vv}) + buf := buffer.NewWithData(append([]byte{}, hdr.View()...)) + return stack.NewPacketBuffer(stack.PacketBufferOptions{Payload: buf}) } func genUDP6(offset int8) *stack.PacketBuffer { @@ -3493,6 +3493,6 @@ func genUDP6(offset int8) *stack.PacketBuffer { DstAddr: dstAddrV6, }) - vv := buffer.NewViewFromBytes(hdr.View()).ToVectorisedView() - return stack.NewPacketBuffer(stack.PacketBufferOptions{Data: vv}) + buf := buffer.NewWithData(append([]byte{}, hdr.View()...)) + return stack.NewPacketBuffer(stack.PacketBufferOptions{Payload: buf}) } diff --git a/pkg/tcpip/tests/integration/link_resolution_test.go b/pkg/tcpip/tests/integration/link_resolution_test.go index acea9cb50..7dedee499 100644 --- a/pkg/tcpip/tests/integration/link_resolution_test.go +++ b/pkg/tcpip/tests/integration/link_resolution_test.go @@ -24,8 +24,8 @@ import ( "github.com/google/go-cmp/cmp" "github.com/google/go-cmp/cmp/cmpopts" + "gvisor.dev/gvisor/pkg/buffer" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/checker" "gvisor.dev/gvisor/pkg/tcpip/faketime" "gvisor.dev/gvisor/pkg/tcpip/header" @@ -953,7 +953,7 @@ func TestWritePacketsLinkResolution(t *testing.T) { for _, d := range data { pkt := stack.NewPacketBuffer(stack.PacketBufferOptions{ ReserveHeaderBytes: header.UDPMinimumSize + int(r.MaxHeaderLength()), - Data: buffer.View([]byte{d}).ToVectorisedView(), + Payload: buffer.NewWithData([]byte{d}), }) pkt.TransportProtocolNumber = udp.ProtocolNumber length := uint16(pkt.Data().Size() + header.UDPMinimumSize) diff --git a/pkg/tcpip/tests/integration/loopback_test.go b/pkg/tcpip/tests/integration/loopback_test.go index 98a63d5ee..b77956499 100644 --- a/pkg/tcpip/tests/integration/loopback_test.go +++ b/pkg/tcpip/tests/integration/loopback_test.go @@ -20,8 +20,8 @@ import ( "time" "github.com/google/go-cmp/cmp" + "gvisor.dev/gvisor/pkg/buffer" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/checker" "gvisor.dev/gvisor/pkg/tcpip/header" "gvisor.dev/gvisor/pkg/tcpip/link/channel" @@ -311,10 +311,10 @@ func TestLoopbackSubnetLifetimeBoundToAddr(t *testing.T) { TTL: 64, TOS: stack.DefaultTOS, } - data := buffer.View([]byte{1, 2, 3, 4}) + data := []byte{1, 2, 3, 4} if err := r.WritePacket(params, stack.NewPacketBuffer(stack.PacketBufferOptions{ ReserveHeaderBytes: int(r.MaxHeaderLength()), - Data: data.ToVectorisedView(), + Payload: buffer.NewWithData(data), })); err != nil { t.Fatalf("r.WritePacket(%#v, _): %s", params, err) } @@ -326,7 +326,7 @@ func TestLoopbackSubnetLifetimeBoundToAddr(t *testing.T) { { err := r.WritePacket(params, stack.NewPacketBuffer(stack.PacketBufferOptions{ ReserveHeaderBytes: int(r.MaxHeaderLength()), - Data: data.ToVectorisedView(), + Payload: buffer.NewWithData(data), })) if _, ok := err.(*tcpip.ErrInvalidEndpointState); !ok { t.Fatalf("got r.WritePacket(%#v, _) = %s, want = %s", params, err, &tcpip.ErrInvalidEndpointState{}) diff --git a/pkg/tcpip/tests/integration/route_test.go b/pkg/tcpip/tests/integration/route_test.go index 6d0b938d5..97796eb75 100644 --- a/pkg/tcpip/tests/integration/route_test.go +++ b/pkg/tcpip/tests/integration/route_test.go @@ -21,7 +21,6 @@ import ( "github.com/google/go-cmp/cmp" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/checker" "gvisor.dev/gvisor/pkg/tcpip/header" "gvisor.dev/gvisor/pkg/tcpip/link/channel" @@ -60,24 +59,24 @@ func TestLocalPing(t *testing.T) { } } - ipv4ICMPBuf := func(t *testing.T) buffer.View { + ipv4ICMPBuf := func(t *testing.T) []byte { data := [8]byte{1, 2, 3, 4, 5, 6, 7, 8} hdr := header.ICMPv4(make([]byte, header.ICMPv4MinimumSize+len(data))) hdr.SetType(header.ICMPv4Echo) if n := copy(hdr.Payload(), data[:]); n != len(data) { t.Fatalf("copied %d bytes but expected to copy %d bytes", n, len(data)) } - return buffer.View(hdr) + return hdr } - ipv6ICMPBuf := func(t *testing.T) buffer.View { + ipv6ICMPBuf := func(t *testing.T) []byte { data := [8]byte{1, 2, 3, 4, 5, 6, 7, 9} hdr := header.ICMPv6(make([]byte, header.ICMPv6MinimumSize+len(data))) hdr.SetType(header.ICMPv6EchoRequest) if n := copy(hdr.Payload(), data[:]); n != len(data) { t.Fatalf("copied %d bytes but expected to copy %d bytes", n, len(data)) } - return buffer.View(hdr) + return hdr } tests := []struct { @@ -86,7 +85,7 @@ func TestLocalPing(t *testing.T) { netProto tcpip.NetworkProtocolNumber linkEndpoint func() stack.LinkEndpoint localAddr tcpip.AddressWithPrefix - icmpBuf func(*testing.T) buffer.View + icmpBuf func(*testing.T) []byte expectedConnectErr tcpip.Error checkLinkEndpoint func(t *testing.T, e stack.LinkEndpoint) }{ @@ -233,7 +232,7 @@ func TestLocalPing(t *testing.T) { if err != nil { t.Fatalf("ep.Read(...): %s", err) } - if diff := cmp.Diff(buffer.View(w.Bytes()[icmpDataOffset:]), payload[icmpDataOffset:]); diff != "" { + if diff := cmp.Diff(w.Bytes()[icmpDataOffset:], payload[icmpDataOffset:]); diff != "" { t.Errorf("received data mismatch (-want +got):\n%s", diff) } if rr.RemoteAddr.Addr != test.localAddr.Address { @@ -387,7 +386,7 @@ func TestLocalUDP(t *testing.T) { )); diff != "" { t.Errorf("server.Read: unexpected result (-want +got):\n%s", diff) } - if diff := cmp.Diff(buffer.View(clientPayload), buffer.View(readBuf.Bytes())); diff != "" { + if diff := cmp.Diff(clientPayload, readBuf.Bytes()); diff != "" { t.Errorf("server read clientPayload mismatch (-want +got):\n%s", diff) } if t.Failed() { @@ -427,7 +426,7 @@ func TestLocalUDP(t *testing.T) { )); diff != "" { t.Errorf("client.Read: unexpected result (-want +got):\n%s", diff) } - if diff := cmp.Diff(buffer.View(serverPayload), buffer.View(readBuf.Bytes())); diff != "" { + if diff := cmp.Diff(serverPayload, readBuf.Bytes()); diff != "" { t.Errorf("client read serverPayload mismatch (-want +got):\n%s", diff) } if t.Failed() { diff --git a/pkg/tcpip/tests/utils/BUILD b/pkg/tcpip/tests/utils/BUILD index 0bdf5c6f2..cfdd447e8 100644 --- a/pkg/tcpip/tests/utils/BUILD +++ b/pkg/tcpip/tests/utils/BUILD @@ -8,8 +8,8 @@ go_library( srcs = ["utils.go"], visibility = ["//pkg/tcpip/tests:__subpackages__"], deps = [ + "//pkg/buffer", "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/header", "//pkg/tcpip/link/channel", "//pkg/tcpip/link/ethernet", diff --git a/pkg/tcpip/tests/utils/utils.go b/pkg/tcpip/tests/utils/utils.go index 1dffdbe1c..d21b66f2f 100644 --- a/pkg/tcpip/tests/utils/utils.go +++ b/pkg/tcpip/tests/utils/utils.go @@ -18,8 +18,8 @@ package utils import ( "testing" + "gvisor.dev/gvisor/pkg/buffer" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/header" "gvisor.dev/gvisor/pkg/tcpip/link/channel" "gvisor.dev/gvisor/pkg/tcpip/link/ethernet" @@ -355,7 +355,7 @@ func SetupRoutedStacks(t *testing.T, host1Stack, routerStack, host2Stack *stack. } // ICMPv4Echo returns an ICMPv4 echo packet. -func ICMPv4Echo(src, dst tcpip.Address, ttl uint8, ty header.ICMPv4Type) buffer.View { +func ICMPv4Echo(src, dst tcpip.Address, ttl uint8, ty header.ICMPv4Type) []byte { totalLen := header.IPv4MinimumSize + header.ICMPv4MinimumSize hdr := prependable.New(totalLen) pkt := header.ICMPv4(hdr.Prepend(header.ICMPv4MinimumSize)) @@ -379,7 +379,7 @@ func ICMPv4Echo(src, dst tcpip.Address, ttl uint8, ty header.ICMPv4Type) buffer. // the provided endpoint. func RxICMPv4EchoRequest(e *channel.Endpoint, src, dst tcpip.Address, ttl uint8) { newPkt := stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: ICMPv4Echo(src, dst, ttl, header.ICMPv4Echo).ToVectorisedView(), + Payload: buffer.NewWithData(ICMPv4Echo(src, dst, ttl, header.ICMPv4Echo)), }) defer newPkt.DecRef() e.InjectInbound(header.IPv4ProtocolNumber, newPkt) @@ -389,14 +389,14 @@ func RxICMPv4EchoRequest(e *channel.Endpoint, src, dst tcpip.Address, ttl uint8) // the provided endpoint. func RxICMPv4EchoReply(e *channel.Endpoint, src, dst tcpip.Address, ttl uint8) { newPkt := stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: ICMPv4Echo(src, dst, ttl, header.ICMPv4EchoReply).ToVectorisedView(), + Payload: buffer.NewWithData(ICMPv4Echo(src, dst, ttl, header.ICMPv4EchoReply)), }) defer newPkt.DecRef() e.InjectInbound(header.IPv4ProtocolNumber, newPkt) } // ICMPv6Echo returns an ICMPv6 echo packet. -func ICMPv6Echo(src, dst tcpip.Address, ttl uint8, ty header.ICMPv6Type) buffer.View { +func ICMPv6Echo(src, dst tcpip.Address, ttl uint8, ty header.ICMPv6Type) []byte { totalLen := header.IPv6MinimumSize + header.ICMPv6MinimumSize hdr := prependable.New(totalLen) pkt := header.ICMPv6(hdr.Prepend(header.ICMPv6MinimumSize)) @@ -423,7 +423,7 @@ func ICMPv6Echo(src, dst tcpip.Address, ttl uint8, ty header.ICMPv6Type) buffer. // the provided endpoint. func RxICMPv6EchoRequest(e *channel.Endpoint, src, dst tcpip.Address, ttl uint8) { newPkt := stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: ICMPv6Echo(src, dst, ttl, header.ICMPv6EchoRequest).ToVectorisedView(), + Payload: buffer.NewWithData(ICMPv6Echo(src, dst, ttl, header.ICMPv6EchoRequest)), }) defer newPkt.DecRef() e.InjectInbound(header.IPv6ProtocolNumber, newPkt) @@ -433,7 +433,7 @@ func RxICMPv6EchoRequest(e *channel.Endpoint, src, dst tcpip.Address, ttl uint8) // the provided endpoint. func RxICMPv6EchoReply(e *channel.Endpoint, src, dst tcpip.Address, ttl uint8) { newPkt := stack.NewPacketBuffer(stack.PacketBufferOptions{ - Data: ICMPv6Echo(src, dst, ttl, header.ICMPv6EchoReply).ToVectorisedView(), + Payload: buffer.NewWithData(ICMPv6Echo(src, dst, ttl, header.ICMPv6EchoReply)), }) defer newPkt.DecRef() e.InjectInbound(header.IPv6ProtocolNumber, newPkt) diff --git a/pkg/tcpip/transport/icmp/BUILD b/pkg/tcpip/transport/icmp/BUILD index 7f65952aa..e32fbf70a 100644 --- a/pkg/tcpip/transport/icmp/BUILD +++ b/pkg/tcpip/transport/icmp/BUILD @@ -23,7 +23,6 @@ go_library( "icmp_packet_list.go", "protocol.go", ], - imports = ["gvisor.dev/gvisor/pkg/tcpip/buffer"], visibility = ["//visibility:public"], deps = [ "//pkg/buffer", @@ -31,7 +30,6 @@ go_library( "//pkg/sleep", "//pkg/sync", "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/header", "//pkg/tcpip/ports", "//pkg/tcpip/stack", diff --git a/pkg/tcpip/transport/icmp/protocol.go b/pkg/tcpip/transport/icmp/protocol.go index d5b2c39cf..7e6e3db18 100644 --- a/pkg/tcpip/transport/icmp/protocol.go +++ b/pkg/tcpip/transport/icmp/protocol.go @@ -20,7 +20,6 @@ import ( "fmt" "gvisor.dev/gvisor/pkg/tcpip" - tcpipbuffer "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/header" "gvisor.dev/gvisor/pkg/tcpip/stack" "gvisor.dev/gvisor/pkg/tcpip/transport/raw" @@ -87,7 +86,7 @@ func (p *protocol) MinimumPacketSize() int { } // ParsePorts in case of ICMP sets src to 0, dst to ICMP ID, and err to nil. -func (p *protocol) ParsePorts(v tcpipbuffer.View) (src, dst uint16, err tcpip.Error) { +func (p *protocol) ParsePorts(v []byte) (src, dst uint16, err tcpip.Error) { switch p.number { case ProtocolNumber4: hdr := header.ICMPv4(v) diff --git a/pkg/tcpip/transport/packet/BUILD b/pkg/tcpip/transport/packet/BUILD index b989b1209..017e6feb9 100644 --- a/pkg/tcpip/transport/packet/BUILD +++ b/pkg/tcpip/transport/packet/BUILD @@ -22,14 +22,13 @@ go_library( "endpoint_state.go", "packet_list.go", ], - imports = ["gvisor.dev/gvisor/pkg/tcpip/buffer"], visibility = ["//visibility:public"], deps = [ + "//pkg/buffer", "//pkg/log", "//pkg/sleep", "//pkg/sync", "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/header", "//pkg/tcpip/stack", "//pkg/waiter", diff --git a/pkg/tcpip/transport/packet/endpoint.go b/pkg/tcpip/transport/packet/endpoint.go index 74d807824..e58a9da9a 100644 --- a/pkg/tcpip/transport/packet/endpoint.go +++ b/pkg/tcpip/transport/packet/endpoint.go @@ -28,9 +28,9 @@ import ( "io" "time" + "gvisor.dev/gvisor/pkg/buffer" "gvisor.dev/gvisor/pkg/sync" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/header" "gvisor.dev/gvisor/pkg/tcpip/stack" "gvisor.dev/gvisor/pkg/waiter" @@ -235,16 +235,16 @@ func (ep *endpoint) Write(p tcpip.Payloader, opts tcpip.WriteOptions) (int64, tc } // TODO(https://gvisor.dev/issue/6538): Avoid this allocation. - payloadBytes := make(buffer.View, p.Len()) + payloadBytes := make([]byte, p.Len()) if _, err := io.ReadFull(p, payloadBytes); err != nil { return 0, &tcpip.ErrBadBuffer{} } if err := func() tcpip.Error { if ep.cooked { - return ep.stack.WritePacketToRemote(nicID, remote, proto, payloadBytes.ToVectorisedView()) + return ep.stack.WritePacketToRemote(nicID, remote, proto, buffer.NewWithData(payloadBytes)) } - return ep.stack.WriteRawPacket(nicID, proto, payloadBytes.ToVectorisedView()) + return ep.stack.WriteRawPacket(nicID, proto, buffer.NewWithData(payloadBytes)) }(); err != nil { return 0, err } @@ -444,7 +444,7 @@ func (ep *endpoint) HandlePacket(nicID tcpip.NICID, netProto tcpip.NetworkProtoc receivedAt: ep.stack.Clock().Now(), } - if !pkt.LinkHeader().View().IsEmpty() { + if len(pkt.LinkHeader().View()) != 0 { hdr := header.Ethernet(pkt.LinkHeader().View()) rcvdPkt.senderAddr.Addr = tcpip.Address(hdr.SourceAddress()) } diff --git a/pkg/tcpip/transport/raw/BUILD b/pkg/tcpip/transport/raw/BUILD index 3c1d329f9..7b4435d39 100644 --- a/pkg/tcpip/transport/raw/BUILD +++ b/pkg/tcpip/transport/raw/BUILD @@ -23,7 +23,6 @@ go_library( "protocol.go", "raw_packet_list.go", ], - imports = ["gvisor.dev/gvisor/pkg/tcpip/buffer"], visibility = ["//visibility:public"], deps = [ "//pkg/buffer", @@ -31,7 +30,6 @@ go_library( "//pkg/sleep", "//pkg/sync", "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/header", "//pkg/tcpip/stack", "//pkg/tcpip/transport", diff --git a/pkg/tcpip/transport/tcp/BUILD b/pkg/tcpip/transport/tcp/BUILD index d1f544661..f68ff29df 100644 --- a/pkg/tcpip/transport/tcp/BUILD +++ b/pkg/tcpip/transport/tcp/BUILD @@ -68,7 +68,6 @@ go_library( "tcp_segment_refs.go", "timer.go", ], - imports = ["gvisor.dev/gvisor/pkg/tcpip/buffer"], visibility = ["//visibility:public"], deps = [ "//pkg/atomicbitops", @@ -79,7 +78,6 @@ go_library( "//pkg/sleep", "//pkg/sync", "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/hash/jenkins", "//pkg/tcpip/header", "//pkg/tcpip/header/parse", diff --git a/pkg/tcpip/transport/tcp/protocol.go b/pkg/tcpip/transport/tcp/protocol.go index d75d84b0a..500c8ab95 100644 --- a/pkg/tcpip/transport/tcp/protocol.go +++ b/pkg/tcpip/transport/tcp/protocol.go @@ -22,7 +22,6 @@ import ( "gvisor.dev/gvisor/pkg/sync" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/hash/jenkins" "gvisor.dev/gvisor/pkg/tcpip/header" "gvisor.dev/gvisor/pkg/tcpip/header/parse" @@ -136,7 +135,7 @@ func (*protocol) MinimumPacketSize() int { // ParsePorts returns the source and destination ports stored in the given tcp // packet. -func (*protocol) ParsePorts(v buffer.View) (src, dst uint16, err tcpip.Error) { +func (*protocol) ParsePorts(v []byte) (src, dst uint16, err tcpip.Error) { h := header.TCP(v) return h.SourcePort(), h.DestinationPort(), nil } diff --git a/pkg/tcpip/transport/udp/BUILD b/pkg/tcpip/transport/udp/BUILD index 57b08a425..342d4dd04 100644 --- a/pkg/tcpip/transport/udp/BUILD +++ b/pkg/tcpip/transport/udp/BUILD @@ -24,14 +24,12 @@ go_library( "protocol.go", "udp_packet_list.go", ], - imports = ["gvisor.dev/gvisor/pkg/tcpip/buffer"], visibility = ["//visibility:public"], deps = [ "//pkg/buffer", "//pkg/sleep", "//pkg/sync", "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/header", "//pkg/tcpip/header/parse", "//pkg/tcpip/ports", diff --git a/pkg/tcpip/transport/udp/protocol.go b/pkg/tcpip/transport/udp/protocol.go index 6ec26b5a1..6a15e3b79 100644 --- a/pkg/tcpip/transport/udp/protocol.go +++ b/pkg/tcpip/transport/udp/protocol.go @@ -17,7 +17,6 @@ package udp import ( "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/header" "gvisor.dev/gvisor/pkg/tcpip/header/parse" "gvisor.dev/gvisor/pkg/tcpip/stack" @@ -71,7 +70,7 @@ func (*protocol) MinimumPacketSize() int { // ParsePorts returns the source and destination ports stored in the given udp // packet. -func (*protocol) ParsePorts(v buffer.View) (src, dst uint16, err tcpip.Error) { +func (*protocol) ParsePorts(v []byte) (src, dst uint16, err tcpip.Error) { h := header.UDP(v) return h.SourcePort(), h.DestinationPort(), nil } diff --git a/test/packetimpact/testbench/BUILD b/test/packetimpact/testbench/BUILD index d8059ab98..61a20adae 100644 --- a/test/packetimpact/testbench/BUILD +++ b/test/packetimpact/testbench/BUILD @@ -18,9 +18,9 @@ go_library( deps = [ "//pkg/abi/linux", "//pkg/binary", + "//pkg/buffer", "//pkg/hostarch", "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/header", "//pkg/tcpip/seqnum", "//test/packetimpact/proto:posix_server_go_proto", diff --git a/test/packetimpact/testbench/layers.go b/test/packetimpact/testbench/layers.go index d6c03343b..e36e4d4a9 100644 --- a/test/packetimpact/testbench/layers.go +++ b/test/packetimpact/testbench/layers.go @@ -24,8 +24,8 @@ import ( "github.com/google/go-cmp/cmp" "github.com/google/go-cmp/cmp/cmpopts" "go.uber.org/multierr" + "gvisor.dev/gvisor/pkg/buffer" "gvisor.dev/gvisor/pkg/tcpip" - "gvisor.dev/gvisor/pkg/tcpip/buffer" "gvisor.dev/gvisor/pkg/tcpip/header" ) @@ -1114,14 +1114,14 @@ func totalLength(l Layer) int { } // payload returns a buffer.VectorisedView of l's payload. -func payload(l Layer) (buffer.VectorisedView, error) { - var payloadBytes buffer.VectorisedView +func payload(l Layer) (buffer.Buffer, error) { + var payloadBytes buffer.Buffer for current := l.next(); current != nil; current = current.next() { payload, err := current.ToBytes() if err != nil { - return buffer.VectorisedView{}, fmt.Errorf("can't get bytes for next header: %s", payload) + return buffer.Buffer{}, fmt.Errorf("can't get bytes for next header: %s", payload) } - payloadBytes.AppendView(payload) + payloadBytes.AppendOwned(payload) } return payloadBytes, nil } @@ -1144,7 +1144,7 @@ func layerChecksum(l Layer, protoNumber tcpip.TransportProtocolNumber) (uint16, if err != nil { return 0, err } - xsum = header.ChecksumVV(payloadBytes, xsum) + xsum = header.ChecksumBuffer(payloadBytes, xsum) return xsum, nil } diff --git a/test/packetimpact/tests/BUILD b/test/packetimpact/tests/BUILD index 9fe53a582..a3707e502 100644 --- a/test/packetimpact/tests/BUILD +++ b/test/packetimpact/tests/BUILD @@ -280,7 +280,6 @@ packetimpact_testbench( name = "ipv4_fragment_reassembly", srcs = ["ipv4_fragment_reassembly_test.go"], deps = [ - "//pkg/tcpip/buffer", "//pkg/tcpip/header", "//test/packetimpact/testbench", "@com_github_google_go_cmp//cmp:go_default_library", @@ -293,7 +292,6 @@ packetimpact_testbench( srcs = ["ipv6_fragment_reassembly_test.go"], deps = [ "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/header", "//test/packetimpact/testbench", "@com_github_google_go_cmp//cmp:go_default_library", @@ -306,7 +304,6 @@ packetimpact_testbench( srcs = ["ipv6_fragment_icmp_error_test.go"], deps = [ "//pkg/tcpip", - "//pkg/tcpip/buffer", "//pkg/tcpip/header", "//pkg/tcpip/network/ipv6", "//test/packetimpact/testbench",