volumeDir, err := s.getVolDir(volume)
	if err != nil {
		return err
	}

	discard := true

	var legacyJSON bool
	buf, _, err := s.readAllData(ctx, volume, volumeDir, pathJoin(volumeDir, path, xlStorageFormatFile), discard)
	if err != nil {
		if !errors.Is(err, errFileNotFound) {
			return err
		}

		s.RLock()
		legacy := s.formatLegacy

func (bp *BytePoolCap) Put(b []byte) {
	if bp == nil {
		return
	}
	select {
	case bp.c <- b:
		// buffer went back into pool
	default:
		// buffer didn't go back into pool, just discard
	}
}

// Width returns the width of the byte arrays in this pool.
func (bp *BytePoolCap) Width() (n int) {
	if bp == nil {
		return 0
	}
	return bp.w
}

					continue
				}
				xl2, err := other.xlmeta()
				if err != nil {
					if err := selectFrom(idx); err != nil {
						return err
					}
					continue
				}
				if xl == nil {
					// Discard current "best"
					if err := selectFrom(bestIdx); err != nil {
						return err
					}
					bestIdx = idx
					best = other
					xl = xl2
				} else {
					// Mark read, unless we added it as new "best".

				foundPrefixes = append(foundPrefixes, result.Prefixes...)
				if !result.IsTruncated {
					break
				}
				marker = result.NextMarker
				if len(result.Objects) > 0 {
					// Discard marker, so it cannot resume listing.
					marker = result.Objects[len(result.Objects)-1].Name
				}
			}

			if len(testCase.result.Objects) != len(foundObjects) {

	for m := range re {
		if err := enc.Encode(m); err != nil {
			s.writeErrorResponse(w, errors.New("Encoding mrf failed: "+err.Error()))
			return
		}
	}
}

// DevNull - everything goes to io.Discard
func (s *peerRESTServer) DevNull(w http.ResponseWriter, r *http.Request) {
	if !s.IsValid(w, r) {
		s.writeErrorResponse(w, errors.New("invalid request"))
		return
	}

	globalNetPerfRX.Connect()

			// unconsumedTimer fires.
			select {
			// Check after a second
			case <-time.After(time.Second):
				h.mutex.Unlock()
				continue

			case <-h.ctx.Done():
				h.mutex.Unlock()
				// discard result and return.
				return errHealStopSignalled

			// Timeout if no results consumed for too long.
			case <-unconsumedTimer.C:
				h.mutex.Unlock()
				return errHealIdleTimeout
			}
		}
		break

		config.EnvRootPassword,
	} {
		os.Unsetenv(env)
	}

	// Set as non-distributed.
	globalIsDistErasure = false

	// Disable printing console messages during tests.
	color.Output = io.Discard
	// Disable Error logging in testing.
	logger.DisableErrorLog = true

	// Uncomment the following line to see trace logs during unit tests.
	// logger.AddTarget(console.New())

				}
				if hdr.OpCode.IsControl() {
					if err := controlHandler(hdr, &wsReader); err != nil {
						return nil, err
					}
					continue
				}
				if hdr.OpCode&want == 0 {
					if err := wsReader.Discard(); err != nil {
						return nil, err
					}
					continue
				}
				if int64(cap(dst)) < hdr.Length+1 {
					dst = make([]byte, 0, hdr.Length+hdr.Length>>3)
				}

	if m == nil {
		return false
	}
	cache := m
	switch {
	case !cache.finished() && time.Since(cache.lastUpdate) > metacacheMaxRunningAge:
		// Not finished and update for metacacheMaxRunningAge, discard it.
		return false
	case cache.finished() && time.Since(cache.lastHandout) > 5*metacacheMaxClientWait:
		// Keep for 15 minutes after we last saw the client.

	enc := json.NewEncoder(w)
	if err := enc.Encode(madmin.ClientPerfExtraTime{TimeSpent: atomic.LoadInt64(&globalLastClientPerfExtraTime)}); err != nil {
		return
	}
}

// ClientDevNull - everything goes to io.Discard
// [POST] /minio/admin/v3/speedtest/client/devnull
func (a adminAPIHandlers) ClientDevNull(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	timeStart := time.Now()