diff --git a/pkg/buffer/BUILD b/pkg/buffer/BUILD deleted file mode 100644 index 19cd28a32..000000000 --- a/pkg/buffer/BUILD +++ /dev/null @@ -1,46 +0,0 @@ -load("//tools:defs.bzl", "go_library", "go_test") -load("//tools/go_generics:defs.bzl", "go_template_instance") - -package(licenses = ["notice"]) - -go_template_instance( - name = "buffer_list", - out = "buffer_list.go", - package = "buffer", - prefix = "buffer", - template = "//pkg/ilist:generic_list", - types = { - "Element": "*buffer", - "Linker": "*buffer", - }, -) - -go_library( - name = "buffer", - srcs = [ - "buffer.go", - "buffer_list.go", - "pool.go", - "view.go", - "view_unsafe.go", - ], - visibility = ["//visibility:public"], - deps = [ - "//pkg/context", - "//pkg/log", - ], -) - -go_test( - name = "buffer_test", - size = "small", - srcs = [ - "buffer_test.go", - "pool_test.go", - "view_test.go", - ], - library = ":buffer", - deps = [ - "//pkg/state", - ], -) diff --git a/pkg/buffer/buffer.go b/pkg/buffer/buffer.go deleted file mode 100644 index 84d112547..000000000 --- a/pkg/buffer/buffer.go +++ /dev/null @@ -1,114 +0,0 @@ -// Copyright 2020 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. -// -// A view is an flexible buffer, supporting the safecopy operations natively as -// 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 -type buffer struct { - data []byte - read int - write int - bufferEntry -} - -// init performs in-place initialization for zero value. -func (b *buffer) init(size int) { - b.data = make([]byte, size) -} - -// initWithData initializes b with data, taking ownership. -func (b *buffer) initWithData(data []byte) { - b.data = data - b.read = 0 - b.write = len(data) -} - -// Reset resets read and write locations, effectively emptying the buffer. -func (b *buffer) Reset() { - b.read = 0 - b.write = 0 -} - -// Remove removes r from the unread portion. It returns false if r does not -// fully reside in b. -func (b *buffer) Remove(r Range) bool { - sz := b.ReadSize() - switch { - case r.Len() != r.Intersect(Range{end: sz}).Len(): - return false - case r.Len() == 0: - // Noop - case r.begin == 0: - b.read += r.end - case r.end == sz: - b.write -= r.Len() - default: - // Remove from the middle of b.data. - copy(b.data[b.read+r.begin:], b.data[b.read+r.end:b.write]) - b.write -= r.Len() - } - return true -} - -// Full indicates the buffer is full. -// -// This indicates there is no capacity left to write. -func (b *buffer) Full() bool { - return b.write == len(b.data) -} - -// ReadSize returns the number of bytes available for reading. -func (b *buffer) ReadSize() int { - return b.write - b.read -} - -// ReadMove advances the read index by the given amount. -func (b *buffer) ReadMove(n int) { - b.read += n -} - -// ReadSlice returns the read slice for this buffer. -func (b *buffer) ReadSlice() []byte { - return b.data[b.read:b.write] -} - -// WriteSize returns the number of bytes available for writing. -func (b *buffer) WriteSize() int { - return len(b.data) - b.write -} - -// WriteMove advances the write index by the given amount. -func (b *buffer) WriteMove(n int) { - b.write += n -} - -// WriteSlice returns the write slice for this buffer. -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/buffer_test.go b/pkg/buffer/buffer_test.go deleted file mode 100644 index 32db841e4..000000000 --- a/pkg/buffer/buffer_test.go +++ /dev/null @@ -1,111 +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 ( - "bytes" - "testing" -) - -func TestBufferRemove(t *testing.T) { - sample := []byte("01234567") - - // Success cases - for _, tc := range []struct { - desc string - data []byte - rng Range - want []byte - }{ - { - desc: "empty slice", - }, - { - desc: "empty range", - data: sample, - want: sample, - }, - { - desc: "empty range with positive begin", - data: sample, - rng: Range{begin: 1, end: 1}, - want: sample, - }, - { - desc: "range at beginning", - data: sample, - rng: Range{begin: 0, end: 1}, - want: sample[1:], - }, - { - desc: "range in middle", - data: sample, - rng: Range{begin: 2, end: 4}, - want: []byte("014567"), - }, - { - desc: "range at end", - data: sample, - rng: Range{begin: 7, end: 8}, - want: sample[:7], - }, - { - desc: "range all", - data: sample, - rng: Range{begin: 0, end: 8}, - }, - } { - t.Run(tc.desc, func(t *testing.T) { - var buf buffer - buf.initWithData(tc.data) - if ok := buf.Remove(tc.rng); !ok { - t.Errorf("buf.Remove(%#v) = false, want true", tc.rng) - } else if got := buf.ReadSlice(); !bytes.Equal(got, tc.want) { - t.Errorf("buf.ReadSlice() = %q, want %q", got, tc.want) - } - }) - } - - // Failure cases - for _, tc := range []struct { - desc string - data []byte - rng Range - }{ - { - desc: "begin out-of-range", - data: sample, - rng: Range{begin: -1, end: 4}, - }, - { - desc: "end out-of-range", - data: sample, - rng: Range{begin: 4, end: 9}, - }, - { - desc: "both out-of-range", - data: sample, - rng: Range{begin: -100, end: 100}, - }, - } { - t.Run(tc.desc, func(t *testing.T) { - var buf buffer - buf.initWithData(tc.data) - if ok := buf.Remove(tc.rng); ok { - t.Errorf("buf.Remove(%#v) = true, want false", tc.rng) - } - }) - } -} diff --git a/pkg/buffer/pool.go b/pkg/buffer/pool.go deleted file mode 100644 index 2ec41dd4f..000000000 --- a/pkg/buffer/pool.go +++ /dev/null @@ -1,90 +0,0 @@ -// Copyright 2020 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 - -const ( - // embeddedCount is the number of buffer structures embedded in the pool. It - // is also the number for overflow allocations. - embeddedCount = 8 - - // defaultBufferSize is the default size for each underlying storage buffer. - // - // It is slightly less than two pages. This is done intentionally to ensure - // that the buffer object aligns with runtime internals. This two page size - // will effectively minimize internal fragmentation, but still have a large - // enough chunk to limit excessive segmentation. - defaultBufferSize = 8144 -) - -// pool allocates buffer. -// -// It contains an embedded buffer storage for fast path when the number of -// buffers needed is small. -// -// +stateify savable -type pool struct { - bufferSize int - avail []buffer `state:"nosave"` - embeddedStorage [embeddedCount]buffer `state:"wait"` -} - -// get gets a new buffer from p. -func (p *pool) get() *buffer { - buf := p.getNoInit() - buf.init(p.bufferSize) - return buf -} - -// get gets a new buffer from p without initializing it. -func (p *pool) getNoInit() *buffer { - if p.avail == nil { - p.avail = p.embeddedStorage[:] - } - if len(p.avail) == 0 { - p.avail = make([]buffer, embeddedCount) - } - if p.bufferSize <= 0 { - p.bufferSize = defaultBufferSize - } - buf := &p.avail[0] - p.avail = p.avail[1:] - return buf -} - -// put releases buf. -func (p *pool) put(buf *buffer) { - // Remove reference to the underlying storage, allowing it to be garbage - // collected. - buf.data = nil - buf.Reset() -} - -// setBufferSize sets the size of underlying storage buffer for future -// allocations. It can be called at any time. -func (p *pool) setBufferSize(size int) { - p.bufferSize = size -} - -// afterLoad is invoked by stateify. -func (p *pool) afterLoad() { - // S/R does not save subslice into embeddedStorage correctly. Restore - // available portion of embeddedStorage manually. Restore as nil if none used. - for i := len(p.embeddedStorage); i > 0; i-- { - if p.embeddedStorage[i-1].data != nil { - p.avail = p.embeddedStorage[i:] - break - } - } -} diff --git a/pkg/buffer/pool_test.go b/pkg/buffer/pool_test.go deleted file mode 100644 index 8584bac89..000000000 --- a/pkg/buffer/pool_test.go +++ /dev/null @@ -1,51 +0,0 @@ -// Copyright 2020 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 ( - "testing" -) - -func TestGetDefaultBufferSize(t *testing.T) { - var p pool - for i := 0; i < embeddedCount*2; i++ { - buf := p.get() - if got, want := len(buf.data), defaultBufferSize; got != want { - t.Errorf("#%d len(buf.data) = %d, want %d", i, got, want) - } - } -} - -func TestGetCustomBufferSize(t *testing.T) { - const size = 100 - - var p pool - p.setBufferSize(size) - for i := 0; i < embeddedCount*2; i++ { - buf := p.get() - if got, want := len(buf.data), size; got != want { - t.Errorf("#%d len(buf.data) = %d, want %d", i, got, want) - } - } -} - -func TestPut(t *testing.T) { - var p pool - buf := p.get() - p.put(buf) - if buf.data != nil { - t.Errorf("buf.data = %x, want nil", buf.data) - } -} diff --git a/pkg/buffer/view.go b/pkg/buffer/view.go deleted file mode 100644 index cc0cddfbf..000000000 --- a/pkg/buffer/view.go +++ /dev/null @@ -1,623 +0,0 @@ -// Copyright 2020 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 ( - "bytes" - "fmt" - "io" -) - -// Buffer is an alias to View. -type Buffer = View - -// View is a non-linear buffer. -// -// All methods are thread compatible. -// -// +stateify savable -type View struct { - data bufferList - size int64 - pool pool -} - -// NewWithData creates a new view initialized with given data. -func NewWithData(b []byte) View { - v := View{ - size: int64(len(b)), - } - if len(b) > 0 { - buf := v.pool.getNoInit() - buf.initWithData(b) - v.data.PushBack(buf) - } - return v -} - -// TrimFront removes the first count bytes from the buffer. -func (v *View) TrimFront(count int64) { - if count >= v.size { - v.advanceRead(v.size) - } else { - v.advanceRead(count) - } -} - -// Remove deletes data at specified location in v. It returns false if specified -// range does not fully reside in v. -func (v *View) Remove(offset, length int) bool { - if offset < 0 || length < 0 { - return false - } - tgt := Range{begin: offset, end: offset + length} - if tgt.Len() != tgt.Intersect(Range{end: int(v.size)}).Len() { - return false - } - - // Scan through each buffer and remove intersections. - var curr Range - for buf := v.data.Front(); buf != nil; { - origLen := buf.ReadSize() - curr.end = curr.begin + origLen - - if x := curr.Intersect(tgt); x.Len() > 0 { - if !buf.Remove(x.Offset(-curr.begin)) { - panic("buf.Remove() failed") - } - if buf.ReadSize() == 0 { - // buf fully removed, removing it from the list. - oldBuf := buf - buf = buf.Next() - v.data.Remove(oldBuf) - v.pool.put(oldBuf) - } else { - // Only partial data intersects, moving on to next one. - buf = buf.Next() - } - v.size -= int64(x.Len()) - } else { - // This buffer is not in range, moving on to next one. - buf = buf.Next() - } - - curr.begin += origLen - if curr.begin >= tgt.end { - break - } - } - return true -} - -// ReadAt implements io.ReaderAt.ReadAt. -func (v *View) ReadAt(p []byte, offset int64) (int, error) { - var ( - skipped int64 - done int64 - ) - for buf := v.data.Front(); buf != nil && done < int64(len(p)); buf = buf.Next() { - needToSkip := int(offset - skipped) - if sz := buf.ReadSize(); sz <= needToSkip { - skipped += int64(sz) - continue - } - - // Actually read data. - n := copy(p[done:], buf.ReadSlice()[needToSkip:]) - skipped += int64(needToSkip) - done += int64(n) - } - if int(done) < len(p) || offset+done == v.size { - return int(done), io.EOF - } - return int(done), nil -} - -// advanceRead advances the view's read index. -// -// Precondition: there must be sufficient bytes in the buffer. -func (v *View) advanceRead(count int64) { - for buf := v.data.Front(); buf != nil && count > 0; { - sz := int64(buf.ReadSize()) - if sz > count { - // There is still data for reading. - buf.ReadMove(int(count)) - v.size -= count - count = 0 - break - } - - // Consume the whole buffer. - oldBuf := buf - buf = buf.Next() // Iterate. - v.data.Remove(oldBuf) - v.pool.put(oldBuf) - - // Update counts. - count -= sz - v.size -= sz - } - if count > 0 { - panic(fmt.Sprintf("advanceRead still has %d bytes remaining", count)) - } -} - -// Truncate truncates the view to the given bytes. -// -// This will not grow the view, only shrink it. If a length is passed that is -// greater than the current size of the view, then nothing will happen. -// -// Precondition: length must be >= 0. -func (v *View) Truncate(length int64) { - if length < 0 { - panic("negative length provided") - } - if length >= v.size { - return // Nothing to do. - } - for buf := v.data.Back(); buf != nil && v.size > length; buf = v.data.Back() { - sz := int64(buf.ReadSize()) - if after := v.size - sz; after < length { - // Truncate the buffer locally. - left := (length - after) - buf.write = buf.read + int(left) - v.size = length - break - } - - // Drop the buffer completely; see above. - v.data.Remove(buf) - v.pool.put(buf) - v.size -= sz - } -} - -// Grow grows the given view to the number of bytes, which will be appended. If -// zero is true, all these bytes will be zero. If zero is false, then this is -// the caller's responsibility. -// -// Precondition: length must be >= 0. -func (v *View) Grow(length int64, zero bool) { - if length < 0 { - panic("negative length provided") - } - for v.size < length { - buf := v.data.Back() - - // Is there some space in the last buffer? - if buf == nil || buf.Full() { - buf = v.pool.get() - v.data.PushBack(buf) - } - - // Write up to length bytes. - sz := buf.WriteSize() - if int64(sz) > length-v.size { - sz = int(length - v.size) - } - - // Zero the written section; note that this pattern is - // specifically recognized and optimized by the compiler. - if zero { - for i := buf.write; i < buf.write+sz; i++ { - buf.data[i] = 0 - } - } - - // Advance the index. - buf.WriteMove(sz) - v.size += int64(sz) - } -} - -// Prepend prepends the given data. -func (v *View) Prepend(data []byte) { - // Is there any space in the first buffer? - if buf := v.data.Front(); buf != nil && buf.read > 0 { - // Fill up before the first write. - avail := buf.read - bStart := 0 - dStart := len(data) - avail - if avail > len(data) { - bStart = avail - len(data) - dStart = 0 - } - n := copy(buf.data[bStart:], data[dStart:]) - data = data[:dStart] - v.size += int64(n) - buf.read -= n - } - - for len(data) > 0 { - // Do we need an empty buffer? - buf := v.pool.get() - v.data.PushFront(buf) - - // The buffer is empty; copy last chunk. - avail := len(buf.data) - bStart := 0 - dStart := len(data) - avail - if avail > len(data) { - bStart = avail - len(data) - dStart = 0 - } - - // We have to put the data at the end of the current - // buffer in order to ensure that the next prepend will - // correctly fill up the beginning of this buffer. - n := copy(buf.data[bStart:], data[dStart:]) - data = data[:dStart] - v.size += int64(n) - buf.read = len(buf.data) - n - buf.write = len(buf.data) - } -} - -// Append appends the given data. -func (v *View) Append(data []byte) { - for done := 0; done < len(data); { - buf := v.data.Back() - - // Ensure there's a buffer with space. - if buf == nil || buf.Full() { - buf = v.pool.get() - v.data.PushBack(buf) - } - - // Copy in to the given buffer. - n := copy(buf.WriteSlice(), data[done:]) - done += n - buf.WriteMove(n) - v.size += int64(n) - } -} - -// AppendOwned takes ownership of data and appends it to v. -func (v *View) AppendOwned(data []byte) { - if len(data) > 0 { - buf := v.pool.getNoInit() - buf.initWithData(data) - v.data.PushBack(buf) - v.size += int64(len(data)) - } -} - -// PrependOwned takes ownership of data and prepends it to v. -func (v *View) PrependOwned(data []byte) { - if len(data) > 0 { - buf := v.pool.getNoInit() - buf.initWithData(data) - v.data.PushFront(buf) - v.size += int64(len(data)) - } -} - -// PullUp makes the specified range contiguous and returns the backing memory. -func (v *View) PullUp(offset, length int) ([]byte, bool) { - if length == 0 { - return nil, true - } - tgt := Range{begin: offset, end: offset + length} - if tgt.Intersect(Range{end: int(v.size)}).Len() != length { - return nil, false - } - - curr := Range{} - buf := v.data.Front() - for ; buf != nil; buf = buf.Next() { - origLen := buf.ReadSize() - curr.end = curr.begin + origLen - - if x := curr.Intersect(tgt); x.Len() == tgt.Len() { - // buf covers the whole requested target range. - sub := x.Offset(-curr.begin) - return buf.ReadSlice()[sub.begin:sub.end], true - } else if x.Len() > 0 { - // buf is pointing at the starting buffer we want to merge. - break - } - - curr.begin += origLen - } - - // Calculate the total merged length. - totLen := 0 - for n := buf; n != nil; n = n.Next() { - totLen += n.ReadSize() - if curr.begin+totLen >= tgt.end { - break - } - } - - // Merge the buffers. - data := make([]byte, totLen) - off := 0 - for n := buf; n != nil && off < totLen; { - copy(data[off:], n.ReadSlice()) - off += n.ReadSize() - - // Remove buffers except for the first one, which will be reused. - if n == buf { - n = n.Next() - } else { - old := n - n = n.Next() - v.data.Remove(old) - v.pool.put(old) - } - } - - // Update the first buffer with merged data. - buf.initWithData(data) - - r := tgt.Offset(-curr.begin) - return buf.data[r.begin:r.end], true -} - -// Flatten returns a flattened copy of this data. -// -// This method should not be used in any performance-sensitive paths. It may -// allocate a fresh byte slice sufficiently large to contain all the data in -// the buffer. This is principally for debugging. -// -// N.B. Tee data still belongs to this view, as if there is a single buffer -// present, then it will be returned directly. This should be used for -// temporary use only, and a reference to the given slice should not be held. -func (v *View) Flatten() []byte { - if buf := v.data.Front(); buf == nil { - return nil // No data at all. - } else if buf.Next() == nil { - return buf.ReadSlice() // Only one buffer. - } - data := make([]byte, 0, v.size) // Need to flatten. - for buf := v.data.Front(); buf != nil; buf = buf.Next() { - // Copy to the allocated slice. - data = append(data, buf.ReadSlice()...) - } - return data -} - -// Size indicates the total amount of data available in this view. -func (v *View) Size() int64 { - return v.size -} - -// Copy makes a strict copy of this view. -func (v *View) Copy() (other View) { - for buf := v.data.Front(); buf != nil; buf = buf.Next() { - other.Append(buf.ReadSlice()) - } - return -} - -// Clone makes a more shallow copy compared to Copy. The underlying payload -// slice (buffer.data) is shared but the buffers themselves are copied. -func (v *View) Clone() View { - other := View{ - size: v.size, - } - for buf := v.data.Front(); buf != nil; buf = buf.Next() { - // Copy the buffer structs itself as they are stateful and - // should not be shared between Views. - // - // TODO(gvisor.dev/issue/7158): revisit need for View.pool. - newBuf := other.pool.getNoInit() - *newBuf = *buf - other.data.PushBack(newBuf) - } - return other -} - -// Apply applies the given function across all valid data. -func (v *View) Apply(fn func([]byte)) { - for buf := v.data.Front(); buf != nil; buf = buf.Next() { - fn(buf.ReadSlice()) - } -} - -// SubApply applies fn to a given range of data in v. Any part of the range -// outside of v is ignored. -func (v *View) SubApply(offset, length int, fn func([]byte)) { - for buf := v.data.Front(); length > 0 && buf != nil; buf = buf.Next() { - d := buf.ReadSlice() - if offset >= len(d) { - offset -= len(d) - continue - } - if offset > 0 { - d = d[offset:] - offset = 0 - } - if length < len(d) { - d = d[:length] - } - fn(d) - length -= len(d) - } -} - -// Merge merges the provided View with this one. -// -// The other view will be appended to v, and other will be empty after this -// operation completes. -func (v *View) Merge(other *View) { - // Copy over all buffers. - for buf := other.data.Front(); buf != nil; buf = other.data.Front() { - other.data.Remove(buf) - // Copy the buffer structs itself as they are stateful and - // should not be shared between Views. - // - // TODO(gvisor.dev/issue/7158): revisit need for View.pool. - newBuf := v.pool.getNoInit() - *newBuf = *buf - v.data.PushBack(newBuf) - } - - // Adjust sizes. - v.size += other.size - other.size = 0 -} - -// WriteFromReader writes to the buffer from an io.Reader. -// -// A minimum read size equal to unsafe.Sizeof(unintptr) is enforced, -// provided that count is greater than or equal to unsafe.Sizeof(uintptr). -func (v *View) WriteFromReader(r io.Reader, count int64) (int64, error) { - var ( - done int64 - n int - err error - ) - for done < count { - buf := v.data.Back() - - // Ensure we have an empty buffer. - if buf == nil || buf.Full() { - buf = v.pool.get() - v.data.PushBack(buf) - } - - // Is this less than the minimum batch? - if buf.WriteSize() < minBatch && (count-done) >= int64(minBatch) { - tmp := make([]byte, minBatch) - n, err = r.Read(tmp) - v.Append(tmp[:n]) - done += int64(n) - if err != nil { - break - } - continue - } - - // Limit the read, if necessary. - sz := buf.WriteSize() - if left := count - done; int64(sz) > left { - sz = int(left) - } - - // Pass the relevant portion of the buffer. - n, err = r.Read(buf.WriteSlice()[:sz]) - buf.WriteMove(n) - done += int64(n) - v.size += int64(n) - if err == io.EOF { - err = nil // Short write allowed. - break - } else if err != nil { - break - } - } - return done, err -} - -// ReadToWriter reads from the buffer into an io.Writer. -// -// N.B. This does not consume the bytes read. TrimFront should -// be called appropriately after this call in order to do so. -// -// A minimum write size equal to unsafe.Sizeof(unintptr) is enforced, -// provided that count is greater than or equal to unsafe.Sizeof(uintptr). -func (v *View) ReadToWriter(w io.Writer, count int64) (int64, error) { - var ( - done int64 - n int - err error - ) - offset := 0 // Spill-over for batching. - for buf := v.data.Front(); buf != nil && done < count; buf = buf.Next() { - // Has this been consumed? Skip it. - sz := buf.ReadSize() - if sz <= offset { - offset -= sz - continue - } - sz -= offset - - // Is this less than the minimum batch? - left := count - done - if sz < minBatch && left >= int64(minBatch) && (v.size-done) >= int64(minBatch) { - tmp := make([]byte, minBatch) - n, err = v.ReadAt(tmp, done) - w.Write(tmp[:n]) - done += int64(n) - offset = n - sz // Reset below. - if err != nil { - break - } - continue - } - - // Limit the write if necessary. - if int64(sz) >= left { - sz = int(left) - } - - // Perform the actual write. - n, err = w.Write(buf.ReadSlice()[offset : offset+sz]) - done += int64(n) - if err != nil { - break - } - - // Reset spill-over. - offset = 0 - } - return done, err -} - -// A Range specifies a range of buffer. -type Range struct { - begin int - end int -} - -// Intersect returns the intersection of x and y. -func (x Range) Intersect(y Range) Range { - if x.begin < y.begin { - x.begin = y.begin - } - if x.end > y.end { - x.end = y.end - } - if x.begin >= x.end { - return Range{} - } - return x -} - -// Offset returns x offset by off. -func (x Range) Offset(off int) Range { - x.begin += off - x.end += off - return x -} - -// Len returns the length of x. -func (x Range) Len() int { - l := x.end - x.begin - if l < 0 { - l = 0 - } - 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/buffer/view_test.go b/pkg/buffer/view_test.go deleted file mode 100644 index 59784eacb..000000000 --- a/pkg/buffer/view_test.go +++ /dev/null @@ -1,918 +0,0 @@ -// Copyright 2020 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 ( - "bytes" - "context" - "fmt" - "io" - "reflect" - "strings" - "testing" - - "gvisor.dev/gvisor/pkg/state" -) - -const bufferSize = defaultBufferSize - -func fillAppend(v *View, data []byte) { - v.Append(data) -} - -func fillAppendEnd(v *View, data []byte) { - v.Grow(bufferSize-1, false) - v.Append(data) - v.TrimFront(bufferSize - 1) -} - -func fillWriteFromReader(v *View, data []byte) { - b := bytes.NewBuffer(data) - v.WriteFromReader(b, int64(len(data))) -} - -func fillWriteFromReaderEnd(v *View, data []byte) { - v.Grow(bufferSize-1, false) - b := bytes.NewBuffer(data) - v.WriteFromReader(b, int64(len(data))) - v.TrimFront(bufferSize - 1) -} - -var fillFuncs = map[string]func(*View, []byte){ - "append": fillAppend, - "appendEnd": fillAppendEnd, - "writeFromReader": fillWriteFromReader, - "writeFromReaderEnd": fillWriteFromReaderEnd, -} - -func BenchmarkReadAt(b *testing.B) { - b.ReportAllocs() - var v View - v.Append(make([]byte, 100)) - - buf := make([]byte, 10) - for i := 0; i < b.N; i++ { - v.ReadAt(buf, 0) - } -} - -func BenchmarkWriteRead(b *testing.B) { - b.ReportAllocs() - var v View - sz := 1000 - wbuf := make([]byte, sz) - rbuf := bytes.NewBuffer(make([]byte, sz)) - for i := 0; i < b.N; i++ { - v.Append(wbuf) - rbuf.Reset() - v.ReadToWriter(rbuf, int64(sz)) - } -} - -func testReadAt(t *testing.T, v *View, offset int64, n int, wantStr string, wantErr error) { - t.Helper() - d := make([]byte, n) - n, err := v.ReadAt(d, offset) - if n != len(wantStr) { - t.Errorf("got %d, want %d", n, len(wantStr)) - } - if err != wantErr { - t.Errorf("got err %v, want %v", err, wantErr) - } - if !bytes.Equal(d[:n], []byte(wantStr)) { - t.Errorf("got %q, want %q", string(d[:n]), wantStr) - } -} - -func TestView(t *testing.T) { - testCases := []struct { - name string - input string - output string - op func(*testing.T, *View) - }{ - // Preconditions. - { - name: "truncate-check", - input: "hello", - output: "hello", // Not touched. - op: func(t *testing.T, v *View) { - defer func() { - if r := recover(); r == nil { - t.Errorf("Truncate(-1) did not panic") - } - }() - v.Truncate(-1) - }, - }, - { - name: "grow-check", - input: "hello", - output: "hello", // Not touched. - op: func(t *testing.T, v *View) { - defer func() { - if r := recover(); r == nil { - t.Errorf("Grow(-1) did not panic") - } - }() - v.Grow(-1, false) - }, - }, - { - name: "advance-check", - input: "hello", - output: "", // Consumed. - op: func(t *testing.T, v *View) { - defer func() { - if r := recover(); r == nil { - t.Errorf("advanceRead(Size()+1) did not panic") - } - }() - v.advanceRead(v.Size() + 1) - }, - }, - - // Prepend. - { - name: "prepend", - input: "world", - output: "hello world", - op: func(t *testing.T, v *View) { - v.Prepend([]byte("hello ")) - }, - }, - { - name: "prepend-backfill-full", - input: "hello world", - output: "jello world", - op: func(t *testing.T, v *View) { - v.TrimFront(1) - v.Prepend([]byte("j")) - }, - }, - { - name: "prepend-backfill-under", - input: "hello world", - output: "hola world", - op: func(t *testing.T, v *View) { - v.TrimFront(5) - v.Prepend([]byte("hola")) - }, - }, - { - name: "prepend-backfill-over", - input: "hello world", - output: "smello world", - op: func(t *testing.T, v *View) { - v.TrimFront(1) - v.Prepend([]byte("sm")) - }, - }, - { - name: "prepend-fill", - input: strings.Repeat("1", bufferSize-1), - output: "0" + strings.Repeat("1", bufferSize-1), - op: func(t *testing.T, v *View) { - v.Prepend([]byte("0")) - }, - }, - { - name: "prepend-overflow", - input: strings.Repeat("1", bufferSize), - output: "0" + strings.Repeat("1", bufferSize), - op: func(t *testing.T, v *View) { - v.Prepend([]byte("0")) - }, - }, - { - name: "prepend-multiple-buffers", - input: strings.Repeat("1", bufferSize-1), - output: strings.Repeat("0", bufferSize*3) + strings.Repeat("1", bufferSize-1), - op: func(t *testing.T, v *View) { - v.Prepend([]byte(strings.Repeat("0", bufferSize*3))) - }, - }, - - // Append and write. - { - name: "append", - input: "hello", - output: "hello world", - op: func(t *testing.T, v *View) { - v.Append([]byte(" world")) - }, - }, - { - name: "append-fill", - input: strings.Repeat("1", bufferSize-1), - output: strings.Repeat("1", bufferSize-1) + "0", - op: func(t *testing.T, v *View) { - v.Append([]byte("0")) - }, - }, - { - name: "append-overflow", - input: strings.Repeat("1", bufferSize), - output: strings.Repeat("1", bufferSize) + "0", - op: func(t *testing.T, v *View) { - v.Append([]byte("0")) - }, - }, - { - name: "append-multiple-buffers", - input: strings.Repeat("1", bufferSize-1), - output: strings.Repeat("1", bufferSize-1) + strings.Repeat("0", bufferSize*3), - op: func(t *testing.T, v *View) { - v.Append([]byte(strings.Repeat("0", bufferSize*3))) - }, - }, - - // AppendOwned. - { - name: "append-owned", - input: "hello", - output: "hello world", - op: func(t *testing.T, v *View) { - b := []byte("Xworld") - v.AppendOwned(b) - b[0] = ' ' - }, - }, - - // Truncate. - { - name: "truncate", - input: "hello world", - output: "hello", - op: func(t *testing.T, v *View) { - v.Truncate(5) - }, - }, - { - name: "truncate-noop", - input: "hello world", - output: "hello world", - op: func(t *testing.T, v *View) { - v.Truncate(v.Size() + 1) - }, - }, - { - name: "truncate-multiple-buffers", - input: strings.Repeat("1", bufferSize*2), - output: strings.Repeat("1", bufferSize*2-1), - op: func(t *testing.T, v *View) { - v.Truncate(bufferSize*2 - 1) - }, - }, - { - name: "truncate-multiple-buffers-to-one", - input: strings.Repeat("1", bufferSize*2), - output: "11111", - op: func(t *testing.T, v *View) { - v.Truncate(5) - }, - }, - - // TrimFront. - { - name: "trim", - input: "hello world", - output: "world", - op: func(t *testing.T, v *View) { - v.TrimFront(6) - }, - }, - { - name: "trim-too-large", - input: "hello world", - output: "", - op: func(t *testing.T, v *View) { - v.TrimFront(v.Size() + 1) - }, - }, - { - name: "trim-multiple-buffers", - input: strings.Repeat("1", bufferSize*2), - output: strings.Repeat("1", bufferSize*2-1), - op: func(t *testing.T, v *View) { - v.TrimFront(1) - }, - }, - { - name: "trim-multiple-buffers-to-one-buffer", - input: strings.Repeat("1", bufferSize*2), - output: "1", - op: func(t *testing.T, v *View) { - v.TrimFront(bufferSize*2 - 1) - }, - }, - - // Grow. - { - name: "grow", - input: "hello world", - output: "hello world", - op: func(t *testing.T, v *View) { - v.Grow(1, true) - }, - }, - { - name: "grow-from-zero", - output: strings.Repeat("\x00", 1024), - op: func(t *testing.T, v *View) { - v.Grow(1024, true) - }, - }, - { - name: "grow-from-non-zero", - input: strings.Repeat("1", bufferSize), - output: strings.Repeat("1", bufferSize) + strings.Repeat("\x00", bufferSize), - op: func(t *testing.T, v *View) { - v.Grow(bufferSize*2, true) - }, - }, - - // Copy. - { - name: "copy", - input: "hello", - output: "hello", - op: func(t *testing.T, v *View) { - other := v.Copy() - bs := other.Flatten() - want := []byte("hello") - if !bytes.Equal(bs, want) { - t.Errorf("expected %v, got %v", want, bs) - } - }, - }, - { - name: "copy-large", - input: strings.Repeat("1", bufferSize+1), - output: strings.Repeat("1", bufferSize+1), - op: func(t *testing.T, v *View) { - other := v.Copy() - bs := other.Flatten() - want := []byte(strings.Repeat("1", bufferSize+1)) - if !bytes.Equal(bs, want) { - t.Errorf("expected %v, got %v", want, bs) - } - }, - }, - - // Merge. - { - name: "merge", - input: "hello", - output: "hello world", - op: func(t *testing.T, v *View) { - var other View - other.Append([]byte(" world")) - v.Merge(&other) - if sz := other.Size(); sz != 0 { - t.Errorf("expected 0, got %d", sz) - } - }, - }, - { - name: "merge-large", - input: strings.Repeat("1", bufferSize+1), - output: strings.Repeat("1", bufferSize+1) + strings.Repeat("0", bufferSize+1), - op: func(t *testing.T, v *View) { - var other View - other.Append([]byte(strings.Repeat("0", bufferSize+1))) - v.Merge(&other) - if sz := other.Size(); sz != 0 { - t.Errorf("expected 0, got %d", sz) - } - }, - }, - - // ReadAt. - { - name: "readat", - input: "hello", - output: "hello", - op: func(t *testing.T, v *View) { testReadAt(t, v, 0, 6, "hello", io.EOF) }, - }, - { - name: "readat-long", - input: "hello", - output: "hello", - op: func(t *testing.T, v *View) { testReadAt(t, v, 0, 8, "hello", io.EOF) }, - }, - { - name: "readat-short", - input: "hello", - output: "hello", - op: func(t *testing.T, v *View) { testReadAt(t, v, 0, 3, "hel", nil) }, - }, - { - name: "readat-offset", - input: "hello", - output: "hello", - op: func(t *testing.T, v *View) { testReadAt(t, v, 2, 3, "llo", io.EOF) }, - }, - { - name: "readat-long-offset", - input: "hello", - output: "hello", - op: func(t *testing.T, v *View) { testReadAt(t, v, 2, 8, "llo", io.EOF) }, - }, - { - name: "readat-short-offset", - input: "hello", - output: "hello", - op: func(t *testing.T, v *View) { testReadAt(t, v, 2, 2, "ll", nil) }, - }, - { - name: "readat-skip-all", - input: "hello", - output: "hello", - op: func(t *testing.T, v *View) { testReadAt(t, v, bufferSize+1, 1, "", io.EOF) }, - }, - { - name: "readat-second-buffer", - input: strings.Repeat("0", bufferSize+1) + "12", - output: strings.Repeat("0", bufferSize+1) + "12", - op: func(t *testing.T, v *View) { testReadAt(t, v, bufferSize+1, 1, "1", nil) }, - }, - { - name: "readat-second-buffer-end", - input: strings.Repeat("0", bufferSize+1) + "12", - output: strings.Repeat("0", bufferSize+1) + "12", - op: func(t *testing.T, v *View) { testReadAt(t, v, bufferSize+1, 2, "12", io.EOF) }, - }, - } - - for _, tc := range testCases { - for fillName, fn := range fillFuncs { - t.Run(fillName+"/"+tc.name, func(t *testing.T) { - // Construct & fill the view. - var view View - fn(&view, []byte(tc.input)) - - // Run the operation. - if tc.op != nil { - tc.op(t, &view) - } - - // Flatten and validate. - out := view.Flatten() - if !bytes.Equal([]byte(tc.output), out) { - t.Errorf("expected %q, got %q", tc.output, string(out)) - } - - // Ensure the size is correct. - if len(out) != int(view.Size()) { - t.Errorf("size is wrong: expected %d, got %d", len(out), view.Size()) - } - - // Calculate contents via apply. - var appliedOut []byte - view.Apply(func(b []byte) { - appliedOut = append(appliedOut, b...) - }) - if len(appliedOut) != len(out) { - t.Errorf("expected %d, got %d", len(out), len(appliedOut)) - } - if !bytes.Equal(appliedOut, out) { - t.Errorf("expected %v, got %v", out, appliedOut) - } - - // Calculate contents via ReadToWriter. - var b bytes.Buffer - n, err := view.ReadToWriter(&b, int64(len(out))) - if n != int64(len(out)) { - t.Errorf("expected %d, got %d", len(out), n) - } - if err != nil { - t.Errorf("expected nil, got %v", err) - } - if !bytes.Equal(b.Bytes(), out) { - t.Errorf("expected %v, got %v", out, b.Bytes()) - } - }) - } - } -} - -func TestViewClone(t *testing.T) { - const ( - originalSize = 90 - bytesToDelete = 30 - ) - var v View - v.AppendOwned(bytes.Repeat([]byte{originalSize}, originalSize)) - - clonedV := v.Clone() - v.TrimFront(bytesToDelete) - if got, want := int(v.Size()), originalSize-bytesToDelete; got != want { - t.Errorf("original packet was not changed: size expected = %d, got = %d", want, got) - } - if got := clonedV.Size(); got != originalSize { - t.Errorf("cloned packet should not be modified: expected size = %d, got = %d", originalSize, got) - } -} - -func TestViewPullUp(t *testing.T) { - for _, tc := range []struct { - desc string - inputs []string - offset int - length int - output string - failed bool - // lengths is the lengths of each buffer node after the pull up. - lengths []int - }{ - { - desc: "whole empty view", - }, - { - desc: "zero pull", - inputs: []string{"hello", " world"}, - lengths: []int{5, 6}, - }, - { - desc: "whole view", - inputs: []string{"hello", " world"}, - offset: 0, - length: 11, - output: "hello world", - lengths: []int{11}, - }, - { - desc: "middle to end aligned", - inputs: []string{"0123", "45678", "9abcd"}, - offset: 4, - length: 10, - output: "456789abcd", - lengths: []int{4, 10}, - }, - { - desc: "middle to end unaligned", - inputs: []string{"0123", "45678", "9abcd"}, - offset: 6, - length: 8, - output: "6789abcd", - lengths: []int{4, 10}, - }, - { - desc: "middle aligned", - inputs: []string{"0123", "45678", "9abcd", "efgh"}, - offset: 6, - length: 5, - output: "6789a", - lengths: []int{4, 10, 4}, - }, - - // Failed cases. - { - desc: "empty view - length too long", - offset: 0, - length: 1, - failed: true, - }, - { - desc: "empty view - offset too large", - offset: 1, - length: 1, - failed: true, - }, - { - desc: "length too long", - inputs: []string{"0123", "45678", "9abcd"}, - offset: 4, - length: 100, - failed: true, - lengths: []int{4, 5, 5}, - }, - { - desc: "offset too large", - inputs: []string{"0123", "45678", "9abcd"}, - offset: 100, - length: 1, - failed: true, - lengths: []int{4, 5, 5}, - }, - } { - t.Run(tc.desc, func(t *testing.T) { - var v View - for _, s := range tc.inputs { - v.AppendOwned([]byte(s)) - } - - got, gotOk := v.PullUp(tc.offset, tc.length) - want, wantOk := []byte(tc.output), !tc.failed - if gotOk != wantOk || !bytes.Equal(got, want) { - t.Errorf("v.PullUp(%d, %d) = %q, %t; %q, %t", tc.offset, tc.length, got, gotOk, want, wantOk) - } - - var gotLengths []int - for buf := v.data.Front(); buf != nil; buf = buf.Next() { - gotLengths = append(gotLengths, buf.ReadSize()) - } - if !reflect.DeepEqual(gotLengths, tc.lengths) { - t.Errorf("lengths = %v; want %v", gotLengths, tc.lengths) - } - }) - } -} - -func TestViewRemove(t *testing.T) { - // Success cases - for _, tc := range []struct { - desc string - // before is the contents for each buffer node initially. - before []string - // after is the contents for each buffer node after removal. - after []string - offset int - length int - }{ - { - desc: "empty view", - }, - { - desc: "nothing removed", - before: []string{"hello", " world"}, - after: []string{"hello", " world"}, - }, - { - desc: "whole view", - before: []string{"hello", " world"}, - offset: 0, - length: 11, - }, - { - desc: "beginning to middle aligned", - before: []string{"0123", "45678", "9abcd"}, - after: []string{"9abcd"}, - offset: 0, - length: 9, - }, - { - desc: "beginning to middle unaligned", - before: []string{"0123", "45678", "9abcd"}, - after: []string{"678", "9abcd"}, - offset: 0, - length: 6, - }, - { - desc: "middle to end aligned", - before: []string{"0123", "45678", "9abcd"}, - after: []string{"0123"}, - offset: 4, - length: 10, - }, - { - desc: "middle to end unaligned", - before: []string{"0123", "45678", "9abcd"}, - after: []string{"0123", "45"}, - offset: 6, - length: 8, - }, - { - desc: "middle aligned", - before: []string{"0123", "45678", "9abcd"}, - after: []string{"0123", "9abcd"}, - offset: 4, - length: 5, - }, - { - desc: "middle unaligned", - before: []string{"0123", "45678", "9abcd"}, - after: []string{"0123", "4578", "9abcd"}, - offset: 6, - length: 1, - }, - } { - t.Run(tc.desc, func(t *testing.T) { - var v View - for _, s := range tc.before { - v.AppendOwned([]byte(s)) - } - - if ok := v.Remove(tc.offset, tc.length); !ok { - t.Errorf("v.Remove(%d, %d) = false, want true", tc.offset, tc.length) - } - - var got []string - for buf := v.data.Front(); buf != nil; buf = buf.Next() { - got = append(got, string(buf.ReadSlice())) - } - if !reflect.DeepEqual(got, tc.after) { - t.Errorf("after = %v; want %v", got, tc.after) - } - }) - } - - // Failure cases - for _, tc := range []struct { - desc string - // before is the contents for each buffer node initially. - before []string - offset int - length int - }{ - { - desc: "offset out-of-range", - before: []string{"hello", " world"}, - offset: -1, - length: 3, - }, - { - desc: "length too long", - before: []string{"hello", " world"}, - offset: 0, - length: 12, - }, - { - desc: "length too long with positive offset", - before: []string{"hello", " world"}, - offset: 3, - length: 9, - }, - { - desc: "length negative", - before: []string{"hello", " world"}, - offset: 0, - length: -1, - }, - } { - t.Run(tc.desc, func(t *testing.T) { - var v View - for _, s := range tc.before { - v.AppendOwned([]byte(s)) - } - if ok := v.Remove(tc.offset, tc.length); ok { - t.Errorf("v.Remove(%d, %d) = true, want false", tc.offset, tc.length) - } - }) - } -} - -func TestViewSubApply(t *testing.T) { - var v View - v.AppendOwned([]byte("0123")) - v.AppendOwned([]byte("45678")) - v.AppendOwned([]byte("9abcd")) - - data := []byte("0123456789abcd") - - for i := 0; i <= len(data); i++ { - for j := i; j <= len(data); j++ { - t.Run(fmt.Sprintf("SubApply(%d,%d)", i, j), func(t *testing.T) { - var got []byte - v.SubApply(i, j-i, func(b []byte) { - got = append(got, b...) - }) - if want := data[i:j]; !bytes.Equal(got, want) { - t.Errorf("got = %q; want %q", got, want) - } - }) - } - } -} - -func doSaveAndLoad(t *testing.T, toSave, toLoad *View) { - t.Helper() - var buf bytes.Buffer - ctx := context.Background() - if _, err := state.Save(ctx, &buf, toSave); err != nil { - t.Fatal("state.Save:", err) - } - if _, err := state.Load(ctx, bytes.NewReader(buf.Bytes()), toLoad); err != nil { - t.Fatal("state.Load:", err) - } -} - -func TestSaveRestoreViewEmpty(t *testing.T) { - var toSave View - var v View - doSaveAndLoad(t, &toSave, &v) - - if got := v.pool.avail; got != nil { - t.Errorf("pool is not in zero state: v.pool.avail = %v, want nil", got) - } - if got := v.Flatten(); len(got) != 0 { - t.Errorf("v.Flatten() = %x, want []", got) - } -} - -func TestSaveRestoreView(t *testing.T) { - // Create data that fits 2.5 slots. - data := bytes.Join([][]byte{ - bytes.Repeat([]byte{1, 2}, defaultBufferSize), - bytes.Repeat([]byte{3}, defaultBufferSize/2), - }, nil) - - var toSave View - toSave.Append(data) - - var v View - doSaveAndLoad(t, &toSave, &v) - - // Next available slot at index 3; 0-2 slot are used. - i := 3 - if got, want := &v.pool.avail[0], &v.pool.embeddedStorage[i]; got != want { - t.Errorf("next available buffer points to %p, want %p (&v.pool.embeddedStorage[%d])", got, want, i) - } - if got := v.Flatten(); !bytes.Equal(got, data) { - t.Errorf("v.Flatten() = %x, want %x", got, data) - } -} - -func TestRangeIntersect(t *testing.T) { - for _, tc := range []struct { - desc string - x, y, want Range - }{ - { - desc: "empty intersects empty", - }, - { - desc: "empty intersection", - x: Range{end: 10}, - y: Range{begin: 10, end: 20}, - }, - { - desc: "some intersection", - x: Range{begin: 5, end: 20}, - y: Range{end: 10}, - want: Range{begin: 5, end: 10}, - }, - } { - t.Run(tc.desc, func(t *testing.T) { - if got := tc.x.Intersect(tc.y); got != tc.want { - t.Errorf("(%#v).Intersect(%#v) = %#v; want %#v", tc.x, tc.y, got, tc.want) - } - if got := tc.y.Intersect(tc.x); got != tc.want { - t.Errorf("(%#v).Intersect(%#v) = %#v; want %#v", tc.y, tc.x, got, tc.want) - } - }) - } -} - -func TestRangeOffset(t *testing.T) { - for _, tc := range []struct { - input Range - offset int - output Range - }{ - { - input: Range{}, - offset: 0, - output: Range{}, - }, - { - input: Range{}, - offset: -1, - output: Range{begin: -1, end: -1}, - }, - { - input: Range{begin: 10, end: 20}, - offset: -1, - output: Range{begin: 9, end: 19}, - }, - { - input: Range{begin: 10, end: 20}, - offset: 2, - output: Range{begin: 12, end: 22}, - }, - } { - if got := tc.input.Offset(tc.offset); got != tc.output { - t.Errorf("(%#v).Offset(%d) = %#v, want %#v", tc.input, tc.offset, got, tc.output) - } - } -} - -func TestRangeLen(t *testing.T) { - for _, tc := range []struct { - r Range - want int - }{ - {r: Range{}, want: 0}, - {r: Range{begin: 1, end: 1}, want: 0}, - {r: Range{begin: -1, end: -1}, want: 0}, - {r: Range{end: 10}, want: 10}, - {r: Range{begin: 5, end: 10}, want: 5}, - } { - if got := tc.r.Len(); got != tc.want { - t.Errorf("(%#v).Len() = %d, want %d", tc.r, got, tc.want) - } - } -} diff --git a/pkg/buffer/view_unsafe.go b/pkg/buffer/view_unsafe.go deleted file mode 100644 index d1ef39b26..000000000 --- a/pkg/buffer/view_unsafe.go +++ /dev/null @@ -1,25 +0,0 @@ -// Copyright 2020 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" -) - -// minBatch is the smallest Read or Write operation that the -// WriteFromReader and ReadToWriter functions will use. -// -// This is defined as the size of a native pointer. -const minBatch = int(unsafe.Sizeof(uintptr(0)))