}
	info.Used = info.Total - info.Free
	return info, nil
}

// GetDriveStats returns IO stats of the drive by its major:minor
func GetDriveStats(major, minor uint32) (iostats IOStats, err error) {
	return IOStats{}, errors.New("operation unsupported")

			for k, v := range d.Metrics.LastMinute {
				if v.Count != 0 {
					dm.LastMinute.Operations[k] = v
				}
			}
		}

		st, err := disk.GetDriveStats(d.Major, d.Minor)
		if err == nil {
			dm.IOStats = madmin.DiskIOStats{
				ReadIOs:        st.ReadIOs,
				ReadMerges:     st.ReadMerges,
				ReadSectors:    st.ReadSectors,
				ReadTicks:      st.ReadTicks,

		return
	}
	z.FreeInodes, err = dc.ReadUint64()
	if err != nil {
		err = msgp.WrapError(err, "FreeInodes")
		return
	}
	z.Major, err = dc.ReadUint32()
	if err != nil {
		err = msgp.WrapError(err, "Major")
		return
	}
	z.Minor, err = dc.ReadUint32()
	if err != nil {
		err = msgp.WrapError(err, "Minor")
		return
	}
	z.NRRequests, err = dc.ReadUint64()

		switch runtime.GOOS {
		case "aix":
			var major, minor uint32
			major = uint32((dev & 0x3fffffff00000000) >> 32)
			minor = uint32((dev & 0x00000000ffffffff) >> 0)
			h.Devmajor, h.Devminor = int64(major), int64(minor)
		case "linux":
			// Copied from golang.org/x/sys/unix/dev_linux.go.
			major := uint32((dev & 0x00000000000fff00) >> 8)
			major |= uint32((dev & 0xfffff00000000000) >> 32)

// Files - total inodes available
// Ffree - free inodes available
// FSType - file system type
// Major - major dev id
// Minor - minor dev id
// Devname - device name
type Info struct {
	Total      uint64
	Free       uint64
	Used       uint64
	Files      uint64
	Ffree      uint64
	FSType     string
	Major      uint32
	Minor      uint32
	Name       string
	Rotational *bool
	NRRequests uint64
}

	}
	info.Used = info.Total - info.Free
	return info, nil
}

// GetDriveStats returns IO stats of the drive by its major:minor
func GetDriveStats(major, minor uint32) (iostats IOStats, err error) {
	return IOStats{}, errors.New("operation unsupported")

	"github.com/gobwas/ws"
	"github.com/gobwas/ws/wsutil"
	"github.com/google/uuid"
	"github.com/minio/madmin-go/v3"
	"github.com/minio/minio/internal/pubsub"
	"github.com/minio/mux"
)

const (
	// apiVersion is a major version of the entire api.
	// Bumping this should only be done when overall,
	// incompatible changes are made, not when adding a new handler
	// or changing an existing handler.
	apiVersion = "v1"

	s.drivePath, err = getValidPath(ep.Path)
	if err != nil {
		s.drivePath = ep.Path
		return s, err
	}

	info, err := disk.GetInfo(s.drivePath, true)
	if err != nil {
		return s, err
	}
	s.major = info.Major
	s.minor = info.Minor
	s.fsType = info.FSType

	if !globalIsCICD && !globalIsErasureSD {
		var rootDrive bool
		if globalRootDiskThreshold > 0 {
			// Use MINIO_ROOTDISK_THRESHOLD_SIZE to figure out if

// The above means that any added/deleted fields are incompatible.
//
//msgp:tuple DiskInfo
type DiskInfo struct {
	Total      uint64
	Free       uint64
	Used       uint64
	UsedInodes uint64
	FreeInodes uint64
	Major      uint32
	Minor      uint32
	NRRequests uint64
	FSType     string
	RootDisk   bool
	Healing    bool
	Scanning   bool
	Endpoint   string
	MountPath  string
	ID         string
	Rotational bool

				if err != nil {
					// if supported errors don't fail, we proceed to
					// printing message and moving forward.
					if errors.Is(err, errDriveIsRoot) {
						err = fmt.Errorf("major: %v: minor: %v: %w", xl.major, xl.minor, err)
					}
					logFatalErrs(err, endpoint, false)
					return false
				}
				storage := newXLStorageDiskIDCheck(xl, true)
				storage.SetDiskID(xl.diskID)