xl.meta-corrupt...

	if algo != HighwayHash256S {
		h := algo.New()
		if n, err := io.Copy(h, r); err != nil || n != wantSize {
			// Premature failure in reading the object, file is corrupt.
			return errFileCorrupt
		}
		if !bytes.Equal(h.Sum(nil), want) {
			return errFileCorrupt
		}
		return nil
	}

	h := algo.New()
	hashBuf := make([]byte, h.Size())
	left := wantSize

					}
					break
				}
			case corruptPart:
				for index, err := range test.errs {
					if err != nil {
						continue
					}
					// Corrupt a part from a disk
					// which has a valid xl.meta,
					// and check if that disk
					// appears in outDatedDisks.
					tamperedIndex = index

			if modTime.IsZero() || modTime.Equal(timeSentinel) {
				ok = etag != "" && etag == fi.Metadata["etag"]
			}
			if ok {
				continue
			}
		} // in all other cases metadata is corrupt, do not read from it.

		onlineMeta[i] = FileInfo{}
		onlineDisks[i] = nil
	}

	select {
	case mrfCheck <- fi.ShallowCopy():
	case <-ctx.Done():

	var xlMeta xlMetaV2
	var legacyPreserved bool
	var legacyEntries []string
	if len(dstBuf) > 0 {
		if isXL2V1Format(dstBuf) {
			if err = xlMeta.Load(dstBuf); err != nil {
				// Data appears corrupt. Drop data.
				xlMeta = xlMetaV2{}
			}
		} else {
			// This code-path is to preserve the legacy data.
			xlMetaLegacy := &xlMetaV1Object{}
			json := jsoniter.ConfigCompatibleWithStandardLibrary

		if err != nil {
			return fmt.Errorf("xlMetaInlineData: %w", err)
		}
	}

	return nil
}

// repair will copy all seemingly valid data entries from a corrupted set.
// This does not ensure that data is correct, but will allow all operations to complete.
func (x *xlMetaInlineData) repair() {
	data := *x
	if len(data) == 0 {
		return
	}

	if !data.versionOK() {
		*x = nil
		return

			},
		},
		5: {
			desc:       "Correct sha256, nested",
			src:        mustReader(t, bytes.NewReader([]byte("abcd")), 4, "", "", 4),
			size:       4,
			actualSize: 4,
			sha256hex:  "88d4266fd4e6338d13b845fcf289579d209c897823b9217da3e161936f031589",
		},
		{
			desc:       "Correct sha256, nested, truncated",

				}
				partsMD5Sum = append(partsMD5Sum, h.Sum(nil))
			}

			if failedMD5 {
				log.Println("CORRUPTED object:", objFullPath(object))
				continue
			}

			corrupted := false
			if !multipart {
				md5sum := fmt.Sprintf("%x", partsMD5Sum[0])
				if md5sum != object.ETag {
					corrupted = true
				}
			} else {
				var totalMD5SumBytes []byte
				for _, sum := range partsMD5Sum {

var errUnexpected = StorageErr("unexpected error, please report this issue at https://github.com/minio/minio/issues")

// errCorruptedFormat - corrupted format.
var errCorruptedFormat = StorageErr("corrupted format")

// errCorruptedBackend - corrupted backend.
var errCorruptedBackend = StorageErr("corrupted backend")

// errUnformattedDisk - unformatted disk found.
var errUnformattedDisk = StorageErr("unformatted drive found")

	for i, set := range f.XL.Sets {
		for j, disk := range set {
			if disk == f.XL.This {
				return fmt.Sprintf("%d-%d", i, j), nil
			}
		}
	}
	return "", errors.New("format.json is corrupted")
}

func main() {
	var node, args string

	flag.StringVar(&node, "local-node-name", "", "the name of the local node")
	flag.StringVar(&args, "args", "", "arguments passed to MinIO server")