}

	return state
}

func getOnlineOfflineDisksStats(disksInfo []madmin.Disk) (onlineDisks, offlineDisks madmin.BackendDisks) {
	onlineDisks = make(madmin.BackendDisks)
	offlineDisks = make(madmin.BackendDisks)

	for _, disk := range disksInfo {
		ep := disk.Endpoint
		if _, ok := offlineDisks[ep]; !ok {
			offlineDisks[ep] = 0
		}
		if _, ok := onlineDisks[ep]; !ok {
			onlineDisks[ep] = 0
		}
	}

	if objLayer == nil {
		return
	}

	server := getLocalServerProperty(globalEndpoints, &http.Request{
		Host: globalLocalNodeName,
	}, true)

	onlineDisks, offlineDisks := getOnlineOfflineDisksStats(server.Disks)
	totalDisks := offlineDisks.Merge(onlineDisks)

	// Report total capacity
	ch <- prometheus.MustNewConstMetric(
		prometheus.NewDesc(
			prometheus.BuildFQName(minioNamespace, "capacity_raw", "total"),

func getOfflineDisks(offlineHost string, endpoints EndpointServerPools) []madmin.Disk {
	var offlineDisks []madmin.Disk
	for _, pool := range endpoints {
		for _, ep := range pool.Endpoints {
			if offlineHost == "" && ep.IsLocal || offlineHost == ep.Host {
				offlineDisks = append(offlineDisks, madmin.Disk{
					Endpoint:  ep.String(),
					State:     string(madmin.ItemOffline),
					PoolIndex: ep.PoolIdx,

		for _, s := range servers {
			allDisks = append(allDisks, s.Disks...)
		}
		onlineDisks, offlineDisks := getOnlineOfflineDisksStats(allDisks)

		backend = madmin.ErasureBackend{
			Type:             madmin.ErasureType,
			OnlineDisks:      onlineDisks.Sum(),
			OfflineDisks:     offlineDisks.Sum(),
			StandardSCParity: backendInfo.StandardSCParity,
			RRSCParity:       backendInfo.RRSCParity,

          <!-- We add the link ourselves so that we can choose Java 25 over the version that -source suggests. -->
          <detectJavaApiLink>false</detectJavaApiLink>
          <offlineLinks>

	content := make([]byte, size)

	for i := range dataDown {
		disks[i] = OfflineDisk
	}
	for i := data; i < data+parityDown; i++ {
		disks[i] = OfflineDisk
	}

	b.SetBytes(size)
	b.ReportAllocs()
	for b.Loop() {
		writers := make([]io.Writer, len(disks))
		for i, disk := range disks {
			if disk == OfflineDisk {
				continue
			}

          <!-- We add the link ourselves so that we can choose Java 25 over the version that -source suggests. -->
          <detectJavaApiLink>false</detectJavaApiLink>
          <offlineLinks>

			}
		}

		for i, r := range bitrotReaders {
			if r == nil {
				disks[i] = OfflineDisk
			}
		}
		if err == nil && !test.shouldFail {
			bitrotReaders = make([]io.ReaderAt, len(disks))
			for index, disk := range disks {
				if disk == OfflineDisk {
					continue
				}
				tillOffset := erasure.ShardFileOffset(test.offset, test.length, test.data)

			readers := make([]io.ReaderAt, len(latestDisks))
			prefer := make([]bool, len(latestDisks))
			checksumAlgo := erasureInfo.GetChecksumInfo(partNumber).Algorithm
			for i, disk := range latestDisks {
				if disk == OfflineDisk {
					continue
				}
				thisPartErrs := shuffleCheckParts(dataErrsByPart[partIndex], latestMeta.Erasure.Distribution)
				if thisPartErrs[i] != checkPartSuccess {
					continue
				}

	metaErrs := make([]error, len(errs))

	for i := range onlineDisks {
		if errs[i] != nil {
			metaErrs[i] = errs[i]
			continue
		}
		if onlineDisks[i] == OfflineDisk {
			metaErrs[i] = errDiskNotFound
			continue
		}

		meta := partsMetadata[i]
		corrupted := false
		if filterByETag {
			corrupted = meta.Metadata["etag"] != latestMeta.Metadata["etag"]
		} else {