remove tons of dead code

Author: JackDoan

overlay/vhostnet/device.go

@@ -123,9 +123,6 @@ func NewDevice(options ...Option) (*Device, error) {
 	if err = dev.refillReceiveQueue(); err != nil {
 		return nil, fmt.Errorf("refill receive queue: %w", err)
 	}
-	if err = dev.refillTransmitQueue(); err != nil {
-		return nil, fmt.Errorf("refill receive queue: %w", err)
-	}
 
 	dev.initialized = true
 
@@ -153,22 +150,6 @@ func (dev *Device) refillReceiveQueue() error {
 	}
 }
 
-func (dev *Device) refillTransmitQueue() error {
-	//for {
-	//	desc, err := dev.TransmitQueue.DescriptorTable().CreateDescriptorForOutputs()
-	//	if err != nil {
-	//		if errors.Is(err, virtqueue.ErrNotEnoughFreeDescriptors) {
-	//			// Queue is full, job is done.
-	//			return nil
-	//		}
-	//		return fmt.Errorf("offer descriptor chain: %w", err)
-	//	} else {
-	//		dev.TransmitQueue.UsedRing().InitOfferSingle(desc, 0)
-	//	}
-	//}
-	return nil
-}
-
 // Close cleans up the vhost networking device within the kernel and releases
 // all resources used for it.
 // The implementation will try to release as many resources as possible and
@@ -214,14 +195,6 @@ func (dev *Device) Close() error {
 	return errors.Join(errs...)
 }
 
