NetlinkRequest: retry on ErrDumpInterrupted in NetlinkRequest.Execute

The addition of ErrDumpInterrupted forced all callers to deal explicitly with
interrupted dumps, while typically the caller should simply retry.

This commit adds a retry system that makes the library retry up to 10 times
before finally giving up with ErrDumpInterrupted. This should lead to fewer
surprised users.

It can be enabled by calling Handle.RetryInterrupted.

Signed-off-by: Timo Beckers <timo@incline.eu>

Author: ti-mo

handle_linux.go

@@ -13,8 +13,9 @@ import (
 var pkgHandle = &Handle{}
 
 type HandleOptions struct {
-	lookupByDump  bool
-	collectVFInfo bool
+	lookupByDump     bool
+	collectVFInfo    bool
+	retryInterrupted bool
 }
 
 // Handle is a handle for the netlink requests on a
@@ -32,6 +33,14 @@ func (h *Handle) DisableVFInfoCollection() *Handle {
 	return h
 }
 
+// RetryInterrupted configures the Handle to automatically retry dump operations
+// a number of times if they fail with EINTR before finally returning
+// [ErrDumpInterrupted].
+func (h *Handle) RetryInterrupted() *Handle {
+	h.options.retryInterrupted = true
+	return h
+}
+
 // SetSocketTimeout configures timeout for default netlink sockets
 func SetSocketTimeout(to time.Duration) error {
 	if to < time.Microsecond {
@@ -197,5 +206,7 @@ func (h *Handle) newNetlinkRequest(proto, flags int) *nl.NetlinkRequest {
 			Flags: unix.NLM_F_REQUEST | uint16(flags),
 		},
 		Sockets: h.sockets,
+
+		RetryInterrupted: h.options.retryInterrupted,
 	}
 }

nl/nl_linux.go

@@ -465,6 +465,8 @@ type NetlinkRequest struct {
 	Data    []NetlinkRequestData
 	RawData []byte
 	Sockets map[int]*SocketHandle
+
+	RetryInterrupted bool
 }
 
 // Serialize the Netlink Request into a byte array
@@ -510,15 +512,41 @@ func (req *NetlinkRequest) AddRawData(data []byte) {
 // If the returned error is [ErrDumpInterrupted], results may be inconsistent
 // or incomplete.
 func (req *NetlinkRequest) Execute(sockType int, resType uint16) ([][]byte, error) {
-	var res [][]byte
-	err := req.ExecuteIter(sockType, resType, func(msg []byte) bool {
-		res = append(res, msg)
-		return true
-	})
-	if err != nil && !errors.Is(err, ErrDumpInterrupted) {
-		return nil, err
+	const attempts = 10
+	var (
+		err     error
+		lastRes [][]byte
+	)
+	for range attempts {
+		var res [][]byte
+		err = req.ExecuteIter(sockType, resType, func(msg []byte) bool {
+			res = append(res, msg)
+			return true
+		})
+		if errors.Is(err, ErrDumpInterrupted) {
+			// Hang on to the last result, callers can use partial results even if the
+			// dump was interrupted.
+			lastRes = res
+
+			// Only retry if the Request is configured to do so for backwards
+			// compatibility.
+			if req.RetryInterrupted {
+				continue
+			}
+		}
+		if err == nil {
+			return res, nil
+		}
+		break
 	}
-	return res, err
+
+	if errors.Is(err, ErrDumpInterrupted) {
+		return lastRes, fmt.Errorf("execute netlink request (%d attempts): %w", attempts, err)
+	}
+
+	// Do not wrap the error from ExecuteIter. It gets type-asserted and replaced
+	// with sentinels in some callers, and wrapping breaks that.
+	return nil, err
 }
 
 // ExecuteIter executes the request against the given sockType.