return
	}

	// Get capacity info when asked.
	if r.Form.Get("capacity") == "true" {
		sinfo := objectAPI.StorageInfo(ctx, false)
		dataUsageInfo.TotalCapacity = GetTotalUsableCapacity(sinfo.Disks, sinfo)
		dataUsageInfo.TotalFreeCapacity = GetTotalUsableCapacityFree(sinfo.Disks, sinfo)
		if dataUsageInfo.TotalCapacity > dataUsageInfo.TotalFreeCapacity {

        lsarpc.LsarQosInfo qosInfo = new lsarpc.LsarQosInfo();
        qosInfo.length = 10;
        qosInfo.impersonation_level = 1;
        qosInfo.context_mode = 2;
        qosInfo.effective_only = 3;

        qosInfo.encode(mockNdrBuffer);

        // Verify encode calls
        verify(mockNdrBuffer).align(4);
        verify(mockNdrBuffer).enc_ndr_long(qosInfo.length);

follow JLine's directory and filename conventions.

[1] https://github.com/jline/jline3/tree/master/native

		float64(GetTotalUsableCapacity(server.Disks, sinfo)),
	)

	// Report total usable capacity free
	ch <- prometheus.MustNewConstMetric(
		prometheus.NewDesc(
			prometheus.BuildFQName(minioNamespace, "capacity_usable_free", "total"),
			"Total free usable capacity online in the cluster",
			nil, nil),
		prometheus.GaugeValue,
		float64(GetTotalUsableCapacityFree(server.Disks, sinfo)),
	)

	// MinIO Offline Disks per node

		}
	}
	return reply
}

// GetOSInfo - Get operating system's information
func (sys *NotificationSys) GetOSInfo(ctx context.Context) []madmin.OSInfo {
	reply := make([]madmin.OSInfo, len(sys.peerClients))

	g := errgroup.WithNErrs(len(sys.peerClients))
	for index, client := range sys.peerClients {
		if client == nil {
			continue
		}
		index := index

pkg syscall (linux-386), func Syscall6(uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
pkg syscall (linux-386), func Sysinfo(*Sysinfo_t) error
pkg syscall (linux-386), func Tee(int, int, int, int) (int64, error)
pkg syscall (linux-386), func Tgkill(int, int, Signal) error
pkg syscall (linux-386), func Time(*Time_t) (Time_t, error)

	sinfo, err := c.siteReplicationStatus(ctx, objAPI, opts)
	if err != nil {
		return info, err
	}
	info = madmin.SRStatusInfo{
		Enabled:           sinfo.Enabled,
		MaxBuckets:        sinfo.MaxBuckets,
		MaxUsers:          sinfo.MaxUsers,
		MaxGroups:         sinfo.MaxGroups,
		MaxPolicies:       sinfo.MaxPolicies,
		MaxILMExpiryRules: sinfo.MaxILMExpiryRules,

	madminCPUs             = grid.NewJSONPool[madmin.CPUs]()
	madminMemInfo          = grid.NewJSONPool[madmin.MemInfo]()
	madminNetInfo          = grid.NewJSONPool[madmin.NetInfo]()
	madminOSInfo           = grid.NewJSONPool[madmin.OSInfo]()
	madminPartitions       = grid.NewJSONPool[madmin.Partitions]()
	madminProcInfo         = grid.NewJSONPool[madmin.ProcInfo]()
	madminRealtimeMetrics  = grid.NewJSONPool[madmin.RealtimeMetrics]()

	return resp.ValueOrZero(), err
}

// GetOSInfo - fetch OS information for a remote node.
func (client *peerRESTClient) GetOSInfo(ctx context.Context) (info madmin.OSInfo, err error) {
	resp, err := getOSInfoRPC.Call(ctx, client.gridConn(), grid.NewMSS())
	return resp.ValueOrZero(), err
}

// GetSELinuxInfo - fetch SELinux information for a remote node.

pkg syscall (linux-arm-cgo), func Syscall6(uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
pkg syscall (linux-arm-cgo), func Sysinfo(*Sysinfo_t) error
pkg syscall (linux-arm-cgo), func Tee(int, int, int, int) (int64, error)
pkg syscall (linux-arm-cgo), func Tgkill(int, int, Signal) error
pkg syscall (linux-arm-cgo), func Time(*Time_t) (Time_t, error)