-// ensureInitialized is used as a guard to prevent methods to be called on an
-// uninitialized instance.
-func (dev *Device) ensureInitialized() {
-	if !dev.initialized {
-		panic("device is not initialized")
-	}
-}
-
 // createQueue creates a new virtqueue and registers it with the vhost device
 // using the given index.
 func createQueue(controlFD int, queueIndex int, queueSize int, itemSize int) (*virtqueue.SplitQueue, error) {
@@ -238,30 +211,10 @@ func createQueue(controlFD int, queueIndex int, queueSize int, itemSize int) (*v
 	return queue, nil
 }
 
-// truncateBuffers returns a new list of buffers whose combined length matches
-// exactly the specified length. When the specified length exceeds the length of
-// the buffers, this is an error. When it is smaller, the buffer list will be
-// truncated accordingly.
-func truncateBuffers(buffers [][]byte, length int) (out [][]byte) {
-	for _, buffer := range buffers {
-		if length < len(buffer) {
-			out = append(out, buffer[:length])
-			return
-		}
-		out = append(out, buffer)
-		length -= len(buffer)
-	}
-	if length > 0 {
-		panic("length exceeds the combined length of all buffers")
-	}
-	return
-}
-
 func (dev *Device) GetPacketForTx() (uint16, []byte, error) {
 	var err error
 	var idx uint16
 	if !dev.fullTable {
-
 		idx, err = dev.TransmitQueue.DescriptorTable().CreateDescriptorForOutputs()
 		if err == virtqueue.ErrNotEnoughFreeDescriptors {
 			dev.fullTable = true
@@ -393,17 +346,14 @@ func (dev *Device) ReceivePackets(out []*packet.VirtIOPacket) (int, error) {
 	//todo optimize?
 	var chains []virtqueue.UsedElement
 	var err error
-	//if len(dev.extraRx) == 0 {
+
 	chains, err = dev.ReceiveQueue.BlockAndGetHeadsCapped(context.TODO(), len(out))
 	if err != nil {
 		return 0, err
 	}
 	if len(chains) == 0 {
 		return 0, nil
 	}
-	//} else {
-	//	chains = dev.extraRx
-	//}
 
 	numPackets := 0
 	chainsIdx := 0
@@ -418,10 +368,5 @@ func (dev *Device) ReceivePackets(out []*packet.VirtIOPacket) (int, error) {
 		chainsIdx += numChains
 	}
 
-	// Now that we have copied all buffers, we can recycle the used descriptor chains
-	//if err = dev.ReceiveQueue.OfferDescriptorChains(chains); err != nil {
-	//	return 0, err
-	//}
-
 	return numPackets, nil
 }

overlay/virtqueue/descriptor_table.go

@@ -172,115 +172,6 @@ func (dt *DescriptorTable) releaseBuffers() error {
 	return nil
 }
 
-// createDescriptorChain creates a new descriptor chain within the descriptor
-// table which contains a number of device-readable buffers (out buffers) and
-// device-writable buffers (in buffers).
-//
-// All buffers in the outBuffers slice will be concatenated by chaining
-// descriptors, one for each buffer in the slice. The size of the single buffers
-// must not exceed the size of a memory page (see [os.Getpagesize]).
-// When numInBuffers is greater than zero, the given number of device-writable
-// descriptors will be appended to the end of the chain, each referencing a
-// whole memory page.
-//
-// The index of the head of the new descriptor chain will be returned. Callers
-// should make sure to free the descriptor chain using [freeDescriptorChain]
-// after it was used by the device.
-//
-// When there are not enough free descriptors to hold the given number of
-// buffers, an [ErrNotEnoughFreeDescriptors] will be returned. In this case, the
-// caller should try again after some descriptor chains were used by the device
-// and returned back into the free chain.
-func (dt *DescriptorTable) createDescriptorChain(outBuffers [][]byte, numInBuffers int) (uint16, error) {
-	// Calculate the number of descriptors needed to build the chain.
-	numDesc := uint16(len(outBuffers) + numInBuffers)
-
-	// Descriptor chains must always contain at least one descriptor.
-	if numDesc < 1 {
-		return 0, ErrDescriptorChainEmpty
-	}
-
-	// Do we still have enough free descriptors?
-	if numDesc > dt.freeNum {
-		return 0, ErrNotEnoughFreeDescriptors
-	}
-
-	// Above validation ensured that there is at least one free descriptor, so
-	// the free descriptor chain head should be valid.
-	if dt.freeHeadIndex == noFreeHead {
-		panic("free descriptor chain head is unset but there should be free descriptors")
-	}
-
-	// To avoid having to iterate over the whole table to find the descriptor
-	// pointing to the head just to replace the free head, we instead always
-	// create descriptor chains from the descriptors coming after the head.
-	// This way we only have to touch the head as a last resort, when all other
-	// descriptors are already used.
-	head := dt.descriptors[dt.freeHeadIndex].next
-	next := head
-	tail := head
-	for i, buffer := range outBuffers {
-		desc := &dt.descriptors[next]
-		checkUnusedDescriptorLength(next, desc)
-
-		if len(buffer) > dt.itemSize {
-			// The caller should already prevent that from happening.
-			panic(fmt.Sprintf("out buffer %d has size %d which exceeds desc length %d", i, len(buffer), dt.itemSize))
-		}
-
-		// Copy the buffer to the memory referenced by the descriptor.
-		// The descriptor address points to memory not managed by Go, so this
-		// conversion is safe. See https://github.com/golang/go/issues/58625
-		//goland:noinspection GoVetUnsafePointer
-		copy(unsafe.Slice((*byte)(unsafe.Pointer(desc.address)), dt.itemSize), buffer)
-		desc.length = uint32(len(buffer))
-
-		// Clear the flags in case there were any others set.
-		desc.flags = descriptorFlagHasNext
-
-		tail = next
-		next = desc.next
-	}
-	for range numInBuffers {
-		desc := &dt.descriptors[next]
-		checkUnusedDescriptorLength(next, desc)
-
-		// Give the device the maximum available number of bytes to write into.
-		desc.length = uint32(dt.itemSize)
-
-		// Mark the descriptor as device-writable.
-		desc.flags = descriptorFlagHasNext | descriptorFlagWritable
-
-		tail = next
-		next = desc.next
-	}
-
-	// The last descriptor should end the chain.
-	tailDesc := &dt.descriptors[tail]
-	tailDesc.flags &= ^descriptorFlagHasNext
-	tailDesc.next = 0 // Not necessary to clear this, it's just for looks.
-
-	dt.freeNum -= numDesc
-
-	if dt.freeNum == 0 {
-		// The last descriptor in the chain should be the free chain head
-		// itself.
-		if tail != dt.freeHeadIndex {
-			panic("descriptor chain takes up all free descriptors but does not end with the free chain head")
-		}
-
-		// When this new chain takes up all remaining descriptors, we no longer
-		// have a free chain.
-		dt.freeHeadIndex = noFreeHead
-	} else {
-		// We took some descriptors out of the free chain, so make sure to close
-		// the circle again.
-		dt.descriptors[dt.freeHeadIndex].next = next
-	}
-
-	return head, nil
-}
-
 func (dt *DescriptorTable) CreateDescriptorForOutputs() (uint16, error) {
 	//todo just fill the damn table
 	// Do we still have enough free descriptors?
@@ -490,73 +381,6 @@ func (dt *DescriptorTable) getDescriptorInbuffers(head uint16, inBuffers *[][]by
 	return nil
 }
 
-func (dt *DescriptorTable) getDescriptorChainContents(head uint16, out []byte, maxLen int) (int, error) {
-	if int(head) > len(dt.descriptors) {
-		return 0, fmt.Errorf("%w: index out of range", ErrInvalidDescriptorChain)
-	}
-
-	// Iterate over the chain. The iteration is limited to the queue size to
-	// avoid ending up in an endless loop when things go very wrong.
-
-	length := 0
-	//find length
-	next := head
-	for range len(dt.descriptors) {
-		if next == dt.freeHeadIndex {
-			return 0, fmt.Errorf("%w: must not be part of the free chain", ErrInvalidDescriptorChain)
-		}
-
-		desc := &dt.descriptors[next]
-
-		if desc.flags&descriptorFlagWritable == 0 {
-			return 0, fmt.Errorf("receive queue contains device-readable buffer")
-		}
-		length += int(desc.length)
-
-		// Is this the tail of the chain?
-		if desc.flags&descriptorFlagHasNext == 0 {
-			break
-		}
-
-		// Detect loops.
-		if desc.next == head {
-			return 0, fmt.Errorf("%w: contains a loop", ErrInvalidDescriptorChain)
-		}
-
-		next = desc.next
-	}
-	if maxLen > 0 {
-		//todo length = min(maxLen, length)
-	}
-	//set out to length:
-	out = out[:length]
-
-	//now do the copying
-	copied := 0
-	for range len(dt.descriptors) {
-		desc := &dt.descriptors[next]
-
-		// The descriptor address points to memory not managed by Go, so this
-		// conversion is safe. See https://github.com/golang/go/issues/58625
-		//goland:noinspection GoVetUnsafePointer
-		bs := unsafe.Slice((*byte)(unsafe.Pointer(desc.address)), min(uint32(length-copied), desc.length))
-		copied += copy(out[copied:], bs)
-
-		// Is this the tail of the chain?
-		if desc.flags&descriptorFlagHasNext == 0 {
-			break
-		}
-
-		// we did this already, no need to detect loops.
-		next = desc.next
-	}
-	if copied != length {
-		panic(fmt.Sprintf("expected to copy %d bytes but only copied %d bytes", length, copied))
-	}
-
-	return length, nil
-}
-
 // freeDescriptorChain can be used to free a descriptor chain when it is no
 // longer in use. The descriptor chain that starts with the given index will be
 // put back into the free chain, so the descriptors can be used for later calls