### Allowed values for STANDARD storage class

`STANDARD` storage class implies more parity than `REDUCED_REDUNDANCY` class. So, `STANDARD` parity drives should be

- Greater than or equal to 2, if `REDUCED_REDUNDANCY` parity is not set.
- Greater than `REDUCED_REDUNDANCY` parity, if it is set.

Parity blocks can not be higher than data blocks, so `STANDARD` storage class parity can not be higher than N/2. (N being total number of drives)

func ValidateParity(ssParity, setDriveCount int) error {
	// SS parity drives should be greater than or equal to minParityDrives.
	// Parity below minParityDrives is not supported.
	if ssParity > 0 && ssParity < minParityDrives {
		return fmt.Errorf("parity %d should be greater than or equal to %d",
			ssParity, minParityDrives)
	}

	if ssParity > setDriveCount/2 {

			parities[i] = -1             // invalid fi are assigned parity -1
		}
		res.metaArr = metaArr
		res.parities = parities
		res.errs = make([]error, N)
		if agree >= N-parity {
			res.parity = parity
		} else {
			res.parity = -1
		}

		return res
	}
	tests := []struct {
		metaArr  []FileInfo
		errs     []error
		parities []int
		parity   int
	}{
		// More than simple majority consensus

	for _, disk := range diskInfo {
		// Ignore invalid.
		if disk.PoolIndex < 0 || len(s.Backend.StandardSCData) <= disk.PoolIndex {
			// https://github.com/minio/minio/issues/16500
			continue
		}
		// Ignore parity disks
		if disk.DiskIndex < s.Backend.StandardSCData[disk.PoolIndex] {
			capacity += disk.TotalSpace
		}
	}
	return capacity
}

// GetTotalCapacityFree gets the total capacity free in the cluster.

```

Example:

```sh
export MINIO_SITE_REGION="us-west-0"
export MINIO_SITE_NAME="sfo-rack-1"
minio server /data
```

### Storage Class

reconstruct missing or corrupted data. MinIO uses Reed-Solomon code to shard objects into variable data and parity blocks. For example, in a 12 drive setup, an object can be sharded to a variable number of data and parity blocks across all the drives - ranging from six data and six parity blocks to ten data and two parity blocks.

By default, MinIO shards the objects across N/2 data and N/2 parity drives. Though, you can use [storage classes](https://github.com/minio/minio/tree/master/docs/erasure/storage-class)...

	occMap := make(map[int]int)
	for _, p := range parities {
		occMap[p]++
	}

	var maxOcc, cparity int
	for parity, occ := range occMap {
		if parity == -1 {
			// Ignore non defined parity
			continue
		}

		readQuorum := N - parity
		if defaultParityCount > 0 && parity == 0 {
			// In this case, parity == 0 implies that this object version is a
			// delete marker
			readQuorum = N/2 + 1
		}

		parities := listObjectParities(metaArr, make([]error, len(metaArr)))
		parity := commonParity(parities, 5)
		var match int
		for _, fi := range metaArr {
			if fi.Erasure.ParityBlocks == parity {
				match++
			}
		}
		if match < len(metaArr)-parity {
			t.Fatalf("Test %d: Expected %d drives with parity=%d, but got %d", idx, len(metaArr)-parity, parity, match)
		}
	}

					otherPart := getPartNum(other[0])
					if part != otherPart {
						fmt.Println("part ", part, " != other part", otherPart, other[0])
						continue
					}
					// fmt.Println("part ", part, "other part", otherPart, other[0])
					fmt.Printf("Reading version %q Part %d.\n", otherKey, otherPart)
					// os.Exit(0)
					otherM, err := readAndMap(other, part, block)
					if err != nil {
						fmt.Println(err)

func erasureSelfTest() {
	// Approx runtime ~1ms
	var testConfigs [][2]uint8
	for total := uint8(4); total < 16; total++ {
		for data := total / 2; data < total; data++ {
			parity := total - data
			testConfigs = append(testConfigs, [2]uint8{data, parity})
		}
	}
	got := make(map[[2]uint8]map[ErasureAlgo]uint64, len(testConfigs))
	// Copied from output of fmt.Printf("%#v", got) at the end.