}

	if err = mkdirAll(pathJoin(path, "testvolume1"), 0o777, ""); err != nil {
		t.Fatal(err)
	}
	if err = renameAll("", "foo", ""); err != errInvalidArgument {
		t.Fatal(err)
	}
	if err = renameAll("foo", "", ""); err != errInvalidArgument {
		t.Fatal(err)
	}
	if err = renameAll(pathJoin(path, "testvolume1"), pathJoin(path, "testvolume2"), ""); err != nil {
		t.Fatal(err)
	}

	historyFile := pathJoin(minioConfigHistoryPrefix, uuidKV+kvPrefix)
	data, err := readConfig(ctx, objAPI, historyFile)
	if err != nil {
		return nil, err
	}

	return decryptData(data, historyFile)
}

func saveServerConfigHistory(ctx context.Context, objAPI ObjectLayer, kv []byte) error {
	uuidKV := mustGetUUID() + kvPrefix
	historyFile := pathJoin(minioConfigHistoryPrefix, uuidKV)

			if o.ignoreDirs {
				continue
			}
			name = trimLeadingSlash(pathJoin(name, slashSeparator))
		case tar.TypeReg, tar.TypeChar, tar.TypeBlock, tar.TypeFifo, tar.TypeGNUSparse: // = regular
			name = trimLeadingSlash(path.Clean(name))
		default:
			// ignore symlink'ed
			continue
		}
		if o.prefixAll != "" {
			name = pathJoin(o.prefixAll, name)
		}

		// Do small files async
		n++

			continue
		}

		var typ os.FileMode // regular file
		switch {
		case data.FileAttributes&syscall.FILE_ATTRIBUTE_REPARSE_POINT != 0:
			// Reparse point is a symlink
			fi, err := os.Stat(pathJoin(dirPath, name))
			if err != nil {
				// It got deleted in the meantime, not found
				// or returns too many symlinks ignore this
				// file/directory.
				if osIsNotExist(err) || isSysErrPathNotFound(err) ||

			}
			err = osErrToFileErr(err)
			if err == errFileNotFound {
				return nil
			}
			return err
		}
		for _, fi := range fis {
			if fi.Mode()&os.ModeSymlink == os.ModeSymlink {
				fi, err = Stat(pathJoin(dirPath, fi.Name()))
				if err != nil {
					// It got deleted in the meantime, not found
					// or returns too many symlinks ignore this
					// file/directory.
					if osIsNotExist(err) || isSysErrPathNotFound(err) ||

	localPaths := globalEndpoints.LocalDisksPaths()
	var ignoredPaths []string
	paths := func() (tmpPaths []string) {
		for _, lp := range localPaths {
			if _, err := Lstat(pathJoin(lp, minioMetaBucket, formatConfigFile)); err == nil {
				tmpPaths = append(tmpPaths, pathJoin(lp, minioMetaTmpBucket))
			} else {
				// Use dperf on only formatted drives.
				ignoredPaths = append(ignoredPaths, lp)
			}
		}
		return tmpPaths
	}()

		tag, _ := tags.ParseObjectTags(userTags)
		if tag != nil {
			tagMap := tag.ToMap()
			keys := make([]string, 0, len(tagMap))
			for k, v := range tagMap {
				args[pathJoin("ExistingObjectTag", k)] = []string{v}
				args[pathJoin("RequestObjectTag", k)] = []string{v}
				keys = append(keys, k)
			}
			args["RequestObjectTagKeys"] = keys
		}
	}

	for _, objLock := range []string{

		// Fallback for filesystems (like old XFS) that don't
		// support Dirent.Type and have DT_UNKNOWN (0) there
		// instead.
		if typ == unexpectedFileMode || typ&os.ModeSymlink == os.ModeSymlink {
			fi, err := Stat(pathJoin(dirPath, string(name)))
			if err != nil {
				// It got deleted in the meantime, not found
				// or returns too many symlinks ignore this
				// file/directory.
				if osIsNotExist(err) || isSysErrPathNotFound(err) ||

}

// Lock the namespace resource.
func (n *nsLockMap) lock(ctx context.Context, volume string, path string, lockSource, opsID string, readLock bool, timeout time.Duration) (locked bool) {
	resource := pathJoin(volume, path)

	n.lockMapMutex.Lock()
	nsLk, found := n.lockMap[resource]
	if !found {
		nsLk = &nsLock{
			LRWMutex: lsync.NewLRWMutex(),
		}

	}

	// Attempt to create a file to verify the permissions later.
	// AppendFile creates file with 0666 perms.
	if err = disk.AppendFile(context.Background(), testCase.volName, pathJoin("hello-world.txt", xlStorageFormatFile), []byte("Hello World")); err != nil {
		t.Fatalf("Create a file `test` failed with %s expected to pass.", err)
	}

	// CheckFile - stat the file.