}
				if err := send(meta); err != nil {
					return err
				}
			case osIsNotExist(err), isSysErrIsDir(err):
				if legacy {
					meta.metadata, err = xioutil.ReadFile(pathJoinBuf(sb, volumeDir, meta.name, xlStorageFormatFileV1))
					diskHealthCheckOK(ctx, err)
					if err == nil {
						// It was an object
						if err := send(meta); err != nil {
							return err
						}
						continue
					}

	var ldapOpts []cr.LDAPIdentityOpt
	if sessionPolicyFile != "" {
		var policy string
		if f, err := os.Open(sessionPolicyFile); err != nil {
			log.Fatalf("Unable to open session policy file %s: %v", sessionPolicyFile, err)
		} else {
			bs, err := io.ReadAll(f)
			if err != nil {
				log.Fatalf("Error reading session policy file: %v", err)
			}
			policy = string(bs)
		}
		ldapOpts = append(ldapOpts, cr.LDAPIdentityPolicyOpt(policy))

	return func(err error) Err {
		u := Err{
			msg:    msg,
			action: action,
			hint:   hint,
		}
		if err != nil {
			u.detail = err.Error()
		}
		return u
	}
}

// ErrorToErr inspects the passed error and transforms it
// to the appropriate UI error.
func ErrorToErr(err error) Err {
	if err == nil {
		return Err{}
	}

	// If this is already a Err, do nothing

	args, err := getLockArgs(r)
	if err != nil {
		lh.writeErrorResponse(w, err)
		return
	}

	if _, err = lh.lsrv.ForceUnlock(&args); err != nil {
		lh.writeErrorResponse(w, err)
		return
	}
}

func (lh *lockServerHandler) RefreshHandler(w http.ResponseWriter, r *http.Request) {
	args, err := getLockArgs(r)
	if err != nil {
		lh.writeErrorResponse(w, err)
		return
	}

	}
	b.h.Reset()
	b.h.Write(p)
	hashBytes := b.h.Sum(nil)
	_, err := b.iow.Write(hashBytes)
	if err != nil {
		b.closeWithErr(err)
		return 0, err
	}
	n, err := b.iow.Write(p)
	if err != nil {
		b.closeWithErr(err)
		return n, err
	}
	if n != len(p) {
		err = io.ErrShortWrite
		b.closeWithErr(err)
	}
	return n, err
}

func (b *streamingBitrotWriter) Close() error {

func isSysErrTooManyFiles(err error) bool {
	return errors.Is(err, syscall.ENFILE) || errors.Is(err, syscall.EMFILE)
}

func osIsNotExist(err error) bool {
	return errors.Is(err, os.ErrNotExist)
}

func osIsPermission(err error) bool {
	return errors.Is(err, os.ErrPermission) || errors.Is(err, syscall.EROFS)
}

func osIsExist(err error) bool {
	return errors.Is(err, os.ErrExist)

		t.Fatalf("expected context.Canceled err, got %v", err)
	}

	ctx, cancel = context.WithCancel(t.Context())
	defer cancel()

	t1, err := cache.GetWithCtx(ctx)
	if err != nil {
		t.Fatalf("expected nil err, got %v", err)
	}

	t2, err := cache.GetWithCtx(ctx)
	if err != nil {
		t.Fatalf("expected nil err, got %v", err)
	}

	if !t1.Equal(t2) {
		t.Fatalf("expected time to be equal: %s != %s", t1, t2)
	}

	storage := globalLocalSetDrives[0][0][0]
	if err = storage.MakeVol(t.Context(), "foo"); err != nil {
		t.Fatalf("unexpected error %v", err)
	}

	if err = storage.MakeVol(t.Context(), "bar"); err != nil {
		t.Fatalf("unexpected error %v", err)
	}

	restClient, err := newStorageRESTClient(endpoint, false, tg.Managers[0])
	if err != nil {
		t.Fatal(err)
	}

	for {

		return nil, errors.New("bucket name cannot be empty")
	}

	clnt, err := f.getMinIOClient()
	if err != nil {
		return nil, err
	}

	obj, err := clnt.GetObject(context.Background(), bucket, object, minio.GetObjectOptions{})
	if err != nil {
		return nil, err
	}

	_, err = obj.Stat()
	if err != nil {
		return nil, err
	}

	return obj, nil
}

			continue
		}
		if isErrReadQuorum(pool.Err) || pool.Err == nil {
			errs = append(errs, poolErrs{Err: pool.Err, Index: pool.Index})
		}
	}
	return errs
}

func (z *erasureServerPools) getPoolIdxExistingWithOpts(ctx context.Context, bucket, object string, opts ObjectOptions) (idx int, err error) {
	pinfo, _, err := z.getPoolInfoExistingWithOpts(ctx, bucket, object, opts)
	if err != nil {
		return -1, err
	}