netbird/gvisor
0
0
Fork 0
mirror of https://github.com/netbirdio/gvisor.git synced 2026-05-22 17:12:49 -07:00
Code Issues Packages Projects Releases Wiki Activity

pkg/buffer: Remove dependency to safemem, code no longer used

Browse Source 
PiperOrigin-RevId: 373846881
This commit is contained in:
Ting-Yu Wang
2021-05-14 12:53:29 -07:00
committed by gVisor bot
parent 436148d68a
commit 2ac6b76884
3 changed files with 0 additions and 310 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/buffer/BUILD
-5
View File
@@ -21,7 +21,6 @@ go_library(
"buffer.go",
"buffer_list.go",
"pool.go",
"safemem.go",
"view.go",
"view_unsafe.go",
],
@@ -29,8 +28,6 @@ go_library(
deps = [
"//pkg/context",
"//pkg/log",
"//pkg/safemem",
"//pkg/usermem",
],
)
@@ -40,12 +37,10 @@ go_test(
srcs = [
"buffer_test.go",
"pool_test.go",
"safemem_test.go",
"view_test.go",
],
library = ":buffer",
deps = [
"//pkg/safemem",
"//pkg/state",
],
)
pkg/buffer/safemem.go
-133
View File
@@ -1,133 +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 (
"gvisor.dev/gvisor/pkg/safemem"
)
// WriteBlock returns this buffer as a write Block.
func (b *buffer) WriteBlock() safemem.Block {
return safemem.BlockFromSafeSlice(b.WriteSlice())
}
// ReadBlock returns this buffer as a read Block.
func (b *buffer) ReadBlock() safemem.Block {
return safemem.BlockFromSafeSlice(b.ReadSlice())
}
// WriteFromSafememReader writes up to count bytes from r to v and advances the
// write index by the number of bytes written. It calls r.ReadToBlocks() at
// most once.
func (v *View) WriteFromSafememReader(r safemem.Reader, count uint64) (uint64, error) {
if count == 0 {
return 0, nil
}
var (
dst safemem.BlockSeq
blocks []safemem.Block
)
// Need at least one buffer.
firstBuf := v.data.Back()
if firstBuf == nil {
firstBuf = v.pool.get()
v.data.PushBack(firstBuf)
}
// Does the last block have sufficient capacity alone?
if l := uint64(firstBuf.WriteSize()); l >= count {
dst = safemem.BlockSeqOf(firstBuf.WriteBlock().TakeFirst64(count))
} else {
// Append blocks until sufficient.
count -= l
blocks = append(blocks, firstBuf.WriteBlock())
for count > 0 {
emptyBuf := v.pool.get()
v.data.PushBack(emptyBuf)
block := emptyBuf.WriteBlock().TakeFirst64(count)
count -= uint64(block.Len())
blocks = append(blocks, block)
}
dst = safemem.BlockSeqFromSlice(blocks)
}
// Perform I/O.
n, err := r.ReadToBlocks(dst)
v.size += int64(n)
// Update all indices.
for left := n; left > 0; firstBuf = firstBuf.Next() {
if l := firstBuf.WriteSize(); left >= uint64(l) {
firstBuf.WriteMove(l) // Whole block.
left -= uint64(l)
} else {
firstBuf.WriteMove(int(left)) // Partial block.
left = 0
}
}
return n, err
}
// WriteFromBlocks implements safemem.Writer.WriteFromBlocks. It advances the
// write index by the number of bytes written.
func (v *View) WriteFromBlocks(srcs safemem.BlockSeq) (uint64, error) {
return v.WriteFromSafememReader(&safemem.BlockSeqReader{srcs}, srcs.NumBytes())
}
// ReadToSafememWriter reads up to count bytes from v to w. It does not advance
// the read index. It calls w.WriteFromBlocks() at most once.
func (v *View) ReadToSafememWriter(w safemem.Writer, count uint64) (uint64, error) {
if count == 0 {
return 0, nil
}
var (
src safemem.BlockSeq
blocks []safemem.Block
)
firstBuf := v.data.Front()
if firstBuf == nil {
return 0, nil // No EOF.
}
// Is all the data in a single block?
if l := uint64(firstBuf.ReadSize()); l >= count {
src = safemem.BlockSeqOf(firstBuf.ReadBlock().TakeFirst64(count))
} else {
// Build a list of all the buffers.
count -= l
blocks = append(blocks, firstBuf.ReadBlock())
for buf := firstBuf.Next(); buf != nil && count > 0; buf = buf.Next() {
block := buf.ReadBlock().TakeFirst64(count)
count -= uint64(block.Len())
blocks = append(blocks, block)
}
src = safemem.BlockSeqFromSlice(blocks)
}
// Perform I/O. As documented, we don't advance the read index.
return w.WriteFromBlocks(src)
}
// ReadToBlocks implements safemem.Reader.ReadToBlocks. It does not advance the
// read index by the number of bytes read, such that it's only safe to call if
// the caller guarantees that ReadToBlocks will only be called once.
func (v *View) ReadToBlocks(dsts safemem.BlockSeq) (uint64, error) {
return v.ReadToSafememWriter(&safemem.BlockSeqWriter{dsts}, dsts.NumBytes())
}
pkg/buffer/safemem_test.go
-172
View File
@@ -1,172 +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"
"strings"
"testing"
"gvisor.dev/gvisor/pkg/safemem"
)
func TestSafemem(t *testing.T) {
const bufferSize = defaultBufferSize
testCases := []struct {
name string
input string
output string
readLen int
op func(*View)
}{
// Basic coverage.
{
name: "short",
input: "010",
output: "010",
},
{
name: "long",
input: "0" + strings.Repeat("1", bufferSize) + "0",
output: "0" + strings.Repeat("1", bufferSize) + "0",
},
{
name: "short-read",
input: "0",
readLen: 100, // > size.
output: "0",
},
{
name: "zero-read",
input: "0",
output: "",
},
{
name: "read-empty",
input: "",
readLen: 1, // > size.
output: "",
},
// Ensure offsets work.
{
name: "offsets-short",
input: "012",
output: "2",
op: func(v *View) {
v.TrimFront(2)
},
},
{
name: "offsets-long0",
input: "0" + strings.Repeat("1", bufferSize) + "0",
output: strings.Repeat("1", bufferSize) + "0",
op: func(v *View) {
v.TrimFront(1)
},
},
{
name: "offsets-long1",
input: "0" + strings.Repeat("1", bufferSize) + "0",
output: strings.Repeat("1", bufferSize-1) + "0",
op: func(v *View) {
v.TrimFront(2)
},
},
{
name: "offsets-long2",
input: "0" + strings.Repeat("1", bufferSize) + "0",
output: "10",
op: func(v *View) {
v.TrimFront(bufferSize)
},
},
// Ensure truncation works.
{
name: "truncate-short",
input: "012",
output: "01",
op: func(v *View) {
v.Truncate(2)
},
},
{
name: "truncate-long0",
input: "0" + strings.Repeat("1", bufferSize) + "0",
output: "0" + strings.Repeat("1", bufferSize),
op: func(v *View) {
v.Truncate(bufferSize + 1)
},
},
{
name: "truncate-long1",
input: "0" + strings.Repeat("1", bufferSize) + "0",
output: "0" + strings.Repeat("1", bufferSize-1),
op: func(v *View) {
v.Truncate(bufferSize)
},
},
{
name: "truncate-long2",
input: "0" + strings.Repeat("1", bufferSize) + "0",
output: "01",
op: func(v *View) {
v.Truncate(2)
},
},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
// Construct the new view.
var view View
bs := safemem.BlockSeqOf(safemem.BlockFromSafeSlice([]byte(tc.input)))
n, err := view.WriteFromBlocks(bs)
if err != nil {
t.Errorf("expected err nil, got %v", err)
}
if n != uint64(len(tc.input)) {
t.Errorf("expected %d bytes, got %d", len(tc.input), n)
}
// Run the operation.
if tc.op != nil {
tc.op(&view)
}
// Read and validate.
readLen := tc.readLen
if readLen == 0 {
readLen = len(tc.output) // Default.
}
out := make([]byte, readLen)
bs = safemem.BlockSeqOf(safemem.BlockFromSafeSlice(out))
n, err = view.ReadToBlocks(bs)
if err != nil {
t.Errorf("expected nil, got %v", err)
}
if n != uint64(len(tc.output)) {
t.Errorf("expected %d bytes, got %d", len(tc.output), n)
}
// Ensure the contents are correct.
if !bytes.Equal(out[:n], []byte(tc.output[:n])) {
t.Errorf("contents are wrong: expected %q, got %q", tc.output, string(out))
}
})
}
}