return n.innerNetns.Close()
}

func (n *NetnsWrapper) Fd() uintptr {
	return n.innerNetns.Fd()
}

func inodeForFd(n NetnsFd) (uint64, error) {
	stats := &unix.Stat_t{}
	err := unix.Fstat(int(n.Fd()), stats)
	return stats.Ino, err
}

func OpenNetns(nspath string) (NetnsCloser, error) {
	n, err := netns.GetNS(nspath)
	if err != nil {
		return nil, err
	}
	i, err := inodeForFd(n)

                        "name": "istio.io/telemetry/stats/prometheus/sidecar/Outbound/HTTP"
                    },
                    "last_updated": "2023-12-23T13:46:00.701Z"
                },
                {
                    "ecds_filter": {
                        "@type": "type.googleapis.com/envoy.config.core.v3.TypedExtensionConfig",
                        "name": "istio.io/telemetry/stats/prometheus/sidecar/Inbound/HTTP"

	}

	ts := make(map[string]madmin.TierStats)
	dui.TierStats.populateStats(ts)

	infos := make([]madmin.TierInfo, 0, len(ts))
	for tier, stats := range ts {
		infos = append(infos, madmin.TierInfo{
			Name:  tier,
			Type:  globalTierConfigMgr.TierType(tier),
			Stats: stats,
		})
	}

	sort.Slice(infos, func(i, j int) bool {
		if infos[i].Type == "internal" {
			return true
		}

	gcStats := debug.GCStats{
		// If stats.PauseQuantiles is non-empty, ReadGCStats fills
		// it with quantiles summarizing the distribution of pause time.
		// For example, if len(stats.PauseQuantiles) is 5, it will be
		// filled with the minimum, 25%, 50%, 75%, and maximum pause times.
		PauseQuantiles: make([]time.Duration, 5),
	}
	debug.ReadGCStats(&gcStats)
	// Truncate GC stats to max 5 entries.
	if len(gcStats.PauseEnd) > 5 {

	driveRealtimeMetrics := collectLocalMetrics(types, collectMetricsOpts{
		hosts: map[string]struct{}{
			globalLocalNodeName: {},
		},
	})

	stats := map[string]madmin.DiskIOStats{}
	for d, m := range driveRealtimeMetrics.ByDisk {
		stats[d] = m.IOStats
	}
	return stats
}

func (m *MetricValues) setDriveBasicMetrics(drive madmin.Disk, labels []string) {
	m.Set(driveUsedBytes, float64(drive.UsedSpace), labels...)

import (
	"errors"
	"fmt"
	"syscall"
)

// GetInfo returns total and free bytes available in a directory, e.g. `/`.
func GetInfo(path string, _ bool) (info Info, err error) {
	s := syscall.Statfs_t{}
	err = syscall.Statfs(path, &s)
	if err != nil {
		return Info{}, err
	}
	reservedBlocks := s.Bfree - uint64(s.Bavail)
	info = Info{
		Total:  uint64(s.Bsize) * (s.Blocks - reservedBlocks),

	"github.com/minio/madmin-go/v3"
	"github.com/minio/minio-go/v7"
)

//go:generate msgp -file $GOFILE

// RStat has replication error stats
type RStat struct {
	Count int64 `json:"count"`
	Bytes int64 `json:"bytes"`
}

// RTimedMetrics has replication error stats for various time windows
type RTimedMetrics struct {
	LastHour    ReplicationLastHour `json:"lastHour"`
	SinceUptime RStat               `json:"sinceUptime"`

       {
        "name": "backend",
        "domains": [
         "*"
        ],
        "routes": [
         {
          "match": {
           "prefix": "/stats/prometheus"
          },
          "route": {
           "cluster": "prometheus_stats"
          }
         }
        ]
       }
      ]
     },
     "last_updated": "2023-11-29T09:58:27.285Z"
    }
   ]
  }
 ]

import (
	"errors"
	"fmt"
	"syscall"
)

// GetInfo returns total and free bytes available in a directory, e.g. `/`.
func GetInfo(path string, _ bool) (info Info, err error) {
	s := syscall.Statfs_t{}
	err = syscall.Statfs(path, &s)
	if err != nil {
		return Info{}, err
	}
	reservedBlocks := s.Bfree - s.Bavail
	info = Info{
		Total:  uint64(s.Bsize) * (s.Blocks - reservedBlocks),
		Free:   uint64(s.Bsize) * s.Bavail,

       {
        "name": "backend",
        "domains": [
         "*"
        ],
        "routes": [
         {
          "match": {
           "prefix": "/stats/prometheus"
          },
          "route": {
           "cluster": "prometheus_stats"
          }
         }
        ]
       }
      ]
     },
     "last_updated": "2023-11-29T09:58:27.285Z"
    }
   ],
   "dynamic_route_configs": [