if deploymentID != "" {
					newFormat.ID = deploymentID
				}
				drive := pool.Endpoints[i*setDriveCount+j]
				fmtBytes, err := json.Marshal(newFormat)
				if err != nil {
					//nolint:gocritic
					log.Fatalf("failed to marshal format.json for %s: %v", drive.String(), err)
				}
				fmtJSON := filepath.Join(drive.Host, drive.Path, minioMetaBucket, "format.json")
				embedFileInZip(fmtZipW, fmtJSON, fmtBytes, 0o600)

- **MinIO creates erasure-coding sets of _2_ to _16_ drives per set.  The number of drives you provide in total must be a multiple of one of those numbers.**
- **MinIO chooses the largest EC set size which divides into the total number of drives or total number of nodes given - making sure to keep the uniform distribution i.e each node participates equal number of drives per set**.

| `minio_system_drive_api_latency_micros`        | Average last minute latency in µs for drive API storage operations. <br><br>Type: gauge | `drive`, `api`, `set_index`, `drive_index`, `pool_index`, `server` |

### 1.2 Host Multiple Tenants on Multiple Drives (Erasure Code)

Use the following commands to host 3 tenants on multiple drives:

```sh
minio server --address :9001 /disk{1...4}/data/tenant1
minio server --address :9002 /disk{1...4}/data/tenant2
minio server --address :9003 /disk{1...4}/data/tenant3
```

			// Fresh setup, wait for first server to be up.
			logger.Info("Waiting for the first server to format the drives (elapsed %s)\n", getElapsedTime())
		case errors.Is(err, errFirstDiskWait):
			// Fresh setup, wait for other servers to come up.
			logger.Info("Waiting for all other servers to be online to format the drives (elapses %s)\n", getElapsedTime())
		case errors.Is(err, errErasureReadQuorum):

### Action Required

* ACTION REQUIRED: Removes defaulting of CSI file system type to ext4. All the production drivers listed under https://kubernetes-csi.github.io/docs/drivers.html were inspected and should not be impacted after this change. If you are using a driver not in that list, please test the drivers on an updated test cluster first. ``` ([#65499](https://github.com/kubernetes/kubernetes/pull/65499), [@krunaljain](https://github.com/krunaljain))

          "legendFormat": "Free [{{drive}}]",
          "refId": "C"
        }
      ],
      "title": "Drive Usage",
      "type": "timeseries"
    },
    {
      "datasource": {
        "type": "prometheus",
        "uid": "${DS_PROMETHEUS}"
      },
      "description": "",
      "fieldConfig": {
        "defaults": {
          "color": {
            "mode": "palette-classic"
          },

		if len(disks) == healing {
			// All drives in this erasure set were reformatted for some reasons, abort healing and mark it as successful
			healingLogIf(ctx, errors.New("all drives are in healing state, aborting.."))
			return nil
		}

		disks = disks[:len(disks)-healing] // healing drives are always at the end of the list

		if len(disks) < er.setDriveCount/2 {

| `minio_node_drive_latency_us`          | Average last minute latency in µs for drive API storage operations. |
| `minio_node_drive_offline_total`       | Total drives offline in this node.                                  |
| `minio_node_drive_online_total`        | Total drives online in this node.                                   |
| `minio_node_drive_total`               | Total drives in this node.                                          |

				Deleted: v.Created,
			})
		}
		return true
	})

	return buckets, nil
}

func cloneDrives(drives map[string]StorageAPI) []StorageAPI {
	copyDrives := make([]StorageAPI, 0, len(drives))
	for _, drive := range drives {
		copyDrives = append(copyDrives, drive)
	}
	return copyDrives
}

func getBucketInfoLocal(ctx context.Context, bucket string, opts BucketOptions) (BucketInfo, error) {