From a1193cc7a2614249e38102e7442ce3683115d845 Mon Sep 17 00:00:00 2001
From: Yang Bo <bo@hyper.sh>
Date: Thu, 24 Nov 2022 18:11:34 +0800
Subject: [PATCH 1/5] overlay: add userspace overlay implementation

Add first implementation of overlay fs which can imitate kernel
overlay fs. This allow you to customize a union fs with many customized
layers, for example, one passthrough fs as upper layer and one NFS as
lower layer.

This can be quite useful for some projects relying on fuse-backend-rs,
e.g. Nydus, which can add writable upper layer on readonly RAFS lower
layer, to act as a complete container rootfs.

More details will be added in docs.

Signed-off-by: Yang Bo <bo@hyper.sh>
---
 src/lib.rs                  |    1 +
 src/overlayfs/config.rs     |   53 +
 src/overlayfs/datasource.rs |    4 +
 src/overlayfs/direct.rs     |  290 +++++
 src/overlayfs/layer.rs      |  223 ++++
 src/overlayfs/mod.rs        | 2432 +++++++++++++++++++++++++++++++++++
 src/overlayfs/plugin.rs     |   92 ++
 testoverlay/Cargo.toml      |   15 +
 testoverlay/src/main.rs     |  128 ++
 9 files changed, 3238 insertions(+)
 create mode 100644 src/overlayfs/config.rs
 create mode 100644 src/overlayfs/datasource.rs
 create mode 100644 src/overlayfs/direct.rs
 create mode 100644 src/overlayfs/layer.rs
 create mode 100644 src/overlayfs/mod.rs
 create mode 100644 src/overlayfs/plugin.rs
 create mode 100644 testoverlay/Cargo.toml
 create mode 100644 testoverlay/src/main.rs

diff --git a/src/lib.rs b/src/lib.rs
index b8756920a..caf3bd086 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -120,6 +120,7 @@ pub mod api;
 #[cfg(all(any(feature = "fusedev", feature = "virtiofs"), target_os = "linux"))]
 pub mod passthrough;
 pub mod transport;
+pub mod overlayfs;
 
 pub mod common;
 pub use self::common::*;
diff --git a/src/overlayfs/config.rs b/src/overlayfs/config.rs
new file mode 100644
index 000000000..ce0e14606
--- /dev/null
+++ b/src/overlayfs/config.rs
@@ -0,0 +1,53 @@
+
+use std::time::Duration;
+use self::super::CachePolicy;
+use std::fmt;
+
+#[derive(Default, Clone, Debug)]
+pub struct Config {
+	pub upper: String,
+	pub lower: Vec<String>,
+	pub work: String,
+	pub mountpoint: String,
+	pub do_import: bool,
+	pub writeback: bool,
+	pub no_open: bool,
+	pub no_opendir: bool,
+	pub killpriv_v2: bool,
+	pub no_readdir: bool,
+	pub xattr: bool,
+	pub xattr_permissions: bool,
+	pub perfile_dax: bool,
+	pub cache_policy: CachePolicy,
+	pub attr_timeout: Duration,
+	pub entry_timeout: Duration,
+}
+
+impl Default for CachePolicy {
+	fn default() -> Self {
+		CachePolicy::Auto
+	}
+}
+
+impl Clone for CachePolicy {
+	fn clone(&self) -> Self {
+		match *self {
+			CachePolicy::Never => CachePolicy::Never,
+			CachePolicy::Always => CachePolicy::Always,
+			CachePolicy::Auto => CachePolicy::Auto,
+		}
+	}
+}
+
+impl fmt::Debug for CachePolicy {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		let policy = 
+		match *self {
+			CachePolicy::Never => "Never",
+			CachePolicy::Always => "Always",
+			CachePolicy::Auto => "Auto",
+		};
+
+		write!(f, "CachePolicy: {}", policy)
+	}
+}
diff --git a/src/overlayfs/datasource.rs b/src/overlayfs/datasource.rs
new file mode 100644
index 000000000..501df060a
--- /dev/null
+++ b/src/overlayfs/datasource.rs
@@ -0,0 +1,4 @@
+
+///! DataSource trait
+pub trait DataSource {
+}
diff --git a/src/overlayfs/direct.rs b/src/overlayfs/direct.rs
new file mode 100644
index 000000000..427bc83e1
--- /dev/null
+++ b/src/overlayfs/direct.rs
@@ -0,0 +1,290 @@
+use std::collections::LinkedList;
+use std::sync::Arc;
+use std::io::{Result, Error, ErrorKind};
+use std::fs;
+use std::ffi::{CStr, CString};
+use std::time::Duration;
+
+
+use self::super::layer::Layer;
+use self::super::BoxedLayer;
+use self::super::{Inode, Handle};
+use crate::passthrough::{PassthroughFs, Config as PassthroughConfig};
+use crate::api::filesystem::{Entry, FileSystem, FsOptions, OpenOptions, GetxattrReply, ListxattrReply, DirEntry, SetattrValid, ZeroCopyReader, ZeroCopyWriter, Context};
+use crate::abi::fuse_abi::CreateIn;
+
+pub struct Direct {
+	pub upper: bool,
+	pub fs: PassthroughFs,
+}
+
+impl Direct {
+	pub fn new(path: String, upper: bool) -> Result<LinkedList<Arc<BoxedLayer>>> {
+		let dir = fs::canonicalize(path.as_str())?;
+		let root_dir = dir.to_string_lossy().into_owned().to_owned();
+		let mut config = PassthroughConfig::default();
+		config.root_dir = root_dir;
+
+		// enable xattr
+		config.xattr = true;
+
+		// under overlay fs, no need to negotiate
+		config.do_import = false;
+		let fs = PassthroughFs::new(config)?;
+
+		let mut layer = Direct{
+			upper,
+			fs,
+		};
+
+		layer.init_layer()?;
+
+		let mut list = LinkedList::new();
+		list.push_back(Arc::new(Box::new(layer) as BoxedLayer));
+
+		Ok(list)
+	}
+}
+
+impl Layer for Direct {
+	fn init_layer(&mut self) -> Result<()> {
+		self.fs.import()
+	}
+
+	fn cleanup(&mut self) -> Result<()> {
+		Ok(())
+	}
+
+	fn is_upper(&self) -> bool {
+		self.upper
+	}
+}
+
+impl FileSystem for Direct {
+	type Inode = Inode;
+	type Handle = Handle;
+
+	fn init(&self, capable: FsOptions) -> Result<FsOptions> {
+		Err(Error::from(ErrorKind::Unsupported))
+	}
+
+	fn destroy(&self) {
+		self.fs.destroy()
+	}
+
+	fn statfs(&self, ctx: &Context, inode: Inode) -> Result<libc::statvfs64> {
+		self.fs.statfs(ctx, inode)
+	}
+
+	fn lookup(&self, ctx: &Context, parent: Inode, name: &CStr) -> Result<Entry> {
+		self.fs.lookup(ctx, parent, name)
+	}
+
+	fn forget(&self, ctx: &Context, inode: Inode, count: u64) {
+		self.fs.forget(ctx, inode, count)
+	}
+
+	fn batch_forget(&self, ctx: &Context, requests: Vec<(Inode, u64)>) {
+		self.fs.batch_forget(ctx, requests)
+	}
+
+	fn opendir(&self, ctx: &Context, inode: Inode, flags: u32) -> Result<(Option<Handle>, OpenOptions)> {
+		// should test flags to refuse write operations
+		let iflags: i32 = flags as i32;
+		let write = iflags & libc::O_RDWR != 0 || iflags & libc::O_WRONLY != 0 || iflags & libc::O_CREAT != 0 || iflags & libc::O_APPEND != 0 || iflags & libc::O_TRUNC != 0;
+		if !self.upper && write {
+			return Err(Error::from_raw_os_error(libc::EROFS));
+		}
+
+		self.fs.opendir(ctx, inode, flags)
+	}
+
+	fn releasedir(&self, ctx: &Context, inode: Inode, flags: u32, handle: Handle) -> Result<()> {
+		self.fs.releasedir(ctx, inode, flags, handle)
+	}
+
+	fn mkdir(&self, ctx: &Context, parent: Inode, name: &CStr, mode: u32, umask: u32) -> Result<Entry> {
+		if !self.upper {
+			return Err(Error::from_raw_os_error(libc::EROFS));
+		}
+
+		self.fs.mkdir(ctx, parent, name, mode, umask)
+	}
+
+	fn rmdir(&self, ctx: &Context, parent: Inode, name: &CStr) -> Result<()> {
+		if !self.upper {
+			return Err(Error::from_raw_os_error(libc::EROFS));
+		}
+
+		self.fs.rmdir(ctx, parent, name)
+	}
+
+	fn readdir(&self, ctx: &Context, inode: Inode, handle: Handle, size: u32, offset: u64, add_entry: &mut dyn FnMut(DirEntry) -> Result<usize>) -> Result<()> {
+		self.fs.readdir(ctx, inode, handle, size, offset, add_entry)
+	}
+
+	fn readdirplus(&self, ctx: &Context, inode: Inode, handle: Handle, size: u32, offset: u64, add_entry: &mut dyn FnMut(DirEntry, Entry) -> Result<usize>) -> Result<()> {
+		self.fs.readdirplus(ctx, inode, handle, size, offset, add_entry)
+	}
+
+	fn open(&self, ctx: &Context, inode: Inode, flags: u32, fuse_flags: u32) -> Result<(Option<Handle>, OpenOptions)> {
+		let iflags: i32 = flags as i32;
+		let write = iflags & libc::O_RDWR != 0 || iflags & libc::O_WRONLY != 0 || iflags & libc::O_CREAT != 0 || iflags & libc::O_APPEND != 0 || iflags & libc::O_TRUNC != 0;
+		if !self.upper && write {
+			return Err(Error::from_raw_os_error(libc::EROFS));
+		}
+
+		self.fs.open(ctx, inode, flags, fuse_flags)
+	}
+
+	fn release(&self, ctx: &Context, inode: Inode, flags: u32, handle: Handle, flush: bool, flock_release: bool, lock_owner: Option<u64>) -> Result<()> {
+		self.fs.release(ctx, inode, flags, handle, flush, flock_release, lock_owner)
+	}
+
+	fn create(&self, ctx: &Context, parent: Inode, name: &CStr, args: CreateIn) -> Result<(Entry, Option<Handle>, OpenOptions)> {
+		if !self.upper {
+			return Err(Error::from_raw_os_error(libc::EROFS));
+		}
+
+		self.fs.create(ctx, parent, name, args)
+	}
+
+	fn unlink(&self, ctx: &Context, parent: Inode, name: &CStr) -> Result<()> {
+		if !self.upper {
+			return Err(Error::from_raw_os_error(libc::EROFS));
+		}
+
+		self.fs.unlink(ctx, parent, name)
+	}
+
+	fn read(&self, ctx: &Context, inode: Inode, handle: Handle, w: &mut dyn ZeroCopyWriter, size: u32, offset: u64, lock_owner: Option<u64>, flags: u32) -> Result<usize> {
+		self.fs.read(ctx, inode, handle, w, size, offset, lock_owner, flags)
+	}
+
+	fn write(&self, ctx: &Context, inode: Inode, handle: Handle, r: &mut dyn ZeroCopyReader, size: u32, offset: u64, lock_owner: Option<u64>, delay_write: bool, flags: u32, fuse_flags: u32) -> Result<usize> {
+		if !self.upper {
+			return Err(Error::from_raw_os_error(libc::EROFS));
+		}
+
+		self.fs.write(ctx, inode, handle, r, size, offset, lock_owner, delay_write, flags, fuse_flags)
+	}
+
+	fn getattr(&self, ctx: &Context, inode: Inode, handle: Option<Handle>) -> Result<(libc::stat64, Duration)> {
+		self.fs.getattr(ctx, inode, handle)
+	}
+
+	fn setattr(&self, ctx: &Context, inode: Inode, attr: libc::stat64, handle: Option<Handle>, valid: SetattrValid) -> Result<(libc::stat64, Duration)> {
+		if !self.upper {
+			return Err(Error::from_raw_os_error(libc::EROFS));
+		}
+
+		self.fs.setattr(ctx, inode, attr, handle, valid)
+	}
+
+	fn rename(&self, ctx: &Context, olddir: Inode, oldname: &CStr, newdir: Inode, newname: &CStr, flags: u32) -> Result<()> {
+		if !self.upper {
+			return Err(Error::from_raw_os_error(libc::EROFS));
+		}
+
+		self.fs.rename(ctx, olddir, oldname, newdir, newname, flags)
+	}
+
+	fn mknod(&self, ctx: &Context, parent: Inode, name: &CStr, mode: u32, rdev: u32, umask: u32) -> Result<Entry> {
+		if !self.upper {
+			return Err(Error::from_raw_os_error(libc::EROFS));
+		}
+
+		self.fs.mknod(ctx, parent, name, mode, rdev, umask)
+	}
+
+	fn link(&self, ctx: &Context, inode: Inode, newparent: Inode, newname: &CStr) -> Result<Entry> {
+		if !self.upper {
+			return Err(Error::from_raw_os_error(libc::EROFS));
+		}
+
+		self.fs.link(ctx, inode, newparent, newname)
+	}
+
+	fn symlink(&self, ctx: &Context, linkname: &CStr, parent: Inode, name: &CStr) -> Result<Entry> {
+		if !self.upper {
+			return Err(Error::from_raw_os_error(libc::EROFS));
+		}
+
+		self.fs.symlink(ctx, linkname, parent, name)
+	}
+
+	fn readlink(&self, ctx: &Context, inode: Inode) -> Result<Vec<u8>> {
+		self.fs.readlink(ctx, inode)
+	}
+
+	fn flush(&self, ctx: &Context, inode: Inode, handle: Handle, lock_owner: u64) -> Result<()> {
+		// even readonly opened file can be flushed,
+		// so it does't have to be in upper layer
+		// if !self.upper {
+		// 	return Err(Error::from_raw_os_error(libc::EROFS));
+		// }
+
+		self.fs.flush(ctx, inode, handle, lock_owner)
+	}
+
+	fn fsync(&self, ctx: &Context, inode: Inode, datasync: bool, handle: Handle) -> Result<()> {
+		if !self.upper {
+			return Err(Error::from_raw_os_error(libc::EROFS));
+		}
+
+		self.fs.fsync(ctx, inode, datasync, handle)
+	}
+
+	fn fsyncdir(&self, ctx: &Context, inode: Inode, datasync: bool, handle: Handle) -> Result<()> {
+		if !self.upper {
+			return Err(Error::from_raw_os_error(libc::EROFS));
+		}
+
+		self.fs.fsyncdir(ctx, inode, datasync, handle)
+	}
+
+	fn access(&self, ctx: &Context, inode: Inode, mask: u32) -> Result<()> {
+		let write = mask as i32 & libc::W_OK != 0;
+		if !self.upper && write {
+			return Err(Error::from_raw_os_error(libc::EROFS));
+		}
+
+		self.fs.access(ctx, inode, mask)
+	}
+
+	fn setxattr(&self, ctx: &Context, inode: Inode, name: &CStr, value: &[u8], flags: u32) -> Result<()> {
+		if !self.upper {
+			return Err(Error::from_raw_os_error(libc::EROFS));
+		}
+
+		self.fs.setxattr(ctx, inode, name, value, flags)
+	}
+
+	fn getxattr(&self, ctx: &Context, inode: Inode, name: &CStr, size: u32) -> Result<GetxattrReply> {
+		self.fs.getxattr(ctx, inode, name, size)
+	}
+
+	fn listxattr(&self, ctx: &Context, inode: Inode, size: u32) -> Result<ListxattrReply> {
+		self.fs.listxattr(ctx, inode, size)
+	}
+
+	fn removexattr(&self, ctx: &Context, inode: Inode, name: &CStr) -> Result<()> {
+		if !self.upper {
+			return Err(Error::from_raw_os_error(libc::EROFS));
+		}
+
+		self.fs.removexattr(ctx, inode, name)
+	}
+
+	fn fallocate(&self, ctx: &Context, inode: Inode, handle: Handle, mode: u32, offset: u64, length: u64) -> Result<()> {
+		if !self.upper {
+			return Err(Error::from_raw_os_error(libc::EROFS));
+		}
+
+		self.fs.fallocate(ctx, inode, handle, mode, offset, length)
+	}
+
+	fn lseek(&self, ctx: &Context, inode: Inode, handle: Handle, offset: u64, whence: u32) -> Result<u64> {
+		self.fs.lseek(ctx, inode, handle, offset, whence)
+	}
+}
diff --git a/src/overlayfs/layer.rs b/src/overlayfs/layer.rs
new file mode 100644
index 000000000..33f08a47a
--- /dev/null
+++ b/src/overlayfs/layer.rs
@@ -0,0 +1,223 @@
+#![allow(missing_docs)]
+
+use std::sync::{Arc, Weak};
+use std::io::{Result, Error};
+use std::os::unix::io::RawFd;
+use std::fs::File;
+use std::path::PathBuf;
+use std::cmp::Eq;
+use std::ffi::{CString, CStr};
+use libc;
+
+
+use self::super::super::abi::fuse_abi::Dirent;
+use self::super::datasource::DataSource;
+use self::super::{OverlayFs, Inode, Handle};
+use self::super::{WHITEOUT_PREFIX, ORIGIN_XATTR, OPAQUE_XATTR, PRIVILEGED_OPAQUE_XATTR, PRIVILEGED_ORIGIN_XATTR, UNPRIVILEGED_OPAQUE_XATTR, OPAQUE_WHITEOUT};
+use crate::api::filesystem::{FileSystem, Context, Entry, GetxattrReply};
+use crate::abi::fuse_abi::{CreateIn};
+use crate::api::VFS_MAX_INO;
+
+pub const OPAQUE_XATTR_LEN: u32 = 16;
+
+// we cannot constraint Layer with Eq, as Eq requires Sized
+// So we need api to get an identifier and then use identifier
+// to do comparation.. Here may have better solutions..
+pub trait Layer: FileSystem {
+	fn init_layer(&mut self) -> Result<()>;
+	fn cleanup(&mut self) -> Result<()>;
+	fn is_upper(&self) -> bool;
+	// file exists, returns true, not exists return false
+	// otherwise, error out
+	// Ok(None) denotes no entry
+	fn lookup_ignore_enoent(&self, ctx: &Context, ino: u64, name: &str) -> Result<Option<Entry>> {
+		let cname = CString::new(name).expect("invalid c string");
+		match self.lookup(ctx, Self::Inode::from(ino), cname.as_c_str()) {
+			Ok(v) => return Ok(Some(v)),
+			Err(e) => {
+				if let Some(raw_error) = e.raw_os_error() {
+					if raw_error == libc::ENOENT || raw_error == libc::ENAMETOOLONG {
+						return Ok(None);
+					}
+				}
+
+				return Err(e);
+			},
+		}
+	}
+
+	fn getxattr_ignore_nodata(&self, ctx: &Context, inode: u64, name: &str, size: u32) -> Result<Option<Vec<u8>>> {
+		let cname = CString::new(name).expect("invalid c string");
+		match self.getxattr(ctx, Self::Inode::from(inode), cname.as_c_str(), size)
+		{
+			Ok(v) => {
+				if let GetxattrReply::Value(buf) = v {
+					return Ok(Some(buf));
+				} else {
+					return Ok(None);
+				}
+			},
+			Err(e) => {
+				if let Some(raw_error) = e.raw_os_error() {
+					if raw_error == libc::ENODATA || raw_error == libc::ENOTSUP || raw_error == libc::ENOSYS {
+						return Ok(None);
+					}
+				}
+
+				return Err(e);
+			},
+		}
+	}
+
+	fn whiteout_exists(&self, ctx: &Context, ino: u64, name: &CStr) -> Result<(bool, u64, String)> {
+		let sname = name.to_string_lossy().into_owned().to_owned();
+
+		let mut wh_name = String::from(WHITEOUT_PREFIX);
+		wh_name.push_str(sname.as_str());
+
+		// .wh.name exists
+		if let Some(v) = self.lookup_ignore_enoent(ctx, ino, wh_name.as_str())? {
+			return Ok((true, v.inode, wh_name));
+		}
+
+		// char node whiteout
+		if let Some(st) = self.lookup_ignore_enoent(ctx, ino, sname.as_str())? {
+			let major = unsafe { libc::major(st.attr.st_rdev) };
+			let minor = unsafe { libc::minor(st.attr.st_rdev) };
+			if st.attr.st_mode & libc::S_IFMT == libc::S_IFCHR && major == 0 && minor == 0 {
+				return Ok((true, st.inode, sname));
+			}
+		}
+		
+		Ok((false, VFS_MAX_INO, String::from("")))
+	}
+
+	fn is_opaque_whiteout(&self, ctx: &Context, inode: u64) -> Result<(bool, Option<u64>)> {
+		let (st, _d) = self.getattr(ctx, Self::Inode::from(inode), None)?;
+		if st.st_mode & libc::S_IFMT != libc::S_IFDIR {
+			return Err(Error::from_raw_os_error(libc::ENOTDIR));
+		}
+
+		// check xattr first
+		if let Some(v) = self.getxattr_ignore_nodata(ctx, inode, PRIVILEGED_OPAQUE_XATTR, OPAQUE_XATTR_LEN)? {
+			if v[0].to_ascii_lowercase() == b'y' {
+				return Ok((true, None));
+			} else {
+				return Ok((false, None));
+			}
+		}
+
+		if let Some(v) = self.getxattr_ignore_nodata(ctx, inode, UNPRIVILEGED_OPAQUE_XATTR, OPAQUE_XATTR_LEN)? {
+			if v[0].to_ascii_lowercase() == b'y' {
+				return Ok((true, None));
+			} else {
+				return Ok((false, None));
+			}
+		}
+
+		if let Some(v) = self.getxattr_ignore_nodata(ctx, inode, OPAQUE_XATTR, OPAQUE_XATTR_LEN)? {
+			if v[0].to_ascii_lowercase() == b'y' {
+				return Ok((true, None));
+			} else {
+				return Ok((false, None));
+			}
+		}
+
+		// check .wh..wh..opaque, hwoever, we have no parent inode number for the parent of .wh..wh..opaque
+		if let Some(v) = self.lookup_ignore_enoent(ctx, inode, OPAQUE_WHITEOUT)? {
+			return Ok((true, Some(v.inode)));
+		}
+
+		Ok((false, None))
+	}
+
+	fn delete_whiteout(&self, ctx: &Context, parent: u64, name: &str) -> Result<()> {
+		if !self.is_upper() {
+			return Err(Error::from_raw_os_error(libc::EROFS));
+		}
+
+		let mut wh_name = String::from(WHITEOUT_PREFIX);
+		wh_name.push_str(name);
+		let cwh_name = CString::new(wh_name.as_str()).expect("invalid c string");
+		let cname = CString::new(name).expect("invalid c string");
+
+		// .wh.name exists
+		if let Some(v) = self.lookup_ignore_enoent(ctx, parent, wh_name.as_str())? {
+			self.unlink(ctx, Self::Inode::from(parent), cwh_name.as_c_str())?;
+		}
+
+		// char node whiteout
+		if let Some(st) = self.lookup_ignore_enoent(ctx, parent, name)? {
+			let major = unsafe { libc::major(st.attr.st_rdev) };
+			let minor = unsafe { libc::minor(st.attr.st_rdev) };
+			if st.attr.st_mode & libc::S_IFMT == libc::S_IFCHR && major == 0 && minor == 0 {
+				self.unlink(ctx, Self::Inode::from(parent), cname.as_c_str())?;
+			}
+		}
+
+		Ok(())
+	}
+	fn create_whiteout(&self, ctx: &Context, parent: u64, name: &str) -> Result<Entry> {
+		if !self.is_upper() {
+			return Err(Error::from_raw_os_error(libc::EROFS));
+		}
+
+		let mut wh_name = String::from(WHITEOUT_PREFIX);
+		wh_name.push_str(name);
+		let cwh_name = CString::new(wh_name.as_str()).expect("invalid c string");
+		let cname = CString::new(name).expect("invalid c string");
+
+		let (exists, _inode, name) = self.whiteout_exists(ctx, parent, cname.as_c_str())?;
+
+		if exists {
+			return self.lookup(ctx, Self::Inode::from(parent), CString::new(name.as_str()).expect("invalid c string").as_c_str());
+		}
+
+		// try to creat .wh.name
+		let args = CreateIn {
+			flags: 0,
+			mode: 0o777,
+			umask: 0,
+			fuse_flags: 0,
+		};
+
+		if let Ok((entry, h, o)) = self.create(ctx, Self::Inode::from(parent), cwh_name.as_c_str(), args) {
+			// if let Some(handle) = h {
+			// 	self.release(ctx, Self::Inode::from(entry.inode), 0, handle, true, true, None)?;
+			// }
+
+			return Ok(entry);
+		}
+
+		// try mknod
+		let dev = unsafe { libc::makedev(0, 0) };
+		let mode = libc::S_IFCHR | 0o777;
+		self.mknod(ctx, Self::Inode::from(parent), cname.as_c_str(), mode, dev as u32, 0)
+	}
+
+	fn create_opaque_whiteout(&self, ctx: &Context, parent: u64) -> Result<Entry> {
+		if !self.is_upper() {
+			return Err(Error::from_raw_os_error(libc::EROFS));
+		}
+
+		let cname = CString::new(OPAQUE_WHITEOUT).expect("invalid c string");
+
+		// opaque whiteout exists
+		if let Some(v) = self.lookup_ignore_enoent(ctx, parent, OPAQUE_WHITEOUT)? {
+			return Ok(v);
+		}
+
+		// create
+		let args = CreateIn {
+			flags: 0,
+			mode: 0o777,
+			umask: 0,
+			fuse_flags: 0,
+		};
+
+		let (entry, h, _o) = self.create(ctx, Self::Inode::from(parent), cname.as_c_str(), args)?;
+
+		Ok(entry)
+	}
+
+}
diff --git a/src/overlayfs/mod.rs b/src/overlayfs/mod.rs
new file mode 100644
index 000000000..3fedc3a5e
--- /dev/null
+++ b/src/overlayfs/mod.rs
@@ -0,0 +1,2432 @@
+#![allow(missing_docs)]
+#![feature(io_error_more)]
+
+pub mod layer;
+pub mod datasource;
+pub mod plugin;
+pub mod config;
+pub mod direct;
+
+use std::collections::{LinkedList, HashMap};
+use std::io::{Result, SeekFrom, Seek};
+use std::fs::File;
+use std::sync::{Arc, Mutex, Weak};
+use std::sync::atomic::{AtomicBool, Ordering, AtomicU64};
+use std::any::Any;
+use std::ffi::{CStr, CString};
+use std::time::Duration;
+use std::string::ToString;
+use std::mem::{size_of, MaybeUninit};
+use std::os::unix::io::FromRawFd;
+
+use crate::api::filesystem::{Entry, FileSystem, FsOptions, OpenOptions, GetxattrReply, ListxattrReply, DirEntry, SetattrValid, ZeroCopyReader, ZeroCopyWriter, Context};
+use crate::api::{BackendFileSystem, SLASH_ASCII, VFS_MAX_INO};
+use crate::abi::fuse_abi::{CreateIn, ROOT_ID as FUSE_ROOT_ID};
+use crate::common::file_buf::FileVolatileSlice;
+use crate::common::file_traits::FileReadWriteVolatile;
+
+use self::plugin::PluginManager;
+use self::layer::Layer;
+use self::config::Config;
+use std::io::{Error, ErrorKind};
+use libc;
+
+
+pub type Inode = u64;
+pub type Handle = u64;
+pub const PLUGIN_PREFIX: &str = "//";
+pub const WHITEOUT_PREFIX: &str = ".wh.";
+pub const XATTR_PREFIX: &str = "user.fuseoverlayfs";
+pub const ORIGIN_XATTR: &str = "user.fuseoverlayfs.origin";
+pub const OPAQUE_XATTR: &str = "user.fuseoverlayfs.opaque";
+pub const XATTR_CONTAINERS_PREFIX: &str = "user.containers";
+pub const UNPRIVILEGED_XATTR_PREFIX: &str = "user.overlay";
+pub const UNPRIVILEGED_OPAQUE_XATTR: &str = "user.overlay.opaque";
+pub const PRIVILEGED_XATTR_PREFIX: &str = "trusted.overlay";
+pub const PRIVILEGED_OPAQUE_XATTR: &str = "trusted.overlay.opaque";
+pub const PRIVILEGED_ORIGIN_XATTR: &str = "trusted.overlay.origin";
+pub const OPAQUE_WHITEOUT: &str = ".wh..wh..opq";
+pub const MAXNAMELEN: usize = 256;
+pub const CURRENT_DIR: &str = ".";
+pub const PARENT_DIR: &str = "..";
+pub const WHITEOUT_MAX_LEN: u64 = ".wh.".len() as u64;
+pub const MAXBUFSIZE: usize = 1<< 20;
+
+pub type BoxedLayer = Box<dyn Layer<Inode = Inode, Handle = Handle> + Send + Sync>;
+
+// need real inode from layers, need inode to do layer
+// operations
+#[derive(Default)]
+pub struct RealInode {
+	pub layer: Option<Arc<BoxedLayer>>,
+	pub inode: AtomicU64,
+	pub whiteout: AtomicBool,
+	pub opaque: AtomicBool,
+	pub hidden: AtomicBool,
+	pub invalid: AtomicBool,
+}
+
+#[derive(Default, Debug)]
+pub struct RealInodeStats {
+	pub inode: u64,
+	pub whiteout: bool,
+	pub opaque: bool,
+	pub stat: Option<libc::stat64>,
+	pub wh_name: Option<String>,
+	pub opaque_inode: Option<u64>,
+}
+
+#[derive(Default)]
+pub struct OverlayInode {
+	pub childrens: Mutex<HashMap<String, Arc<OverlayInode>>>,
+	pub parent: Mutex<Weak<OverlayInode>>,
+	pub lower_inodes: Vec<Arc<RealInode>>,
+	pub upper_inode: Mutex<Option<Arc<RealInode>>>,
+	pub first_inode: Mutex<Arc<RealInode>>,
+	pub last_inode: Mutex<Arc<RealInode>>,
+	pub inode: u64,
+	pub st_ino: libc::ino64_t,
+	pub st_dev: libc::dev_t,
+	pub mode: libc::mode_t,
+	pub entry_type: u32,
+	pub path: String,
+	pub name: String,
+	pub lookups: Mutex<u64>,
+
+	pub hidden: AtomicBool,
+	pub whiteout: AtomicBool,
+	pub loaded: AtomicBool,
+
+	// what about data source related data for each inode
+	// put it into layer struct, ino -> private data hash
+}
+
+pub enum CachePolicy {
+	Never,
+	Auto,
+	Always,
+}
+
+pub struct OverlayFs {
+	// should be in daemon structure
+	pub config: Config,
+	pub layers: LinkedList<Arc<BoxedLayer>>,
+	pub upper_layer: Option<Arc<BoxedLayer>>,
+	// inode management..
+	pub root: Option<Arc<OverlayInode>>,
+	pub inodes: Mutex<HashMap<u64, Arc<OverlayInode>>>, 
+	pub next_inode: AtomicU64,
+
+	// manage opened fds..
+	pub handles: Mutex<HashMap<u64, HandleData>>,
+	pub next_handle: AtomicU64,
+	pub writeback: AtomicBool,
+	pub no_open: AtomicBool,
+	pub no_opendir: AtomicBool,
+	pub killpriv_v2: AtomicBool,
+	pub perfile_dax: AtomicBool,
+}
+
+pub struct RealHandle {
+	pub real_inode: Arc<RealInode>,
+	pub handle: AtomicU64,
+	pub invalid: AtomicBool,
+}
+
+pub struct HandleData {
+	pub node: Arc<OverlayInode>,
+	pub childrens: Option<Vec<Arc<OverlayInode>>>,
+	pub offset: libc::off_t,
+
+	// others?
+	pub real_handle: Option<RealHandle>,
+}
+
+impl RealInode {
+	pub fn stat64_ignore_enoent(&self, ctx: &Context) -> Result<Option<libc::stat64>> {
+		if self.invalid.load(Ordering::Relaxed) {
+			return Ok(None);
+		}
+
+		match self.layer.as_ref().unwrap().getattr(ctx, self.inode.load(Ordering::Relaxed), None) {
+			Ok((v1, _v2)) => {
+				return Ok(Some(v1));
+			},
+
+			Err(e) => {
+				match e.raw_os_error() {
+					Some(raw_error) => {
+						if raw_error != libc::ENOENT && raw_error != libc::ENOTDIR && raw_error != libc::ENAMETOOLONG {
+							return Ok(None);
+						}
+						return Err(e);
+					},
+
+					None => {
+						return Err(e);
+					},
+				}
+			},
+		}
+	}
+
+	// Ok(None) represents noent
+	pub fn lookup_node(&self, ctx: &Context, name: &CStr) -> Result<Option<RealInodeStats>> {
+
+		if self.whiteout.load(Ordering::Relaxed) || self.invalid.load(Ordering::Relaxed) {
+			return Ok(None);
+		}
+
+		let sname = name.to_string_lossy().into_owned().to_owned();
+		if sname.starts_with(WHITEOUT_PREFIX){
+			return Err(Error::from_raw_os_error(libc::EINVAL));
+		}
+
+		let layer = self.layer.as_ref().unwrap();
+
+		let (whiteout, inode, wh_name) = layer.whiteout_exists(ctx, self.inode.load(Ordering::Relaxed), name)?;
+
+		if whiteout {
+			return Ok(Some(RealInodeStats {
+				inode,
+				whiteout,
+				opaque: false,
+				stat: None,
+				wh_name: Some(wh_name),
+				opaque_inode: None,
+			}));
+		}
+
+		if let Some(v) = layer.lookup_ignore_enoent(ctx, self.inode.load(Ordering::Relaxed), sname.as_str())? {
+			// directory?
+			if v.attr.st_mode & libc::S_IFMT != libc::S_IFDIR {
+				return Ok(Some(RealInodeStats {
+					inode: v.inode,
+					whiteout: false,
+					opaque: false,
+					stat: Some(v.attr),
+					wh_name: None,
+					opaque_inode: None,
+				}));
+			}
+
+			let (opaque, opaque_inode) = layer.is_opaque_whiteout(ctx, v.inode)?;
+
+			return Ok(Some(RealInodeStats {
+				inode: v.inode,
+				whiteout: false,
+				opaque,
+				stat: Some(v.attr),
+				wh_name: None,
+				opaque_inode,
+			}));
+		} else {
+			return Ok(None);
+		}
+	}
+}
+
+impl OverlayInode {
+	pub fn stat64(&self, ctx: &Context) -> Result<libc::stat64> {
+		// try upper layer if there is
+		if let Some(ref l) = *self.upper_inode.lock().unwrap() {
+			if let Some(v) = l.stat64_ignore_enoent(ctx)? {
+				return Ok(v);
+			}
+		}
+
+		// try layers in order or just take stst from first layer?
+		for l in &self.lower_inodes {
+			if let Some(v) = l.stat64_ignore_enoent(ctx)? {
+				return Ok(v);
+			}
+		}
+
+		// not in any layer 
+		Err(Error::from_raw_os_error(libc::ENOENT))
+	}
+
+	pub fn count_entries_and_whiteout(&self, ctx: &Context) -> Result<(u64, u64, u64)> {
+		let mut count = 0;
+		let mut whiteouts = 0;
+		let mut opaque = 0;
+
+		let st = self.stat64(ctx)?;
+
+		// must be directory
+		assert!(st.st_mode & libc::S_IFMT == libc::S_IFDIR);
+		if let Some(ref ri) = *self.upper_inode.lock().unwrap() {
+			if ri.opaque.load(Ordering::Relaxed) {
+				opaque = 1;
+			}
+		}
+
+		for (_, child) in self.childrens.lock().unwrap().iter() {
+			if child.whiteout.load(Ordering::Relaxed) {
+				whiteouts += 1;
+			} else {
+				count += 1;
+			}
+		}
+
+		Ok((count, whiteouts, opaque))
+	}
+
+	pub fn open(&self, ctx: &Context, flags: u32, fuse_flags: u32) -> Result<(Arc<BoxedLayer>, Option<Handle>, OpenOptions)> {
+		let ri = Arc::clone(&self.first_inode.lock().unwrap());
+		if let Some(ref l) = ri.layer {
+			let (h, o) = l.open(ctx, ri.inode.load(Ordering::Relaxed), flags, fuse_flags)?;
+			Ok((Arc::clone(l), h, o))
+		} else {
+			Err(Error::new(ErrorKind::Other, "no first layer"))
+		}
+	}
+
+	pub fn in_upper_layer(&self) -> bool {
+		self.upper_inode.lock().unwrap().is_some()
+	}
+
+	pub fn upper_layer_only(&self) -> bool {
+		self.lower_inodes.len() == 0
+	}
+}
+
+fn process_lower_layer(manager: &PluginManager, opaque: &[String]) -> Result<LinkedList<Arc<BoxedLayer>>> {
+	let mut layers = LinkedList::new();
+
+	for lower in opaque {
+		let mut lower_layers = plugin::process_onelayer(manager, lower.into(), false)?;
+		layers.append(&mut lower_layers);
+	}
+
+	Ok(layers)
+}
+
+impl OverlayInode {
+	pub fn new() -> Self {
+		OverlayInode::default()
+	}
+}
+
+fn entry_type_from_mode(mode: libc::mode_t) -> u8 {
+	if mode & libc::S_IFBLK  != 0 {
+		return libc::DT_BLK;
+	}
+
+	if mode & libc::S_IFCHR != 0 {
+		return libc::DT_CHR;
+	}
+
+	if mode & libc::S_IFDIR != 0 {
+		return libc::DT_DIR;
+	}
+
+	if mode & libc::S_IFIFO != 0 {
+		return libc::DT_FIFO;
+	}
+
+	if mode & libc::S_IFLNK != 0 {
+		return libc::DT_LNK;
+	}
+
+	if mode & libc::S_IFREG != 0 {
+		return libc::DT_REG;
+	}
+
+	if mode & libc::S_IFSOCK != 0 {
+		return libc::DT_SOCK;
+	}
+
+	return libc::DT_UNKNOWN;
+}
+
+impl OverlayFs {
+	pub fn new(manager: &PluginManager, params: Config) -> Result<Self> {
+		// upper dir 
+		let mut layers = plugin::process_onelayer(manager, String::from(params.upper.as_str()), true)?;
+
+		let upper_layer = if let Some(ref v) = layers.front() {
+			Some(Arc::clone(v))
+		}else {
+			None
+		};
+
+		// lower dir
+		let mut lower_layers = process_lower_layer(manager, params.lower.as_slice())?;
+
+		layers.append(&mut lower_layers);
+		// load root inode
+		Ok(OverlayFs {
+				config: params,
+				upper_layer,
+				layers,
+				inodes: Mutex::new(HashMap::new()),
+				root: None,
+				next_inode: AtomicU64::new(FUSE_ROOT_ID + 1),
+				handles: Mutex::new(HashMap::new()),
+				next_handle: AtomicU64::new(1),
+				writeback: AtomicBool::new(false),
+				no_open: AtomicBool::new(false),
+				no_opendir: AtomicBool::new(false),
+				killpriv_v2: AtomicBool::new(false),
+				perfile_dax: AtomicBool::new(false),
+			})
+	}
+
+	pub fn init_root(&mut self) -> Result<()> {
+		let mut root = OverlayInode::new();
+		root.inode = FUSE_ROOT_ID;
+		root.path = String::from(".");
+		root.name = String::from("");
+		root.entry_type = libc::DT_DIR as u32;
+		root.lookups = Mutex::new(2);
+		let ctx = Context::default();
+
+		let mut first= true;
+		for layer in self.layers.iter() {
+			let (opaque, _ino) = layer.is_opaque_whiteout(&ctx, FUSE_ROOT_ID)?;
+			let real = RealInode {
+				layer: Some(Arc::clone(layer)),
+				inode: AtomicU64::new(FUSE_ROOT_ID),
+				whiteout: AtomicBool::new(false),
+				opaque: AtomicBool::new(opaque),
+				hidden: AtomicBool::new(false),
+				invalid: AtomicBool::new(false),
+			};
+
+			let real_inode = Arc::new(real);
+
+			if first {
+				first = false;
+				root.first_inode = Mutex::new(Arc::clone(&real_inode));
+			}
+
+			if layer.is_upper() {
+				root.upper_inode = Mutex::new(Some(Arc::clone(&real_inode)));
+			} else {
+				root.lower_inodes.push(Arc::clone(&real_inode));
+			}
+
+			root.last_inode = Mutex::new(Arc::clone(&real_inode));
+		}
+
+		let root_node = Arc::new(root);
+
+		// insert root inode into hash
+		{
+			self.inodes.lock().unwrap().insert(FUSE_ROOT_ID, Arc::clone(&root_node));
+		}
+
+		let ctx = Context::default();
+		info!("loading root directory\n");
+		self.load_directory(&ctx, Arc::clone(&root_node))?;
+
+		self.root = Some(root_node);
+
+		Ok(())
+	}
+
+	pub fn import(&self) -> Result<()> {
+		Ok(())
+	}
+
+	pub fn make_overlay_inode(&self, ris: &RealInodeStats, layer: Arc<BoxedLayer>) -> Result<OverlayInode> {
+		let mut new = OverlayInode::new();
+		new.whiteout.store(ris.whiteout, Ordering::Relaxed);
+		let real_inode = Arc::new(RealInode {
+			layer: Some(Arc::clone(&layer)),
+			inode: AtomicU64::new(ris.inode),
+			whiteout: AtomicBool::new(ris.whiteout),
+			opaque: AtomicBool::new(ris.opaque),
+			hidden: AtomicBool::new(false),
+			invalid: AtomicBool::new(false),
+		});
+
+		new.first_inode = Mutex::new(Arc::clone(&real_inode));
+		new.last_inode = Mutex::new(Arc::clone(&real_inode));
+		new.lookups = Mutex::new(1);
+		if layer.is_upper() {
+			new.upper_inode = Mutex::new(Some(Arc::clone(&real_inode)));
+		}
+
+		let inode = self.next_inode.fetch_add(1, Ordering::Relaxed);
+		if inode > VFS_MAX_INO {
+			error!("reached maximum inode number: {}", VFS_MAX_INO);
+			return Err(Error::new(ErrorKind::Other, format!("maximum inode number {} reached", VFS_MAX_INO)));
+		}
+		new.inode = inode;
+		if let Some(st) = ris.stat {
+			new.st_ino = st.st_ino;
+			new.st_dev= st.st_dev;
+			new.mode = st.st_mode;
+			new.entry_type = entry_type_from_mode(st.st_mode) as u32;
+		}
+
+		Ok(new)
+	}
+
+	pub fn lookup_node(&self, ctx: &Context, parent: Inode, name: &CStr) -> Result<Arc<OverlayInode>> {
+		if name.to_bytes_with_nul().contains(&SLASH_ASCII) {
+			return Err(Error::from_raw_os_error(libc::EINVAL));
+		}
+
+		// lookup name
+		let pnode = {
+			let inodes = self.inodes.lock().unwrap();
+			if let Some(v) = inodes.get(&parent) {
+				Arc::clone(v)
+			} else {
+				// no parent inode?
+				return Err(Error::from_raw_os_error(libc::EINVAL));
+			}
+		};
+
+		let sname = name.to_string_lossy().into_owned().to_owned();
+		if sname.starts_with(WHITEOUT_PREFIX){
+			return Err(Error::from_raw_os_error(libc::EINVAL));
+		}
+
+		if sname.eq(".") || (parent == FUSE_ROOT_ID && sname.eq("..")) || sname.is_empty() {
+			return Ok(Arc::clone(&pnode));
+		}
+
+		if pnode.whiteout.load(Ordering::Relaxed) {
+			return Err(Error::from_raw_os_error(libc::ENOENT));
+		}
+
+		// found the node
+		if let Some (v) = pnode.childrens.lock().unwrap().get(sname.as_str()) {
+			return Ok(Arc::clone(v));
+		}
+
+		// if the directory is already loaded, not found
+		// we will change dir/file, we will toggle loaded
+		// flag to scan directory
+		if pnode.loaded.load(Ordering::Relaxed) {
+			return Err(Error::from_raw_os_error(libc::ENOENT));
+		}
+
+		// don't find it, lookup in layers
+		let mut path = String::from(pnode.path.as_str());
+		path.push_str("/");
+		path.push_str(sname.as_str());
+
+		let mut node_inited: bool = false;
+		let mut new = OverlayInode::new();
+
+		// lookup until meet whiteout/opaque whiteout/file in lower layer..
+		{
+			if let Some(ref ri) = *pnode.upper_inode.lock().unwrap() {
+				// find an entry
+				if let Some(ris) = ri.lookup_node(ctx, name)? {
+					node_inited = true;
+					new = self.make_overlay_inode(&ris, Arc::clone(ri.layer.as_ref().unwrap()))?;
+				}
+			}
+		}
+
+		'layer_loop:
+		for ri in &pnode.lower_inodes {
+			if let Some(ris) = ri.lookup_node(ctx, name)? {
+				// find an entry
+				let layer = Arc::clone(ri.layer.as_ref().unwrap());
+				let mut real_inode = Arc::new(RealInode {
+					layer: Some(Arc::clone(&layer)),
+					inode: AtomicU64::new(ris.inode),
+					whiteout: AtomicBool::new(ris.whiteout),
+					hidden: AtomicBool::new(false),
+					opaque: AtomicBool::new(ris.opaque),
+					invalid: AtomicBool::new(false),
+				});
+
+				if !node_inited {
+					node_inited = true;
+					new = self.make_overlay_inode(&ris, Arc::clone(&layer))?;
+					new.lower_inodes.push(Arc::clone(&real_inode));
+
+					// should stop?
+					if ris.whiteout {
+						break 'layer_loop;
+					}
+
+					// not whiteout, must have stat
+					let st = ris.stat.as_ref().unwrap();
+					if st.st_mode & libc::S_IFMT != libc::S_IFDIR {
+						break 'layer_loop;
+					}
+
+					// opaque?
+					if ris.opaque {
+						break 'layer_loop;
+					}
+				} else {
+
+					// should stop?
+					if ris.whiteout {
+						break 'layer_loop;
+					}
+
+					// not whiteout, must have stat
+					let st = ris.stat.as_ref().unwrap();
+					if st.st_mode & libc::S_IFMT != libc::S_IFDIR {
+						break 'layer_loop;
+					}
+
+					// directory
+					if node_inited {
+						new.lower_inodes.push(Arc::clone(&real_inode));
+						new.last_inode = Mutex::new(Arc::clone(&real_inode));
+					}
+
+					// opaque?
+					if ris.opaque {
+						break 'layer_loop;
+					}
+				}
+			}
+		}
+
+		if node_inited {
+			new.path = String::from(path.as_str());
+			new.name = String::from(sname.as_str());
+			// set its parent node
+			*new.parent.lock().unwrap() = Arc::downgrade(&pnode);
+			// insert node into hashs
+			let new_node = Arc::new(new);
+			self.inodes.lock().unwrap().insert(new_node.inode as u64, Arc::clone(&new_node));
+			pnode.childrens.lock().unwrap().insert(sname, Arc::clone(&new_node));
+			return Ok(Arc::clone(&new_node));
+		}
+
+		// return specific errors?
+		Err(Error::from_raw_os_error(libc::ENOENT))
+	}
+
+	pub fn lookup_node_ignore_enoent(&self, ctx: &Context, parent: u64, name: &CStr) -> Result<Option<Arc<OverlayInode>>> {
+		match self.lookup_node(ctx, parent, name) {
+			Ok(n) => {
+				return Ok(Some(Arc::clone(&n)));
+			},
+
+			Err(e) => {
+				if let Some(raw_error) = e.raw_os_error() {
+					if raw_error == libc::ENOENT {
+						return Ok(None);
+					}
+				}
+				return Err(e);
+			},
+		}
+		
+	}
+
+	pub fn get_node_from_inode(&self, inode: u64) -> Option<Arc<OverlayInode>> {
+		if let Some(v) = self.inodes.lock().unwrap().get(&inode) {
+			return Some(Arc::clone(v));
+		}
+
+		return None;
+	}
+
+	pub fn load_directory_layer(&self, ctx: &Context, ovl_inode: u64, real: Arc<RealInode>) -> Result<()> {
+		if real.whiteout.load(Ordering::Relaxed) || real.invalid.load(Ordering::Relaxed) {
+			return Err(Error::from_raw_os_error(libc::ENOENT));
+		}
+
+		if let Some(st) = real.stat64_ignore_enoent(ctx)? {
+			if st.st_mode & libc::S_IFMT != libc::S_IFDIR {
+				return Err(Error::from_raw_os_error(libc::ENOTDIR));
+			}
+
+			// process this directory
+			let l = Arc::clone(real.layer.as_ref().unwrap());
+			let rinode = real.inode.load(Ordering::Relaxed);
+
+			let handle = if let (Some(h), _) = l.opendir(ctx, rinode, libc::O_RDONLY as u32)? {
+				h
+			} else {
+				return Err(Error::new(ErrorKind::Other, "no dir handle"));
+			};
+
+			let mut more = true;
+			let mut offset = 0;
+			let bufsize = 1024;
+			while more {
+				more = false;
+				l.readdir(ctx, rinode, handle, bufsize, offset, &mut |d| -> Result<usize> {
+					more = true;
+					offset = d.offset;
+					let cname = unsafe { CString::from_vec_unchecked(d.name.to_vec()) };
+					let cstr_name = cname.as_c_str();
+
+					let child_name = cstr_name.to_string_lossy().into_owned().to_owned();
+
+					info!("entry: {}", child_name.as_str());
+
+					if child_name.eq(CURRENT_DIR) || child_name.eq(PARENT_DIR) || child_name.starts_with(WHITEOUT_PREFIX) {
+						return Ok(1);
+					}
+
+					self.lookup_node(ctx, ovl_inode, cstr_name)?;
+
+					Ok(1)
+				})?;
+			}
+
+			l.releasedir(ctx, rinode, libc::O_RDONLY as u32, handle)?;
+
+		} else {
+			return Err(Error::from_raw_os_error(libc::ENOENT));
+		}
+
+		Ok(())
+	}
+
+	pub fn load_directory(&self, ctx: &Context, node: Arc<OverlayInode>) -> Result<()> {
+		let tmp_ui = {
+			if let Some(ref v) = *node.upper_inode.lock().unwrap() {
+				Some(Arc::clone(v))
+			} else {
+				None
+			}
+		};
+
+		if let Some(ref ui) = tmp_ui {
+			debug!("load upper for {}", node.path.as_str());
+			// upper layer
+			if ui.whiteout.load(Ordering::Relaxed) || ui.invalid.load(Ordering::Relaxed) {
+				return Ok(());
+			}
+
+			if let Some(st) = ui.stat64_ignore_enoent(ctx)? {
+				if st.st_mode & libc::S_IFMT != libc::S_IFDIR {
+					// not directory
+					return Ok(());
+				}
+			
+				// process this layer
+				self.load_directory_layer(ctx, node.inode, Arc::clone(ui))?;
+			}
+
+			// if opaque, stop here
+			if ui.opaque.load(Ordering::Relaxed) {
+				node.loaded.store(true, Ordering::Relaxed);
+				return Ok(());
+			}
+		}
+
+		// read out directories from each layer
+		'layer_loop:
+		for li in &node.lower_inodes {
+			debug!("loading lower for {}", node.path.as_str());
+			if li.whiteout.load(Ordering::Relaxed) || li.invalid.load(Ordering::Relaxed) {
+				break 'layer_loop;
+			}
+
+			if let Some(st) = li.stat64_ignore_enoent(ctx)? {
+				if st.st_mode & libc::S_IFMT != libc::S_IFDIR {
+					// not directory
+					break 'layer_loop;
+				}
+			
+				// process this layer
+				self.load_directory_layer(ctx, node.inode, Arc::clone(li))?;
+			}
+
+			// if opaque, stop here
+			if li.opaque.load(Ordering::Relaxed) {
+				break 'layer_loop;
+			}
+		}
+
+		node.loaded.store(true, Ordering::Relaxed);
+
+		Ok(())
+	}
+
+	pub fn reload_directory(&self, ctx: &Context, node: Arc<OverlayInode>) -> Result<()> {
+		if node.loaded.load(Ordering::Relaxed) {
+			return Ok(())
+		}
+		{
+			let mut children =node.childrens.lock().unwrap();
+			*children = HashMap::new();
+		}
+
+		self.load_directory(ctx, node)
+	}
+
+	pub fn get_first_layer(&self) -> Option<Arc<BoxedLayer>> {
+		if let Some(v) = self.layers.front() {
+			Some(Arc::clone(v))
+		} else {
+			None
+		}
+	}
+
+	pub fn get_upper_layer(&self) -> Option<Arc<BoxedLayer>> {
+		if let Some(ref v) = self.upper_layer.as_ref() {
+			Some(Arc::clone(v))
+		} else {
+			None
+		}
+	}
+
+	pub fn get_first_lower_layer(&self) -> Option<Arc<BoxedLayer>> {
+		if let Some(ref _v) = self.upper_layer.as_ref() {
+			let mut index = 0;
+			for layer in self.layers.iter() {
+				if index == 1 {
+					return Some(Arc::clone(layer));
+				}
+				index += 1;
+			}
+
+			None
+		} else {
+			if let Some(v) = self.layers.front() {
+				Some(Arc::clone(v))
+			} else {
+				None
+			}
+		}
+	}
+
+	pub fn forget_one(&self, inode: Inode, count: u64) {
+		if inode == FUSE_ROOT_ID || inode == 0 {
+			return;
+		}
+
+		let v =  {
+			if let Some(n) = self.inodes.lock().unwrap().get(&inode) {
+				Arc::clone(n)
+			} else {
+				return;
+			}
+		};
+		// lock up lookups
+		let mut lookups = v.lookups.lock().unwrap();
+
+		if *lookups < count {
+			*lookups = 0;
+		} else {
+			*lookups -= count;
+		}
+
+		// remove it from hashmap
+
+		if *lookups == 0 {
+			self.inodes.lock().unwrap().remove(&inode);
+			let parent = v.parent.lock().unwrap();
+
+			if let Some(p) = parent.upgrade() {
+				p.childrens.lock().unwrap().remove(v.name.as_str());
+				p.loaded.store(true, Ordering::Relaxed);
+			}
+		}
+
+		// FIXME: is it possible that the inode still in childrens map?
+	}
+	
+	pub fn do_statvfs(&self, ctx: &Context, inode: Inode) -> Result<libc::statvfs64> {
+		if let Some(v) = self.get_first_layer() {
+			if let Ok(sfs) = v.statfs(ctx, inode) {
+				return Ok(sfs);
+			}
+		}
+
+		// otherwise stat on mountpoint
+		let mut sfs = MaybeUninit::<libc::statvfs64>::zeroed();
+		let cpath = CString::new(self.config.mountpoint.as_str()).expect("invalid path");
+		let path = cpath.as_c_str().as_ptr();
+
+		match unsafe { libc::statvfs64(path, sfs.as_mut_ptr()) } {
+			0 => {
+				let mut sfs = unsafe { sfs.assume_init() };
+				sfs.f_namemax -= WHITEOUT_MAX_LEN;
+
+				Ok(sfs)
+			},
+
+			_ => {
+				Err(Error::last_os_error())
+			},
+		}
+	}
+
+	pub fn get_fs_namemax(&self, ctx: &Context) -> u64 {
+		match self.do_statvfs(ctx, FUSE_ROOT_ID) {
+			Ok(sfs) => sfs.f_namemax,
+			Err(_) => 255 - WHITEOUT_MAX_LEN,
+		}
+	}
+
+	pub fn do_readdir(&self, ctx: &Context, handle: u64, size: u32, offset: u64, add_entry: &mut dyn FnMut(DirEntry, Entry) -> Result<usize>) -> Result<()> {
+		if size == 0 {
+			return Ok(());
+		}
+
+		// FIXME: if offset == 0, need to reconstruct dir for this handle
+		// if offset == 0 {
+		// reconstruct directory
+		// }
+
+		// lookup the directory
+		if let Some(dir) = self.handles.lock().unwrap().get(&handle) {
+			let mut len: usize = 0;
+			debug!("overlay dir: {}, off: {}, size: {}", dir.node.path.as_str(), offset, size);
+
+			let childrens = 
+			if let Some(ref cs) = dir.childrens {
+				cs
+			} else {
+				return Err(Error::new(ErrorKind::Other, "no child!"));
+			};
+
+			if offset >= childrens.len() as u64 {
+				return Ok(());
+			}
+
+			let mut index: u64 = 0;
+			for child in childrens {
+				if index >= offset {
+					let name = match index {
+						0 => ".",
+						1 => "..",
+						_ => child.name.as_str(),
+					};
+
+					// make struct DireEntry and Entry
+					let st = child.stat64(ctx)?;
+					let dir_entry = DirEntry {
+						ino: st.st_ino,
+						offset: index + 1,
+						type_: entry_type_from_mode(st.st_mode) as u32,
+						name: name.as_bytes(),
+					};
+
+					let entry = Entry {
+						inode: child.inode,
+						generation: 0,
+						attr: st,
+						attr_flags: 0,
+						attr_timeout: self.config.attr_timeout,
+						entry_timeout: self.config.entry_timeout,
+					};
+
+					match add_entry(dir_entry, entry) {
+						Ok(0) => break,
+						Ok(l) => {
+							len += l;
+							if len as u32 >= size {
+								// no more space, stop here
+								return Ok(());
+							}
+						},
+
+						Err(e) => {
+							// when the buffer is still empty, return error, otherwise return the entry already added
+							if len == 0 {
+								return Err(e);
+							} else {
+								return Ok(());
+							}
+						},
+					}
+				}
+
+				index += 1;
+			}
+		}
+
+		Ok(())
+	}
+
+	pub fn node_in_upper_layer(&self, node: Arc<OverlayInode>) -> Result<bool> {
+		Ok(node.in_upper_layer())
+	}
+
+	pub fn create_node_directory(&self, ctx: &Context, node: Arc<OverlayInode>) -> Result<()> {
+		// recursively going up and update hashmaps
+		if self.node_in_upper_layer(Arc::clone(&node))? {
+			return Ok(());
+		}
+
+		// not in upper layer, check parent
+		let pnode = if let Some(n) = node.parent.lock().unwrap().upgrade() {
+			Arc::clone(&n)
+		} else {
+			return Err(Error::new(ErrorKind::Other, "no parent?"));
+		};
+
+		if self.node_in_upper_layer(Arc::clone(&pnode))? {
+			// create directory here
+			let upper = Arc::clone(pnode.upper_inode.lock().unwrap().as_ref().unwrap());
+			let layer = Arc::clone(upper.layer.as_ref().unwrap());
+			let cname = CString::new(node.name.as_str()).expect("invalid c string");
+			let st = node.stat64(ctx)?;
+			let entry = layer.mkdir(ctx, upper.inode.load(Ordering::Relaxed), cname.as_c_str(), st.st_mode, 0)?;
+
+			// update node's first_layer
+			let real_inode = Arc::new(RealInode {
+				layer: Some(Arc::clone(&layer)),
+				inode: AtomicU64::new(entry.inode),
+				whiteout: AtomicBool::new(false),
+				opaque: AtomicBool::new(false),
+				hidden: AtomicBool::new(false),
+				invalid: AtomicBool::new(false),
+			});
+
+			// what about st_ino/mode/dev..
+			// FIXME: update st_ino/mode/dev, or query it from layer
+			// on fly?
+			*node.first_inode.lock().unwrap() = Arc::clone(&real_inode);
+			*node.upper_inode.lock().unwrap() = Some(Arc::clone(&real_inode));
+
+			return Ok(());
+
+		} else {
+			return self.create_node_directory(ctx, Arc::clone(&pnode));
+		}
+	}
+
+	pub fn copy_symlink_up(&self, ctx: &Context, node: Arc<OverlayInode>) -> Result<Arc<OverlayInode>> {
+		if self.node_in_upper_layer(Arc::clone(&node))? {
+			return Ok(node);
+		}
+
+		let pnode = if let Some(ref n) = node.parent.lock().unwrap().upgrade() {
+			Arc::clone(n)
+		} else {
+			return Err(Error::new(ErrorKind::Other, "no parent?"));
+		};
+
+		let st = node.stat64(ctx)?;
+
+		let empty_name =CString::new("").expect("invalid c string");
+		let upper = self.get_upper_layer().unwrap();
+		let pnode = self.lookup_node(ctx, pnode.inode, empty_name.as_c_str())?;
+
+		assert!(pnode.in_upper_layer());
+		assert!(st.st_mode & libc::S_IFMT == libc::S_IFLNK);
+		let parent_real_inode = Arc::clone(pnode.upper_inode.lock().unwrap().as_ref().unwrap());
+		let cname = CString::new(node.name.as_str()).expect("invalid c string");
+		let node = self.lookup_node(ctx, pnode.inode, cname.as_c_str())?;
+		let rinode = Arc::clone(&node.first_inode.lock().unwrap());
+		let layer = Arc::clone(rinode.layer.as_ref().unwrap());
+
+		// symlink
+		// first inode, upper most layer inode
+		let path = layer.readlink(ctx, rinode.inode.load(Ordering::Relaxed))?;
+		let cpath = unsafe { CString::from_vec_unchecked(path) };
+		let entry = upper.symlink(ctx, cpath.as_c_str(), parent_real_inode.inode.load(Ordering::Relaxed), cname.as_c_str())?;
+
+		let real_inode = Arc::new(RealInode {
+			layer: Some(Arc::clone(&upper)),
+			inode: AtomicU64::new(entry.inode),
+			whiteout: AtomicBool::new(false),
+			opaque: AtomicBool::new(false),
+			hidden: AtomicBool::new(false),
+			invalid: AtomicBool::new(false),
+		});
+
+		// update first_inode and upper_inode
+		*node.upper_inode.lock().unwrap() = Some(Arc::clone(&real_inode));
+		*node.first_inode.lock().unwrap() = Arc::clone(&real_inode);
+
+		return Ok(Arc::clone(&node));
+	}
+
+	pub fn copy_regfile_up(&self, ctx: &Context, node: Arc<OverlayInode>) -> Result<Arc<OverlayInode>> {
+		if self.node_in_upper_layer(Arc::clone(&node))? {
+			return Ok(node);
+		}
+
+		let pnode = if let Some(ref n) = node.parent.lock().unwrap().upgrade() {
+			Arc::clone(n)
+		} else {
+			return Err(Error::new(ErrorKind::Other, "no parent?"));
+		};
+
+		let st = node.stat64(ctx)?;
+
+		let empty_name =CString::new("").expect("invalid c string");
+		let upper = self.get_upper_layer().unwrap();
+		let pnode = self.lookup_node(ctx, pnode.inode, empty_name.as_c_str())?;
+
+		assert!(pnode.in_upper_layer());
+		assert!(st.st_mode & libc::S_IFMT != libc::S_IFLNK && st.st_mode & libc::S_IFMT != libc::S_IFDIR);
+
+		let parent_real_inode = Arc::clone(pnode.upper_inode.lock().unwrap().as_ref().unwrap());
+		let cname = CString::new(node.name.as_str()).expect("invalid c string");
+		let node = self.lookup_node(ctx, pnode.inode, cname.as_c_str())?;
+		let rinode = Arc::clone(&node.first_inode.lock().unwrap());
+		let layer = Arc::clone(rinode.layer.as_ref().unwrap());
+
+		// create the file in upper layer using information from lower layer
+
+		let args = CreateIn {
+			flags: 0,
+			mode: st.st_mode,
+			umask: 0,
+			fuse_flags: 0,
+		};
+
+		let (entry, h, o) = upper.create(ctx, parent_real_inode.inode.load(Ordering::Relaxed), cname.as_c_str(), args)?;
+
+		let real_inode = Arc::new(RealInode {
+			layer: Some(Arc::clone(&upper)),
+			inode: AtomicU64::new(entry.inode),
+			whiteout: AtomicBool::new(false),
+			opaque: AtomicBool::new(false),
+			hidden: AtomicBool::new(false),
+			invalid: AtomicBool::new(false),
+		});
+
+		if h.is_none() {
+			error!("no handle!!!");
+			return Err(Error::new(ErrorKind::Other, "non handle!"));
+		}
+
+		let dst_handle = h.unwrap();
+
+		let (h, o) = layer.open(ctx, rinode.inode.load(Ordering::Relaxed), libc::O_RDONLY as u32, 0)?;
+		
+		if h.is_none() {
+			error!("no handle!!!");
+			return Err(Error::new(ErrorKind::Other, "non handle!"));
+		}
+
+		let src_handle = h.unwrap();
+
+		// copy... 
+		// source: layer, rinode.inode, src_handle
+		// dst: upper, real_inode.inode, dst_handle
+
+		// need to impl ZeroCopyReader/ZeroCopyWriter, somehow like a pipe..
+		// stupid: to create a temp file for now..
+		// FIXME: need to copy xattr, futimes, set origin.TODO
+
+		let mut template = CString::new("/tmp/fuse-overlay-XXXXXX").expect("invalid c string");
+		let mut template = template.into_raw();
+		let suffixlen = 10;
+		let flags = libc::O_RDWR | libc::O_CREAT;
+		let fd = unsafe { libc::mkostemp(template, flags) };
+
+		if fd < 0 {
+			return Err(Error::last_os_error());
+		}
+
+		let mut file = unsafe { File::from_raw_fd(fd) };
+		let mut offset: usize = 0;
+		let size = 4 * 1024 * 1024;
+		loop {
+			let ret = layer.read(ctx, rinode.inode.load(Ordering::Relaxed), src_handle, &mut file, size, offset as u64, None, 0)?;
+			if ret == 0 {
+				break;
+			}
+
+			offset += ret;
+		}
+
+		file.seek(SeekFrom::Start(0))?;
+		offset = 0;
+		loop {
+			let ret = upper.write(ctx, entry.inode, dst_handle, &mut file, size, offset as u64, None, false, 0, 0)?;
+			if ret == 0 {
+				break;
+			}
+
+			offset += ret;
+		}
+
+		drop(file);
+		unsafe { libc::unlink(template); }
+
+		// close handles
+		layer.release(ctx, rinode.inode.load(Ordering::Relaxed), 0, src_handle, true, true, None)?;
+		upper.release(ctx, entry.inode, 0, dst_handle, true, true, None)?;
+
+		// update upper_inode and first_inode
+		*node.upper_inode.lock().unwrap() = Some(Arc::clone(&real_inode));
+		*node.first_inode.lock().unwrap() = Arc::clone(&real_inode);
+
+		return Ok(Arc::clone(&node));
+	}
+
+	pub fn copy_node_up(&self, ctx: &Context, node: Arc<OverlayInode>) -> Result<Arc<OverlayInode>> {
+		if self.node_in_upper_layer(Arc::clone(&node))? {
+			return Ok(node);
+		}
+		// not in upper, copy it up
+		let pnode = if let Some(ref n) = node.parent.lock().unwrap().upgrade() {
+			Arc::clone(n)
+		} else {
+			return Err(Error::new(ErrorKind::Other, "no parent?"));
+		};
+
+		self.create_node_directory(ctx, Arc::clone(&pnode))?;
+		// parent prepared
+		let st = node.stat64(ctx)?;
+
+		// directory
+		if st.st_mode & libc::S_IFMT == libc::S_IFDIR {
+			self.create_node_directory(ctx, Arc::clone(&node))?;
+			return Ok(Arc::clone(&node));
+		}
+
+		// other kind of files
+
+		// symlink
+		if st.st_mode * libc::S_IFMT == libc::S_IFLNK {
+			return self.copy_symlink_up(ctx, Arc::clone(&node));
+		}
+
+		// reg file
+		// need to use work directory and then rename file to 
+		// final destination for atomic reasons.. not deal with it for now,
+		// use stupid copy at present. FIXME:
+		// this need a lot of work here, ntimes, xattr, etc
+		self.copy_regfile_up(ctx, Arc::clone(&node))
+	}
+
+	pub fn is_upper_layer(&self, l: Arc<BoxedLayer>) -> bool {
+		l.is_upper()
+	}
+
+	pub fn do_rm(&self, ctx: &Context, parent: u64, name: &CStr, dir: bool) -> Result<()> {
+		let upper = if let Some(ref v) = self.upper_layer.as_ref() {
+			Arc::clone(v)
+		} else {
+			return Err(Error::from_raw_os_error(libc::EROFS));
+		};
+
+		let pnode = self.lookup_node(ctx, parent, CString::new("").expect("invalid path!").as_c_str())?;
+		if pnode.whiteout.load(Ordering::Relaxed) {
+			return Err(Error::from_raw_os_error(libc::ENOENT));
+		}
+
+		let node = self.lookup_node(ctx, parent, name)?;
+		if node.whiteout.load(Ordering::Relaxed) {
+			return Err(Error::from_raw_os_error(libc::ENOENT));
+		}
+
+		if dir {
+			self.reload_directory(ctx, Arc::clone(&node))?;
+			let (count, whiteouts, opaque) = node.count_entries_and_whiteout(ctx)?;
+			trace!("files: {}, whiteouts: {} opaque: {}\n", count, whiteouts, opaque);
+			if count > 0 {
+				return Err(Error::from_raw_os_error(libc::ENOTEMPTY));
+			}
+
+			// need to delete whiteouts?
+			if whiteouts + opaque > 0 {
+				if node.in_upper_layer() {
+					self.empty_node_directory(ctx, Arc::clone(&node))?;
+				}
+			}
+
+			trace!("whiteouts deleted!\n");
+		}
+
+		let mut need_whiteout = true;
+		let pnode = self.copy_node_up(ctx, Arc::clone(&pnode))?;
+
+		if node.upper_layer_only() {
+			need_whiteout = false;
+		}
+
+		// parent opaqued
+		let real_pnode = Arc::clone(pnode.upper_inode.lock().unwrap().as_ref().unwrap());
+		let real_parent_inode = real_pnode.inode.load(Ordering::Relaxed);
+		if real_pnode.opaque.load(Ordering::Relaxed) {
+			need_whiteout = false;
+		}
+
+		let layer = Arc::clone(real_pnode.layer.as_ref().unwrap());
+
+		if node.in_upper_layer() {
+			if dir {
+				layer.rmdir(ctx, real_parent_inode, name)?;
+			} else {
+				layer.unlink(ctx, real_parent_inode, name)?;
+			}
+		}
+
+		trace!("toggling children and inodes hash\n");
+
+		{
+			pnode.childrens.lock().unwrap().remove(node.name.as_str());
+			self.inodes.lock().unwrap().remove(&node.inode);
+		}
+
+		let sname = name.to_string_lossy().into_owned().to_owned();
+
+		if need_whiteout {
+			trace!("do_rm: creating whiteout\n");
+			layer.create_whiteout(ctx, real_parent_inode, sname.as_str())?;
+			pnode.loaded.store(false, Ordering::Relaxed);
+			// readd whiteout node
+			self.lookup_node(ctx, parent, name)?;
+			pnode.loaded.store(true, Ordering::Relaxed);
+		}
+
+		Ok(())
+	}
+
+	pub fn node_upper_layer_only(&self, node: Arc<OverlayInode>) -> bool {
+		node.upper_layer_only()
+	}
+
+	pub fn empty_node_directory(&self, ctx: &Context, node: Arc<OverlayInode>) -> Result<()> {
+		let st = node.stat64(ctx)?;
+		if st.st_mode & libc::S_IFMT != libc::S_IFDIR {
+			return Err(Error::from_raw_os_error(libc::ENOTDIR));
+		}
+
+		self.reload_directory(ctx, Arc::clone(&node))?;
+		if !node.in_upper_layer() {
+			return Ok(());
+		}
+
+		// find the real inode
+		let real_node = Arc::clone(node.upper_inode.lock().unwrap().as_ref().unwrap());
+		let layer = Arc::clone(real_node.layer.as_ref().unwrap());
+		let real_inode = real_node.inode.load(Ordering::Relaxed);
+
+		// delete opaque
+		let copaque = CString::new(OPAQUE_WHITEOUT).expect("invalid c string");
+		let (opaque, _ino) = layer.is_opaque_whiteout(ctx, real_inode)?;
+		if opaque {
+			if let Some(v) = layer.lookup_ignore_enoent(ctx, real_inode, OPAQUE_WHITEOUT)? {
+				layer.unlink(ctx, real_inode, copaque.as_c_str())?;
+			}
+		}
+
+		let iter = {
+			let mut all = Vec::new();
+			for (_, v) in node.childrens.lock().unwrap().iter() {
+				all.push(Arc::clone(v));
+			}
+
+			all
+		};
+
+		for child in &iter {
+			if child.in_upper_layer() {
+				if child.whiteout.load(Ordering::Relaxed) {
+					layer.delete_whiteout(ctx, real_inode, child.name.as_str())?
+				} else {
+					let s = child.stat64(ctx)?;
+					let cname = CString::new(child.name.as_str()).expect("invalid c string");
+					if s.st_mode & libc::S_IFMT == libc::S_IFDIR {
+						let (count, whiteouts, opaque) = child.count_entries_and_whiteout(ctx)?;
+						if count + whiteouts + opaque > 0 {
+							self.empty_node_directory(ctx, Arc::clone(&child))?;
+						}
+
+						layer.rmdir(ctx, real_inode, cname.as_c_str())?
+					} else {
+						layer.unlink(ctx, real_inode, cname.as_c_str())?;
+					}
+				}
+
+				{
+					// delete the child
+					self.inodes.lock().unwrap().remove(&child.inode);
+					node.childrens.lock().unwrap().remove(child.name.as_str());
+				}
+			}
+
+		}
+
+		Ok(())
+	}
+
+	pub fn do_open(&self, inode: Inode, flags: u32, fuse_flags: u32) -> Result<(Option<Handle>, OpenOptions)> {
+			Err(Error::from(ErrorKind::Unsupported))
+	}
+
+	pub fn delete_whiteout_node(&self, ctx: &Context, node: Arc<OverlayInode>) -> Result<()> {
+		if !node.whiteout.load(Ordering::Relaxed) {
+			return Ok(());
+		}
+
+		if !self.node_in_upper_layer(Arc::clone(&node))? {
+			return Ok(());
+		}
+
+		let name = CString::new(node.name.as_str()).expect("invalid c string");
+		let (layer, real_parent, pnode) = {
+			let pnode = if let Some(ref n) = node.parent.lock().unwrap().upgrade() {
+				Arc::clone(n)
+			} else {
+				return Err(Error::new(ErrorKind::Other, "no parent"));
+			};
+
+			let first_inode = pnode.first_inode.lock().unwrap();
+
+			(Arc::clone(first_inode.layer.as_ref().unwrap()), first_inode.inode.load(Ordering::Relaxed), Arc::clone(&pnode))
+		};
+
+		// delete white out and update hash
+		layer.delete_whiteout(ctx, real_parent, node.name.as_str())?;
+		self.inodes.lock().unwrap().remove(&node.inode);
+		pnode.childrens.lock().unwrap().remove(node.name.as_str());
+
+		Ok(())
+	}
+
+	pub fn find_real_info_from_handle(&self, ctx: &Context, handle: Handle) -> Result<(Arc<BoxedLayer>, Inode, Handle)> {
+		if let Some(h) = self.handles.lock().unwrap().get(&handle) {
+			if let Some( ref rhd) = h.real_handle {
+				let real_handle = rhd.handle.load(Ordering::Relaxed);
+				let ri = Arc::clone(&rhd.real_inode);
+				let layer = Arc::clone(ri.layer.as_ref().unwrap());
+				let real_inode = ri.inode.load(Ordering::Relaxed);
+				return Ok((layer, real_inode, real_handle))
+			}
+		}
+
+		Err(Error::from_raw_os_error(libc::ENOENT))
+	}
+
+	pub fn find_real_inode(&self, ctx: &Context, inode: Inode) -> Result<(Arc<BoxedLayer>, Inode)> {
+		if let Some(n) = self.inodes.lock().unwrap().get(&inode) {
+			let first = n.first_inode.lock().unwrap();
+			let layer = Arc::clone(first.layer.as_ref().unwrap());
+			let real_inode = first.inode.load(Ordering::Relaxed);
+
+			return Ok((layer, real_inode))
+		}
+
+		Err(Error::from_raw_os_error(libc::ENOENT))
+	}
+}
+
+impl BackendFileSystem for OverlayFs {
+	fn mount(&self) -> Result<(Entry, u64)> {
+		if let Some(ref root) = self.root.as_ref() {
+			let ctx = Context::default();
+			Ok((Entry {
+				inode: root.inode,
+				generation: 0,
+				attr: root.stat64(&ctx)?,
+				attr_flags: 0,
+				attr_timeout: self.config.attr_timeout,
+				entry_timeout: self.config.entry_timeout,
+			}, VFS_MAX_INO))
+		} else {
+			Err(Error::new(ErrorKind::Other, "fs not inited"))
+		}
+	}
+
+	fn as_any(&self) -> &dyn Any {
+		self
+	}
+}
+
+impl FileSystem for OverlayFs {
+	type Inode = Inode;
+	type Handle = Handle;
+
+	fn init(&self, capable: FsOptions) -> Result<FsOptions> {
+		// use vfs' negotiated capability if imported
+		// other wise, do our own negotiation
+		let mut opts = FsOptions::DO_READDIRPLUS | FsOptions::READDIRPLUS_AUTO;
+
+		if self.config.do_import {
+			self.import()?;
+		}
+
+		if (!self.config.do_import || self.config.writeback) && capable.contains(FsOptions::WRITEBACK_CACHE) {
+			opts |= FsOptions::WRITEBACK_CACHE;
+			self.writeback.store(true, Ordering::Relaxed);
+		}
+
+		if (!self.config.do_import || self.config.no_open) && capable.contains(FsOptions::ZERO_MESSAGE_OPEN) {
+			opts |= FsOptions::ZERO_MESSAGE_OPEN;
+			opts.remove(FsOptions::ATOMIC_O_TRUNC);
+			self.no_open.store(true, Ordering::Relaxed);
+		}
+
+		if (!self.config.do_import || self.config.no_opendir) && capable.contains(FsOptions::ZERO_MESSAGE_OPENDIR) {
+			opts |= FsOptions::ZERO_MESSAGE_OPENDIR;
+			self.no_opendir.store(true, Ordering::Relaxed);
+		}
+
+		if (!self.config.do_import || self.config.killpriv_v2) && capable.contains(FsOptions::HANDLE_KILLPRIV_V2) {
+			opts |= FsOptions::HANDLE_KILLPRIV_V2;
+			self.killpriv_v2.store(true, Ordering::Relaxed);
+		}
+
+		if self.config.perfile_dax && capable.contains(FsOptions::PERFILE_DAX) {
+			opts |= FsOptions::PERFILE_DAX;
+			self.perfile_dax.store(true, Ordering::Relaxed);
+		}
+
+		Ok(opts)
+	}
+
+	fn destroy(&self) {
+	}
+
+	fn statfs(&self, ctx: &Context, inode: Inode) -> Result<libc::statvfs64> {
+		self.do_statvfs(ctx, inode)
+	}
+
+	fn lookup(&self, ctx: &Context, parent: Inode, name: &CStr) -> Result<Entry> {
+		let tmp =name.to_string_lossy().into_owned().to_owned();
+		trace!("LOOKUP: parent: {}, name: {}\n", parent, tmp);
+		let node = self.lookup_node(ctx, parent, name)?;
+
+		if node.whiteout.load(Ordering::Relaxed) {
+			return Err(Error::from_raw_os_error(libc::ENOENT));
+		}
+
+		let pnode = if let Some(v) = self.get_node_from_inode(parent) {
+			v
+		} else {
+			return Err(Error::from_raw_os_error(libc::EINVAL));
+		};
+
+		let ppath = String::from(pnode.path.as_str());
+		let sname = name.to_string_lossy().into_owned().to_owned();
+		let st = node.stat64(ctx)?;
+
+		// load this directory here
+		if st.st_mode & libc::S_IFMT == libc::S_IFDIR {
+			self.load_directory(ctx, Arc::clone(&node))?;
+			node.loaded.store(true, Ordering::Relaxed);
+		}
+
+		// FIXME: can forget happen between found and increase reference counter? 
+
+		*node.lookups.lock().unwrap() += 1;
+
+		Ok(Entry{
+			inode: node.inode as u64,
+			generation: 0,
+			attr: st,//libc::stat64
+			attr_flags: 0,
+			attr_timeout: self.config.attr_timeout,
+			entry_timeout: self.config.entry_timeout,
+		})
+	}
+
+	fn forget(&self, ctx: &Context, inode: Inode, count: u64) {
+		self.forget_one(inode, count)
+	}
+
+	fn batch_forget(&self, ctx: &Context, requests: Vec<(Inode, u64)>) {
+		for (inode, count) in requests {
+			self.forget_one(inode, count);
+		}
+	}
+
+	fn opendir(&self, ctx: &Context, inode: Inode, flags: u32) -> Result<(Option<Handle>, OpenOptions)> {
+		let mut opts = OpenOptions::empty();
+
+		match self.config.cache_policy {
+			CachePolicy::Always => {
+				opts |= OpenOptions::KEEP_CACHE;
+			},
+
+			_ => {
+			},
+		}
+
+		// lookup node
+		let node = self.lookup_node(ctx, inode, CString::new(".").expect("invalid path!").as_c_str())?;
+
+		if node.whiteout.load(Ordering::Relaxed) {
+			return Err(Error::new(ErrorKind::InvalidInput, "invalid inode number"));
+		}
+
+		let st = node.stat64(ctx)?;
+		if st.st_mode & libc::S_IFDIR == 0 {
+			return Err(Error::from_raw_os_error(libc::ENOTDIR));
+		}
+
+		let handle = self.next_handle.fetch_add(1, Ordering::Relaxed);
+
+		// reload directory?
+		self.reload_directory(ctx, Arc::clone(&node))?;
+
+		let mut cs = Vec::new();
+		//add myself
+		cs.push(Arc::clone(&node));
+
+		//add parent
+		if let Some(p) = node.parent.lock().unwrap().upgrade() {
+			cs.push(p);	
+		} else {
+			cs.push(Arc::clone(self.root.as_ref().unwrap()));
+		};
+
+		for (_, child) in node.childrens.lock().unwrap().iter() {
+			// skip whiteout node
+			if child.whiteout.load(Ordering::Relaxed) || child.hidden.load(Ordering::Relaxed) {
+				continue;
+			}
+			// *child.lookups.lock().unwrap() += 1;
+			cs.push(Arc::clone(child));
+		}
+
+		for c in cs.iter() {
+			*c.lookups.lock().unwrap() += 1;
+		}
+
+		*node.lookups.lock().unwrap() += 1;
+
+		self.handles.lock().unwrap().insert(handle, HandleData{
+			node: Arc::clone(&node),
+			childrens: Some(cs),
+			offset: 0,
+			real_handle: None,
+		});
+		
+		Ok((Some(handle), opts))
+	}
+
+	fn releasedir(&self, ctx: &Context, inode: Inode, flags: u32, handle: Handle) -> Result<()> {
+		trace!("RELEASEDIR: inode: {}, handle: {}\n", inode, handle);
+		{
+			if let Some(v) = self.handles.lock().unwrap().get(&handle) {
+				for child in v.childrens.as_ref().unwrap() {
+					self.forget_one(child.inode, 1);
+				}
+
+				self.forget_one(v.node.inode, 1);
+			}
+		}
+
+		trace!("RELEASEDIR: returning");
+
+		self.handles.lock().unwrap().remove(&handle);
+
+		Ok(())
+	}
+
+	// for mkdir or create file
+	// 1. lookup name, if exists and not whiteout, return EEXIST
+	// 2. not exists and no whiteout, copy up parent node, ususally  a mkdir on upper layer would do the work
+	// 3. find whiteout, if whiteout in upper layer, shoudl set opaque. if in lower layer, just mkdir?
+	fn mkdir(&self, ctx: &Context, parent: Inode, name: &CStr, mode: u32, umask: u32) -> Result<Entry> {
+		let mut delete_whiteout: bool = false;
+		let mut has_whiteout: bool = false;
+		let mut upper_layer_only: bool = false;
+		let mut opaque = false;
+		let mut node: Arc<OverlayInode> = Arc::new(OverlayInode::default());
+
+		let sname = name.to_string_lossy().into_owned().to_owned();
+		if let Some(n) = self.lookup_node_ignore_enoent(ctx, parent, name)? {
+			if !n.whiteout.load(Ordering::Relaxed) {
+				return Err(Error::from_raw_os_error(libc::EEXIST));
+			}
+
+			node = Arc::clone(&n);
+			has_whiteout = true;
+		}
+
+		let upper = if let Some(l) = self.get_upper_layer() {
+			l
+		} else {
+			return Err(Error::from_raw_os_error(libc::EROFS));
+			// return Err(Error::new(ErrorKind::ReadOnlyFilesystem, "readonly filesystem!"));
+		};
+
+		if has_whiteout {
+			if node.in_upper_layer() {
+				// whiteout in upper layer, other lower layers are readonly, don't try to delete it
+				delete_whiteout = true;
+			}
+
+			if node.upper_layer_only() {
+				upper_layer_only = true;
+			}
+		}
+
+		let pnode = self.lookup_node(ctx, parent, CString::new("").expect("invalid file name").as_c_str())?;
+		// actual work to copy pnode up..
+		let pnode = self.copy_node_up(ctx, Arc::clone(&pnode))?;
+
+		assert!(pnode.in_upper_layer());
+		let real_pnode = Arc::clone(pnode.upper_inode.lock().unwrap().as_ref().unwrap());
+
+		let real_parent_inode = real_pnode.inode.load(Ordering::Relaxed);
+
+		if delete_whiteout {
+			upper.delete_whiteout(ctx, real_parent_inode, sname.as_str());
+		}
+
+		// create dir in upper layer
+		let entry = upper.mkdir(ctx, real_parent_inode, name, mode, umask)?;
+
+		if !upper_layer_only {
+			upper.create_opaque_whiteout(ctx, entry.inode)?;
+			opaque = true;
+		}
+
+		pnode.loaded.store(false, Ordering::Relaxed);
+		// remove whiteout node from child and inode hash
+		// FIXME: maybe a reload from start better
+		if has_whiteout {
+			pnode.childrens.lock().unwrap().remove(sname.as_str());
+			self.inodes.lock().unwrap().remove(&node.inode);
+		}
+
+		let node = self.lookup_node(ctx, parent, name)?;
+
+		pnode.loaded.store(true, Ordering::Relaxed);
+
+		Ok(Entry {
+			inode: node.inode,
+			generation: 0,
+			attr: node.stat64(ctx)?,
+			attr_flags: 0,
+			attr_timeout: self.config.attr_timeout,
+			entry_timeout: self.config.entry_timeout,
+		})
+	}
+
+	fn rmdir(&self, ctx: &Context, parent: Inode, name: &CStr) -> Result<()> {
+		self.do_rm(ctx, parent, name, true)
+	}
+
+	fn readdir(&self, ctx: &Context, inode: Inode, handle: Handle, size: u32, offset: u64, add_entry: &mut dyn FnMut(DirEntry) -> Result<usize>) -> Result<()> {
+		self.do_readdir(ctx, handle, size, offset, &mut |dir_entry, _entry| -> Result<usize> {
+			add_entry(dir_entry)
+		})
+	}
+
+	fn readdirplus(&self, ctx: &Context, inode: Inode, handle: Handle, size: u32, offset: u64, add_entry: &mut dyn FnMut(DirEntry, Entry) -> Result<usize>) -> Result<()> {
+		self.do_readdir(ctx, handle, size, offset, &mut |dir_entry, entry| -> Result<usize> {
+			add_entry(dir_entry, entry)
+		})
+	}
+
+	fn open(&self, ctx: &Context, inode: Inode, flags: u32, fuse_flags: u32) -> Result<(Option<Handle>, OpenOptions)> {
+		// open assume file always exist
+
+		let readonly: bool = flags & (libc::O_APPEND | libc::O_CREAT | libc::O_TRUNC | libc::O_RDWR | libc::O_WRONLY) as u32== 0;
+
+		trace!("OPEN: inode: {}, readonly: {}", inode, readonly);
+
+		// toggle flags
+		let mut flags: i32 = flags as i32;
+
+		flags |= libc::O_NOFOLLOW;
+		flags &= !libc::O_DIRECT;
+		if self.config.writeback {
+			if flags & libc::O_ACCMODE == libc::O_WRONLY {
+				flags &= !libc::O_ACCMODE;
+				flags |= libc::O_RDWR;
+			}
+
+			if flags & libc::O_APPEND != 0 {
+				flags &= !libc::O_APPEND;
+			}
+		}
+
+		// lookup node
+		let node = self.lookup_node(ctx, inode, CString::new("").expect("invalid c string").as_c_str())?;
+
+		// whiteout node
+		if node.whiteout.load(Ordering::Relaxed) {
+			return Err(Error::from_raw_os_error(libc::ENOENT));
+		}
+
+		if !readonly {
+			// copy up to upper layer
+			self.copy_node_up(ctx, Arc::clone(&node))?;
+		}
+
+		// assign a handle in overlayfs and open it
+		let (l, h, o) =  node.open(ctx, flags as u32, fuse_flags)?;
+		if let Some(handle) = h {
+			let hd = self.next_handle.fetch_add(1, Ordering::Relaxed);
+			let handle_data = HandleData {
+				node: Arc::clone(&node),
+				childrens: None,
+				offset: 0,
+				real_handle: Some(RealHandle {
+					real_inode: Arc::clone(&node.first_inode.lock().unwrap()),
+					handle: AtomicU64::new(handle),
+					invalid: AtomicBool::new(false),
+				}),
+			};
+
+			self.handles.lock().unwrap().insert(hd, handle_data);
+
+			let mut opts = OpenOptions::empty();
+			match self.config.cache_policy {
+				CachePolicy::Never => opts |= OpenOptions::DIRECT_IO,
+				CachePolicy::Always => opts |= OpenOptions::KEEP_CACHE,
+				_ => {},
+			}
+
+			trace!("OPEN: returning handle: {}", hd);
+
+			return Ok((Some(hd), opts));
+		}
+
+		Err(Error::from_raw_os_error(libc::ENOENT))
+	}
+
+	fn release(&self, ctx: &Context, inode: Inode, flags: u32, handle: Handle, flush: bool, flock_release: bool, lock_owner: Option<u64>) -> Result<()> {
+		if let Some(hd) = self.handles.lock().unwrap().get(&handle) {
+			let rh = if let Some(ref h) = hd.real_handle {
+				h
+			} else {
+				return Err(Error::new(ErrorKind::Other, "no handle"));
+			};
+			let real_handle = rh.handle.load(Ordering::Relaxed);
+			let ri = Arc::clone(&rh.real_inode);
+			let real_inode = ri.inode.load(Ordering::Relaxed);
+			let l = Arc::clone(&ri.layer.as_ref().unwrap());
+			l.release(ctx, real_inode, flags, real_handle, flush, flock_release, lock_owner)?;
+		}
+
+		self.handles.lock().unwrap().remove(&handle);
+
+		Ok(())
+	}
+
+	fn create(&self, ctx: &Context, parent: Inode, name: &CStr, args: CreateIn) -> Result<(Entry, Option<Handle>, OpenOptions)> {
+		let mut is_whiteout = false;
+		let node = self.lookup_node_ignore_enoent(ctx, parent, name)?;
+		let sname = name.to_string_lossy().into_owned().to_owned();
+
+		let mut hargs = args;
+
+		let mut flags: i32 = args.flags as i32;
+
+		flags |= libc::O_NOFOLLOW;
+		flags &= !libc::O_DIRECT;
+		if self.config.writeback {
+			if flags & libc::O_ACCMODE == libc::O_WRONLY {
+				flags &= !libc::O_ACCMODE;
+				flags |= libc::O_RDWR;
+			}
+
+			if flags & libc::O_APPEND != 0 {
+				flags &= !libc::O_APPEND;
+			}
+		}
+
+		hargs.flags = flags as u32;
+
+
+		if let Some(ref n) = node {
+			if !n.whiteout.load(Ordering::Relaxed) {
+				return Err(Error::from_raw_os_error(libc::EEXIST));
+			} else {
+				is_whiteout = true;
+			}
+		}
+
+		// no entry or whiteout
+		let pnode = self.lookup_node(ctx, parent, CString::new("").expect("invalid c string").as_c_str())?;
+		if pnode.whiteout.load(Ordering::Relaxed) {
+			return Err(Error::from_raw_os_error(libc::ENOENT));
+		}
+
+		let pnode = self.copy_node_up(ctx, Arc::clone(&pnode))?;
+
+		assert!(pnode.upper_inode.lock().unwrap().is_some());
+
+		let real_parent_inode = pnode.first_inode.lock().unwrap().inode.load(Ordering::Relaxed);
+
+		// need to delete whiteout?
+		if is_whiteout {
+			let node = Arc::clone(node.as_ref().unwrap());
+			let first_inode = Arc::clone(&node.first_inode.lock().unwrap());
+			let first_layer =  first_inode.layer.as_ref().unwrap();
+			if node.in_upper_layer() {
+				// whiteout in upper layer, need to delete
+				first_layer.delete_whiteout(ctx, real_parent_inode, sname.as_str())?;
+			}
+
+			// delete inode from inodes and childrens
+			self.inodes.lock().unwrap().remove(&node.inode);
+			pnode.childrens.lock().unwrap().remove(sname.as_str());
+		}
+
+		// create file in upper layer
+		if let Some(ref upper_layer) = self.upper_layer.as_ref() {
+			let (entry, h, o) = upper_layer.create(ctx, real_parent_inode, name, hargs)?;
+
+			// record inode, handle
+			// lookup will insert inode into children and inodes hash
+			//let real_inode = Arc::new(RealInode {
+			// 	layer: Arc::clone(&upper_layer),
+			//	inode: entry.inode,
+			//	whiteout: AtomicBool::new(false),
+			//	opaque: AtomicBool::new(false),
+			//	hidden: AtomicBool::new(false),
+			//	invalid: AtomicBool::new(false),
+			//});
+
+			pnode.loaded.store(false, Ordering::Relaxed);
+			let node = self.lookup_node(ctx, parent, name)?;
+			pnode.loaded.store(true, Ordering::Relaxed);
+
+			let real_inode = Arc::clone(node.upper_inode.lock().unwrap().as_ref().unwrap());
+
+			let final_handle = 
+			if let Some(hd) = h {
+				let handle = self.next_handle.fetch_add(1, Ordering::Relaxed);
+				let handle_data = HandleData {
+					node: Arc::clone(&node),
+					childrens: None,
+					offset: 0,
+					real_handle: Some(RealHandle {
+						real_inode: Arc::clone(&real_inode),
+						handle: AtomicU64::new(hd),
+						invalid: AtomicBool::new(false),
+					}),
+				};
+				self.handles.lock().unwrap().insert(handle, handle_data);
+				Some(handle)
+			} else {
+				None
+			};
+
+			// return data
+			let entry = Entry {
+				inode: node.inode,
+				generation: 0,
+				attr: node.stat64(ctx)?,
+				attr_flags: 0,
+				attr_timeout: self.config.attr_timeout,
+				entry_timeout: self.config.entry_timeout,
+			};
+
+			let mut opts = OpenOptions::empty();
+			match self.config.cache_policy {
+				CachePolicy::Never => opts |= OpenOptions::DIRECT_IO,
+				CachePolicy::Always => opts |= OpenOptions::KEEP_CACHE,
+				_ => {},
+			}
+
+			return Ok((entry, final_handle, opts));
+
+		} else {
+			return Err(Error::from_raw_os_error(libc::EROFS));
+		}
+
+		Err(Error::new(ErrorKind::Other, "Unknown error"))
+	}
+
+	fn unlink(&self, ctx: &Context, parent: Inode, name: &CStr) -> Result<()> {
+		self.do_rm(ctx, parent, name, false)
+	}
+
+	fn read(&self, ctx: &Context, inode: Inode, handle: Handle, w: &mut dyn ZeroCopyWriter, size: u32, offset: u64, lock_owner: Option<u64>, flags: u32) -> Result<usize> {
+		if let Some(v) = self.handles.lock().unwrap().get(&handle) {
+			if let Some(ref hd) = v.real_handle {
+				let real_handle = hd.handle.load(Ordering::Relaxed);
+				let ri = Arc::clone(&hd.real_inode);
+				let (real_inode, layer) = (ri.inode.load(Ordering::Relaxed), Arc::clone(ri.layer.as_ref().unwrap()));
+
+				return layer.read(ctx, real_inode, real_handle, w, size, offset, lock_owner, flags);
+			}
+		}
+
+		Err(Error::from_raw_os_error(libc::ENOENT))
+	}
+
+	fn write(&self, ctx: &Context, inode: Inode, handle: Handle, r: &mut dyn ZeroCopyReader, size: u32, offset: u64, lock_owner: Option<u64>, delayed_write: bool, flags: u32, fuse_flags: u32) -> Result<usize> {
+		if let Some(v) = self.handles.lock().unwrap().get(&handle) {
+			if let Some(ref hd) = v.real_handle {
+				let real_handle = hd.handle.load(Ordering::Relaxed);
+				let ri = Arc::clone(&hd.real_inode);
+				let (real_inode, layer) = (ri.inode.load(Ordering::Relaxed), Arc::clone(ri.layer.as_ref().unwrap()));
+
+				return layer.write(ctx, real_inode, real_handle, r, size, offset, lock_owner, delayed_write, flags, fuse_flags);
+				// remove whiteout node from child and inode hash
+			}
+		}
+
+		Err(Error::from_raw_os_error(libc::ENOENT))
+	}
+
+	fn getattr(&self, ctx: &Context, inode: Inode, handle: Option<Handle>) -> Result<(libc::stat64, Duration)> {
+		trace!("GETATTR: inode: {}\n", inode);
+		if let Some(h) = handle {
+			if let Some(hd) = self.handles.lock().unwrap().get(&h) {
+				if let Some(ref v) = hd.real_handle {
+					let ri = Arc::clone(&v.real_inode);
+					let layer = Arc::clone(ri.layer.as_ref().unwrap());
+					let real_inode = ri.inode.load(Ordering::Relaxed);
+					let real_handle = v.handle.load(Ordering::Relaxed);
+					let (st, _d) = layer.getattr(ctx, real_inode, Some(real_handle))?;
+					return Ok((st, self.config.attr_timeout));
+				}
+			}
+		} else {
+			let node = self.lookup_node(ctx, inode, CString::new("").expect("invalid c string").as_c_str())?;
+			let rl = Arc::clone(&node.first_inode.lock().unwrap());
+			if let Some(ref v) = rl.layer {
+				let layer = Arc::clone(v);
+				let real_inode = rl.inode.load(Ordering::Relaxed);
+
+				let (st, _d) = layer.getattr(ctx, real_inode, None)?;
+				return Ok((st, self.config.attr_timeout));
+			}
+		}
+
+		Err(Error::from_raw_os_error(libc::ENOENT))
+	}
+
+	fn setattr(&self, ctx: &Context, inode: Inode, attr: libc::stat64, handle: Option<Handle>, valid: SetattrValid) -> Result<(libc::stat64, Duration)> {
+		// find out real inode and real handle, if the first
+		// layer id not upper layer copy it up
+
+		// deal with handle first
+		if let Some(h) = handle {
+			if let Some(hd) = self.handles.lock().unwrap().get(&h) {
+				if let Some(ref rhd) = hd.real_handle {
+					let ri = Arc::clone(&rhd.real_inode);
+					let layer = Arc::clone(ri.layer.as_ref().unwrap());
+					let real_inode = ri.inode.load(Ordering::Relaxed);
+					let real_handle = rhd.handle.load(Ordering::Relaxed);
+					// handle opened in upper layer
+					if self.is_upper_layer(Arc::clone(&layer)) {
+						let (st, _d) = layer.setattr(ctx, real_inode, attr, Some(real_handle), valid)?;
+
+						return Ok((st, self.config.attr_timeout));
+					}
+				}
+			}
+		}
+
+		let node = self.lookup_node(ctx, inode, CString::new("").expect("invalid c string").as_c_str())?;
+
+		//layer is upper layer
+		let node = 
+		if !self.node_in_upper_layer(Arc::clone(&node))? {
+			self.copy_node_up(ctx, Arc::clone(&node))?
+		} else {
+			Arc::clone(&node)
+		};
+
+		let v = Arc::clone(&node.first_inode.lock().unwrap());
+		let (layer, real_inode) = (Arc::clone(v.layer.as_ref().unwrap()), v.inode.load(Ordering::Relaxed));
+
+		let (st, _d) = layer.setattr(ctx, real_inode, attr, None, valid)?;
+		Ok((st, self.config.attr_timeout))
+	}
+
+	fn rename(&self, ctx: &Context, olddir: Inode, odlname: &CStr, newdir: Inode, newname: &CStr, flags: u32) -> Result<()> {
+		// complex, implement it later
+		Err(Error::from_raw_os_error(libc::EXDEV))
+	}
+
+	fn mknod(&self, ctx: &Context, parent: Inode, name: &CStr, mode: u32, rdev: u32, umask: u32) -> Result<Entry> {
+		let mut is_whiteout = false;
+		let node = self.lookup_node_ignore_enoent(ctx, parent, name)?;
+		let sname = name.to_string_lossy().into_owned().to_owned();
+
+		if let Some(ref n) = node {
+			if !n.whiteout.load(Ordering::Relaxed) {
+				return Err(Error::from_raw_os_error(libc::EEXIST));
+			} else {
+				is_whiteout = true;
+			}
+		}
+
+		// no entry or whiteout
+		let pnode = self.lookup_node(ctx, parent, CString::new("").expect("invalid c string").as_c_str())?;
+		if pnode.whiteout.load(Ordering::Relaxed) {
+			return Err(Error::from_raw_os_error(libc::ENOENT));
+		}
+
+		let pnode = self.copy_node_up(ctx, Arc::clone(&pnode))?;
+
+		assert!(pnode.upper_inode.lock().unwrap().is_some());
+
+		let real_parent_inode = pnode.first_inode.lock().unwrap().inode.load(Ordering::Relaxed);
+
+		// need to delete whiteout?
+		if is_whiteout {
+			let node = Arc::clone(node.as_ref().unwrap());
+			let first_inode = Arc::clone(&node.first_inode.lock().unwrap());
+			let first_layer =  first_inode.layer.as_ref().unwrap();
+			if node.in_upper_layer() {
+				// whiteout in upper layer, need to delete
+				first_layer.delete_whiteout(ctx, real_parent_inode, sname.as_str())?;
+			}
+
+			// delete inode from inodes and childrens
+			self.inodes.lock().unwrap().remove(&node.inode);
+			pnode.childrens.lock().unwrap().remove(sname.as_str());
+		}
+
+		// make it
+		assert!(pnode.in_upper_layer());
+
+		let real_inode = Arc::clone(pnode.upper_inode.lock().unwrap().as_ref().unwrap());
+		let layer = Arc::clone(real_inode.layer.as_ref().unwrap());
+		let _entry = layer.mknod(ctx, real_parent_inode, name, mode, rdev, umask)?;
+
+		pnode.loaded.store(false, Ordering::Relaxed);
+		let node = self.lookup_node(ctx, parent, name)?;
+		pnode.loaded.store(true, Ordering::Relaxed);
+		Ok(Entry {
+			inode: node.inode,
+			generation: 0,
+			attr: node.stat64(ctx)?,
+			attr_flags: 0,
+			attr_timeout: self.config.attr_timeout,
+			entry_timeout: self.config.entry_timeout,
+		})
+	}
+
+	fn link(&self, ctx: &Context, inode: Inode, newparent: Inode, name: &CStr) -> Result<Entry> {
+		// hard link..
+		let node = self.lookup_node(ctx, inode, CString::new("").expect("invalic c string").as_c_str())?;
+		if node.whiteout.load(Ordering::Relaxed) {
+			return Err(Error::from_raw_os_error(libc::ENOENT));
+		}
+
+		let newpnode = self.lookup_node(ctx, newparent, CString::new("").expect("invalid c string").as_c_str())?;
+		if newpnode.whiteout.load(Ordering::Relaxed) {
+			return Err(Error::from_raw_os_error(libc::ENOENT));
+		}
+
+		let newnode = self.lookup_node_ignore_enoent(ctx, newparent, name)?;
+
+		// copy node up
+		let node = self.copy_node_up(ctx, Arc::clone(&node))?;
+		let newpnode = self.copy_node_up(ctx, Arc::clone(&newpnode))?;
+		let sname = name.to_string_lossy().into_owned().to_owned();
+
+		if let Some(n) = newnode {
+			if !n.whiteout.load(Ordering::Relaxed) {
+				return Err(Error::from_raw_os_error(libc::EEXIST));
+			}
+
+			// need to delete whiteout? if whiteout in upper layer
+			// delete it
+			if self.node_in_upper_layer(Arc::clone(&n))? {
+				// find out the real parent inode and delete whiteout
+				let pri = &newpnode.first_inode.lock().unwrap();
+				let layer = Arc::clone(pri.layer.as_ref().unwrap());
+				let real_parent_inode = pri.inode.load(Ordering::Relaxed);
+				layer.delete_whiteout(ctx, real_parent_inode, sname.as_str())?;
+			}
+
+			// delete from hash
+			self.inodes.lock().unwrap().remove(&n.inode);
+			newpnode.childrens.lock().unwrap().remove(sname.as_str());
+		}
+
+		// create the link
+		let pri = &newpnode.first_inode.lock().unwrap();
+		let layer = Arc::clone(pri.layer.as_ref().unwrap());
+		let real_parent_inode = pri.inode.load(Ordering::Relaxed);
+		let real_inode = node.first_inode.lock().unwrap().inode.load(Ordering::Relaxed);
+		layer.link(ctx, real_inode, real_parent_inode, name)?;
+		
+		newpnode.loaded.store(false, Ordering::Relaxed);
+		let node = self.lookup_node(ctx, newparent, name)?;
+		newpnode.loaded.store(true, Ordering::Relaxed);
+		
+		Ok(Entry {
+			inode: node.inode, 
+			generation: 0,
+			attr: node.stat64(ctx)?,
+			attr_flags: 0,
+			attr_timeout: self.config.attr_timeout,
+			entry_timeout: self.config.entry_timeout,
+		})
+	}
+
+	fn symlink(&self, ctx: &Context, linkname: &CStr, parent: Inode, name: &CStr) -> Result<Entry> {
+		// soft link
+		let empty_name = CString::new("").expect("invalid c string");
+		let sname = name.to_string_lossy().into_owned().to_owned();
+
+		let pnode = self.lookup_node(ctx, parent, empty_name.as_c_str())?;
+
+		if pnode.whiteout.load(Ordering::Relaxed) {
+			return Err(Error::from_raw_os_error(libc::ENOENT));
+		}
+
+		let node = self.lookup_node_ignore_enoent(ctx, parent, name)?;
+		if let Some(n) = node {
+			if !n.whiteout.load(Ordering::Relaxed) {
+				return Err(Error::from_raw_os_error(libc::EEXIST));
+			}
+
+			// whiteout, may need to delete it
+			self.delete_whiteout_node(ctx, Arc::clone(&n))?;
+
+			// delete from hash
+			self.inodes.lock().unwrap().remove(&n.inode);
+			pnode.childrens.lock().unwrap().remove(sname.as_str());
+		}
+
+		let pnode = self.copy_node_up(ctx, Arc::clone(&pnode))?;
+		// find out layer, real parent..
+		let (layer, real_parent) = {
+			let first = pnode.first_inode.lock().unwrap();
+			(Arc::clone(first.layer.as_ref().unwrap()), first.inode.load(Ordering::Relaxed))
+		};
+
+		layer.symlink(ctx, linkname, real_parent, name)?;
+
+		pnode.loaded.store(false, Ordering::Relaxed);
+		let node = self.lookup_node(ctx, parent, name)?;
+		pnode.loaded.store(true, Ordering::Relaxed);
+
+		Ok(Entry {
+			inode: node.inode,
+			generation: 0,
+			attr: node.stat64(ctx)?,
+			attr_flags: 0, 
+			attr_timeout: self.config.attr_timeout,
+			entry_timeout: self.config.entry_timeout,
+		})
+	}
+
+	fn readlink(&self, ctx: &Context, inode: Inode) -> Result<Vec<u8>> {
+		let empty_name =CString::new("").expect("invalid c string");
+		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
+
+		if node.whiteout.load(Ordering::Relaxed) {
+			return Err(Error::from_raw_os_error(libc::ENOENT));
+		}
+
+		// find out real inode
+		let (layer, real_inode) = {
+			let first = node.first_inode.lock().unwrap();
+			(Arc::clone(first.layer.as_ref().unwrap()), first.inode.load(Ordering::Relaxed))
+		};
+
+		layer.readlink(ctx, real_inode)
+
+	}
+
+	fn flush(&self, ctx: &Context, inode: Inode, handle: Handle, lock_owner: u64) -> Result<()> {
+		let empty_name = CString::new("").expect("invalid c string");
+		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
+
+		if node.whiteout.load(Ordering::Relaxed) {
+			return Err(Error::from_raw_os_error(libc::ENOENT));
+		}
+
+		// readonly file can also be flushed, pass flush request
+		// to lower layer instead of return EROFS here
+		// if !self.node_in_upper_layer(Arc::clone(&node))? {
+			// in lower layer, error out or just success?
+			// FIXME:
+		//	return Err(Error::from_raw_os_error(libc::EROFS));
+		// }
+
+		let (layer, real_inode, real_handle) = self.find_real_info_from_handle(ctx, handle)?;
+
+		// FIXME: need to test if inode matches corresponding handle?
+
+		layer.flush(ctx, real_inode, real_handle, lock_owner)
+	}
+
+	fn fsync(&self, ctx: &Context, inode: Inode, datasync: bool, handle: Handle) -> Result<()> {
+		let empty_name = CString::new("").expect("invalid c string");
+		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
+
+		if node.whiteout.load(Ordering::Relaxed) {
+			return Err(Error::from_raw_os_error(libc::ENOENT));
+		}
+
+		if !self.node_in_upper_layer(Arc::clone(&node))? {
+			// in lower layer, error out or just success?
+			// FIXME:
+			return Err(Error::from_raw_os_error(libc::EROFS));
+		}
+
+		let (layer, real_inode, real_handle) = self.find_real_info_from_handle(ctx, handle)?;
+
+		// FIXME: need to test if inode matches corresponding handle?
+
+		layer.fsync(ctx, real_inode, datasync, real_handle)
+	}
+
+	fn fsyncdir(&self, ctx: &Context, inode: Inode, datasync: bool, handle: Handle) -> Result<()> {
+		let empty_name = CString::new("").expect("invalid c string");
+		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
+
+		if node.whiteout.load(Ordering::Relaxed) {
+			return Err(Error::from_raw_os_error(libc::ENOENT));
+		}
+
+		if !self.node_in_upper_layer(Arc::clone(&node))? {
+			// in lower layer, error out or just success?
+			// FIXME:
+			return Err(Error::from_raw_os_error(libc::EROFS));
+		}
+
+		let (layer, real_inode, real_handle) = self.find_real_info_from_handle(ctx, handle)?;
+
+		// FIXME: need to test if inode matches corresponding handle?
+
+		layer.fsyncdir(ctx, real_inode, datasync, real_handle)
+	}
+
+	fn access(&self, ctx: &Context, inode: Inode, mask: u32) -> Result<()> {
+		let empty_name = CString::new("").expect("invalid c string");
+		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
+
+		if node.whiteout.load(Ordering::Relaxed) {
+			return Err(Error::from_raw_os_error(libc::ENOENT));
+		}
+
+		let (layer, real_inode) = self.find_real_inode(ctx, inode)?;
+		layer.access(ctx, real_inode, mask)
+	}
+
+	fn setxattr(&self, ctx: &Context, inode: Inode, name: &CStr, value: &[u8], flags: u32) -> Result<()> {
+		let empty_name = CString::new("").expect("invalid c string");
+		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
+
+		if node.whiteout.load(Ordering::Relaxed) {
+			return Err(Error::from_raw_os_error(libc::ENOENT));
+		}
+
+		if !self.node_in_upper_layer(Arc::clone(&node))? {
+			// copy node into upper layer
+			// FIXME:
+			self.copy_node_up(ctx, Arc::clone(&node))?;
+		}
+
+		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
+
+		let (layer, real_inode) = self.find_real_inode(ctx, inode)?;
+
+		layer.setxattr(ctx, real_inode, name, value, flags)
+	}
+
+	fn getxattr(&self, ctx: &Context, inode: Inode, name: &CStr, size: u32) -> Result<GetxattrReply> {
+		let empty_name = CString::new("").expect("invalid c string");
+		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
+
+		if node.whiteout.load(Ordering::Relaxed) {
+			return Err(Error::from_raw_os_error(libc::ENOENT));
+		}
+
+		let (layer, real_inode) = self.find_real_inode(ctx, inode)?;
+
+		layer.getxattr(ctx, real_inode, name, size)
+	}
+
+	fn listxattr(&self, ctx: &Context, inode: Inode, size: u32) -> Result<ListxattrReply> {
+		let empty_name = CString::new("").expect("invalid c string");
+		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
+
+		if node.whiteout.load(Ordering::Relaxed) {
+			return Err(Error::from_raw_os_error(libc::ENOENT));
+		}
+
+		let (layer, real_inode) = self.find_real_inode(ctx, inode)?;
+
+		layer.listxattr(ctx, real_inode, size)
+	}
+
+	fn removexattr(&self, ctx: &Context, inode: Inode, name: &CStr) -> Result<()> {
+		let empty_name = CString::new("").expect("invalid c string");
+		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
+
+		if node.whiteout.load(Ordering::Relaxed) {
+			return Err(Error::from_raw_os_error(libc::ENOENT));
+		}
+
+		if !self.node_in_upper_layer(Arc::clone(&node))? {
+			// copy node into upper layer
+			// FIXME:
+			self.copy_node_up(ctx, Arc::clone(&node))?;
+		}
+
+		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
+
+		let (layer, real_inode) = self.find_real_inode(ctx, inode)?;
+
+		layer.removexattr(ctx, real_inode, name)
+	}
+
+	fn fallocate(&self, ctx: &Context, inode: Inode, handle: Handle, mode: u32, offset: u64, length: u64) -> Result<()> {
+		let empty_name = CString::new("").expect("invalid c string");
+		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
+
+		if node.whiteout.load(Ordering::Relaxed) {
+			return Err(Error::from_raw_os_error(libc::ENOENT));
+		}
+
+		if !self.node_in_upper_layer(Arc::clone(&node))? {
+			// copy node into upper layer
+			// FIXME:
+			// only for node in upper layer, not in upper layer
+			// indicates open in readonly mode, and cannot fallocate
+			return Err(Error::from_raw_os_error(libc::EPERM));
+		}
+
+		let (layer, real_inode, real_handle) = self.find_real_info_from_handle(ctx, handle)?;
+
+		layer.fallocate(ctx, real_inode, real_handle, mode, offset, length)
+	}
+
+	fn lseek(&self, ctx: &Context, inode: Inode, handle: Handle, offset: u64, whence: u32) -> Result<u64> {
+		// can this be on dir? FIXME: assume file for now
+		// we need special process if it can be called on dir
+		let empty_name = CString::new("").expect("invalid c string");
+		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
+
+		if node.whiteout.load(Ordering::Relaxed) {
+			return Err(Error::from_raw_os_error(libc::ENOENT));
+		}
+
+		let st = node.stat64(ctx)?;
+		if st.st_mode & libc::S_IFMT == libc::S_IFDIR {
+			error!("lseek on directory");
+			return Err(Error::from_raw_os_error(libc::EINVAL));
+		}
+
+		let (layer, real_inode, real_handle) = self.find_real_info_from_handle(ctx, handle)?;
+		layer.lseek(ctx, real_inode, real_handle, offset, whence)
+	}
+
+}
+
+
+impl ZeroCopyReader for File {
+	fn read_to(&mut self, f: &mut dyn FileReadWriteVolatile, count: usize, off: u64) -> Result<usize> {
+		let mut buf = Vec::<u8>::with_capacity(count);
+		unsafe { buf.set_len(count); }
+		let slice = unsafe { FileVolatileSlice::from_raw_ptr(buf.as_mut_ptr(), count) };
+
+		let ret = f.read_at_volatile(slice, off)?;
+		if ret > 0 {
+			let slice = unsafe { FileVolatileSlice::from_raw_ptr(buf.as_mut_ptr(), ret) };
+			f.write_volatile(slice)
+		} else {
+			Ok(0)
+		}
+	}
+}
+
+impl ZeroCopyWriter for File {
+	fn write_from(&mut self, f: &mut dyn FileReadWriteVolatile, count: usize, off: u64) -> Result<usize> {
+		let mut buf = Vec::<u8>::with_capacity(count);
+		unsafe { buf.set_len(count); }
+		let slice = unsafe { FileVolatileSlice::from_raw_ptr(buf.as_mut_ptr(), count) };
+		let ret = f.read_at_volatile(slice, off)?;
+
+		if ret > 0 {
+			let slice = unsafe { FileVolatileSlice::from_raw_ptr(buf.as_mut_ptr(), ret) };
+			self.write_volatile(slice)
+		} else {
+			Ok(0)
+		}
+	}
+}
diff --git a/src/overlayfs/plugin.rs b/src/overlayfs/plugin.rs
new file mode 100644
index 000000000..11480d947
--- /dev/null
+++ b/src/overlayfs/plugin.rs
@@ -0,0 +1,92 @@
+
+#![allow(missing_docs)]
+
+use std::collections::{HashMap, LinkedList};
+use std::io::Result;
+use std::sync::{Arc};
+use std::io::{Error, ErrorKind};
+use libc;
+
+use self::super::layer::Layer;
+use self::super::PLUGIN_PREFIX;
+use self::super::direct::Direct;
+use self::super::BoxedLayer;
+
+pub type BoxedPlugin = Box<dyn Plugin + Send + Sync>;
+
+/// ! plugin trait
+pub trait Plugin {
+	///! name
+	fn name(&self) -> String;
+	///! load data source
+	fn load(&self, opaque: String, upper: bool) -> Result<LinkedList<Arc<BoxedLayer>>>;
+	///! release plugin
+	fn release(&self) -> Result<()>;
+}
+
+///! plugin manager
+pub struct PluginManager {
+	///! inner data
+	pub plugins: HashMap<String, Arc<Box<dyn Plugin + Send + Sync>>>,
+}
+
+impl PluginManager {
+	///! new
+	pub fn new() -> Self {
+		PluginManager {
+			plugins: HashMap::new(),
+		}
+	}
+
+	///! register a plugin
+	pub fn register(&mut self, name: String, plugin: Arc<Box<dyn Plugin + Send + Sync>>) -> Result<()> {
+		if self.plugins.get(name.as_str()).is_some() {
+			return Err(Error::from_raw_os_error(libc::EEXIST));
+		}
+		self.plugins.insert(name, plugin);
+
+		Ok(())
+	}
+
+	///! find a registerd plugin
+	pub fn get_plugin(&self, name: String) -> Option<Arc<Box<dyn Plugin + Send + Sync>>> {
+		if let Some(ref v) = self.plugins.get(name.as_str()) {
+			Some(Arc::clone(v))
+		} else {
+			None
+		}
+	}
+}
+
+pub fn find_plugin(manager: &PluginManager, name: String) -> Option<Arc<Box<dyn Plugin + Send + Sync>>> {
+	manager.get_plugin(name)
+}
+
+pub fn process_onelayer(manager: &PluginManager, opaque: String, upper: bool) -> Result<LinkedList<Arc<BoxedLayer>>> {
+	if opaque.starts_with(PLUGIN_PREFIX) {
+		// plugin
+		let striped = opaque.strip_prefix(PLUGIN_PREFIX).unwrap();
+		let ps: Vec<&str> = striped.splitn(2, "/").collect();
+		if ps.len() != 2 {
+			error!("invalid upperdir parameters!");
+			return Err(Error::from(ErrorKind::InvalidData));
+		}
+
+		let plugin_name = ps[0];
+		let plugin_params = ps[1];
+		let plugin = match manager.get_plugin(plugin_name.into()) {
+			Some(v) => v,
+			None => {
+				error!("unknown plugin");
+				return Err(Error::from(ErrorKind::InvalidData));
+			}
+		};
+
+		// load layers from plugin
+		return plugin.load(plugin_params.into(), upper);
+
+	} else {
+		// directory
+		return Direct::new(opaque, upper);
+	}
+}
diff --git a/testoverlay/Cargo.toml b/testoverlay/Cargo.toml
new file mode 100644
index 000000000..9aac03820
--- /dev/null
+++ b/testoverlay/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "testoverlay"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+fuse-backend-rs = { path = "../../fuse-backend-overlay.git", features = ["fusedev"] }
+log = ">=0.4.6"
+vmm-sys-util = ">=0.4"
+libc = ">=0.2.68"
+simple_logger = ">=1.13.0"
+signal-hook = ">=0.3.10"
+lazy_static = ">=1.4.0"
diff --git a/testoverlay/src/main.rs b/testoverlay/src/main.rs
new file mode 100644
index 000000000..fb41aa124
--- /dev/null
+++ b/testoverlay/src/main.rs
@@ -0,0 +1,128 @@
+extern crate fuse_backend_rs;
+extern crate log;
+extern crate vmm_sys_util;
+extern crate libc;
+extern crate simple_logger;
+extern crate signal_hook;
+#[macro_use]
+extern crate lazy_static;
+
+use std::io::{Result, Error};
+use std::sync::{Arc, Mutex};
+use std::path::Path;
+
+use fuse_backend_rs::overlayfs::{OverlayFs};
+use fuse_backend_rs::overlayfs::config::Config;
+use fuse_backend_rs::overlayfs::plugin::PluginManager;
+use fuse_backend_rs::api::server::Server;
+use fuse_backend_rs::transport::{FuseChannel, FuseSession};
+use fuse_backend_rs::api::{Vfs, VfsOptions};
+use signal_hook::{consts::TERM_SIGNALS, iterator::Signals};
+use std::thread;
+use simple_logger::SimpleLogger;
+use log::LevelFilter;
+
+pub struct FuseServer {
+	server: Arc<Server<Arc<OverlayFs>>>,
+	ch: FuseChannel,
+}
+
+fn main() -> Result<()> {
+	SimpleLogger::new().with_level(LevelFilter::Trace).init().unwrap();
+	let upperdir = String::from("/home/boyang/sources/testoverlay/testdir/upper");
+	let mut lowerdir = Vec::new();
+	lowerdir.push(String::from("/home/boyang/sources/testoverlay/testdir/lower1"));
+	lowerdir.push(String::from("/home/boyang/sources/testoverlay/testdir/lower2"));
+	let workdir = String::from("/home/boyang/sources/testoverlay/testdir/work");
+	let mountpoint = String::from("/home/boyang/sources/testoverlay/testdir/merged");
+
+	let mut config = Config::default();
+	config.upper = upperdir;
+	config.lower = lowerdir;
+	config.work = workdir;
+	config.mountpoint = String::from(mountpoint.as_str());
+	config.do_import = true;
+
+	let manager = PluginManager::new();
+
+	print!("new overlay fs\n");
+	let mut fs = OverlayFs::new(&manager, config)?;
+	print!("init root inode\n");
+	fs.init_root()?;
+
+	// let vfs = Vfs::new(VfsOptions {
+	//	no_open: false,
+	//	no_opendir: false,
+	//	..Default::default()
+	// });
+
+	// vfs.mount(Box::new(fs), "/")?;
+	print!("open fuse session\n");
+	let mut se = FuseSession::new(Path::new(mountpoint.as_str()), "testoverlay", "", false).unwrap();
+	print!("session opened\n");
+	se.mount().unwrap();
+
+	let mut server = FuseServer {
+		server: Arc::new(Server::new(Arc::new(fs))),
+		ch: se.new_channel().unwrap(),
+	};
+
+	let quit = Arc::new(Mutex::new(false));
+	let quit1 = Arc::clone(&quit);
+
+	let handle = thread::spawn(move || {
+		let _ = server.svc_loop(quit1);
+	});
+
+	// main thread
+	let mut signals = Signals::new(TERM_SIGNALS).unwrap();
+	for _sig in signals.forever() {
+		*quit.lock().unwrap() = true;
+		break;
+	}
+
+	let _ = handle.join();
+
+	se.umount().unwrap();
+	se.wake().unwrap();
+
+	Ok(())
+}
+
+impl FuseServer {
+	pub fn svc_loop(&mut self, quit: Arc<Mutex<bool>>) -> Result<()>{
+        let _ebadf = std::io::Error::from_raw_os_error(libc::EBADF);
+		print!("entering server loop\n");
+        loop {
+
+			if *quit.lock().unwrap() {
+				break;
+			}
+
+            if let Some((reader, writer)) = self
+                .ch
+                .get_request()
+                .map_err(|_| std::io::Error::from_raw_os_error(libc::EINVAL))?
+            {
+                if let Err(e) = self
+                    .server
+                    .handle_message(reader, writer.into(), None, None)
+                {
+                    match e {
+                        fuse_backend_rs::Error::EncodeMessage(_ebadf) => {
+                            break;
+                        }
+                        _ => {
+                            print!("Handling fuse message failed");
+                            continue;
+                        }
+                    }
+                }
+            } else {
+                print!("fuse server exits");
+                break;
+            }
+        }
+        Ok(())
+	}
+}

From cfaa6966fa99a008310d35fec0ad25201c7659b7 Mon Sep 17 00:00:00 2001
From: Wei Zhang <weizhang555.zw@gmail.com>
Date: Tue, 26 Sep 2023 16:11:19 +0800
Subject: [PATCH 2/5] overlay: refactor first implementation

This commit refactor a lot to previous one, including:

* Modified layer trait
* Lots of bugfixes to make xfstests happy.
* Performance improvement.
* Whiteout logics
* Remove plugin & Direct layer logics.
* A better inode allocator with inode consistency guarantee.

Signed-off-by: Wei Zhang <weizhang555.zw@gmail.com>
---
 Cargo.toml                                    |    1 +
 src/api/filesystem/mod.rs                     |    5 +
 src/api/filesystem/overlay.rs                 |  205 +
 src/lib.rs                                    |    3 +-
 src/overlayfs/config.rs                       |   70 +-
 src/overlayfs/datasource.rs                   |    4 -
 src/overlayfs/direct.rs                       |  290 --
 src/overlayfs/inode_store.rs                  |  238 +
 src/overlayfs/layer.rs                        |  223 -
 src/overlayfs/mod.rs                          | 4555 ++++++++---------
 src/overlayfs/plugin.rs                       |   92 -
 src/overlayfs/sync_io.rs                      |  913 ++++
 src/overlayfs/utils.rs                        |   14 +
 src/passthrough/mod.rs                        |   58 +-
 src/passthrough/overlay.rs                    |   14 +
 src/passthrough/sync_io.rs                    |    7 +-
 testoverlay/src/main.rs                       |  128 -
 {testoverlay => tests/testoverlay}/Cargo.toml |    2 +-
 tests/testoverlay/src/main.rs                 |  237 +
 19 files changed, 3841 insertions(+), 3218 deletions(-)
 create mode 100644 src/api/filesystem/overlay.rs
 delete mode 100644 src/overlayfs/datasource.rs
 delete mode 100644 src/overlayfs/direct.rs
 create mode 100644 src/overlayfs/inode_store.rs
 delete mode 100644 src/overlayfs/layer.rs
 delete mode 100644 src/overlayfs/plugin.rs
 create mode 100644 src/overlayfs/sync_io.rs
 create mode 100644 src/overlayfs/utils.rs
 create mode 100644 src/passthrough/overlay.rs
 delete mode 100644 testoverlay/src/main.rs
 rename {testoverlay => tests/testoverlay}/Cargo.toml (78%)
 create mode 100644 tests/testoverlay/src/main.rs

diff --git a/Cargo.toml b/Cargo.toml
index 34eb3d4b3..b046011bf 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,6 +27,7 @@ libc = "0.2.68"
 log = "0.4.6"
 mio = { version = "0.8", features = ["os-poll", "os-ext"] }
 nix = "0.24"
+radix_trie = "0.2.1"
 tokio = { version = "1", optional = true }
 tokio-uring = { version = "0.4.0", optional = true }
 vmm-sys-util = { version = "0.11", optional = true }
diff --git a/src/api/filesystem/mod.rs b/src/api/filesystem/mod.rs
index 9ecadfb71..3168f1eaa 100644
--- a/src/api/filesystem/mod.rs
+++ b/src/api/filesystem/mod.rs
@@ -30,6 +30,11 @@ pub use async_io::{AsyncFileSystem, AsyncZeroCopyReader, AsyncZeroCopyWriter};
 mod sync_io;
 pub use sync_io::FileSystem;
 
+#[cfg(all(any(feature = "fusedev", feature = "virtiofs"), target_os = "linux"))]
+mod overlay;
+#[cfg(all(any(feature = "fusedev", feature = "virtiofs"), target_os = "linux"))]
+pub use overlay::Layer;
+
 /// Information about a path in the filesystem.
 #[derive(Copy, Clone, Debug)]
 pub struct Entry {
diff --git a/src/api/filesystem/overlay.rs b/src/api/filesystem/overlay.rs
new file mode 100644
index 000000000..bc175371a
--- /dev/null
+++ b/src/api/filesystem/overlay.rs
@@ -0,0 +1,205 @@
+// Copyright (C) 2023 Ant Group. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE-BSD-3-Clause file.
+
+#![allow(missing_docs)]
+
+use std::ffi::{CStr, CString};
+use std::io::{Error, ErrorKind, Result};
+
+use super::{Context, Entry, FileSystem, GetxattrReply};
+use crate::abi::fuse_abi::stat64;
+
+pub const OPAQUE_XATTR_LEN: u32 = 16;
+pub const OPAQUE_XATTR: &str = "user.fuseoverlayfs.opaque";
+pub const UNPRIVILEGED_OPAQUE_XATTR: &str = "user.overlay.opaque";
+pub const PRIVILEGED_OPAQUE_XATTR: &str = "trusted.overlay.opaque";
+
+/// A filesystem must implement Layer trait, or it cannot be used as an OverlayFS layer.
+pub trait Layer: FileSystem {
+    /// Return the root inode number
+    fn root_inode(&self) -> Self::Inode;
+
+    /// Create whiteout file with name <name>.
+    ///
+    /// If this call is successful then the lookup count of the `Inode` associated with the returned
+    /// `Entry` must be increased by 1.
+    fn create_whiteout(&self, ctx: &Context, parent: Self::Inode, name: &CStr) -> Result<Entry> {
+        // Use temp value to avoid moved 'parent'.
+        let ino: u64 = parent.into();
+        match self.lookup(ctx, ino.into(), name) {
+            Ok(v) => {
+                // Find whiteout char dev.
+                if is_whiteout(v.attr) {
+                    return Ok(v);
+                }
+                // Non-negative entry with inode larger than 0 indicates file exists.
+                if v.inode != 0 {
+                    // Decrease the refcount.
+                    self.forget(ctx, v.inode.into(), 1);
+                    // File exists with same name, create whiteout file is not allowed.
+                    return Err(Error::from_raw_os_error(libc::EEXIST));
+                }
+            }
+            Err(e) => match e.raw_os_error() {
+                Some(raw_error) => {
+                    // We expect ENOENT error.
+                    if raw_error != libc::ENOENT {
+                        return Err(e);
+                    }
+                }
+                None => return Err(e),
+            },
+        }
+
+        // Try to create whiteout char device with 0/0 device number.
+        let dev = libc::makedev(0, 0);
+        let mode = libc::S_IFCHR | 0o777;
+        self.mknod(ctx, ino.into(), name, mode, dev as u32, 0)
+    }
+
+    /// Delete whiteout file with name <name>.
+    fn delete_whiteout(&self, ctx: &Context, parent: Self::Inode, name: &CStr) -> Result<()> {
+        // Use temp value to avoid moved 'parent'.
+        let ino: u64 = parent.into();
+        match self.lookup(ctx, ino.into(), name) {
+            Ok(v) => {
+                if v.inode != 0 {
+                    // Decrease the refcount since we make a lookup call.
+                    self.forget(ctx, v.inode.into(), 1);
+                }
+
+                // Find whiteout so we can safely delete it.
+                if is_whiteout(v.attr) {
+                    return self.unlink(ctx, ino.into(), name);
+                }
+                //  Non-negative entry with inode larger than 0 indicates file exists.
+                if v.inode != 0 {
+                    // File exists but not whiteout file.
+                    return Err(Error::from_raw_os_error(libc::EINVAL));
+                }
+            }
+            Err(e) => match e.raw_os_error() {
+                Some(raw_error) => {
+                    // ENOENT is acceptable.
+                    if raw_error != libc::ENOENT {
+                        return Err(e);
+                    }
+                }
+                None => return Err(e),
+            },
+        }
+        Ok(())
+    }
+
+    /// Check if the Inode is a whiteout file
+    fn is_whiteout(&self, ctx: &Context, inode: Self::Inode) -> Result<bool> {
+        let (st, _) = self.getattr(ctx, inode, None)?;
+
+        // Check attributes of the inode to see if it's a whiteout char device.
+        Ok(is_whiteout(st))
+    }
+
+    /// Set the directory to opaque.
+    fn set_opaque(&self, ctx: &Context, inode: Self::Inode) -> Result<()> {
+        // Use temp value to avoid moved 'parent'.
+        let ino: u64 = inode.into();
+
+        // Get attributes and check if it's directory.
+        let (st, _d) = self.getattr(ctx, ino.into(), None)?;
+        if !is_dir(st) {
+            // Only directory can be set to opaque.
+            return Err(Error::from_raw_os_error(libc::ENOTDIR));
+        }
+        // A directory is made opaque by setting the xattr "trusted.overlay.opaque" to "y".
+        // See ref: https://docs.kernel.org/filesystems/overlayfs.html#whiteouts-and-opaque-directories
+        self.setxattr(
+            ctx,
+            ino.into(),
+            to_cstring(OPAQUE_XATTR)?.as_c_str(),
+            b"y",
+            0,
+        )
+    }
+
+    /// Check if the directory is opaque.
+    fn is_opaque(&self, ctx: &Context, inode: Self::Inode) -> Result<bool> {
+        // Use temp value to avoid moved 'parent'.
+        let ino: u64 = inode.into();
+
+        // Get attributes of the directory.
+        let (st, _d) = self.getattr(ctx, ino.into(), None)?;
+        if !is_dir(st) {
+            return Err(Error::from_raw_os_error(libc::ENOTDIR));
+        }
+
+        // Return Result<is_opaque>.
+        let check_attr = |inode: Self::Inode, attr_name: &str, attr_size: u32| -> Result<bool> {
+            let cname = CString::new(attr_name)?;
+            match self.getxattr(ctx, inode, cname.as_c_str(), attr_size) {
+                Ok(v) => {
+                    // xattr name exists and we get value.
+                    if let GetxattrReply::Value(buf) = v {
+                        if buf.len() == 1 && buf[0].to_ascii_lowercase() == b'y' {
+                            return Ok(true);
+                        }
+                    }
+                    // No value found, go on to next check.
+                    Ok(false)
+                }
+                Err(e) => {
+                    if let Some(raw_error) = e.raw_os_error() {
+                        if raw_error == libc::ENODATA {
+                            return Ok(false);
+                        }
+                    }
+
+                    Err(e)
+                }
+            }
+        };
+
+        // A directory is made opaque by setting some specific xattr to "y".
+        // See ref: https://docs.kernel.org/filesystems/overlayfs.html#whiteouts-and-opaque-directories
+
+        // Check our customized version of the xattr "user.fuseoverlayfs.opaque".
+        let is_opaque = check_attr(ino.into(), OPAQUE_XATTR, OPAQUE_XATTR_LEN)?;
+        if is_opaque {
+            return Ok(true);
+        }
+
+        // Also check for the unprivileged version of the xattr "trusted.overlay.opaque".
+        let is_opaque = check_attr(ino.into(), PRIVILEGED_OPAQUE_XATTR, OPAQUE_XATTR_LEN)?;
+        if is_opaque {
+            return Ok(true);
+        }
+
+        // Also check for the unprivileged version of the xattr "user.overlay.opaque".
+        let is_opaque = check_attr(ino.into(), UNPRIVILEGED_OPAQUE_XATTR, OPAQUE_XATTR_LEN)?;
+        if is_opaque {
+            return Ok(true);
+        }
+
+        Ok(false)
+    }
+}
+
+pub(crate) fn is_dir(st: stat64) -> bool {
+    st.st_mode & libc::S_IFMT == libc::S_IFDIR
+}
+
+pub(crate) fn is_chardev(st: stat64) -> bool {
+    st.st_mode & libc::S_IFMT == libc::S_IFCHR
+}
+
+pub(crate) fn is_whiteout(st: stat64) -> bool {
+    // A whiteout is created as a character device with 0/0 device number.
+    // See ref: https://docs.kernel.org/filesystems/overlayfs.html#whiteouts-and-opaque-directories
+    let major = unsafe { libc::major(st.st_rdev) };
+    let minor = unsafe { libc::minor(st.st_rdev) };
+    is_chardev(st) && major == 0 && minor == 0
+}
+
+pub(crate) fn to_cstring(name: &str) -> Result<CString> {
+    CString::new(name).map_err(|e| Error::new(ErrorKind::InvalidData, e))
+}
diff --git a/src/lib.rs b/src/lib.rs
index caf3bd086..e1b89d79a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -117,10 +117,11 @@ pub type Result<T> = ::std::result::Result<T, Error>;
 pub mod abi;
 pub mod api;
 
+#[cfg(all(any(feature = "fusedev", feature = "virtiofs"), target_os = "linux"))]
+pub mod overlayfs;
 #[cfg(all(any(feature = "fusedev", feature = "virtiofs"), target_os = "linux"))]
 pub mod passthrough;
 pub mod transport;
-pub mod overlayfs;
 
 pub mod common;
 pub use self::common::*;
diff --git a/src/overlayfs/config.rs b/src/overlayfs/config.rs
index ce0e14606..37312bf5d 100644
--- a/src/overlayfs/config.rs
+++ b/src/overlayfs/config.rs
@@ -1,53 +1,45 @@
+// Copyright (C) 2023 Ant Group. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
 
-use std::time::Duration;
 use self::super::CachePolicy;
 use std::fmt;
+use std::time::Duration;
 
 #[derive(Default, Clone, Debug)]
 pub struct Config {
-	pub upper: String,
-	pub lower: Vec<String>,
-	pub work: String,
-	pub mountpoint: String,
-	pub do_import: bool,
-	pub writeback: bool,
-	pub no_open: bool,
-	pub no_opendir: bool,
-	pub killpriv_v2: bool,
-	pub no_readdir: bool,
-	pub xattr: bool,
-	pub xattr_permissions: bool,
-	pub perfile_dax: bool,
-	pub cache_policy: CachePolicy,
-	pub attr_timeout: Duration,
-	pub entry_timeout: Duration,
-}
-
-impl Default for CachePolicy {
-	fn default() -> Self {
-		CachePolicy::Auto
-	}
+    pub mountpoint: String,
+    pub work: String,
+    pub do_import: bool,
+    // Filesystem options.
+    pub writeback: bool,
+    pub no_open: bool,
+    pub no_opendir: bool,
+    pub killpriv_v2: bool,
+    pub no_readdir: bool,
+    pub perfile_dax: bool,
+    pub cache_policy: CachePolicy,
+    pub attr_timeout: Duration,
+    pub entry_timeout: Duration,
 }
 
 impl Clone for CachePolicy {
-	fn clone(&self) -> Self {
-		match *self {
-			CachePolicy::Never => CachePolicy::Never,
-			CachePolicy::Always => CachePolicy::Always,
-			CachePolicy::Auto => CachePolicy::Auto,
-		}
-	}
+    fn clone(&self) -> Self {
+        match *self {
+            CachePolicy::Never => CachePolicy::Never,
+            CachePolicy::Always => CachePolicy::Always,
+            CachePolicy::Auto => CachePolicy::Auto,
+        }
+    }
 }
 
 impl fmt::Debug for CachePolicy {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		let policy = 
-		match *self {
-			CachePolicy::Never => "Never",
-			CachePolicy::Always => "Always",
-			CachePolicy::Auto => "Auto",
-		};
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let policy = match *self {
+            CachePolicy::Never => "Never",
+            CachePolicy::Always => "Always",
+            CachePolicy::Auto => "Auto",
+        };
 
-		write!(f, "CachePolicy: {}", policy)
-	}
+        write!(f, "CachePolicy: {}", policy)
+    }
 }
diff --git a/src/overlayfs/datasource.rs b/src/overlayfs/datasource.rs
deleted file mode 100644
index 501df060a..000000000
--- a/src/overlayfs/datasource.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-
-///! DataSource trait
-pub trait DataSource {
-}
diff --git a/src/overlayfs/direct.rs b/src/overlayfs/direct.rs
deleted file mode 100644
index 427bc83e1..000000000
--- a/src/overlayfs/direct.rs
+++ /dev/null
@@ -1,290 +0,0 @@
-use std::collections::LinkedList;
-use std::sync::Arc;
-use std::io::{Result, Error, ErrorKind};
-use std::fs;
-use std::ffi::{CStr, CString};
-use std::time::Duration;
-
-
-use self::super::layer::Layer;
-use self::super::BoxedLayer;
-use self::super::{Inode, Handle};
-use crate::passthrough::{PassthroughFs, Config as PassthroughConfig};
-use crate::api::filesystem::{Entry, FileSystem, FsOptions, OpenOptions, GetxattrReply, ListxattrReply, DirEntry, SetattrValid, ZeroCopyReader, ZeroCopyWriter, Context};
-use crate::abi::fuse_abi::CreateIn;
-
-pub struct Direct {
-	pub upper: bool,
-	pub fs: PassthroughFs,
-}
-
-impl Direct {
-	pub fn new(path: String, upper: bool) -> Result<LinkedList<Arc<BoxedLayer>>> {
-		let dir = fs::canonicalize(path.as_str())?;
-		let root_dir = dir.to_string_lossy().into_owned().to_owned();
-		let mut config = PassthroughConfig::default();
-		config.root_dir = root_dir;
-
-		// enable xattr
-		config.xattr = true;
-
-		// under overlay fs, no need to negotiate
-		config.do_import = false;
-		let fs = PassthroughFs::new(config)?;
-
-		let mut layer = Direct{
-			upper,
-			fs,
-		};
-
-		layer.init_layer()?;
-
-		let mut list = LinkedList::new();
-		list.push_back(Arc::new(Box::new(layer) as BoxedLayer));
-
-		Ok(list)
-	}
-}
-
-impl Layer for Direct {
-	fn init_layer(&mut self) -> Result<()> {
-		self.fs.import()
-	}
-
-	fn cleanup(&mut self) -> Result<()> {
-		Ok(())
-	}
-
-	fn is_upper(&self) -> bool {
-		self.upper
-	}
-}
-
-impl FileSystem for Direct {
-	type Inode = Inode;
-	type Handle = Handle;
-
-	fn init(&self, capable: FsOptions) -> Result<FsOptions> {
-		Err(Error::from(ErrorKind::Unsupported))
-	}
-
-	fn destroy(&self) {
-		self.fs.destroy()
-	}
-
-	fn statfs(&self, ctx: &Context, inode: Inode) -> Result<libc::statvfs64> {
-		self.fs.statfs(ctx, inode)
-	}
-
-	fn lookup(&self, ctx: &Context, parent: Inode, name: &CStr) -> Result<Entry> {
-		self.fs.lookup(ctx, parent, name)
-	}
-
-	fn forget(&self, ctx: &Context, inode: Inode, count: u64) {
-		self.fs.forget(ctx, inode, count)
-	}
-
-	fn batch_forget(&self, ctx: &Context, requests: Vec<(Inode, u64)>) {
-		self.fs.batch_forget(ctx, requests)
-	}
-
-	fn opendir(&self, ctx: &Context, inode: Inode, flags: u32) -> Result<(Option<Handle>, OpenOptions)> {
-		// should test flags to refuse write operations
-		let iflags: i32 = flags as i32;
-		let write = iflags & libc::O_RDWR != 0 || iflags & libc::O_WRONLY != 0 || iflags & libc::O_CREAT != 0 || iflags & libc::O_APPEND != 0 || iflags & libc::O_TRUNC != 0;
-		if !self.upper && write {
-			return Err(Error::from_raw_os_error(libc::EROFS));
-		}
-
-		self.fs.opendir(ctx, inode, flags)
-	}
-
-	fn releasedir(&self, ctx: &Context, inode: Inode, flags: u32, handle: Handle) -> Result<()> {
-		self.fs.releasedir(ctx, inode, flags, handle)
-	}
-
-	fn mkdir(&self, ctx: &Context, parent: Inode, name: &CStr, mode: u32, umask: u32) -> Result<Entry> {
-		if !self.upper {
-			return Err(Error::from_raw_os_error(libc::EROFS));
-		}
-
-		self.fs.mkdir(ctx, parent, name, mode, umask)
-	}
-
-	fn rmdir(&self, ctx: &Context, parent: Inode, name: &CStr) -> Result<()> {
-		if !self.upper {
-			return Err(Error::from_raw_os_error(libc::EROFS));
-		}
-
-		self.fs.rmdir(ctx, parent, name)
-	}
-
-	fn readdir(&self, ctx: &Context, inode: Inode, handle: Handle, size: u32, offset: u64, add_entry: &mut dyn FnMut(DirEntry) -> Result<usize>) -> Result<()> {
-		self.fs.readdir(ctx, inode, handle, size, offset, add_entry)
-	}
-
-	fn readdirplus(&self, ctx: &Context, inode: Inode, handle: Handle, size: u32, offset: u64, add_entry: &mut dyn FnMut(DirEntry, Entry) -> Result<usize>) -> Result<()> {
-		self.fs.readdirplus(ctx, inode, handle, size, offset, add_entry)
-	}
-
-	fn open(&self, ctx: &Context, inode: Inode, flags: u32, fuse_flags: u32) -> Result<(Option<Handle>, OpenOptions)> {
-		let iflags: i32 = flags as i32;
-		let write = iflags & libc::O_RDWR != 0 || iflags & libc::O_WRONLY != 0 || iflags & libc::O_CREAT != 0 || iflags & libc::O_APPEND != 0 || iflags & libc::O_TRUNC != 0;
-		if !self.upper && write {
-			return Err(Error::from_raw_os_error(libc::EROFS));
-		}
-
-		self.fs.open(ctx, inode, flags, fuse_flags)
-	}
-
-	fn release(&self, ctx: &Context, inode: Inode, flags: u32, handle: Handle, flush: bool, flock_release: bool, lock_owner: Option<u64>) -> Result<()> {
-		self.fs.release(ctx, inode, flags, handle, flush, flock_release, lock_owner)
-	}
-
-	fn create(&self, ctx: &Context, parent: Inode, name: &CStr, args: CreateIn) -> Result<(Entry, Option<Handle>, OpenOptions)> {
-		if !self.upper {
-			return Err(Error::from_raw_os_error(libc::EROFS));
-		}
-
-		self.fs.create(ctx, parent, name, args)
-	}
-
-	fn unlink(&self, ctx: &Context, parent: Inode, name: &CStr) -> Result<()> {
-		if !self.upper {
-			return Err(Error::from_raw_os_error(libc::EROFS));
-		}
-
-		self.fs.unlink(ctx, parent, name)
-	}
-
-	fn read(&self, ctx: &Context, inode: Inode, handle: Handle, w: &mut dyn ZeroCopyWriter, size: u32, offset: u64, lock_owner: Option<u64>, flags: u32) -> Result<usize> {
-		self.fs.read(ctx, inode, handle, w, size, offset, lock_owner, flags)
-	}
-
-	fn write(&self, ctx: &Context, inode: Inode, handle: Handle, r: &mut dyn ZeroCopyReader, size: u32, offset: u64, lock_owner: Option<u64>, delay_write: bool, flags: u32, fuse_flags: u32) -> Result<usize> {
-		if !self.upper {
-			return Err(Error::from_raw_os_error(libc::EROFS));
-		}
-
-		self.fs.write(ctx, inode, handle, r, size, offset, lock_owner, delay_write, flags, fuse_flags)
-	}
-
-	fn getattr(&self, ctx: &Context, inode: Inode, handle: Option<Handle>) -> Result<(libc::stat64, Duration)> {
-		self.fs.getattr(ctx, inode, handle)
-	}
-
-	fn setattr(&self, ctx: &Context, inode: Inode, attr: libc::stat64, handle: Option<Handle>, valid: SetattrValid) -> Result<(libc::stat64, Duration)> {
-		if !self.upper {
-			return Err(Error::from_raw_os_error(libc::EROFS));
-		}
-
-		self.fs.setattr(ctx, inode, attr, handle, valid)
-	}
-
-	fn rename(&self, ctx: &Context, olddir: Inode, oldname: &CStr, newdir: Inode, newname: &CStr, flags: u32) -> Result<()> {
-		if !self.upper {
-			return Err(Error::from_raw_os_error(libc::EROFS));
-		}
-
-		self.fs.rename(ctx, olddir, oldname, newdir, newname, flags)
-	}
-
-	fn mknod(&self, ctx: &Context, parent: Inode, name: &CStr, mode: u32, rdev: u32, umask: u32) -> Result<Entry> {
-		if !self.upper {
-			return Err(Error::from_raw_os_error(libc::EROFS));
-		}
-
-		self.fs.mknod(ctx, parent, name, mode, rdev, umask)
-	}
-
-	fn link(&self, ctx: &Context, inode: Inode, newparent: Inode, newname: &CStr) -> Result<Entry> {
-		if !self.upper {
-			return Err(Error::from_raw_os_error(libc::EROFS));
-		}
-
-		self.fs.link(ctx, inode, newparent, newname)
-	}
-
-	fn symlink(&self, ctx: &Context, linkname: &CStr, parent: Inode, name: &CStr) -> Result<Entry> {
-		if !self.upper {
-			return Err(Error::from_raw_os_error(libc::EROFS));
-		}
-
-		self.fs.symlink(ctx, linkname, parent, name)
-	}
-
-	fn readlink(&self, ctx: &Context, inode: Inode) -> Result<Vec<u8>> {
-		self.fs.readlink(ctx, inode)
-	}
-
-	fn flush(&self, ctx: &Context, inode: Inode, handle: Handle, lock_owner: u64) -> Result<()> {
-		// even readonly opened file can be flushed,
-		// so it does't have to be in upper layer
-		// if !self.upper {
-		// 	return Err(Error::from_raw_os_error(libc::EROFS));
-		// }
-
-		self.fs.flush(ctx, inode, handle, lock_owner)
-	}
-
-	fn fsync(&self, ctx: &Context, inode: Inode, datasync: bool, handle: Handle) -> Result<()> {
-		if !self.upper {
-			return Err(Error::from_raw_os_error(libc::EROFS));
-		}
-
-		self.fs.fsync(ctx, inode, datasync, handle)
-	}
-
-	fn fsyncdir(&self, ctx: &Context, inode: Inode, datasync: bool, handle: Handle) -> Result<()> {
-		if !self.upper {
-			return Err(Error::from_raw_os_error(libc::EROFS));
-		}
-
-		self.fs.fsyncdir(ctx, inode, datasync, handle)
-	}
-
-	fn access(&self, ctx: &Context, inode: Inode, mask: u32) -> Result<()> {
-		let write = mask as i32 & libc::W_OK != 0;
-		if !self.upper && write {
-			return Err(Error::from_raw_os_error(libc::EROFS));
-		}
-
-		self.fs.access(ctx, inode, mask)
-	}
-
-	fn setxattr(&self, ctx: &Context, inode: Inode, name: &CStr, value: &[u8], flags: u32) -> Result<()> {
-		if !self.upper {
-			return Err(Error::from_raw_os_error(libc::EROFS));
-		}
-
-		self.fs.setxattr(ctx, inode, name, value, flags)
-	}
-
-	fn getxattr(&self, ctx: &Context, inode: Inode, name: &CStr, size: u32) -> Result<GetxattrReply> {
-		self.fs.getxattr(ctx, inode, name, size)
-	}
-
-	fn listxattr(&self, ctx: &Context, inode: Inode, size: u32) -> Result<ListxattrReply> {
-		self.fs.listxattr(ctx, inode, size)
-	}
-
-	fn removexattr(&self, ctx: &Context, inode: Inode, name: &CStr) -> Result<()> {
-		if !self.upper {
-			return Err(Error::from_raw_os_error(libc::EROFS));
-		}
-
-		self.fs.removexattr(ctx, inode, name)
-	}
-
-	fn fallocate(&self, ctx: &Context, inode: Inode, handle: Handle, mode: u32, offset: u64, length: u64) -> Result<()> {
-		if !self.upper {
-			return Err(Error::from_raw_os_error(libc::EROFS));
-		}
-
-		self.fs.fallocate(ctx, inode, handle, mode, offset, length)
-	}
-
-	fn lseek(&self, ctx: &Context, inode: Inode, handle: Handle, offset: u64, whence: u32) -> Result<u64> {
-		self.fs.lseek(ctx, inode, handle, offset, whence)
-	}
-}
diff --git a/src/overlayfs/inode_store.rs b/src/overlayfs/inode_store.rs
new file mode 100644
index 000000000..a5d069072
--- /dev/null
+++ b/src/overlayfs/inode_store.rs
@@ -0,0 +1,238 @@
+// Copyright (C) 2023 Ant Group. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+use std::io::{Error, ErrorKind, Result};
+use std::{
+    collections::HashMap,
+    sync::{atomic::Ordering, Arc},
+};
+
+use super::{Inode, OverlayInode, VFS_MAX_INO};
+
+use radix_trie::Trie;
+
+pub struct InodeStore {
+    // Active inodes.
+    inodes: HashMap<Inode, Arc<OverlayInode>>,
+    // Deleted inodes which were unlinked but have non zero lookup count.
+    deleted: HashMap<Inode, Arc<OverlayInode>>,
+    // Path to inode mapping, used to reserve inode number for same path.
+    path_mapping: Trie<String, Inode>,
+    next_inode: u64,
+}
+
+impl InodeStore {
+    pub(crate) fn new() -> Self {
+        Self {
+            inodes: HashMap::new(),
+            deleted: HashMap::new(),
+            path_mapping: Trie::new(),
+            next_inode: 1,
+        }
+    }
+
+    pub(crate) fn alloc_unique_inode(&mut self) -> Result<Inode> {
+        // Iter VFS_MAX_INO times to find a free inode number.
+        let mut ino = self.next_inode;
+        for _ in 0..VFS_MAX_INO {
+            if ino > VFS_MAX_INO {
+                ino = 1;
+            }
+            if !self.inodes.contains_key(&ino) && !self.deleted.contains_key(&ino) {
+                self.next_inode = ino + 1;
+                return Ok(ino);
+            }
+            ino += 1;
+        }
+        error!("reached maximum inode number: {}", VFS_MAX_INO);
+        Err(Error::new(
+            ErrorKind::Other,
+            format!("maximum inode number {} reached", VFS_MAX_INO),
+        ))
+    }
+
+    pub(crate) fn alloc_inode(&mut self, path: &String) -> Result<Inode> {
+        match self.path_mapping.get(path) {
+            // If the path is already in the mapping, return the reserved inode number.
+            Some(v) => Ok(*v),
+            // Or allocate a new inode number.
+            None => self.alloc_unique_inode(),
+        }
+    }
+
+    pub(crate) fn insert_inode(&mut self, inode: Inode, node: Arc<OverlayInode>) {
+        self.path_mapping.insert(node.path.clone(), inode);
+        self.inodes.insert(inode, node);
+    }
+
+    pub(crate) fn get_inode(&self, inode: Inode) -> Option<Arc<OverlayInode>> {
+        self.inodes.get(&inode).cloned()
+    }
+
+    pub(crate) fn get_deleted_inode(&self, inode: Inode) -> Option<Arc<OverlayInode>> {
+        self.deleted.get(&inode).cloned()
+    }
+
+    // Return the inode only if it's permanently deleted from both self.inodes and self.deleted_inodes.
+    pub(crate) fn remove_inode(
+        &mut self,
+        inode: Inode,
+        path_removed: Option<String>,
+    ) -> Option<Arc<OverlayInode>> {
+        let removed = match self.inodes.remove(&inode) {
+            Some(v) => {
+                // Refcount is not 0, we have to delay the removal.
+                if v.lookups.load(Ordering::Relaxed) > 0 {
+                    self.deleted.insert(inode, v.clone());
+                    return None;
+                }
+                Some(v)
+            }
+            None => {
+                // If the inode is not in hash, it must be in deleted_inodes.
+                match self.deleted.get(&inode) {
+                    Some(v) => {
+                        // Refcount is 0, the inode can be removed now.
+                        if v.lookups.load(Ordering::Relaxed) == 0 {
+                            self.deleted.remove(&inode)
+                        } else {
+                            // Refcount is not 0, the inode will be removed later.
+                            None
+                        }
+                    }
+                    None => None,
+                }
+            }
+        };
+
+        if let Some(path) = path_removed {
+            self.path_mapping.remove(&path);
+        }
+        removed
+    }
+
+    // As a debug function, print all inode numbers in hash table.
+    // This function consumes quite lots of memory, so it's disabled by default.
+    #[allow(dead_code)]
+    pub(crate) fn debug_print_all_inodes(&self) {
+        // Convert the HashMap to Vector<(inode, pathname)>
+        let mut all_inodes = self
+            .inodes
+            .iter()
+            .map(|(inode, ovi)| (inode, ovi.path.clone(), ovi.lookups.load(Ordering::Relaxed)))
+            .collect::<Vec<_>>();
+        all_inodes.sort_by(|a, b| a.0.cmp(b.0));
+        trace!("all active inodes: {:?}", all_inodes);
+
+        let mut to_delete = self
+            .deleted
+            .iter()
+            .map(|(inode, ovi)| (inode, ovi.path.clone(), ovi.lookups.load(Ordering::Relaxed)))
+            .collect::<Vec<_>>();
+        to_delete.sort_by(|a, b| a.0.cmp(b.0));
+        trace!("all deleted inodes: {:?}", to_delete);
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_alloc_unique() {
+        let mut store = InodeStore::new();
+        let empty_node = Arc::new(OverlayInode::new());
+        store.insert_inode(1, empty_node.clone());
+        store.insert_inode(2, empty_node.clone());
+        store.insert_inode(VFS_MAX_INO - 1, empty_node.clone());
+
+        let inode = store.alloc_unique_inode().unwrap();
+        assert_eq!(inode, 3);
+        assert_eq!(store.next_inode, 4);
+
+        store.next_inode = VFS_MAX_INO - 1;
+        let inode = store.alloc_unique_inode().unwrap();
+        assert_eq!(inode, VFS_MAX_INO);
+
+        let inode = store.alloc_unique_inode().unwrap();
+        assert_eq!(inode, 3);
+    }
+
+    #[test]
+    fn test_alloc_existing_path() {
+        let mut store = InodeStore::new();
+        let mut node_a = OverlayInode::new();
+        node_a.path = "/a".to_string();
+        store.insert_inode(1, Arc::new(node_a));
+        let mut node_b = OverlayInode::new();
+        node_b.path = "/b".to_string();
+        store.insert_inode(2, Arc::new(node_b));
+        let mut node_c = OverlayInode::new();
+        node_c.path = "/c".to_string();
+        store.insert_inode(VFS_MAX_INO - 1, Arc::new(node_c));
+
+        let inode = store.alloc_inode(&"/a".to_string()).unwrap();
+        assert_eq!(inode, 1);
+
+        let inode = store.alloc_inode(&"/b".to_string()).unwrap();
+        assert_eq!(inode, 2);
+
+        let inode = store.alloc_inode(&"/c".to_string()).unwrap();
+        assert_eq!(inode, VFS_MAX_INO - 1);
+
+        let inode = store.alloc_inode(&"/notexist".to_string()).unwrap();
+        assert_eq!(inode, 3);
+    }
+
+    #[test]
+    fn test_remove_inode() {
+        let mut store = InodeStore::new();
+        let mut node_a = OverlayInode::new();
+        node_a.lookups.fetch_add(1, Ordering::Relaxed);
+        node_a.path = "/a".to_string();
+        store.insert_inode(1, Arc::new(node_a));
+
+        let mut node_b = OverlayInode::new();
+        node_b.path = "/b".to_string();
+        store.insert_inode(2, Arc::new(node_b));
+
+        let mut node_c = OverlayInode::new();
+        node_c.lookups.fetch_add(1, Ordering::Relaxed);
+        node_c.path = "/c".to_string();
+        store.insert_inode(VFS_MAX_INO - 1, Arc::new(node_c));
+
+        let inode = store.alloc_inode(&"/new".to_string()).unwrap();
+        assert_eq!(inode, 3);
+
+        // Not existing.
+        let inode = store.remove_inode(4, None);
+        assert!(inode.is_none());
+
+        // Existing but with non-zero refcount.
+        let inode = store.remove_inode(1, None);
+        assert!(inode.is_none());
+        assert!(store.get_deleted_inode(1).is_some());
+        assert!(store.path_mapping.get(&"/a".to_string()).is_some());
+
+        // Remove again with file path.
+        let inode = store.remove_inode(1, Some("/a".to_string()));
+        assert!(inode.is_none());
+        assert!(store.get_deleted_inode(1).is_some());
+        assert!(store.path_mapping.get(&"/a".to_string()).is_none());
+
+        // Node b has refcount 0, removing will be permanent.
+        let inode = store.remove_inode(2, Some("/b".to_string()));
+        assert!(inode.is_some());
+        assert!(store.get_deleted_inode(2).is_none());
+        assert!(store.path_mapping.get(&"/b".to_string()).is_none());
+
+        // Allocate new inode, it should reuse inode 2 since inode 1 is still in deleted list.
+        store.next_inode = 1;
+        let inode = store.alloc_inode(&"/b".to_string()).unwrap();
+        assert_eq!(inode, 2);
+
+        // Allocate inode with path "/c" will reuse its inode number.
+        let inode = store.alloc_inode(&"/c".to_string()).unwrap();
+        assert_eq!(inode, VFS_MAX_INO - 1);
+    }
+}
diff --git a/src/overlayfs/layer.rs b/src/overlayfs/layer.rs
deleted file mode 100644
index 33f08a47a..000000000
--- a/src/overlayfs/layer.rs
+++ /dev/null
@@ -1,223 +0,0 @@
-#![allow(missing_docs)]
-
-use std::sync::{Arc, Weak};
-use std::io::{Result, Error};
-use std::os::unix::io::RawFd;
-use std::fs::File;
-use std::path::PathBuf;
-use std::cmp::Eq;
-use std::ffi::{CString, CStr};
-use libc;
-
-
-use self::super::super::abi::fuse_abi::Dirent;
-use self::super::datasource::DataSource;
-use self::super::{OverlayFs, Inode, Handle};
-use self::super::{WHITEOUT_PREFIX, ORIGIN_XATTR, OPAQUE_XATTR, PRIVILEGED_OPAQUE_XATTR, PRIVILEGED_ORIGIN_XATTR, UNPRIVILEGED_OPAQUE_XATTR, OPAQUE_WHITEOUT};
-use crate::api::filesystem::{FileSystem, Context, Entry, GetxattrReply};
-use crate::abi::fuse_abi::{CreateIn};
-use crate::api::VFS_MAX_INO;
-
-pub const OPAQUE_XATTR_LEN: u32 = 16;
-
-// we cannot constraint Layer with Eq, as Eq requires Sized
-// So we need api to get an identifier and then use identifier
-// to do comparation.. Here may have better solutions..
-pub trait Layer: FileSystem {
-	fn init_layer(&mut self) -> Result<()>;
-	fn cleanup(&mut self) -> Result<()>;
-	fn is_upper(&self) -> bool;
-	// file exists, returns true, not exists return false
-	// otherwise, error out
-	// Ok(None) denotes no entry
-	fn lookup_ignore_enoent(&self, ctx: &Context, ino: u64, name: &str) -> Result<Option<Entry>> {
-		let cname = CString::new(name).expect("invalid c string");
-		match self.lookup(ctx, Self::Inode::from(ino), cname.as_c_str()) {
-			Ok(v) => return Ok(Some(v)),
-			Err(e) => {
-				if let Some(raw_error) = e.raw_os_error() {
-					if raw_error == libc::ENOENT || raw_error == libc::ENAMETOOLONG {
-						return Ok(None);
-					}
-				}
-
-				return Err(e);
-			},
-		}
-	}
-
-	fn getxattr_ignore_nodata(&self, ctx: &Context, inode: u64, name: &str, size: u32) -> Result<Option<Vec<u8>>> {
-		let cname = CString::new(name).expect("invalid c string");
-		match self.getxattr(ctx, Self::Inode::from(inode), cname.as_c_str(), size)
-		{
-			Ok(v) => {
-				if let GetxattrReply::Value(buf) = v {
-					return Ok(Some(buf));
-				} else {
-					return Ok(None);
-				}
-			},
-			Err(e) => {
-				if let Some(raw_error) = e.raw_os_error() {
-					if raw_error == libc::ENODATA || raw_error == libc::ENOTSUP || raw_error == libc::ENOSYS {
-						return Ok(None);
-					}
-				}
-
-				return Err(e);
-			},
-		}
-	}
-
-	fn whiteout_exists(&self, ctx: &Context, ino: u64, name: &CStr) -> Result<(bool, u64, String)> {
-		let sname = name.to_string_lossy().into_owned().to_owned();
-
-		let mut wh_name = String::from(WHITEOUT_PREFIX);
-		wh_name.push_str(sname.as_str());
-
-		// .wh.name exists
-		if let Some(v) = self.lookup_ignore_enoent(ctx, ino, wh_name.as_str())? {
-			return Ok((true, v.inode, wh_name));
-		}
-
-		// char node whiteout
-		if let Some(st) = self.lookup_ignore_enoent(ctx, ino, sname.as_str())? {
-			let major = unsafe { libc::major(st.attr.st_rdev) };
-			let minor = unsafe { libc::minor(st.attr.st_rdev) };
-			if st.attr.st_mode & libc::S_IFMT == libc::S_IFCHR && major == 0 && minor == 0 {
-				return Ok((true, st.inode, sname));
-			}
-		}
-		
-		Ok((false, VFS_MAX_INO, String::from("")))
-	}
-
-	fn is_opaque_whiteout(&self, ctx: &Context, inode: u64) -> Result<(bool, Option<u64>)> {
-		let (st, _d) = self.getattr(ctx, Self::Inode::from(inode), None)?;
-		if st.st_mode & libc::S_IFMT != libc::S_IFDIR {
-			return Err(Error::from_raw_os_error(libc::ENOTDIR));
-		}
-
-		// check xattr first
-		if let Some(v) = self.getxattr_ignore_nodata(ctx, inode, PRIVILEGED_OPAQUE_XATTR, OPAQUE_XATTR_LEN)? {
-			if v[0].to_ascii_lowercase() == b'y' {
-				return Ok((true, None));
-			} else {
-				return Ok((false, None));
-			}
-		}
-
-		if let Some(v) = self.getxattr_ignore_nodata(ctx, inode, UNPRIVILEGED_OPAQUE_XATTR, OPAQUE_XATTR_LEN)? {
-			if v[0].to_ascii_lowercase() == b'y' {
-				return Ok((true, None));
-			} else {
-				return Ok((false, None));
-			}
-		}
-
-		if let Some(v) = self.getxattr_ignore_nodata(ctx, inode, OPAQUE_XATTR, OPAQUE_XATTR_LEN)? {
-			if v[0].to_ascii_lowercase() == b'y' {
-				return Ok((true, None));
-			} else {
-				return Ok((false, None));
-			}
-		}
-
-		// check .wh..wh..opaque, hwoever, we have no parent inode number for the parent of .wh..wh..opaque
-		if let Some(v) = self.lookup_ignore_enoent(ctx, inode, OPAQUE_WHITEOUT)? {
-			return Ok((true, Some(v.inode)));
-		}
-
-		Ok((false, None))
-	}
-
-	fn delete_whiteout(&self, ctx: &Context, parent: u64, name: &str) -> Result<()> {
-		if !self.is_upper() {
-			return Err(Error::from_raw_os_error(libc::EROFS));
-		}
-
-		let mut wh_name = String::from(WHITEOUT_PREFIX);
-		wh_name.push_str(name);
-		let cwh_name = CString::new(wh_name.as_str()).expect("invalid c string");
-		let cname = CString::new(name).expect("invalid c string");
-
-		// .wh.name exists
-		if let Some(v) = self.lookup_ignore_enoent(ctx, parent, wh_name.as_str())? {
-			self.unlink(ctx, Self::Inode::from(parent), cwh_name.as_c_str())?;
-		}
-
-		// char node whiteout
-		if let Some(st) = self.lookup_ignore_enoent(ctx, parent, name)? {
-			let major = unsafe { libc::major(st.attr.st_rdev) };
-			let minor = unsafe { libc::minor(st.attr.st_rdev) };
-			if st.attr.st_mode & libc::S_IFMT == libc::S_IFCHR && major == 0 && minor == 0 {
-				self.unlink(ctx, Self::Inode::from(parent), cname.as_c_str())?;
-			}
-		}
-
-		Ok(())
-	}
-	fn create_whiteout(&self, ctx: &Context, parent: u64, name: &str) -> Result<Entry> {
-		if !self.is_upper() {
-			return Err(Error::from_raw_os_error(libc::EROFS));
-		}
-
-		let mut wh_name = String::from(WHITEOUT_PREFIX);
-		wh_name.push_str(name);
-		let cwh_name = CString::new(wh_name.as_str()).expect("invalid c string");
-		let cname = CString::new(name).expect("invalid c string");
-
-		let (exists, _inode, name) = self.whiteout_exists(ctx, parent, cname.as_c_str())?;
-
-		if exists {
-			return self.lookup(ctx, Self::Inode::from(parent), CString::new(name.as_str()).expect("invalid c string").as_c_str());
-		}
-
-		// try to creat .wh.name
-		let args = CreateIn {
-			flags: 0,
-			mode: 0o777,
-			umask: 0,
-			fuse_flags: 0,
-		};
-
-		if let Ok((entry, h, o)) = self.create(ctx, Self::Inode::from(parent), cwh_name.as_c_str(), args) {
-			// if let Some(handle) = h {
-			// 	self.release(ctx, Self::Inode::from(entry.inode), 0, handle, true, true, None)?;
-			// }
-
-			return Ok(entry);
-		}
-
-		// try mknod
-		let dev = unsafe { libc::makedev(0, 0) };
-		let mode = libc::S_IFCHR | 0o777;
-		self.mknod(ctx, Self::Inode::from(parent), cname.as_c_str(), mode, dev as u32, 0)
-	}
-
-	fn create_opaque_whiteout(&self, ctx: &Context, parent: u64) -> Result<Entry> {
-		if !self.is_upper() {
-			return Err(Error::from_raw_os_error(libc::EROFS));
-		}
-
-		let cname = CString::new(OPAQUE_WHITEOUT).expect("invalid c string");
-
-		// opaque whiteout exists
-		if let Some(v) = self.lookup_ignore_enoent(ctx, parent, OPAQUE_WHITEOUT)? {
-			return Ok(v);
-		}
-
-		// create
-		let args = CreateIn {
-			flags: 0,
-			mode: 0o777,
-			umask: 0,
-			fuse_flags: 0,
-		};
-
-		let (entry, h, _o) = self.create(ctx, Self::Inode::from(parent), cname.as_c_str(), args)?;
-
-		Ok(entry)
-	}
-
-}
diff --git a/src/overlayfs/mod.rs b/src/overlayfs/mod.rs
index 3fedc3a5e..c6a5e03be 100644
--- a/src/overlayfs/mod.rs
+++ b/src/overlayfs/mod.rs
@@ -1,2432 +1,2223 @@
-#![allow(missing_docs)]
-#![feature(io_error_more)]
+// Copyright (C) 2023 Ant Group. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
 
-pub mod layer;
-pub mod datasource;
-pub mod plugin;
+#![allow(missing_docs)]
 pub mod config;
-pub mod direct;
+mod inode_store;
+pub mod sync_io;
+mod utils;
 
-use std::collections::{LinkedList, HashMap};
-use std::io::{Result, SeekFrom, Seek};
-use std::fs::File;
-use std::sync::{Arc, Mutex, Weak};
-use std::sync::atomic::{AtomicBool, Ordering, AtomicU64};
-use std::any::Any;
+use core::panic;
+use std::collections::HashMap;
 use std::ffi::{CStr, CString};
-use std::time::Duration;
-use std::string::ToString;
-use std::mem::{size_of, MaybeUninit};
-use std::os::unix::io::FromRawFd;
-
-use crate::api::filesystem::{Entry, FileSystem, FsOptions, OpenOptions, GetxattrReply, ListxattrReply, DirEntry, SetattrValid, ZeroCopyReader, ZeroCopyWriter, Context};
-use crate::api::{BackendFileSystem, SLASH_ASCII, VFS_MAX_INO};
-use crate::abi::fuse_abi::{CreateIn, ROOT_ID as FUSE_ROOT_ID};
+use std::fs::File;
+use std::io::{Error, ErrorKind, Result, Seek, SeekFrom};
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+use std::sync::{Arc, Mutex, RwLock, Weak};
+
+use crate::abi::fuse_abi::{stat64, statvfs64, CreateIn, ROOT_ID as FUSE_ROOT_ID};
+use crate::api::filesystem::{
+    Context, DirEntry, Entry, Layer, OpenOptions, ZeroCopyReader, ZeroCopyWriter,
+};
+#[cfg(not(feature = "async-io"))]
+use crate::api::BackendFileSystem;
+use crate::api::{SLASH_ASCII, VFS_MAX_INO};
+
 use crate::common::file_buf::FileVolatileSlice;
 use crate::common::file_traits::FileReadWriteVolatile;
+use vmm_sys_util::tempfile::TempFile;
 
-use self::plugin::PluginManager;
-use self::layer::Layer;
 use self::config::Config;
-use std::io::{Error, ErrorKind};
-use libc;
-
+use self::inode_store::InodeStore;
 
 pub type Inode = u64;
 pub type Handle = u64;
-pub const PLUGIN_PREFIX: &str = "//";
-pub const WHITEOUT_PREFIX: &str = ".wh.";
-pub const XATTR_PREFIX: &str = "user.fuseoverlayfs";
-pub const ORIGIN_XATTR: &str = "user.fuseoverlayfs.origin";
-pub const OPAQUE_XATTR: &str = "user.fuseoverlayfs.opaque";
-pub const XATTR_CONTAINERS_PREFIX: &str = "user.containers";
-pub const UNPRIVILEGED_XATTR_PREFIX: &str = "user.overlay";
-pub const UNPRIVILEGED_OPAQUE_XATTR: &str = "user.overlay.opaque";
-pub const PRIVILEGED_XATTR_PREFIX: &str = "trusted.overlay";
-pub const PRIVILEGED_OPAQUE_XATTR: &str = "trusted.overlay.opaque";
-pub const PRIVILEGED_ORIGIN_XATTR: &str = "trusted.overlay.origin";
-pub const OPAQUE_WHITEOUT: &str = ".wh..wh..opq";
 pub const MAXNAMELEN: usize = 256;
 pub const CURRENT_DIR: &str = ".";
 pub const PARENT_DIR: &str = "..";
-pub const WHITEOUT_MAX_LEN: u64 = ".wh.".len() as u64;
-pub const MAXBUFSIZE: usize = 1<< 20;
+pub const MAXBUFSIZE: usize = 1 << 20;
 
+//type BoxedFileSystem = Box<dyn FileSystem<Inode = Inode, Handle = Handle> + Send + Sync>;
 pub type BoxedLayer = Box<dyn Layer<Inode = Inode, Handle = Handle> + Send + Sync>;
 
-// need real inode from layers, need inode to do layer
-// operations
-#[derive(Default)]
-pub struct RealInode {
-	pub layer: Option<Arc<BoxedLayer>>,
-	pub inode: AtomicU64,
-	pub whiteout: AtomicBool,
-	pub opaque: AtomicBool,
-	pub hidden: AtomicBool,
-	pub invalid: AtomicBool,
-}
-
-#[derive(Default, Debug)]
-pub struct RealInodeStats {
-	pub inode: u64,
-	pub whiteout: bool,
-	pub opaque: bool,
-	pub stat: Option<libc::stat64>,
-	pub wh_name: Option<String>,
-	pub opaque_inode: Option<u64>,
+// RealInode represents one inode object in specific layer.
+// Also, each RealInode maps to one Entry, which should be 'forgotten' after drop.
+// Important note: do not impl Clone trait for it or refcount will be messed up.
+pub(crate) struct RealInode {
+    pub layer: Arc<BoxedLayer>,
+    pub in_upper_layer: bool,
+    pub inode: u64,
+    // File is whiteouted, we need to hide it.
+    pub whiteout: bool,
+    // Directory is opaque, we need to hide all entries inside it.
+    pub opaque: bool,
+    pub stat: Option<stat64>,
 }
 
+// OverlayInode must be protected by lock, it can be operated by multiple threads.
 #[derive(Default)]
-pub struct OverlayInode {
-	pub childrens: Mutex<HashMap<String, Arc<OverlayInode>>>,
-	pub parent: Mutex<Weak<OverlayInode>>,
-	pub lower_inodes: Vec<Arc<RealInode>>,
-	pub upper_inode: Mutex<Option<Arc<RealInode>>>,
-	pub first_inode: Mutex<Arc<RealInode>>,
-	pub last_inode: Mutex<Arc<RealInode>>,
-	pub inode: u64,
-	pub st_ino: libc::ino64_t,
-	pub st_dev: libc::dev_t,
-	pub mode: libc::mode_t,
-	pub entry_type: u32,
-	pub path: String,
-	pub name: String,
-	pub lookups: Mutex<u64>,
-
-	pub hidden: AtomicBool,
-	pub whiteout: AtomicBool,
-	pub loaded: AtomicBool,
-
-	// what about data source related data for each inode
-	// put it into layer struct, ino -> private data hash
+pub(crate) struct OverlayInode {
+    // Inode hash table, map from 'name' to 'OverlayInode'.
+    pub childrens: Mutex<HashMap<String, Arc<OverlayInode>>>,
+    pub parent: Mutex<Weak<OverlayInode>>,
+    // Backend inodes from all layers.
+    pub real_inodes: Mutex<Vec<RealInode>>,
+    // Inode number.
+    pub inode: u64,
+    pub path: String,
+    pub name: String,
+    pub lookups: AtomicU64,
+    // Node is whiteout-ed.
+    pub whiteout: AtomicBool,
+    // Directory is loaded.
+    pub loaded: AtomicBool,
 }
 
+#[derive(Default)]
 pub enum CachePolicy {
-	Never,
-	Auto,
-	Always,
+    Never,
+    #[default]
+    Auto,
+    Always,
 }
-
 pub struct OverlayFs {
-	// should be in daemon structure
-	pub config: Config,
-	pub layers: LinkedList<Arc<BoxedLayer>>,
-	pub upper_layer: Option<Arc<BoxedLayer>>,
-	// inode management..
-	pub root: Option<Arc<OverlayInode>>,
-	pub inodes: Mutex<HashMap<u64, Arc<OverlayInode>>>, 
-	pub next_inode: AtomicU64,
-
-	// manage opened fds..
-	pub handles: Mutex<HashMap<u64, HandleData>>,
-	pub next_handle: AtomicU64,
-	pub writeback: AtomicBool,
-	pub no_open: AtomicBool,
-	pub no_opendir: AtomicBool,
-	pub killpriv_v2: AtomicBool,
-	pub perfile_dax: AtomicBool,
+    config: Config,
+    lower_layers: Vec<Arc<BoxedLayer>>,
+    upper_layer: Option<Arc<BoxedLayer>>,
+    // All inodes in FS.
+    inodes: RwLock<InodeStore>,
+    // Open file handles.
+    handles: Mutex<HashMap<u64, Arc<HandleData>>>,
+    next_handle: AtomicU64,
+    writeback: AtomicBool,
+    no_open: AtomicBool,
+    no_opendir: AtomicBool,
+    killpriv_v2: AtomicBool,
+    perfile_dax: AtomicBool,
 }
 
-pub struct RealHandle {
-	pub real_inode: Arc<RealInode>,
-	pub handle: AtomicU64,
-	pub invalid: AtomicBool,
+struct RealHandle {
+    layer: Arc<BoxedLayer>,
+    in_upper_layer: bool,
+    inode: u64,
+    handle: AtomicU64,
 }
 
-pub struct HandleData {
-	pub node: Arc<OverlayInode>,
-	pub childrens: Option<Vec<Arc<OverlayInode>>>,
-	pub offset: libc::off_t,
-
-	// others?
-	pub real_handle: Option<RealHandle>,
+struct HandleData {
+    node: Arc<OverlayInode>,
+    //offset: libc::off_t,
+    real_handle: Option<RealHandle>,
 }
 
+// RealInode is a wrapper of one inode in specific layer.
+// All layer operations returning Entry should be wrapped in RealInode implementation
+// so that we can increase the refcount(lookup count) of each inode and decrease it after Drop.
+// Important: do not impl 'Copy' trait for it or refcount will be messed up.
 impl RealInode {
-	pub fn stat64_ignore_enoent(&self, ctx: &Context) -> Result<Option<libc::stat64>> {
-		if self.invalid.load(Ordering::Relaxed) {
-			return Ok(None);
-		}
-
-		match self.layer.as_ref().unwrap().getattr(ctx, self.inode.load(Ordering::Relaxed), None) {
-			Ok((v1, _v2)) => {
-				return Ok(Some(v1));
-			},
-
-			Err(e) => {
-				match e.raw_os_error() {
-					Some(raw_error) => {
-						if raw_error != libc::ENOENT && raw_error != libc::ENOTDIR && raw_error != libc::ENAMETOOLONG {
-							return Ok(None);
-						}
-						return Err(e);
-					},
-
-					None => {
-						return Err(e);
-					},
-				}
-			},
-		}
-	}
-
-	// Ok(None) represents noent
-	pub fn lookup_node(&self, ctx: &Context, name: &CStr) -> Result<Option<RealInodeStats>> {
-
-		if self.whiteout.load(Ordering::Relaxed) || self.invalid.load(Ordering::Relaxed) {
-			return Ok(None);
-		}
-
-		let sname = name.to_string_lossy().into_owned().to_owned();
-		if sname.starts_with(WHITEOUT_PREFIX){
-			return Err(Error::from_raw_os_error(libc::EINVAL));
-		}
-
-		let layer = self.layer.as_ref().unwrap();
-
-		let (whiteout, inode, wh_name) = layer.whiteout_exists(ctx, self.inode.load(Ordering::Relaxed), name)?;
-
-		if whiteout {
-			return Ok(Some(RealInodeStats {
-				inode,
-				whiteout,
-				opaque: false,
-				stat: None,
-				wh_name: Some(wh_name),
-				opaque_inode: None,
-			}));
-		}
-
-		if let Some(v) = layer.lookup_ignore_enoent(ctx, self.inode.load(Ordering::Relaxed), sname.as_str())? {
-			// directory?
-			if v.attr.st_mode & libc::S_IFMT != libc::S_IFDIR {
-				return Ok(Some(RealInodeStats {
-					inode: v.inode,
-					whiteout: false,
-					opaque: false,
-					stat: Some(v.attr),
-					wh_name: None,
-					opaque_inode: None,
-				}));
-			}
-
-			let (opaque, opaque_inode) = layer.is_opaque_whiteout(ctx, v.inode)?;
-
-			return Ok(Some(RealInodeStats {
-				inode: v.inode,
-				whiteout: false,
-				opaque,
-				stat: Some(v.attr),
-				wh_name: None,
-				opaque_inode,
-			}));
-		} else {
-			return Ok(None);
-		}
-	}
-}
-
-impl OverlayInode {
-	pub fn stat64(&self, ctx: &Context) -> Result<libc::stat64> {
-		// try upper layer if there is
-		if let Some(ref l) = *self.upper_inode.lock().unwrap() {
-			if let Some(v) = l.stat64_ignore_enoent(ctx)? {
-				return Ok(v);
-			}
-		}
-
-		// try layers in order or just take stst from first layer?
-		for l in &self.lower_inodes {
-			if let Some(v) = l.stat64_ignore_enoent(ctx)? {
-				return Ok(v);
-			}
-		}
-
-		// not in any layer 
-		Err(Error::from_raw_os_error(libc::ENOENT))
-	}
-
-	pub fn count_entries_and_whiteout(&self, ctx: &Context) -> Result<(u64, u64, u64)> {
-		let mut count = 0;
-		let mut whiteouts = 0;
-		let mut opaque = 0;
-
-		let st = self.stat64(ctx)?;
-
-		// must be directory
-		assert!(st.st_mode & libc::S_IFMT == libc::S_IFDIR);
-		if let Some(ref ri) = *self.upper_inode.lock().unwrap() {
-			if ri.opaque.load(Ordering::Relaxed) {
-				opaque = 1;
-			}
-		}
-
-		for (_, child) in self.childrens.lock().unwrap().iter() {
-			if child.whiteout.load(Ordering::Relaxed) {
-				whiteouts += 1;
-			} else {
-				count += 1;
-			}
-		}
-
-		Ok((count, whiteouts, opaque))
-	}
-
-	pub fn open(&self, ctx: &Context, flags: u32, fuse_flags: u32) -> Result<(Arc<BoxedLayer>, Option<Handle>, OpenOptions)> {
-		let ri = Arc::clone(&self.first_inode.lock().unwrap());
-		if let Some(ref l) = ri.layer {
-			let (h, o) = l.open(ctx, ri.inode.load(Ordering::Relaxed), flags, fuse_flags)?;
-			Ok((Arc::clone(l), h, o))
-		} else {
-			Err(Error::new(ErrorKind::Other, "no first layer"))
-		}
-	}
-
-	pub fn in_upper_layer(&self) -> bool {
-		self.upper_inode.lock().unwrap().is_some()
-	}
-
-	pub fn upper_layer_only(&self) -> bool {
-		self.lower_inodes.len() == 0
-	}
+    fn new(
+        layer: Arc<BoxedLayer>,
+        in_upper_layer: bool,
+        inode: u64,
+        whiteout: bool,
+        opaque: bool,
+    ) -> Self {
+        let mut ri = RealInode {
+            layer,
+            in_upper_layer,
+            inode,
+            whiteout,
+            opaque,
+            stat: None,
+        };
+        match ri.stat64_ignore_enoent(&Context::default()) {
+            Ok(v) => {
+                ri.stat = v;
+            }
+            Err(e) => {
+                error!("stat64 failed during RealInode creation: {}", e);
+            }
+        }
+        ri
+    }
+
+    fn stat64(&self, ctx: &Context) -> Result<stat64> {
+        let layer = self.layer.as_ref();
+        if self.inode == 0 {
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        match layer.getattr(ctx, self.inode, None) {
+            Ok((v1, _v2)) => Ok(v1),
+            Err(e) => Err(e),
+        }
+    }
+
+    fn stat64_ignore_enoent(&self, ctx: &Context) -> Result<Option<stat64>> {
+        match self.stat64(ctx) {
+            Ok(v1) => Ok(Some(v1)),
+            Err(e) => match e.raw_os_error() {
+                Some(raw_error) => {
+                    if raw_error != libc::ENOENT || raw_error != libc::ENAMETOOLONG {
+                        return Ok(None);
+                    }
+                    Err(e)
+                }
+                None => Err(e),
+            },
+        }
+    }
+
+    // Do real lookup action in specific layer, this call will increase Entry refcount which must be released later.
+    fn lookup_child_ignore_enoent(&self, ctx: &Context, name: &str) -> Result<Option<Entry>> {
+        let cname = CString::new(name).map_err(|e| Error::new(ErrorKind::InvalidData, e))?;
+        // Real inode must have a layer.
+        let layer = self.layer.as_ref();
+        match layer.lookup(ctx, self.inode, cname.as_c_str()) {
+            Ok(v) => {
+                // Negative entry also indicates missing entry.
+                if v.inode == 0 {
+                    return Ok(None);
+                }
+                Ok(Some(v))
+            }
+            Err(e) => {
+                if let Some(raw_error) = e.raw_os_error() {
+                    if raw_error == libc::ENOENT || raw_error == libc::ENAMETOOLONG {
+                        return Ok(None);
+                    }
+                }
+
+                Err(e)
+            }
+        }
+    }
+
+    // Find child inode in same layer under this directory(Self).
+    // Return None if not found.
+    fn lookup_child(&self, ctx: &Context, name: &str) -> Result<Option<RealInode>> {
+        if self.whiteout {
+            return Ok(None);
+        }
+
+        let layer = self.layer.as_ref();
+
+        // Find child Entry with <name> under directory with inode <self.inode>.
+        match self.lookup_child_ignore_enoent(ctx, name)? {
+            Some(v) => {
+                // The Entry must be forgotten in each layer, which will be done automatically by Drop operation.
+                let (whiteout, opaque) = if utils::is_dir(v.attr) {
+                    (false, layer.is_opaque(ctx, v.inode)?)
+                } else {
+                    (layer.is_whiteout(ctx, v.inode)?, false)
+                };
+
+                Ok(Some(RealInode {
+                    layer: self.layer.clone(),
+                    in_upper_layer: self.in_upper_layer,
+                    inode: v.inode,
+                    whiteout,
+                    opaque,
+                    stat: Some(v.attr),
+                }))
+            }
+            None => Ok(None),
+        }
+    }
+
+    // Read directory entries from specific RealInode, error out if it's not directory.
+    fn readdir(&self, ctx: &Context) -> Result<HashMap<String, RealInode>> {
+        // Deleted inode should not be read.
+        if self.whiteout {
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        let stat = match self.stat {
+            Some(v) => v,
+            None => self.stat64(ctx)?,
+        };
+
+        // Must be directory.
+        if !utils::is_dir(stat) {
+            return Err(Error::from_raw_os_error(libc::ENOTDIR));
+        }
+
+        // Open the directory and load each entry.
+        let opendir_res = self.layer.opendir(ctx, self.inode, libc::O_RDONLY as u32);
+        let handle = match opendir_res {
+            Ok((handle, _)) => match handle {
+                Some(h) => h,
+                _ => 0,
+            },
+            // opendir may not be supported if no_opendir is set, so we can ignore this error.
+            Err(e) => {
+                match e.raw_os_error() {
+                    Some(raw_error) => {
+                        if raw_error == libc::ENOSYS {
+                            // We can still call readdir with inode if opendir is not supported in this layer.
+                            0
+                        } else {
+                            return Err(e);
+                        }
+                    }
+                    None => {
+                        return Err(e);
+                    }
+                }
+            }
+        };
+
+        let mut child_names = vec![];
+        let mut more = true;
+        let mut offset = 0;
+        let bufsize = 1024;
+        while more {
+            more = false;
+            self.layer.readdir(
+                ctx,
+                self.inode,
+                handle,
+                bufsize,
+                offset,
+                &mut |d| -> Result<usize> {
+                    more = true;
+                    offset = d.offset;
+                    let child_name = String::from_utf8_lossy(d.name).into_owned();
+
+                    trace!("entry: {}", child_name.as_str());
+
+                    if child_name.eq(CURRENT_DIR) || child_name.eq(PARENT_DIR) {
+                        return Ok(1);
+                    }
+
+                    child_names.push(child_name);
+
+                    Ok(1)
+                },
+            )?;
+        }
+
+        // Non-zero handle indicates successful 'open', we should 'release' it.
+        if handle > 0 {
+            if let Err(e) = self
+                .layer
+                .releasedir(ctx, self.inode, libc::O_RDONLY as u32, handle)
+            {
+                // ignore ENOSYS
+                match e.raw_os_error() {
+                    Some(raw_error) => {
+                        if raw_error != libc::ENOSYS {
+                            return Err(e);
+                        }
+                    }
+                    None => {
+                        return Err(e);
+                    }
+                }
+            }
+        }
+
+        // Lookup all child and construct "RealInode"s.
+        let mut child_real_inodes = HashMap::new();
+        for name in child_names {
+            if let Some(child) = self.lookup_child(ctx, name.as_str())? {
+                child_real_inodes.insert(name, child);
+            }
+        }
+
+        Ok(child_real_inodes)
+    }
+
+    fn create_whiteout(&self, ctx: &Context, name: &str) -> Result<RealInode> {
+        if !self.in_upper_layer {
+            return Err(Error::from_raw_os_error(libc::EROFS));
+        }
+
+        let cname = utils::to_cstring(name)?;
+        let entry = self
+            .layer
+            .create_whiteout(ctx, self.inode, cname.as_c_str())?;
+
+        // Wrap whiteout to RealInode.
+        Ok(RealInode {
+            layer: self.layer.clone(),
+            in_upper_layer: true,
+            inode: entry.inode,
+            whiteout: true,
+            opaque: false,
+            stat: Some(entry.attr),
+        })
+    }
+
+    fn mkdir(&self, ctx: &Context, name: &str, mode: u32, umask: u32) -> Result<RealInode> {
+        if !self.in_upper_layer {
+            return Err(Error::from_raw_os_error(libc::EROFS));
+        }
+
+        let cname = utils::to_cstring(name)?;
+        let entry = self
+            .layer
+            .mkdir(ctx, self.inode, cname.as_c_str(), mode, umask)?;
+
+        // update node's first_layer
+        Ok(RealInode {
+            layer: self.layer.clone(),
+            in_upper_layer: true,
+            inode: entry.inode,
+            whiteout: false,
+            opaque: false,
+            stat: Some(entry.attr),
+        })
+    }
+
+    fn create(
+        &self,
+        ctx: &Context,
+        name: &str,
+        args: CreateIn,
+    ) -> Result<(RealInode, Option<u64>)> {
+        if !self.in_upper_layer {
+            return Err(Error::from_raw_os_error(libc::EROFS));
+        }
+
+        let (entry, h, _, _) =
+            self.layer
+                .create(ctx, self.inode, utils::to_cstring(name)?.as_c_str(), args)?;
+
+        Ok((
+            RealInode {
+                layer: self.layer.clone(),
+                in_upper_layer: true,
+                inode: entry.inode,
+                whiteout: false,
+                opaque: false,
+                stat: Some(entry.attr),
+            },
+            h,
+        ))
+    }
+
+    fn mknod(
+        &self,
+        ctx: &Context,
+        name: &str,
+        mode: u32,
+        rdev: u32,
+        umask: u32,
+    ) -> Result<RealInode> {
+        if !self.in_upper_layer {
+            return Err(Error::from_raw_os_error(libc::EROFS));
+        }
+
+        let entry = self.layer.mknod(
+            ctx,
+            self.inode,
+            utils::to_cstring(name)?.as_c_str(),
+            mode,
+            rdev,
+            umask,
+        )?;
+        Ok(RealInode {
+            layer: self.layer.clone(),
+            in_upper_layer: true,
+            inode: entry.inode,
+            whiteout: false,
+            opaque: false,
+            stat: Some(entry.attr),
+        })
+    }
+
+    fn link(&self, ctx: &Context, ino: u64, name: &str) -> Result<RealInode> {
+        if !self.in_upper_layer {
+            return Err(Error::from_raw_os_error(libc::EROFS));
+        }
+
+        let entry = self
+            .layer
+            .link(ctx, ino, self.inode, utils::to_cstring(name)?.as_c_str())?;
+
+        let opaque = if utils::is_dir(entry.attr) {
+            self.layer.is_opaque(ctx, entry.inode)?
+        } else {
+            false
+        };
+        Ok(RealInode {
+            layer: self.layer.clone(),
+            in_upper_layer: true,
+            inode: entry.inode,
+            whiteout: false,
+            opaque,
+            stat: Some(entry.attr),
+        })
+    }
+
+    // Create a symlink in self directory.
+    fn symlink(&self, ctx: &Context, link_name: &str, filename: &str) -> Result<RealInode> {
+        if !self.in_upper_layer {
+            return Err(Error::from_raw_os_error(libc::EROFS));
+        }
+
+        let entry = self.layer.symlink(
+            ctx,
+            utils::to_cstring(link_name)?.as_c_str(),
+            self.inode,
+            utils::to_cstring(filename)?.as_c_str(),
+        )?;
+
+        Ok(RealInode {
+            layer: self.layer.clone(),
+            in_upper_layer: self.in_upper_layer,
+            inode: entry.inode,
+            whiteout: false,
+            opaque: false,
+            stat: Some(entry.attr),
+        })
+    }
 }
 
-fn process_lower_layer(manager: &PluginManager, opaque: &[String]) -> Result<LinkedList<Arc<BoxedLayer>>> {
-	let mut layers = LinkedList::new();
-
-	for lower in opaque {
-		let mut lower_layers = plugin::process_onelayer(manager, lower.into(), false)?;
-		layers.append(&mut lower_layers);
-	}
-
-	Ok(layers)
+impl Drop for RealInode {
+    fn drop(&mut self) {
+        // Release refcount of inode in layer.
+        let ctx = Context::default();
+        let layer = self.layer.as_ref();
+        let inode = self.inode;
+        debug!("forget inode {} by 1 for backend inode in layer ", inode);
+        layer.forget(&ctx, inode, 1);
+    }
 }
 
 impl OverlayInode {
-	pub fn new() -> Self {
-		OverlayInode::default()
-	}
+    pub fn new() -> Self {
+        OverlayInode::default()
+    }
+
+    // Allocate new OverlayInode based on one RealInode,
+    // inode number is always 0 since only OverlayFs has global unique inode allocator.
+    pub fn new_from_real_inode(name: &str, ino: u64, path: String, real_inode: RealInode) -> Self {
+        let mut new = OverlayInode::new();
+        new.inode = ino;
+        new.path = path.clone();
+        new.name = name.to_string();
+        new.whiteout.store(real_inode.whiteout, Ordering::Relaxed);
+        new.lookups = AtomicU64::new(1);
+        new.real_inodes = Mutex::new(vec![real_inode]);
+        new
+    }
+
+    pub fn new_from_real_inodes(
+        name: &str,
+        ino: u64,
+        path: String,
+        real_inodes: Vec<RealInode>,
+    ) -> Result<Self> {
+        if real_inodes.is_empty() {
+            error!("BUG: new_from_real_inodes() called with empty real_inodes");
+            return Err(Error::from_raw_os_error(libc::EINVAL));
+        }
+
+        let mut first = true;
+        let mut new = Self::new();
+        for ri in real_inodes {
+            let whiteout = ri.whiteout;
+            let opaque = ri.opaque;
+            let stat = match ri.stat {
+                Some(v) => v,
+                None => ri.stat64(&Context::default())?,
+            };
+
+            if first {
+                first = false;
+                new = Self::new_from_real_inode(name, ino, path.clone(), ri);
+
+                // This is whiteout, no need to check lower layers.
+                if whiteout {
+                    break;
+                }
+
+                // A non-directory file shadows all lower layers as default.
+                if !utils::is_dir(stat) {
+                    break;
+                }
+
+                // Opaque directory shadows all lower layers.
+                if opaque {
+                    break;
+                }
+            } else {
+                // This is whiteout, no need to record this, break directly.
+                if ri.whiteout {
+                    break;
+                }
+
+                // Only directory have multiple real inodes, so if this is non-first real-inode
+                // and it's not directory, it should indicates some invalid layout. @weizhang555
+                if !utils::is_dir(stat) {
+                    error!("invalid layout: non-directory has multiple real inodes");
+                    break;
+                }
+
+                // Valid directory.
+                new.real_inodes.lock().unwrap().push(ri);
+                // Opaque directory shadows all lower layers.
+                if opaque {
+                    break;
+                }
+            }
+        }
+        Ok(new)
+    }
+
+    pub fn stat64(&self, ctx: &Context) -> Result<stat64> {
+        // try layers in order or just take stat from first layer?
+        for l in self.real_inodes.lock().unwrap().iter() {
+            if let Some(v) = l.stat64_ignore_enoent(ctx)? {
+                return Ok(v);
+            }
+        }
+
+        // not in any layer
+        Err(Error::from_raw_os_error(libc::ENOENT))
+    }
+
+    pub fn count_entries_and_whiteout(&self, ctx: &Context) -> Result<(u64, u64)> {
+        let mut count = 0;
+        let mut whiteouts = 0;
+
+        let st = self.stat64(ctx)?;
+
+        // must be directory
+        if !utils::is_dir(st) {
+            return Err(Error::from_raw_os_error(libc::ENOTDIR));
+        }
+
+        for (_, child) in self.childrens.lock().unwrap().iter() {
+            if child.whiteout.load(Ordering::Relaxed) {
+                whiteouts += 1;
+            } else {
+                count += 1;
+            }
+        }
+
+        Ok((count, whiteouts))
+    }
+
+    pub fn open(
+        &self,
+        ctx: &Context,
+        flags: u32,
+        fuse_flags: u32,
+    ) -> Result<(Arc<BoxedLayer>, Option<Handle>, OpenOptions)> {
+        let (layer, _, inode) = self.first_layer_inode();
+        let (h, o, _) = layer.as_ref().open(ctx, inode, flags, fuse_flags)?;
+        Ok((layer, h, o))
+    }
+
+    // Self is directory, fill all childrens.
+    pub fn scan_childrens(self: &Arc<Self>, ctx: &Context) -> Result<Vec<OverlayInode>> {
+        let st = self.stat64(ctx)?;
+        if !utils::is_dir(st) {
+            return Err(Error::from_raw_os_error(libc::ENOTDIR));
+        }
+
+        let mut all_layer_inodes: HashMap<String, Vec<RealInode>> = HashMap::new();
+        // read out directories from each layer
+        let mut counter = 1;
+        let layers_count = self.real_inodes.lock().unwrap().len();
+        // Scan from upper layer to lower layer.
+        for ri in self.real_inodes.lock().unwrap().iter() {
+            debug!(
+                "loading Layer {}/{} for dir '{}', is_upper_layer: {}",
+                counter,
+                layers_count,
+                self.path.as_str(),
+                ri.in_upper_layer
+            );
+            counter += 1;
+            if ri.whiteout {
+                // Node is deleted from some upper layer, skip it.
+                debug!("directory is whiteout");
+                break;
+            }
+
+            let stat = match ri.stat {
+                Some(v) => v,
+                None => ri.stat64(ctx)?,
+            };
+
+            if !utils::is_dir(stat) {
+                debug!("{} is not a directory", self.path.as_str());
+                // not directory
+                break;
+            }
+
+            // Read all entries from one layer.
+            let entries = ri.readdir(ctx)?;
+
+            // Merge entries from one layer to all_layer_inodes.
+            for (name, inode) in entries {
+                match all_layer_inodes.get_mut(&name) {
+                    Some(v) => {
+                        // Append additional RealInode to the end of vector.
+                        v.push(inode)
+                    }
+                    None => {
+                        all_layer_inodes.insert(name, vec![inode]);
+                    }
+                };
+            }
+
+            // if opaque, stop here
+            if ri.opaque {
+                debug!("directory {} is opaque", self.path.as_str());
+                break;
+            }
+        }
+
+        // Construct OverlayInode for each entry.
+        let mut childrens = vec![];
+        for (name, real_inodes) in all_layer_inodes {
+            // Inode numbers are not allocated yet.
+            let path = format!("{}/{}", self.path, name);
+            let new = Self::new_from_real_inodes(name.as_str(), 0, path, real_inodes)?;
+            childrens.push(new);
+        }
+
+        Ok(childrens)
+    }
+
+    // Create a new directory in upper layer for node, node must be directory.
+    pub fn create_upper_dir(
+        self: &Arc<Self>,
+        ctx: &Context,
+        mode_umask: Option<(u32, u32)>,
+    ) -> Result<()> {
+        let st = self.stat64(ctx)?;
+        if !utils::is_dir(st) {
+            return Err(Error::from_raw_os_error(libc::ENOTDIR));
+        }
+
+        // If node already has upper layer, we can just return here.
+        if self.in_upper_layer() {
+            return Ok(());
+        }
+
+        // not in upper layer, check parent.
+        let pnode = if let Some(n) = self.parent.lock().unwrap().upgrade() {
+            Arc::clone(&n)
+        } else {
+            return Err(Error::new(ErrorKind::Other, "no parent?"));
+        };
+
+        if !pnode.in_upper_layer() {
+            pnode.create_upper_dir(ctx, None)?; // recursive call
+        }
+        let mut child = None;
+        pnode.handle_upper_inode_locked(&mut |parent_upper_inode| -> Result<bool> {
+            match parent_upper_inode {
+                Some(parent_ri) => {
+                    let ri = match mode_umask {
+                        Some((mode, umask)) => {
+                            parent_ri.mkdir(ctx, self.name.as_str(), mode, umask)?
+                        }
+                        None => parent_ri.mkdir(ctx, self.name.as_str(), st.st_mode, 0)?,
+                    };
+                    // create directory here
+                    child.replace(ri);
+                }
+                None => {
+                    error!(
+                        "BUG: parent {} has no upper inode after create_upper_dir",
+                        pnode.inode
+                    );
+                    return Err(Error::from_raw_os_error(libc::EINVAL));
+                }
+            }
+            Ok(false)
+        })?;
+
+        if let Some(ri) = child {
+            // Push the new real inode to the front of vector.
+            self.add_upper_inode(ri, false);
+        }
+
+        Ok(())
+    }
+
+    // Add new upper RealInode to OverlayInode, clear all lower RealInodes if 'clear_lowers' is true.
+    fn add_upper_inode(self: &Arc<Self>, ri: RealInode, clear_lowers: bool) {
+        let mut inodes = self.real_inodes.lock().unwrap();
+        // Update self according to upper attribute.
+        self.whiteout.store(ri.whiteout, Ordering::Relaxed);
+
+        // Push the new real inode to the front of vector.
+        let mut new = vec![ri];
+        // Drain lower RealInodes.
+        let lowers = inodes.drain(..).collect::<Vec<RealInode>>();
+        if !clear_lowers {
+            // If not clear lowers, append them to the end of vector.
+            new.extend(lowers);
+        }
+        inodes.extend(new);
+    }
+
+    pub fn in_upper_layer(&self) -> bool {
+        let all_inodes = self.real_inodes.lock().unwrap();
+        let first = all_inodes.first();
+        match first {
+            Some(v) => v.in_upper_layer,
+            None => false,
+        }
+    }
+
+    pub fn upper_layer_only(&self) -> bool {
+        let real_inodes = self.real_inodes.lock().unwrap();
+        let first = real_inodes.first();
+        match first {
+            Some(v) => {
+                if !v.in_upper_layer {
+                    false
+                } else {
+                    real_inodes.len() == 1
+                }
+            }
+            None => false,
+        }
+    }
+
+    pub fn first_layer_inode(&self) -> (Arc<BoxedLayer>, bool, u64) {
+        let all_inodes = self.real_inodes.lock().unwrap();
+        let first = all_inodes.first();
+        match first {
+            Some(v) => (v.layer.clone(), v.in_upper_layer, v.inode),
+            None => panic!("BUG: dangling OverlayInode"),
+        }
+    }
+
+    pub fn child(&self, name: &str) -> Option<Arc<OverlayInode>> {
+        self.childrens.lock().unwrap().get(name).cloned()
+    }
+
+    pub fn remove_child(&self, name: &str) {
+        self.childrens.lock().unwrap().remove(name);
+    }
+
+    pub fn insert_child(&self, name: &str, node: Arc<OverlayInode>) {
+        self.childrens
+            .lock()
+            .unwrap()
+            .insert(name.to_string(), node);
+    }
+
+    pub fn handle_upper_inode_locked(
+        &self,
+        f: &mut dyn FnMut(Option<&RealInode>) -> Result<bool>,
+    ) -> Result<bool> {
+        let all_inodes = self.real_inodes.lock().unwrap();
+        let first = all_inodes.first();
+        match first {
+            Some(v) => {
+                if v.in_upper_layer {
+                    f(Some(v))
+                } else {
+                    f(None)
+                }
+            }
+            None => Err(Error::new(
+                ErrorKind::Other,
+                format!(
+                    "BUG: dangling OverlayInode {} without any backend inode",
+                    self.inode
+                ),
+            )),
+        }
+    }
 }
 
 fn entry_type_from_mode(mode: libc::mode_t) -> u8 {
-	if mode & libc::S_IFBLK  != 0 {
-		return libc::DT_BLK;
-	}
-
-	if mode & libc::S_IFCHR != 0 {
-		return libc::DT_CHR;
-	}
-
-	if mode & libc::S_IFDIR != 0 {
-		return libc::DT_DIR;
-	}
-
-	if mode & libc::S_IFIFO != 0 {
-		return libc::DT_FIFO;
-	}
-
-	if mode & libc::S_IFLNK != 0 {
-		return libc::DT_LNK;
-	}
-
-	if mode & libc::S_IFREG != 0 {
-		return libc::DT_REG;
-	}
-
-	if mode & libc::S_IFSOCK != 0 {
-		return libc::DT_SOCK;
-	}
-
-	return libc::DT_UNKNOWN;
+    match mode & libc::S_IFMT {
+        libc::S_IFBLK => libc::DT_BLK,
+        libc::S_IFCHR => libc::DT_CHR,
+        libc::S_IFDIR => libc::DT_DIR,
+        libc::S_IFIFO => libc::DT_FIFO,
+        libc::S_IFLNK => libc::DT_LNK,
+        libc::S_IFREG => libc::DT_REG,
+        libc::S_IFSOCK => libc::DT_SOCK,
+        _ => libc::DT_UNKNOWN,
+    }
 }
 
 impl OverlayFs {
-	pub fn new(manager: &PluginManager, params: Config) -> Result<Self> {
-		// upper dir 
-		let mut layers = plugin::process_onelayer(manager, String::from(params.upper.as_str()), true)?;
-
-		let upper_layer = if let Some(ref v) = layers.front() {
-			Some(Arc::clone(v))
-		}else {
-			None
-		};
-
-		// lower dir
-		let mut lower_layers = process_lower_layer(manager, params.lower.as_slice())?;
-
-		layers.append(&mut lower_layers);
-		// load root inode
-		Ok(OverlayFs {
-				config: params,
-				upper_layer,
-				layers,
-				inodes: Mutex::new(HashMap::new()),
-				root: None,
-				next_inode: AtomicU64::new(FUSE_ROOT_ID + 1),
-				handles: Mutex::new(HashMap::new()),
-				next_handle: AtomicU64::new(1),
-				writeback: AtomicBool::new(false),
-				no_open: AtomicBool::new(false),
-				no_opendir: AtomicBool::new(false),
-				killpriv_v2: AtomicBool::new(false),
-				perfile_dax: AtomicBool::new(false),
-			})
-	}
-
-	pub fn init_root(&mut self) -> Result<()> {
-		let mut root = OverlayInode::new();
-		root.inode = FUSE_ROOT_ID;
-		root.path = String::from(".");
-		root.name = String::from("");
-		root.entry_type = libc::DT_DIR as u32;
-		root.lookups = Mutex::new(2);
-		let ctx = Context::default();
-
-		let mut first= true;
-		for layer in self.layers.iter() {
-			let (opaque, _ino) = layer.is_opaque_whiteout(&ctx, FUSE_ROOT_ID)?;
-			let real = RealInode {
-				layer: Some(Arc::clone(layer)),
-				inode: AtomicU64::new(FUSE_ROOT_ID),
-				whiteout: AtomicBool::new(false),
-				opaque: AtomicBool::new(opaque),
-				hidden: AtomicBool::new(false),
-				invalid: AtomicBool::new(false),
-			};
-
-			let real_inode = Arc::new(real);
-
-			if first {
-				first = false;
-				root.first_inode = Mutex::new(Arc::clone(&real_inode));
-			}
-
-			if layer.is_upper() {
-				root.upper_inode = Mutex::new(Some(Arc::clone(&real_inode)));
-			} else {
-				root.lower_inodes.push(Arc::clone(&real_inode));
-			}
-
-			root.last_inode = Mutex::new(Arc::clone(&real_inode));
-		}
-
-		let root_node = Arc::new(root);
-
-		// insert root inode into hash
-		{
-			self.inodes.lock().unwrap().insert(FUSE_ROOT_ID, Arc::clone(&root_node));
-		}
-
-		let ctx = Context::default();
-		info!("loading root directory\n");
-		self.load_directory(&ctx, Arc::clone(&root_node))?;
-
-		self.root = Some(root_node);
-
-		Ok(())
-	}
-
-	pub fn import(&self) -> Result<()> {
-		Ok(())
-	}
-
-	pub fn make_overlay_inode(&self, ris: &RealInodeStats, layer: Arc<BoxedLayer>) -> Result<OverlayInode> {
-		let mut new = OverlayInode::new();
-		new.whiteout.store(ris.whiteout, Ordering::Relaxed);
-		let real_inode = Arc::new(RealInode {
-			layer: Some(Arc::clone(&layer)),
-			inode: AtomicU64::new(ris.inode),
-			whiteout: AtomicBool::new(ris.whiteout),
-			opaque: AtomicBool::new(ris.opaque),
-			hidden: AtomicBool::new(false),
-			invalid: AtomicBool::new(false),
-		});
-
-		new.first_inode = Mutex::new(Arc::clone(&real_inode));
-		new.last_inode = Mutex::new(Arc::clone(&real_inode));
-		new.lookups = Mutex::new(1);
-		if layer.is_upper() {
-			new.upper_inode = Mutex::new(Some(Arc::clone(&real_inode)));
-		}
-
-		let inode = self.next_inode.fetch_add(1, Ordering::Relaxed);
-		if inode > VFS_MAX_INO {
-			error!("reached maximum inode number: {}", VFS_MAX_INO);
-			return Err(Error::new(ErrorKind::Other, format!("maximum inode number {} reached", VFS_MAX_INO)));
-		}
-		new.inode = inode;
-		if let Some(st) = ris.stat {
-			new.st_ino = st.st_ino;
-			new.st_dev= st.st_dev;
-			new.mode = st.st_mode;
-			new.entry_type = entry_type_from_mode(st.st_mode) as u32;
-		}
-
-		Ok(new)
-	}
-
-	pub fn lookup_node(&self, ctx: &Context, parent: Inode, name: &CStr) -> Result<Arc<OverlayInode>> {
-		if name.to_bytes_with_nul().contains(&SLASH_ASCII) {
-			return Err(Error::from_raw_os_error(libc::EINVAL));
-		}
-
-		// lookup name
-		let pnode = {
-			let inodes = self.inodes.lock().unwrap();
-			if let Some(v) = inodes.get(&parent) {
-				Arc::clone(v)
-			} else {
-				// no parent inode?
-				return Err(Error::from_raw_os_error(libc::EINVAL));
-			}
-		};
-
-		let sname = name.to_string_lossy().into_owned().to_owned();
-		if sname.starts_with(WHITEOUT_PREFIX){
-			return Err(Error::from_raw_os_error(libc::EINVAL));
-		}
-
-		if sname.eq(".") || (parent == FUSE_ROOT_ID && sname.eq("..")) || sname.is_empty() {
-			return Ok(Arc::clone(&pnode));
-		}
-
-		if pnode.whiteout.load(Ordering::Relaxed) {
-			return Err(Error::from_raw_os_error(libc::ENOENT));
-		}
-
-		// found the node
-		if let Some (v) = pnode.childrens.lock().unwrap().get(sname.as_str()) {
-			return Ok(Arc::clone(v));
-		}
-
-		// if the directory is already loaded, not found
-		// we will change dir/file, we will toggle loaded
-		// flag to scan directory
-		if pnode.loaded.load(Ordering::Relaxed) {
-			return Err(Error::from_raw_os_error(libc::ENOENT));
-		}
-
-		// don't find it, lookup in layers
-		let mut path = String::from(pnode.path.as_str());
-		path.push_str("/");
-		path.push_str(sname.as_str());
-
-		let mut node_inited: bool = false;
-		let mut new = OverlayInode::new();
-
-		// lookup until meet whiteout/opaque whiteout/file in lower layer..
-		{
-			if let Some(ref ri) = *pnode.upper_inode.lock().unwrap() {
-				// find an entry
-				if let Some(ris) = ri.lookup_node(ctx, name)? {
-					node_inited = true;
-					new = self.make_overlay_inode(&ris, Arc::clone(ri.layer.as_ref().unwrap()))?;
-				}
-			}
-		}
-
-		'layer_loop:
-		for ri in &pnode.lower_inodes {
-			if let Some(ris) = ri.lookup_node(ctx, name)? {
-				// find an entry
-				let layer = Arc::clone(ri.layer.as_ref().unwrap());
-				let mut real_inode = Arc::new(RealInode {
-					layer: Some(Arc::clone(&layer)),
-					inode: AtomicU64::new(ris.inode),
-					whiteout: AtomicBool::new(ris.whiteout),
-					hidden: AtomicBool::new(false),
-					opaque: AtomicBool::new(ris.opaque),
-					invalid: AtomicBool::new(false),
-				});
-
-				if !node_inited {
-					node_inited = true;
-					new = self.make_overlay_inode(&ris, Arc::clone(&layer))?;
-					new.lower_inodes.push(Arc::clone(&real_inode));
-
-					// should stop?
-					if ris.whiteout {
-						break 'layer_loop;
-					}
-
-					// not whiteout, must have stat
-					let st = ris.stat.as_ref().unwrap();
-					if st.st_mode & libc::S_IFMT != libc::S_IFDIR {
-						break 'layer_loop;
-					}
-
-					// opaque?
-					if ris.opaque {
-						break 'layer_loop;
-					}
-				} else {
-
-					// should stop?
-					if ris.whiteout {
-						break 'layer_loop;
-					}
-
-					// not whiteout, must have stat
-					let st = ris.stat.as_ref().unwrap();
-					if st.st_mode & libc::S_IFMT != libc::S_IFDIR {
-						break 'layer_loop;
-					}
-
-					// directory
-					if node_inited {
-						new.lower_inodes.push(Arc::clone(&real_inode));
-						new.last_inode = Mutex::new(Arc::clone(&real_inode));
-					}
-
-					// opaque?
-					if ris.opaque {
-						break 'layer_loop;
-					}
-				}
-			}
-		}
-
-		if node_inited {
-			new.path = String::from(path.as_str());
-			new.name = String::from(sname.as_str());
-			// set its parent node
-			*new.parent.lock().unwrap() = Arc::downgrade(&pnode);
-			// insert node into hashs
-			let new_node = Arc::new(new);
-			self.inodes.lock().unwrap().insert(new_node.inode as u64, Arc::clone(&new_node));
-			pnode.childrens.lock().unwrap().insert(sname, Arc::clone(&new_node));
-			return Ok(Arc::clone(&new_node));
-		}
-
-		// return specific errors?
-		Err(Error::from_raw_os_error(libc::ENOENT))
-	}
-
-	pub fn lookup_node_ignore_enoent(&self, ctx: &Context, parent: u64, name: &CStr) -> Result<Option<Arc<OverlayInode>>> {
-		match self.lookup_node(ctx, parent, name) {
-			Ok(n) => {
-				return Ok(Some(Arc::clone(&n)));
-			},
-
-			Err(e) => {
-				if let Some(raw_error) = e.raw_os_error() {
-					if raw_error == libc::ENOENT {
-						return Ok(None);
-					}
-				}
-				return Err(e);
-			},
-		}
-		
-	}
-
-	pub fn get_node_from_inode(&self, inode: u64) -> Option<Arc<OverlayInode>> {
-		if let Some(v) = self.inodes.lock().unwrap().get(&inode) {
-			return Some(Arc::clone(v));
-		}
-
-		return None;
-	}
-
-	pub fn load_directory_layer(&self, ctx: &Context, ovl_inode: u64, real: Arc<RealInode>) -> Result<()> {
-		if real.whiteout.load(Ordering::Relaxed) || real.invalid.load(Ordering::Relaxed) {
-			return Err(Error::from_raw_os_error(libc::ENOENT));
-		}
-
-		if let Some(st) = real.stat64_ignore_enoent(ctx)? {
-			if st.st_mode & libc::S_IFMT != libc::S_IFDIR {
-				return Err(Error::from_raw_os_error(libc::ENOTDIR));
-			}
-
-			// process this directory
-			let l = Arc::clone(real.layer.as_ref().unwrap());
-			let rinode = real.inode.load(Ordering::Relaxed);
-
-			let handle = if let (Some(h), _) = l.opendir(ctx, rinode, libc::O_RDONLY as u32)? {
-				h
-			} else {
-				return Err(Error::new(ErrorKind::Other, "no dir handle"));
-			};
-
-			let mut more = true;
-			let mut offset = 0;
-			let bufsize = 1024;
-			while more {
-				more = false;
-				l.readdir(ctx, rinode, handle, bufsize, offset, &mut |d| -> Result<usize> {
-					more = true;
-					offset = d.offset;
-					let cname = unsafe { CString::from_vec_unchecked(d.name.to_vec()) };
-					let cstr_name = cname.as_c_str();
-
-					let child_name = cstr_name.to_string_lossy().into_owned().to_owned();
-
-					info!("entry: {}", child_name.as_str());
-
-					if child_name.eq(CURRENT_DIR) || child_name.eq(PARENT_DIR) || child_name.starts_with(WHITEOUT_PREFIX) {
-						return Ok(1);
-					}
-
-					self.lookup_node(ctx, ovl_inode, cstr_name)?;
-
-					Ok(1)
-				})?;
-			}
-
-			l.releasedir(ctx, rinode, libc::O_RDONLY as u32, handle)?;
-
-		} else {
-			return Err(Error::from_raw_os_error(libc::ENOENT));
-		}
-
-		Ok(())
-	}
-
-	pub fn load_directory(&self, ctx: &Context, node: Arc<OverlayInode>) -> Result<()> {
-		let tmp_ui = {
-			if let Some(ref v) = *node.upper_inode.lock().unwrap() {
-				Some(Arc::clone(v))
-			} else {
-				None
-			}
-		};
-
-		if let Some(ref ui) = tmp_ui {
-			debug!("load upper for {}", node.path.as_str());
-			// upper layer
-			if ui.whiteout.load(Ordering::Relaxed) || ui.invalid.load(Ordering::Relaxed) {
-				return Ok(());
-			}
-
-			if let Some(st) = ui.stat64_ignore_enoent(ctx)? {
-				if st.st_mode & libc::S_IFMT != libc::S_IFDIR {
-					// not directory
-					return Ok(());
-				}
-			
-				// process this layer
-				self.load_directory_layer(ctx, node.inode, Arc::clone(ui))?;
-			}
-
-			// if opaque, stop here
-			if ui.opaque.load(Ordering::Relaxed) {
-				node.loaded.store(true, Ordering::Relaxed);
-				return Ok(());
-			}
-		}
-
-		// read out directories from each layer
-		'layer_loop:
-		for li in &node.lower_inodes {
-			debug!("loading lower for {}", node.path.as_str());
-			if li.whiteout.load(Ordering::Relaxed) || li.invalid.load(Ordering::Relaxed) {
-				break 'layer_loop;
-			}
-
-			if let Some(st) = li.stat64_ignore_enoent(ctx)? {
-				if st.st_mode & libc::S_IFMT != libc::S_IFDIR {
-					// not directory
-					break 'layer_loop;
-				}
-			
-				// process this layer
-				self.load_directory_layer(ctx, node.inode, Arc::clone(li))?;
-			}
-
-			// if opaque, stop here
-			if li.opaque.load(Ordering::Relaxed) {
-				break 'layer_loop;
-			}
-		}
-
-		node.loaded.store(true, Ordering::Relaxed);
-
-		Ok(())
-	}
-
-	pub fn reload_directory(&self, ctx: &Context, node: Arc<OverlayInode>) -> Result<()> {
-		if node.loaded.load(Ordering::Relaxed) {
-			return Ok(())
-		}
-		{
-			let mut children =node.childrens.lock().unwrap();
-			*children = HashMap::new();
-		}
-
-		self.load_directory(ctx, node)
-	}
-
-	pub fn get_first_layer(&self) -> Option<Arc<BoxedLayer>> {
-		if let Some(v) = self.layers.front() {
-			Some(Arc::clone(v))
-		} else {
-			None
-		}
-	}
-
-	pub fn get_upper_layer(&self) -> Option<Arc<BoxedLayer>> {
-		if let Some(ref v) = self.upper_layer.as_ref() {
-			Some(Arc::clone(v))
-		} else {
-			None
-		}
-	}
-
-	pub fn get_first_lower_layer(&self) -> Option<Arc<BoxedLayer>> {
-		if let Some(ref _v) = self.upper_layer.as_ref() {
-			let mut index = 0;
-			for layer in self.layers.iter() {
-				if index == 1 {
-					return Some(Arc::clone(layer));
-				}
-				index += 1;
-			}
-
-			None
-		} else {
-			if let Some(v) = self.layers.front() {
-				Some(Arc::clone(v))
-			} else {
-				None
-			}
-		}
-	}
-
-	pub fn forget_one(&self, inode: Inode, count: u64) {
-		if inode == FUSE_ROOT_ID || inode == 0 {
-			return;
-		}
-
-		let v =  {
-			if let Some(n) = self.inodes.lock().unwrap().get(&inode) {
-				Arc::clone(n)
-			} else {
-				return;
-			}
-		};
-		// lock up lookups
-		let mut lookups = v.lookups.lock().unwrap();
-
-		if *lookups < count {
-			*lookups = 0;
-		} else {
-			*lookups -= count;
-		}
-
-		// remove it from hashmap
-
-		if *lookups == 0 {
-			self.inodes.lock().unwrap().remove(&inode);
-			let parent = v.parent.lock().unwrap();
-
-			if let Some(p) = parent.upgrade() {
-				p.childrens.lock().unwrap().remove(v.name.as_str());
-				p.loaded.store(true, Ordering::Relaxed);
-			}
-		}
-
-		// FIXME: is it possible that the inode still in childrens map?
-	}
-	
-	pub fn do_statvfs(&self, ctx: &Context, inode: Inode) -> Result<libc::statvfs64> {
-		if let Some(v) = self.get_first_layer() {
-			if let Ok(sfs) = v.statfs(ctx, inode) {
-				return Ok(sfs);
-			}
-		}
-
-		// otherwise stat on mountpoint
-		let mut sfs = MaybeUninit::<libc::statvfs64>::zeroed();
-		let cpath = CString::new(self.config.mountpoint.as_str()).expect("invalid path");
-		let path = cpath.as_c_str().as_ptr();
-
-		match unsafe { libc::statvfs64(path, sfs.as_mut_ptr()) } {
-			0 => {
-				let mut sfs = unsafe { sfs.assume_init() };
-				sfs.f_namemax -= WHITEOUT_MAX_LEN;
-
-				Ok(sfs)
-			},
-
-			_ => {
-				Err(Error::last_os_error())
-			},
-		}
-	}
-
-	pub fn get_fs_namemax(&self, ctx: &Context) -> u64 {
-		match self.do_statvfs(ctx, FUSE_ROOT_ID) {
-			Ok(sfs) => sfs.f_namemax,
-			Err(_) => 255 - WHITEOUT_MAX_LEN,
-		}
-	}
-
-	pub fn do_readdir(&self, ctx: &Context, handle: u64, size: u32, offset: u64, add_entry: &mut dyn FnMut(DirEntry, Entry) -> Result<usize>) -> Result<()> {
-		if size == 0 {
-			return Ok(());
-		}
-
-		// FIXME: if offset == 0, need to reconstruct dir for this handle
-		// if offset == 0 {
-		// reconstruct directory
-		// }
-
-		// lookup the directory
-		if let Some(dir) = self.handles.lock().unwrap().get(&handle) {
-			let mut len: usize = 0;
-			debug!("overlay dir: {}, off: {}, size: {}", dir.node.path.as_str(), offset, size);
-
-			let childrens = 
-			if let Some(ref cs) = dir.childrens {
-				cs
-			} else {
-				return Err(Error::new(ErrorKind::Other, "no child!"));
-			};
-
-			if offset >= childrens.len() as u64 {
-				return Ok(());
-			}
-
-			let mut index: u64 = 0;
-			for child in childrens {
-				if index >= offset {
-					let name = match index {
-						0 => ".",
-						1 => "..",
-						_ => child.name.as_str(),
-					};
-
-					// make struct DireEntry and Entry
-					let st = child.stat64(ctx)?;
-					let dir_entry = DirEntry {
-						ino: st.st_ino,
-						offset: index + 1,
-						type_: entry_type_from_mode(st.st_mode) as u32,
-						name: name.as_bytes(),
-					};
-
-					let entry = Entry {
-						inode: child.inode,
-						generation: 0,
-						attr: st,
-						attr_flags: 0,
-						attr_timeout: self.config.attr_timeout,
-						entry_timeout: self.config.entry_timeout,
-					};
-
-					match add_entry(dir_entry, entry) {
-						Ok(0) => break,
-						Ok(l) => {
-							len += l;
-							if len as u32 >= size {
-								// no more space, stop here
-								return Ok(());
-							}
-						},
-
-						Err(e) => {
-							// when the buffer is still empty, return error, otherwise return the entry already added
-							if len == 0 {
-								return Err(e);
-							} else {
-								return Ok(());
-							}
-						},
-					}
-				}
-
-				index += 1;
-			}
-		}
-
-		Ok(())
-	}
-
-	pub fn node_in_upper_layer(&self, node: Arc<OverlayInode>) -> Result<bool> {
-		Ok(node.in_upper_layer())
-	}
-
-	pub fn create_node_directory(&self, ctx: &Context, node: Arc<OverlayInode>) -> Result<()> {
-		// recursively going up and update hashmaps
-		if self.node_in_upper_layer(Arc::clone(&node))? {
-			return Ok(());
-		}
-
-		// not in upper layer, check parent
-		let pnode = if let Some(n) = node.parent.lock().unwrap().upgrade() {
-			Arc::clone(&n)
-		} else {
-			return Err(Error::new(ErrorKind::Other, "no parent?"));
-		};
-
-		if self.node_in_upper_layer(Arc::clone(&pnode))? {
-			// create directory here
-			let upper = Arc::clone(pnode.upper_inode.lock().unwrap().as_ref().unwrap());
-			let layer = Arc::clone(upper.layer.as_ref().unwrap());
-			let cname = CString::new(node.name.as_str()).expect("invalid c string");
-			let st = node.stat64(ctx)?;
-			let entry = layer.mkdir(ctx, upper.inode.load(Ordering::Relaxed), cname.as_c_str(), st.st_mode, 0)?;
-
-			// update node's first_layer
-			let real_inode = Arc::new(RealInode {
-				layer: Some(Arc::clone(&layer)),
-				inode: AtomicU64::new(entry.inode),
-				whiteout: AtomicBool::new(false),
-				opaque: AtomicBool::new(false),
-				hidden: AtomicBool::new(false),
-				invalid: AtomicBool::new(false),
-			});
-
-			// what about st_ino/mode/dev..
-			// FIXME: update st_ino/mode/dev, or query it from layer
-			// on fly?
-			*node.first_inode.lock().unwrap() = Arc::clone(&real_inode);
-			*node.upper_inode.lock().unwrap() = Some(Arc::clone(&real_inode));
-
-			return Ok(());
-
-		} else {
-			return self.create_node_directory(ctx, Arc::clone(&pnode));
-		}
-	}
-
-	pub fn copy_symlink_up(&self, ctx: &Context, node: Arc<OverlayInode>) -> Result<Arc<OverlayInode>> {
-		if self.node_in_upper_layer(Arc::clone(&node))? {
-			return Ok(node);
-		}
-
-		let pnode = if let Some(ref n) = node.parent.lock().unwrap().upgrade() {
-			Arc::clone(n)
-		} else {
-			return Err(Error::new(ErrorKind::Other, "no parent?"));
-		};
-
-		let st = node.stat64(ctx)?;
-
-		let empty_name =CString::new("").expect("invalid c string");
-		let upper = self.get_upper_layer().unwrap();
-		let pnode = self.lookup_node(ctx, pnode.inode, empty_name.as_c_str())?;
-
-		assert!(pnode.in_upper_layer());
-		assert!(st.st_mode & libc::S_IFMT == libc::S_IFLNK);
-		let parent_real_inode = Arc::clone(pnode.upper_inode.lock().unwrap().as_ref().unwrap());
-		let cname = CString::new(node.name.as_str()).expect("invalid c string");
-		let node = self.lookup_node(ctx, pnode.inode, cname.as_c_str())?;
-		let rinode = Arc::clone(&node.first_inode.lock().unwrap());
-		let layer = Arc::clone(rinode.layer.as_ref().unwrap());
-
-		// symlink
-		// first inode, upper most layer inode
-		let path = layer.readlink(ctx, rinode.inode.load(Ordering::Relaxed))?;
-		let cpath = unsafe { CString::from_vec_unchecked(path) };
-		let entry = upper.symlink(ctx, cpath.as_c_str(), parent_real_inode.inode.load(Ordering::Relaxed), cname.as_c_str())?;
-
-		let real_inode = Arc::new(RealInode {
-			layer: Some(Arc::clone(&upper)),
-			inode: AtomicU64::new(entry.inode),
-			whiteout: AtomicBool::new(false),
-			opaque: AtomicBool::new(false),
-			hidden: AtomicBool::new(false),
-			invalid: AtomicBool::new(false),
-		});
-
-		// update first_inode and upper_inode
-		*node.upper_inode.lock().unwrap() = Some(Arc::clone(&real_inode));
-		*node.first_inode.lock().unwrap() = Arc::clone(&real_inode);
-
-		return Ok(Arc::clone(&node));
-	}
-
-	pub fn copy_regfile_up(&self, ctx: &Context, node: Arc<OverlayInode>) -> Result<Arc<OverlayInode>> {
-		if self.node_in_upper_layer(Arc::clone(&node))? {
-			return Ok(node);
-		}
-
-		let pnode = if let Some(ref n) = node.parent.lock().unwrap().upgrade() {
-			Arc::clone(n)
-		} else {
-			return Err(Error::new(ErrorKind::Other, "no parent?"));
-		};
-
-		let st = node.stat64(ctx)?;
-
-		let empty_name =CString::new("").expect("invalid c string");
-		let upper = self.get_upper_layer().unwrap();
-		let pnode = self.lookup_node(ctx, pnode.inode, empty_name.as_c_str())?;
-
-		assert!(pnode.in_upper_layer());
-		assert!(st.st_mode & libc::S_IFMT != libc::S_IFLNK && st.st_mode & libc::S_IFMT != libc::S_IFDIR);
-
-		let parent_real_inode = Arc::clone(pnode.upper_inode.lock().unwrap().as_ref().unwrap());
-		let cname = CString::new(node.name.as_str()).expect("invalid c string");
-		let node = self.lookup_node(ctx, pnode.inode, cname.as_c_str())?;
-		let rinode = Arc::clone(&node.first_inode.lock().unwrap());
-		let layer = Arc::clone(rinode.layer.as_ref().unwrap());
-
-		// create the file in upper layer using information from lower layer
-
-		let args = CreateIn {
-			flags: 0,
-			mode: st.st_mode,
-			umask: 0,
-			fuse_flags: 0,
-		};
-
-		let (entry, h, o) = upper.create(ctx, parent_real_inode.inode.load(Ordering::Relaxed), cname.as_c_str(), args)?;
-
-		let real_inode = Arc::new(RealInode {
-			layer: Some(Arc::clone(&upper)),
-			inode: AtomicU64::new(entry.inode),
-			whiteout: AtomicBool::new(false),
-			opaque: AtomicBool::new(false),
-			hidden: AtomicBool::new(false),
-			invalid: AtomicBool::new(false),
-		});
-
-		if h.is_none() {
-			error!("no handle!!!");
-			return Err(Error::new(ErrorKind::Other, "non handle!"));
-		}
-
-		let dst_handle = h.unwrap();
-
-		let (h, o) = layer.open(ctx, rinode.inode.load(Ordering::Relaxed), libc::O_RDONLY as u32, 0)?;
-		
-		if h.is_none() {
-			error!("no handle!!!");
-			return Err(Error::new(ErrorKind::Other, "non handle!"));
-		}
-
-		let src_handle = h.unwrap();
-
-		// copy... 
-		// source: layer, rinode.inode, src_handle
-		// dst: upper, real_inode.inode, dst_handle
-
-		// need to impl ZeroCopyReader/ZeroCopyWriter, somehow like a pipe..
-		// stupid: to create a temp file for now..
-		// FIXME: need to copy xattr, futimes, set origin.TODO
-
-		let mut template = CString::new("/tmp/fuse-overlay-XXXXXX").expect("invalid c string");
-		let mut template = template.into_raw();
-		let suffixlen = 10;
-		let flags = libc::O_RDWR | libc::O_CREAT;
-		let fd = unsafe { libc::mkostemp(template, flags) };
-
-		if fd < 0 {
-			return Err(Error::last_os_error());
-		}
-
-		let mut file = unsafe { File::from_raw_fd(fd) };
-		let mut offset: usize = 0;
-		let size = 4 * 1024 * 1024;
-		loop {
-			let ret = layer.read(ctx, rinode.inode.load(Ordering::Relaxed), src_handle, &mut file, size, offset as u64, None, 0)?;
-			if ret == 0 {
-				break;
-			}
-
-			offset += ret;
-		}
-
-		file.seek(SeekFrom::Start(0))?;
-		offset = 0;
-		loop {
-			let ret = upper.write(ctx, entry.inode, dst_handle, &mut file, size, offset as u64, None, false, 0, 0)?;
-			if ret == 0 {
-				break;
-			}
-
-			offset += ret;
-		}
-
-		drop(file);
-		unsafe { libc::unlink(template); }
-
-		// close handles
-		layer.release(ctx, rinode.inode.load(Ordering::Relaxed), 0, src_handle, true, true, None)?;
-		upper.release(ctx, entry.inode, 0, dst_handle, true, true, None)?;
-
-		// update upper_inode and first_inode
-		*node.upper_inode.lock().unwrap() = Some(Arc::clone(&real_inode));
-		*node.first_inode.lock().unwrap() = Arc::clone(&real_inode);
-
-		return Ok(Arc::clone(&node));
-	}
-
-	pub fn copy_node_up(&self, ctx: &Context, node: Arc<OverlayInode>) -> Result<Arc<OverlayInode>> {
-		if self.node_in_upper_layer(Arc::clone(&node))? {
-			return Ok(node);
-		}
-		// not in upper, copy it up
-		let pnode = if let Some(ref n) = node.parent.lock().unwrap().upgrade() {
-			Arc::clone(n)
-		} else {
-			return Err(Error::new(ErrorKind::Other, "no parent?"));
-		};
-
-		self.create_node_directory(ctx, Arc::clone(&pnode))?;
-		// parent prepared
-		let st = node.stat64(ctx)?;
-
-		// directory
-		if st.st_mode & libc::S_IFMT == libc::S_IFDIR {
-			self.create_node_directory(ctx, Arc::clone(&node))?;
-			return Ok(Arc::clone(&node));
-		}
-
-		// other kind of files
-
-		// symlink
-		if st.st_mode * libc::S_IFMT == libc::S_IFLNK {
-			return self.copy_symlink_up(ctx, Arc::clone(&node));
-		}
-
-		// reg file
-		// need to use work directory and then rename file to 
-		// final destination for atomic reasons.. not deal with it for now,
-		// use stupid copy at present. FIXME:
-		// this need a lot of work here, ntimes, xattr, etc
-		self.copy_regfile_up(ctx, Arc::clone(&node))
-	}
-
-	pub fn is_upper_layer(&self, l: Arc<BoxedLayer>) -> bool {
-		l.is_upper()
-	}
-
-	pub fn do_rm(&self, ctx: &Context, parent: u64, name: &CStr, dir: bool) -> Result<()> {
-		let upper = if let Some(ref v) = self.upper_layer.as_ref() {
-			Arc::clone(v)
-		} else {
-			return Err(Error::from_raw_os_error(libc::EROFS));
-		};
-
-		let pnode = self.lookup_node(ctx, parent, CString::new("").expect("invalid path!").as_c_str())?;
-		if pnode.whiteout.load(Ordering::Relaxed) {
-			return Err(Error::from_raw_os_error(libc::ENOENT));
-		}
-
-		let node = self.lookup_node(ctx, parent, name)?;
-		if node.whiteout.load(Ordering::Relaxed) {
-			return Err(Error::from_raw_os_error(libc::ENOENT));
-		}
-
-		if dir {
-			self.reload_directory(ctx, Arc::clone(&node))?;
-			let (count, whiteouts, opaque) = node.count_entries_and_whiteout(ctx)?;
-			trace!("files: {}, whiteouts: {} opaque: {}\n", count, whiteouts, opaque);
-			if count > 0 {
-				return Err(Error::from_raw_os_error(libc::ENOTEMPTY));
-			}
-
-			// need to delete whiteouts?
-			if whiteouts + opaque > 0 {
-				if node.in_upper_layer() {
-					self.empty_node_directory(ctx, Arc::clone(&node))?;
-				}
-			}
-
-			trace!("whiteouts deleted!\n");
-		}
-
-		let mut need_whiteout = true;
-		let pnode = self.copy_node_up(ctx, Arc::clone(&pnode))?;
-
-		if node.upper_layer_only() {
-			need_whiteout = false;
-		}
-
-		// parent opaqued
-		let real_pnode = Arc::clone(pnode.upper_inode.lock().unwrap().as_ref().unwrap());
-		let real_parent_inode = real_pnode.inode.load(Ordering::Relaxed);
-		if real_pnode.opaque.load(Ordering::Relaxed) {
-			need_whiteout = false;
-		}
-
-		let layer = Arc::clone(real_pnode.layer.as_ref().unwrap());
-
-		if node.in_upper_layer() {
-			if dir {
-				layer.rmdir(ctx, real_parent_inode, name)?;
-			} else {
-				layer.unlink(ctx, real_parent_inode, name)?;
-			}
-		}
-
-		trace!("toggling children and inodes hash\n");
-
-		{
-			pnode.childrens.lock().unwrap().remove(node.name.as_str());
-			self.inodes.lock().unwrap().remove(&node.inode);
-		}
-
-		let sname = name.to_string_lossy().into_owned().to_owned();
-
-		if need_whiteout {
-			trace!("do_rm: creating whiteout\n");
-			layer.create_whiteout(ctx, real_parent_inode, sname.as_str())?;
-			pnode.loaded.store(false, Ordering::Relaxed);
-			// readd whiteout node
-			self.lookup_node(ctx, parent, name)?;
-			pnode.loaded.store(true, Ordering::Relaxed);
-		}
-
-		Ok(())
-	}
-
-	pub fn node_upper_layer_only(&self, node: Arc<OverlayInode>) -> bool {
-		node.upper_layer_only()
-	}
-
-	pub fn empty_node_directory(&self, ctx: &Context, node: Arc<OverlayInode>) -> Result<()> {
-		let st = node.stat64(ctx)?;
-		if st.st_mode & libc::S_IFMT != libc::S_IFDIR {
-			return Err(Error::from_raw_os_error(libc::ENOTDIR));
-		}
-
-		self.reload_directory(ctx, Arc::clone(&node))?;
-		if !node.in_upper_layer() {
-			return Ok(());
-		}
-
-		// find the real inode
-		let real_node = Arc::clone(node.upper_inode.lock().unwrap().as_ref().unwrap());
-		let layer = Arc::clone(real_node.layer.as_ref().unwrap());
-		let real_inode = real_node.inode.load(Ordering::Relaxed);
-
-		// delete opaque
-		let copaque = CString::new(OPAQUE_WHITEOUT).expect("invalid c string");
-		let (opaque, _ino) = layer.is_opaque_whiteout(ctx, real_inode)?;
-		if opaque {
-			if let Some(v) = layer.lookup_ignore_enoent(ctx, real_inode, OPAQUE_WHITEOUT)? {
-				layer.unlink(ctx, real_inode, copaque.as_c_str())?;
-			}
-		}
-
-		let iter = {
-			let mut all = Vec::new();
-			for (_, v) in node.childrens.lock().unwrap().iter() {
-				all.push(Arc::clone(v));
-			}
-
-			all
-		};
-
-		for child in &iter {
-			if child.in_upper_layer() {
-				if child.whiteout.load(Ordering::Relaxed) {
-					layer.delete_whiteout(ctx, real_inode, child.name.as_str())?
-				} else {
-					let s = child.stat64(ctx)?;
-					let cname = CString::new(child.name.as_str()).expect("invalid c string");
-					if s.st_mode & libc::S_IFMT == libc::S_IFDIR {
-						let (count, whiteouts, opaque) = child.count_entries_and_whiteout(ctx)?;
-						if count + whiteouts + opaque > 0 {
-							self.empty_node_directory(ctx, Arc::clone(&child))?;
-						}
-
-						layer.rmdir(ctx, real_inode, cname.as_c_str())?
-					} else {
-						layer.unlink(ctx, real_inode, cname.as_c_str())?;
-					}
-				}
-
-				{
-					// delete the child
-					self.inodes.lock().unwrap().remove(&child.inode);
-					node.childrens.lock().unwrap().remove(child.name.as_str());
-				}
-			}
-
-		}
-
-		Ok(())
-	}
-
-	pub fn do_open(&self, inode: Inode, flags: u32, fuse_flags: u32) -> Result<(Option<Handle>, OpenOptions)> {
-			Err(Error::from(ErrorKind::Unsupported))
-	}
-
-	pub fn delete_whiteout_node(&self, ctx: &Context, node: Arc<OverlayInode>) -> Result<()> {
-		if !node.whiteout.load(Ordering::Relaxed) {
-			return Ok(());
-		}
-
-		if !self.node_in_upper_layer(Arc::clone(&node))? {
-			return Ok(());
-		}
-
-		let name = CString::new(node.name.as_str()).expect("invalid c string");
-		let (layer, real_parent, pnode) = {
-			let pnode = if let Some(ref n) = node.parent.lock().unwrap().upgrade() {
-				Arc::clone(n)
-			} else {
-				return Err(Error::new(ErrorKind::Other, "no parent"));
-			};
-
-			let first_inode = pnode.first_inode.lock().unwrap();
-
-			(Arc::clone(first_inode.layer.as_ref().unwrap()), first_inode.inode.load(Ordering::Relaxed), Arc::clone(&pnode))
-		};
-
-		// delete white out and update hash
-		layer.delete_whiteout(ctx, real_parent, node.name.as_str())?;
-		self.inodes.lock().unwrap().remove(&node.inode);
-		pnode.childrens.lock().unwrap().remove(node.name.as_str());
-
-		Ok(())
-	}
-
-	pub fn find_real_info_from_handle(&self, ctx: &Context, handle: Handle) -> Result<(Arc<BoxedLayer>, Inode, Handle)> {
-		if let Some(h) = self.handles.lock().unwrap().get(&handle) {
-			if let Some( ref rhd) = h.real_handle {
-				let real_handle = rhd.handle.load(Ordering::Relaxed);
-				let ri = Arc::clone(&rhd.real_inode);
-				let layer = Arc::clone(ri.layer.as_ref().unwrap());
-				let real_inode = ri.inode.load(Ordering::Relaxed);
-				return Ok((layer, real_inode, real_handle))
-			}
-		}
-
-		Err(Error::from_raw_os_error(libc::ENOENT))
-	}
-
-	pub fn find_real_inode(&self, ctx: &Context, inode: Inode) -> Result<(Arc<BoxedLayer>, Inode)> {
-		if let Some(n) = self.inodes.lock().unwrap().get(&inode) {
-			let first = n.first_inode.lock().unwrap();
-			let layer = Arc::clone(first.layer.as_ref().unwrap());
-			let real_inode = first.inode.load(Ordering::Relaxed);
-
-			return Ok((layer, real_inode))
-		}
-
-		Err(Error::from_raw_os_error(libc::ENOENT))
-	}
-}
-
-impl BackendFileSystem for OverlayFs {
-	fn mount(&self) -> Result<(Entry, u64)> {
-		if let Some(ref root) = self.root.as_ref() {
-			let ctx = Context::default();
-			Ok((Entry {
-				inode: root.inode,
-				generation: 0,
-				attr: root.stat64(&ctx)?,
-				attr_flags: 0,
-				attr_timeout: self.config.attr_timeout,
-				entry_timeout: self.config.entry_timeout,
-			}, VFS_MAX_INO))
-		} else {
-			Err(Error::new(ErrorKind::Other, "fs not inited"))
-		}
-	}
-
-	fn as_any(&self) -> &dyn Any {
-		self
-	}
-}
-
-impl FileSystem for OverlayFs {
-	type Inode = Inode;
-	type Handle = Handle;
-
-	fn init(&self, capable: FsOptions) -> Result<FsOptions> {
-		// use vfs' negotiated capability if imported
-		// other wise, do our own negotiation
-		let mut opts = FsOptions::DO_READDIRPLUS | FsOptions::READDIRPLUS_AUTO;
-
-		if self.config.do_import {
-			self.import()?;
-		}
-
-		if (!self.config.do_import || self.config.writeback) && capable.contains(FsOptions::WRITEBACK_CACHE) {
-			opts |= FsOptions::WRITEBACK_CACHE;
-			self.writeback.store(true, Ordering::Relaxed);
-		}
-
-		if (!self.config.do_import || self.config.no_open) && capable.contains(FsOptions::ZERO_MESSAGE_OPEN) {
-			opts |= FsOptions::ZERO_MESSAGE_OPEN;
-			opts.remove(FsOptions::ATOMIC_O_TRUNC);
-			self.no_open.store(true, Ordering::Relaxed);
-		}
-
-		if (!self.config.do_import || self.config.no_opendir) && capable.contains(FsOptions::ZERO_MESSAGE_OPENDIR) {
-			opts |= FsOptions::ZERO_MESSAGE_OPENDIR;
-			self.no_opendir.store(true, Ordering::Relaxed);
-		}
-
-		if (!self.config.do_import || self.config.killpriv_v2) && capable.contains(FsOptions::HANDLE_KILLPRIV_V2) {
-			opts |= FsOptions::HANDLE_KILLPRIV_V2;
-			self.killpriv_v2.store(true, Ordering::Relaxed);
-		}
-
-		if self.config.perfile_dax && capable.contains(FsOptions::PERFILE_DAX) {
-			opts |= FsOptions::PERFILE_DAX;
-			self.perfile_dax.store(true, Ordering::Relaxed);
-		}
-
-		Ok(opts)
-	}
-
-	fn destroy(&self) {
-	}
-
-	fn statfs(&self, ctx: &Context, inode: Inode) -> Result<libc::statvfs64> {
-		self.do_statvfs(ctx, inode)
-	}
-
-	fn lookup(&self, ctx: &Context, parent: Inode, name: &CStr) -> Result<Entry> {
-		let tmp =name.to_string_lossy().into_owned().to_owned();
-		trace!("LOOKUP: parent: {}, name: {}\n", parent, tmp);
-		let node = self.lookup_node(ctx, parent, name)?;
-
-		if node.whiteout.load(Ordering::Relaxed) {
-			return Err(Error::from_raw_os_error(libc::ENOENT));
-		}
-
-		let pnode = if let Some(v) = self.get_node_from_inode(parent) {
-			v
-		} else {
-			return Err(Error::from_raw_os_error(libc::EINVAL));
-		};
-
-		let ppath = String::from(pnode.path.as_str());
-		let sname = name.to_string_lossy().into_owned().to_owned();
-		let st = node.stat64(ctx)?;
-
-		// load this directory here
-		if st.st_mode & libc::S_IFMT == libc::S_IFDIR {
-			self.load_directory(ctx, Arc::clone(&node))?;
-			node.loaded.store(true, Ordering::Relaxed);
-		}
-
-		// FIXME: can forget happen between found and increase reference counter? 
-
-		*node.lookups.lock().unwrap() += 1;
-
-		Ok(Entry{
-			inode: node.inode as u64,
-			generation: 0,
-			attr: st,//libc::stat64
-			attr_flags: 0,
-			attr_timeout: self.config.attr_timeout,
-			entry_timeout: self.config.entry_timeout,
-		})
-	}
-
-	fn forget(&self, ctx: &Context, inode: Inode, count: u64) {
-		self.forget_one(inode, count)
-	}
-
-	fn batch_forget(&self, ctx: &Context, requests: Vec<(Inode, u64)>) {
-		for (inode, count) in requests {
-			self.forget_one(inode, count);
-		}
-	}
-
-	fn opendir(&self, ctx: &Context, inode: Inode, flags: u32) -> Result<(Option<Handle>, OpenOptions)> {
-		let mut opts = OpenOptions::empty();
-
-		match self.config.cache_policy {
-			CachePolicy::Always => {
-				opts |= OpenOptions::KEEP_CACHE;
-			},
-
-			_ => {
-			},
-		}
-
-		// lookup node
-		let node = self.lookup_node(ctx, inode, CString::new(".").expect("invalid path!").as_c_str())?;
-
-		if node.whiteout.load(Ordering::Relaxed) {
-			return Err(Error::new(ErrorKind::InvalidInput, "invalid inode number"));
-		}
-
-		let st = node.stat64(ctx)?;
-		if st.st_mode & libc::S_IFDIR == 0 {
-			return Err(Error::from_raw_os_error(libc::ENOTDIR));
-		}
-
-		let handle = self.next_handle.fetch_add(1, Ordering::Relaxed);
-
-		// reload directory?
-		self.reload_directory(ctx, Arc::clone(&node))?;
-
-		let mut cs = Vec::new();
-		//add myself
-		cs.push(Arc::clone(&node));
-
-		//add parent
-		if let Some(p) = node.parent.lock().unwrap().upgrade() {
-			cs.push(p);	
-		} else {
-			cs.push(Arc::clone(self.root.as_ref().unwrap()));
-		};
-
-		for (_, child) in node.childrens.lock().unwrap().iter() {
-			// skip whiteout node
-			if child.whiteout.load(Ordering::Relaxed) || child.hidden.load(Ordering::Relaxed) {
-				continue;
-			}
-			// *child.lookups.lock().unwrap() += 1;
-			cs.push(Arc::clone(child));
-		}
-
-		for c in cs.iter() {
-			*c.lookups.lock().unwrap() += 1;
-		}
-
-		*node.lookups.lock().unwrap() += 1;
-
-		self.handles.lock().unwrap().insert(handle, HandleData{
-			node: Arc::clone(&node),
-			childrens: Some(cs),
-			offset: 0,
-			real_handle: None,
-		});
-		
-		Ok((Some(handle), opts))
-	}
-
-	fn releasedir(&self, ctx: &Context, inode: Inode, flags: u32, handle: Handle) -> Result<()> {
-		trace!("RELEASEDIR: inode: {}, handle: {}\n", inode, handle);
-		{
-			if let Some(v) = self.handles.lock().unwrap().get(&handle) {
-				for child in v.childrens.as_ref().unwrap() {
-					self.forget_one(child.inode, 1);
-				}
-
-				self.forget_one(v.node.inode, 1);
-			}
-		}
-
-		trace!("RELEASEDIR: returning");
-
-		self.handles.lock().unwrap().remove(&handle);
-
-		Ok(())
-	}
-
-	// for mkdir or create file
-	// 1. lookup name, if exists and not whiteout, return EEXIST
-	// 2. not exists and no whiteout, copy up parent node, ususally  a mkdir on upper layer would do the work
-	// 3. find whiteout, if whiteout in upper layer, shoudl set opaque. if in lower layer, just mkdir?
-	fn mkdir(&self, ctx: &Context, parent: Inode, name: &CStr, mode: u32, umask: u32) -> Result<Entry> {
-		let mut delete_whiteout: bool = false;
-		let mut has_whiteout: bool = false;
-		let mut upper_layer_only: bool = false;
-		let mut opaque = false;
-		let mut node: Arc<OverlayInode> = Arc::new(OverlayInode::default());
-
-		let sname = name.to_string_lossy().into_owned().to_owned();
-		if let Some(n) = self.lookup_node_ignore_enoent(ctx, parent, name)? {
-			if !n.whiteout.load(Ordering::Relaxed) {
-				return Err(Error::from_raw_os_error(libc::EEXIST));
-			}
-
-			node = Arc::clone(&n);
-			has_whiteout = true;
-		}
-
-		let upper = if let Some(l) = self.get_upper_layer() {
-			l
-		} else {
-			return Err(Error::from_raw_os_error(libc::EROFS));
-			// return Err(Error::new(ErrorKind::ReadOnlyFilesystem, "readonly filesystem!"));
-		};
-
-		if has_whiteout {
-			if node.in_upper_layer() {
-				// whiteout in upper layer, other lower layers are readonly, don't try to delete it
-				delete_whiteout = true;
-			}
-
-			if node.upper_layer_only() {
-				upper_layer_only = true;
-			}
-		}
-
-		let pnode = self.lookup_node(ctx, parent, CString::new("").expect("invalid file name").as_c_str())?;
-		// actual work to copy pnode up..
-		let pnode = self.copy_node_up(ctx, Arc::clone(&pnode))?;
-
-		assert!(pnode.in_upper_layer());
-		let real_pnode = Arc::clone(pnode.upper_inode.lock().unwrap().as_ref().unwrap());
-
-		let real_parent_inode = real_pnode.inode.load(Ordering::Relaxed);
-
-		if delete_whiteout {
-			upper.delete_whiteout(ctx, real_parent_inode, sname.as_str());
-		}
-
-		// create dir in upper layer
-		let entry = upper.mkdir(ctx, real_parent_inode, name, mode, umask)?;
-
-		if !upper_layer_only {
-			upper.create_opaque_whiteout(ctx, entry.inode)?;
-			opaque = true;
-		}
-
-		pnode.loaded.store(false, Ordering::Relaxed);
-		// remove whiteout node from child and inode hash
-		// FIXME: maybe a reload from start better
-		if has_whiteout {
-			pnode.childrens.lock().unwrap().remove(sname.as_str());
-			self.inodes.lock().unwrap().remove(&node.inode);
-		}
-
-		let node = self.lookup_node(ctx, parent, name)?;
-
-		pnode.loaded.store(true, Ordering::Relaxed);
-
-		Ok(Entry {
-			inode: node.inode,
-			generation: 0,
-			attr: node.stat64(ctx)?,
-			attr_flags: 0,
-			attr_timeout: self.config.attr_timeout,
-			entry_timeout: self.config.entry_timeout,
-		})
-	}
-
-	fn rmdir(&self, ctx: &Context, parent: Inode, name: &CStr) -> Result<()> {
-		self.do_rm(ctx, parent, name, true)
-	}
-
-	fn readdir(&self, ctx: &Context, inode: Inode, handle: Handle, size: u32, offset: u64, add_entry: &mut dyn FnMut(DirEntry) -> Result<usize>) -> Result<()> {
-		self.do_readdir(ctx, handle, size, offset, &mut |dir_entry, _entry| -> Result<usize> {
-			add_entry(dir_entry)
-		})
-	}
-
-	fn readdirplus(&self, ctx: &Context, inode: Inode, handle: Handle, size: u32, offset: u64, add_entry: &mut dyn FnMut(DirEntry, Entry) -> Result<usize>) -> Result<()> {
-		self.do_readdir(ctx, handle, size, offset, &mut |dir_entry, entry| -> Result<usize> {
-			add_entry(dir_entry, entry)
-		})
-	}
-
-	fn open(&self, ctx: &Context, inode: Inode, flags: u32, fuse_flags: u32) -> Result<(Option<Handle>, OpenOptions)> {
-		// open assume file always exist
-
-		let readonly: bool = flags & (libc::O_APPEND | libc::O_CREAT | libc::O_TRUNC | libc::O_RDWR | libc::O_WRONLY) as u32== 0;
-
-		trace!("OPEN: inode: {}, readonly: {}", inode, readonly);
-
-		// toggle flags
-		let mut flags: i32 = flags as i32;
-
-		flags |= libc::O_NOFOLLOW;
-		flags &= !libc::O_DIRECT;
-		if self.config.writeback {
-			if flags & libc::O_ACCMODE == libc::O_WRONLY {
-				flags &= !libc::O_ACCMODE;
-				flags |= libc::O_RDWR;
-			}
-
-			if flags & libc::O_APPEND != 0 {
-				flags &= !libc::O_APPEND;
-			}
-		}
-
-		// lookup node
-		let node = self.lookup_node(ctx, inode, CString::new("").expect("invalid c string").as_c_str())?;
-
-		// whiteout node
-		if node.whiteout.load(Ordering::Relaxed) {
-			return Err(Error::from_raw_os_error(libc::ENOENT));
-		}
-
-		if !readonly {
-			// copy up to upper layer
-			self.copy_node_up(ctx, Arc::clone(&node))?;
-		}
-
-		// assign a handle in overlayfs and open it
-		let (l, h, o) =  node.open(ctx, flags as u32, fuse_flags)?;
-		if let Some(handle) = h {
-			let hd = self.next_handle.fetch_add(1, Ordering::Relaxed);
-			let handle_data = HandleData {
-				node: Arc::clone(&node),
-				childrens: None,
-				offset: 0,
-				real_handle: Some(RealHandle {
-					real_inode: Arc::clone(&node.first_inode.lock().unwrap()),
-					handle: AtomicU64::new(handle),
-					invalid: AtomicBool::new(false),
-				}),
-			};
-
-			self.handles.lock().unwrap().insert(hd, handle_data);
-
-			let mut opts = OpenOptions::empty();
-			match self.config.cache_policy {
-				CachePolicy::Never => opts |= OpenOptions::DIRECT_IO,
-				CachePolicy::Always => opts |= OpenOptions::KEEP_CACHE,
-				_ => {},
-			}
-
-			trace!("OPEN: returning handle: {}", hd);
-
-			return Ok((Some(hd), opts));
-		}
-
-		Err(Error::from_raw_os_error(libc::ENOENT))
-	}
-
-	fn release(&self, ctx: &Context, inode: Inode, flags: u32, handle: Handle, flush: bool, flock_release: bool, lock_owner: Option<u64>) -> Result<()> {
-		if let Some(hd) = self.handles.lock().unwrap().get(&handle) {
-			let rh = if let Some(ref h) = hd.real_handle {
-				h
-			} else {
-				return Err(Error::new(ErrorKind::Other, "no handle"));
-			};
-			let real_handle = rh.handle.load(Ordering::Relaxed);
-			let ri = Arc::clone(&rh.real_inode);
-			let real_inode = ri.inode.load(Ordering::Relaxed);
-			let l = Arc::clone(&ri.layer.as_ref().unwrap());
-			l.release(ctx, real_inode, flags, real_handle, flush, flock_release, lock_owner)?;
-		}
-
-		self.handles.lock().unwrap().remove(&handle);
-
-		Ok(())
-	}
-
-	fn create(&self, ctx: &Context, parent: Inode, name: &CStr, args: CreateIn) -> Result<(Entry, Option<Handle>, OpenOptions)> {
-		let mut is_whiteout = false;
-		let node = self.lookup_node_ignore_enoent(ctx, parent, name)?;
-		let sname = name.to_string_lossy().into_owned().to_owned();
-
-		let mut hargs = args;
-
-		let mut flags: i32 = args.flags as i32;
-
-		flags |= libc::O_NOFOLLOW;
-		flags &= !libc::O_DIRECT;
-		if self.config.writeback {
-			if flags & libc::O_ACCMODE == libc::O_WRONLY {
-				flags &= !libc::O_ACCMODE;
-				flags |= libc::O_RDWR;
-			}
-
-			if flags & libc::O_APPEND != 0 {
-				flags &= !libc::O_APPEND;
-			}
-		}
-
-		hargs.flags = flags as u32;
-
-
-		if let Some(ref n) = node {
-			if !n.whiteout.load(Ordering::Relaxed) {
-				return Err(Error::from_raw_os_error(libc::EEXIST));
-			} else {
-				is_whiteout = true;
-			}
-		}
-
-		// no entry or whiteout
-		let pnode = self.lookup_node(ctx, parent, CString::new("").expect("invalid c string").as_c_str())?;
-		if pnode.whiteout.load(Ordering::Relaxed) {
-			return Err(Error::from_raw_os_error(libc::ENOENT));
-		}
-
-		let pnode = self.copy_node_up(ctx, Arc::clone(&pnode))?;
-
-		assert!(pnode.upper_inode.lock().unwrap().is_some());
-
-		let real_parent_inode = pnode.first_inode.lock().unwrap().inode.load(Ordering::Relaxed);
-
-		// need to delete whiteout?
-		if is_whiteout {
-			let node = Arc::clone(node.as_ref().unwrap());
-			let first_inode = Arc::clone(&node.first_inode.lock().unwrap());
-			let first_layer =  first_inode.layer.as_ref().unwrap();
-			if node.in_upper_layer() {
-				// whiteout in upper layer, need to delete
-				first_layer.delete_whiteout(ctx, real_parent_inode, sname.as_str())?;
-			}
-
-			// delete inode from inodes and childrens
-			self.inodes.lock().unwrap().remove(&node.inode);
-			pnode.childrens.lock().unwrap().remove(sname.as_str());
-		}
-
-		// create file in upper layer
-		if let Some(ref upper_layer) = self.upper_layer.as_ref() {
-			let (entry, h, o) = upper_layer.create(ctx, real_parent_inode, name, hargs)?;
-
-			// record inode, handle
-			// lookup will insert inode into children and inodes hash
-			//let real_inode = Arc::new(RealInode {
-			// 	layer: Arc::clone(&upper_layer),
-			//	inode: entry.inode,
-			//	whiteout: AtomicBool::new(false),
-			//	opaque: AtomicBool::new(false),
-			//	hidden: AtomicBool::new(false),
-			//	invalid: AtomicBool::new(false),
-			//});
-
-			pnode.loaded.store(false, Ordering::Relaxed);
-			let node = self.lookup_node(ctx, parent, name)?;
-			pnode.loaded.store(true, Ordering::Relaxed);
-
-			let real_inode = Arc::clone(node.upper_inode.lock().unwrap().as_ref().unwrap());
-
-			let final_handle = 
-			if let Some(hd) = h {
-				let handle = self.next_handle.fetch_add(1, Ordering::Relaxed);
-				let handle_data = HandleData {
-					node: Arc::clone(&node),
-					childrens: None,
-					offset: 0,
-					real_handle: Some(RealHandle {
-						real_inode: Arc::clone(&real_inode),
-						handle: AtomicU64::new(hd),
-						invalid: AtomicBool::new(false),
-					}),
-				};
-				self.handles.lock().unwrap().insert(handle, handle_data);
-				Some(handle)
-			} else {
-				None
-			};
-
-			// return data
-			let entry = Entry {
-				inode: node.inode,
-				generation: 0,
-				attr: node.stat64(ctx)?,
-				attr_flags: 0,
-				attr_timeout: self.config.attr_timeout,
-				entry_timeout: self.config.entry_timeout,
-			};
-
-			let mut opts = OpenOptions::empty();
-			match self.config.cache_policy {
-				CachePolicy::Never => opts |= OpenOptions::DIRECT_IO,
-				CachePolicy::Always => opts |= OpenOptions::KEEP_CACHE,
-				_ => {},
-			}
-
-			return Ok((entry, final_handle, opts));
-
-		} else {
-			return Err(Error::from_raw_os_error(libc::EROFS));
-		}
-
-		Err(Error::new(ErrorKind::Other, "Unknown error"))
-	}
-
-	fn unlink(&self, ctx: &Context, parent: Inode, name: &CStr) -> Result<()> {
-		self.do_rm(ctx, parent, name, false)
-	}
-
-	fn read(&self, ctx: &Context, inode: Inode, handle: Handle, w: &mut dyn ZeroCopyWriter, size: u32, offset: u64, lock_owner: Option<u64>, flags: u32) -> Result<usize> {
-		if let Some(v) = self.handles.lock().unwrap().get(&handle) {
-			if let Some(ref hd) = v.real_handle {
-				let real_handle = hd.handle.load(Ordering::Relaxed);
-				let ri = Arc::clone(&hd.real_inode);
-				let (real_inode, layer) = (ri.inode.load(Ordering::Relaxed), Arc::clone(ri.layer.as_ref().unwrap()));
-
-				return layer.read(ctx, real_inode, real_handle, w, size, offset, lock_owner, flags);
-			}
-		}
-
-		Err(Error::from_raw_os_error(libc::ENOENT))
-	}
-
-	fn write(&self, ctx: &Context, inode: Inode, handle: Handle, r: &mut dyn ZeroCopyReader, size: u32, offset: u64, lock_owner: Option<u64>, delayed_write: bool, flags: u32, fuse_flags: u32) -> Result<usize> {
-		if let Some(v) = self.handles.lock().unwrap().get(&handle) {
-			if let Some(ref hd) = v.real_handle {
-				let real_handle = hd.handle.load(Ordering::Relaxed);
-				let ri = Arc::clone(&hd.real_inode);
-				let (real_inode, layer) = (ri.inode.load(Ordering::Relaxed), Arc::clone(ri.layer.as_ref().unwrap()));
-
-				return layer.write(ctx, real_inode, real_handle, r, size, offset, lock_owner, delayed_write, flags, fuse_flags);
-				// remove whiteout node from child and inode hash
-			}
-		}
-
-		Err(Error::from_raw_os_error(libc::ENOENT))
-	}
-
-	fn getattr(&self, ctx: &Context, inode: Inode, handle: Option<Handle>) -> Result<(libc::stat64, Duration)> {
-		trace!("GETATTR: inode: {}\n", inode);
-		if let Some(h) = handle {
-			if let Some(hd) = self.handles.lock().unwrap().get(&h) {
-				if let Some(ref v) = hd.real_handle {
-					let ri = Arc::clone(&v.real_inode);
-					let layer = Arc::clone(ri.layer.as_ref().unwrap());
-					let real_inode = ri.inode.load(Ordering::Relaxed);
-					let real_handle = v.handle.load(Ordering::Relaxed);
-					let (st, _d) = layer.getattr(ctx, real_inode, Some(real_handle))?;
-					return Ok((st, self.config.attr_timeout));
-				}
-			}
-		} else {
-			let node = self.lookup_node(ctx, inode, CString::new("").expect("invalid c string").as_c_str())?;
-			let rl = Arc::clone(&node.first_inode.lock().unwrap());
-			if let Some(ref v) = rl.layer {
-				let layer = Arc::clone(v);
-				let real_inode = rl.inode.load(Ordering::Relaxed);
-
-				let (st, _d) = layer.getattr(ctx, real_inode, None)?;
-				return Ok((st, self.config.attr_timeout));
-			}
-		}
-
-		Err(Error::from_raw_os_error(libc::ENOENT))
-	}
-
-	fn setattr(&self, ctx: &Context, inode: Inode, attr: libc::stat64, handle: Option<Handle>, valid: SetattrValid) -> Result<(libc::stat64, Duration)> {
-		// find out real inode and real handle, if the first
-		// layer id not upper layer copy it up
-
-		// deal with handle first
-		if let Some(h) = handle {
-			if let Some(hd) = self.handles.lock().unwrap().get(&h) {
-				if let Some(ref rhd) = hd.real_handle {
-					let ri = Arc::clone(&rhd.real_inode);
-					let layer = Arc::clone(ri.layer.as_ref().unwrap());
-					let real_inode = ri.inode.load(Ordering::Relaxed);
-					let real_handle = rhd.handle.load(Ordering::Relaxed);
-					// handle opened in upper layer
-					if self.is_upper_layer(Arc::clone(&layer)) {
-						let (st, _d) = layer.setattr(ctx, real_inode, attr, Some(real_handle), valid)?;
-
-						return Ok((st, self.config.attr_timeout));
-					}
-				}
-			}
-		}
-
-		let node = self.lookup_node(ctx, inode, CString::new("").expect("invalid c string").as_c_str())?;
-
-		//layer is upper layer
-		let node = 
-		if !self.node_in_upper_layer(Arc::clone(&node))? {
-			self.copy_node_up(ctx, Arc::clone(&node))?
-		} else {
-			Arc::clone(&node)
-		};
-
-		let v = Arc::clone(&node.first_inode.lock().unwrap());
-		let (layer, real_inode) = (Arc::clone(v.layer.as_ref().unwrap()), v.inode.load(Ordering::Relaxed));
-
-		let (st, _d) = layer.setattr(ctx, real_inode, attr, None, valid)?;
-		Ok((st, self.config.attr_timeout))
-	}
-
-	fn rename(&self, ctx: &Context, olddir: Inode, odlname: &CStr, newdir: Inode, newname: &CStr, flags: u32) -> Result<()> {
-		// complex, implement it later
-		Err(Error::from_raw_os_error(libc::EXDEV))
-	}
-
-	fn mknod(&self, ctx: &Context, parent: Inode, name: &CStr, mode: u32, rdev: u32, umask: u32) -> Result<Entry> {
-		let mut is_whiteout = false;
-		let node = self.lookup_node_ignore_enoent(ctx, parent, name)?;
-		let sname = name.to_string_lossy().into_owned().to_owned();
-
-		if let Some(ref n) = node {
-			if !n.whiteout.load(Ordering::Relaxed) {
-				return Err(Error::from_raw_os_error(libc::EEXIST));
-			} else {
-				is_whiteout = true;
-			}
-		}
-
-		// no entry or whiteout
-		let pnode = self.lookup_node(ctx, parent, CString::new("").expect("invalid c string").as_c_str())?;
-		if pnode.whiteout.load(Ordering::Relaxed) {
-			return Err(Error::from_raw_os_error(libc::ENOENT));
-		}
-
-		let pnode = self.copy_node_up(ctx, Arc::clone(&pnode))?;
-
-		assert!(pnode.upper_inode.lock().unwrap().is_some());
-
-		let real_parent_inode = pnode.first_inode.lock().unwrap().inode.load(Ordering::Relaxed);
-
-		// need to delete whiteout?
-		if is_whiteout {
-			let node = Arc::clone(node.as_ref().unwrap());
-			let first_inode = Arc::clone(&node.first_inode.lock().unwrap());
-			let first_layer =  first_inode.layer.as_ref().unwrap();
-			if node.in_upper_layer() {
-				// whiteout in upper layer, need to delete
-				first_layer.delete_whiteout(ctx, real_parent_inode, sname.as_str())?;
-			}
-
-			// delete inode from inodes and childrens
-			self.inodes.lock().unwrap().remove(&node.inode);
-			pnode.childrens.lock().unwrap().remove(sname.as_str());
-		}
-
-		// make it
-		assert!(pnode.in_upper_layer());
-
-		let real_inode = Arc::clone(pnode.upper_inode.lock().unwrap().as_ref().unwrap());
-		let layer = Arc::clone(real_inode.layer.as_ref().unwrap());
-		let _entry = layer.mknod(ctx, real_parent_inode, name, mode, rdev, umask)?;
-
-		pnode.loaded.store(false, Ordering::Relaxed);
-		let node = self.lookup_node(ctx, parent, name)?;
-		pnode.loaded.store(true, Ordering::Relaxed);
-		Ok(Entry {
-			inode: node.inode,
-			generation: 0,
-			attr: node.stat64(ctx)?,
-			attr_flags: 0,
-			attr_timeout: self.config.attr_timeout,
-			entry_timeout: self.config.entry_timeout,
-		})
-	}
-
-	fn link(&self, ctx: &Context, inode: Inode, newparent: Inode, name: &CStr) -> Result<Entry> {
-		// hard link..
-		let node = self.lookup_node(ctx, inode, CString::new("").expect("invalic c string").as_c_str())?;
-		if node.whiteout.load(Ordering::Relaxed) {
-			return Err(Error::from_raw_os_error(libc::ENOENT));
-		}
-
-		let newpnode = self.lookup_node(ctx, newparent, CString::new("").expect("invalid c string").as_c_str())?;
-		if newpnode.whiteout.load(Ordering::Relaxed) {
-			return Err(Error::from_raw_os_error(libc::ENOENT));
-		}
-
-		let newnode = self.lookup_node_ignore_enoent(ctx, newparent, name)?;
-
-		// copy node up
-		let node = self.copy_node_up(ctx, Arc::clone(&node))?;
-		let newpnode = self.copy_node_up(ctx, Arc::clone(&newpnode))?;
-		let sname = name.to_string_lossy().into_owned().to_owned();
-
-		if let Some(n) = newnode {
-			if !n.whiteout.load(Ordering::Relaxed) {
-				return Err(Error::from_raw_os_error(libc::EEXIST));
-			}
-
-			// need to delete whiteout? if whiteout in upper layer
-			// delete it
-			if self.node_in_upper_layer(Arc::clone(&n))? {
-				// find out the real parent inode and delete whiteout
-				let pri = &newpnode.first_inode.lock().unwrap();
-				let layer = Arc::clone(pri.layer.as_ref().unwrap());
-				let real_parent_inode = pri.inode.load(Ordering::Relaxed);
-				layer.delete_whiteout(ctx, real_parent_inode, sname.as_str())?;
-			}
-
-			// delete from hash
-			self.inodes.lock().unwrap().remove(&n.inode);
-			newpnode.childrens.lock().unwrap().remove(sname.as_str());
-		}
-
-		// create the link
-		let pri = &newpnode.first_inode.lock().unwrap();
-		let layer = Arc::clone(pri.layer.as_ref().unwrap());
-		let real_parent_inode = pri.inode.load(Ordering::Relaxed);
-		let real_inode = node.first_inode.lock().unwrap().inode.load(Ordering::Relaxed);
-		layer.link(ctx, real_inode, real_parent_inode, name)?;
-		
-		newpnode.loaded.store(false, Ordering::Relaxed);
-		let node = self.lookup_node(ctx, newparent, name)?;
-		newpnode.loaded.store(true, Ordering::Relaxed);
-		
-		Ok(Entry {
-			inode: node.inode, 
-			generation: 0,
-			attr: node.stat64(ctx)?,
-			attr_flags: 0,
-			attr_timeout: self.config.attr_timeout,
-			entry_timeout: self.config.entry_timeout,
-		})
-	}
-
-	fn symlink(&self, ctx: &Context, linkname: &CStr, parent: Inode, name: &CStr) -> Result<Entry> {
-		// soft link
-		let empty_name = CString::new("").expect("invalid c string");
-		let sname = name.to_string_lossy().into_owned().to_owned();
-
-		let pnode = self.lookup_node(ctx, parent, empty_name.as_c_str())?;
-
-		if pnode.whiteout.load(Ordering::Relaxed) {
-			return Err(Error::from_raw_os_error(libc::ENOENT));
-		}
-
-		let node = self.lookup_node_ignore_enoent(ctx, parent, name)?;
-		if let Some(n) = node {
-			if !n.whiteout.load(Ordering::Relaxed) {
-				return Err(Error::from_raw_os_error(libc::EEXIST));
-			}
-
-			// whiteout, may need to delete it
-			self.delete_whiteout_node(ctx, Arc::clone(&n))?;
-
-			// delete from hash
-			self.inodes.lock().unwrap().remove(&n.inode);
-			pnode.childrens.lock().unwrap().remove(sname.as_str());
-		}
-
-		let pnode = self.copy_node_up(ctx, Arc::clone(&pnode))?;
-		// find out layer, real parent..
-		let (layer, real_parent) = {
-			let first = pnode.first_inode.lock().unwrap();
-			(Arc::clone(first.layer.as_ref().unwrap()), first.inode.load(Ordering::Relaxed))
-		};
-
-		layer.symlink(ctx, linkname, real_parent, name)?;
-
-		pnode.loaded.store(false, Ordering::Relaxed);
-		let node = self.lookup_node(ctx, parent, name)?;
-		pnode.loaded.store(true, Ordering::Relaxed);
-
-		Ok(Entry {
-			inode: node.inode,
-			generation: 0,
-			attr: node.stat64(ctx)?,
-			attr_flags: 0, 
-			attr_timeout: self.config.attr_timeout,
-			entry_timeout: self.config.entry_timeout,
-		})
-	}
-
-	fn readlink(&self, ctx: &Context, inode: Inode) -> Result<Vec<u8>> {
-		let empty_name =CString::new("").expect("invalid c string");
-		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
-
-		if node.whiteout.load(Ordering::Relaxed) {
-			return Err(Error::from_raw_os_error(libc::ENOENT));
-		}
-
-		// find out real inode
-		let (layer, real_inode) = {
-			let first = node.first_inode.lock().unwrap();
-			(Arc::clone(first.layer.as_ref().unwrap()), first.inode.load(Ordering::Relaxed))
-		};
-
-		layer.readlink(ctx, real_inode)
-
-	}
-
-	fn flush(&self, ctx: &Context, inode: Inode, handle: Handle, lock_owner: u64) -> Result<()> {
-		let empty_name = CString::new("").expect("invalid c string");
-		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
-
-		if node.whiteout.load(Ordering::Relaxed) {
-			return Err(Error::from_raw_os_error(libc::ENOENT));
-		}
-
-		// readonly file can also be flushed, pass flush request
-		// to lower layer instead of return EROFS here
-		// if !self.node_in_upper_layer(Arc::clone(&node))? {
-			// in lower layer, error out or just success?
-			// FIXME:
-		//	return Err(Error::from_raw_os_error(libc::EROFS));
-		// }
-
-		let (layer, real_inode, real_handle) = self.find_real_info_from_handle(ctx, handle)?;
-
-		// FIXME: need to test if inode matches corresponding handle?
-
-		layer.flush(ctx, real_inode, real_handle, lock_owner)
-	}
-
-	fn fsync(&self, ctx: &Context, inode: Inode, datasync: bool, handle: Handle) -> Result<()> {
-		let empty_name = CString::new("").expect("invalid c string");
-		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
-
-		if node.whiteout.load(Ordering::Relaxed) {
-			return Err(Error::from_raw_os_error(libc::ENOENT));
-		}
-
-		if !self.node_in_upper_layer(Arc::clone(&node))? {
-			// in lower layer, error out or just success?
-			// FIXME:
-			return Err(Error::from_raw_os_error(libc::EROFS));
-		}
-
-		let (layer, real_inode, real_handle) = self.find_real_info_from_handle(ctx, handle)?;
-
-		// FIXME: need to test if inode matches corresponding handle?
-
-		layer.fsync(ctx, real_inode, datasync, real_handle)
-	}
-
-	fn fsyncdir(&self, ctx: &Context, inode: Inode, datasync: bool, handle: Handle) -> Result<()> {
-		let empty_name = CString::new("").expect("invalid c string");
-		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
-
-		if node.whiteout.load(Ordering::Relaxed) {
-			return Err(Error::from_raw_os_error(libc::ENOENT));
-		}
-
-		if !self.node_in_upper_layer(Arc::clone(&node))? {
-			// in lower layer, error out or just success?
-			// FIXME:
-			return Err(Error::from_raw_os_error(libc::EROFS));
-		}
-
-		let (layer, real_inode, real_handle) = self.find_real_info_from_handle(ctx, handle)?;
-
-		// FIXME: need to test if inode matches corresponding handle?
-
-		layer.fsyncdir(ctx, real_inode, datasync, real_handle)
-	}
-
-	fn access(&self, ctx: &Context, inode: Inode, mask: u32) -> Result<()> {
-		let empty_name = CString::new("").expect("invalid c string");
-		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
-
-		if node.whiteout.load(Ordering::Relaxed) {
-			return Err(Error::from_raw_os_error(libc::ENOENT));
-		}
-
-		let (layer, real_inode) = self.find_real_inode(ctx, inode)?;
-		layer.access(ctx, real_inode, mask)
-	}
-
-	fn setxattr(&self, ctx: &Context, inode: Inode, name: &CStr, value: &[u8], flags: u32) -> Result<()> {
-		let empty_name = CString::new("").expect("invalid c string");
-		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
-
-		if node.whiteout.load(Ordering::Relaxed) {
-			return Err(Error::from_raw_os_error(libc::ENOENT));
-		}
-
-		if !self.node_in_upper_layer(Arc::clone(&node))? {
-			// copy node into upper layer
-			// FIXME:
-			self.copy_node_up(ctx, Arc::clone(&node))?;
-		}
-
-		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
-
-		let (layer, real_inode) = self.find_real_inode(ctx, inode)?;
-
-		layer.setxattr(ctx, real_inode, name, value, flags)
-	}
-
-	fn getxattr(&self, ctx: &Context, inode: Inode, name: &CStr, size: u32) -> Result<GetxattrReply> {
-		let empty_name = CString::new("").expect("invalid c string");
-		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
-
-		if node.whiteout.load(Ordering::Relaxed) {
-			return Err(Error::from_raw_os_error(libc::ENOENT));
-		}
-
-		let (layer, real_inode) = self.find_real_inode(ctx, inode)?;
-
-		layer.getxattr(ctx, real_inode, name, size)
-	}
-
-	fn listxattr(&self, ctx: &Context, inode: Inode, size: u32) -> Result<ListxattrReply> {
-		let empty_name = CString::new("").expect("invalid c string");
-		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
-
-		if node.whiteout.load(Ordering::Relaxed) {
-			return Err(Error::from_raw_os_error(libc::ENOENT));
-		}
-
-		let (layer, real_inode) = self.find_real_inode(ctx, inode)?;
-
-		layer.listxattr(ctx, real_inode, size)
-	}
-
-	fn removexattr(&self, ctx: &Context, inode: Inode, name: &CStr) -> Result<()> {
-		let empty_name = CString::new("").expect("invalid c string");
-		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
-
-		if node.whiteout.load(Ordering::Relaxed) {
-			return Err(Error::from_raw_os_error(libc::ENOENT));
-		}
-
-		if !self.node_in_upper_layer(Arc::clone(&node))? {
-			// copy node into upper layer
-			// FIXME:
-			self.copy_node_up(ctx, Arc::clone(&node))?;
-		}
-
-		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
-
-		let (layer, real_inode) = self.find_real_inode(ctx, inode)?;
-
-		layer.removexattr(ctx, real_inode, name)
-	}
-
-	fn fallocate(&self, ctx: &Context, inode: Inode, handle: Handle, mode: u32, offset: u64, length: u64) -> Result<()> {
-		let empty_name = CString::new("").expect("invalid c string");
-		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
-
-		if node.whiteout.load(Ordering::Relaxed) {
-			return Err(Error::from_raw_os_error(libc::ENOENT));
-		}
-
-		if !self.node_in_upper_layer(Arc::clone(&node))? {
-			// copy node into upper layer
-			// FIXME:
-			// only for node in upper layer, not in upper layer
-			// indicates open in readonly mode, and cannot fallocate
-			return Err(Error::from_raw_os_error(libc::EPERM));
-		}
-
-		let (layer, real_inode, real_handle) = self.find_real_info_from_handle(ctx, handle)?;
-
-		layer.fallocate(ctx, real_inode, real_handle, mode, offset, length)
-	}
-
-	fn lseek(&self, ctx: &Context, inode: Inode, handle: Handle, offset: u64, whence: u32) -> Result<u64> {
-		// can this be on dir? FIXME: assume file for now
-		// we need special process if it can be called on dir
-		let empty_name = CString::new("").expect("invalid c string");
-		let node = self.lookup_node(ctx, inode, empty_name.as_c_str())?;
-
-		if node.whiteout.load(Ordering::Relaxed) {
-			return Err(Error::from_raw_os_error(libc::ENOENT));
-		}
-
-		let st = node.stat64(ctx)?;
-		if st.st_mode & libc::S_IFMT == libc::S_IFDIR {
-			error!("lseek on directory");
-			return Err(Error::from_raw_os_error(libc::EINVAL));
-		}
-
-		let (layer, real_inode, real_handle) = self.find_real_info_from_handle(ctx, handle)?;
-		layer.lseek(ctx, real_inode, real_handle, offset, whence)
-	}
-
+    pub fn new(
+        upper: Option<Arc<BoxedLayer>>,
+        lowers: Vec<Arc<BoxedLayer>>,
+        params: Config,
+    ) -> Result<Self> {
+        // load root inode
+        Ok(OverlayFs {
+            config: params,
+            lower_layers: lowers,
+            upper_layer: upper,
+            inodes: RwLock::new(InodeStore::new()),
+            handles: Mutex::new(HashMap::new()),
+            next_handle: AtomicU64::new(1),
+            writeback: AtomicBool::new(false),
+            no_open: AtomicBool::new(false),
+            no_opendir: AtomicBool::new(false),
+            killpriv_v2: AtomicBool::new(false),
+            perfile_dax: AtomicBool::new(false),
+        })
+    }
+
+    pub fn root_inode(&self) -> Inode {
+        FUSE_ROOT_ID
+    }
+
+    fn alloc_inode(&self, path: &String) -> Result<u64> {
+        self.inodes.write().unwrap().alloc_inode(path)
+    }
+
+    pub fn import(&self) -> Result<()> {
+        let mut root = OverlayInode::new();
+        root.inode = FUSE_ROOT_ID;
+        root.path = String::from("");
+        root.name = String::from("");
+        root.lookups = AtomicU64::new(2);
+        root.real_inodes = Mutex::new(vec![]);
+        let ctx = Context::default();
+
+        // Update upper inode
+        if let Some(layer) = self.upper_layer.as_ref() {
+            let ino = layer.root_inode();
+            let real = RealInode::new(layer.clone(), true, ino, false, layer.is_opaque(&ctx, ino)?);
+            root.real_inodes.lock().unwrap().push(real);
+        }
+
+        // Update lower inodes.
+        for layer in self.lower_layers.iter() {
+            let ino = layer.root_inode();
+            let real = RealInode::new(
+                layer.clone(),
+                false,
+                ino,
+                false,
+                layer.is_opaque(&ctx, ino)?,
+            );
+            root.real_inodes.lock().unwrap().push(real);
+        }
+        let root_node = Arc::new(root);
+
+        // insert root inode into hash
+        self.insert_inode(FUSE_ROOT_ID, Arc::clone(&root_node));
+
+        info!("loading root directory\n");
+        self.load_directory(&ctx, &root_node)?;
+
+        Ok(())
+    }
+
+    fn root_node(&self) -> Arc<OverlayInode> {
+        // Root node must exist.
+        self.get_active_inode(FUSE_ROOT_ID).unwrap()
+    }
+
+    fn insert_inode(&self, inode: u64, node: Arc<OverlayInode>) {
+        self.inodes.write().unwrap().insert_inode(inode, node);
+    }
+
+    fn get_active_inode(&self, inode: u64) -> Option<Arc<OverlayInode>> {
+        self.inodes.read().unwrap().get_inode(inode)
+    }
+
+    // Get inode which is active or deleted.
+    fn get_all_inode(&self, inode: u64) -> Option<Arc<OverlayInode>> {
+        let inode_store = self.inodes.read().unwrap();
+        match inode_store.get_inode(inode) {
+            Some(n) => Some(n),
+            None => inode_store.get_deleted_inode(inode),
+        }
+    }
+
+    // Return the inode only if it's permanently deleted from both self.inodes and self.deleted_inodes.
+    fn remove_inode(&self, inode: u64, path_removed: Option<String>) -> Option<Arc<OverlayInode>> {
+        self.inodes
+            .write()
+            .unwrap()
+            .remove_inode(inode, path_removed)
+    }
+
+    // Lookup child OverlayInode with <name> under <parent> directory.
+    // If name is empty, return parent itself.
+    // Parent dir will be loaded, but returned OverlayInode won't.
+    fn lookup_node(&self, ctx: &Context, parent: Inode, name: &str) -> Result<Arc<OverlayInode>> {
+        if name.contains([SLASH_ASCII as char]) {
+            return Err(Error::from_raw_os_error(libc::EINVAL));
+        }
+
+        // Parent inode is expected to be loaded before this function is called.
+        let pnode = match self.get_active_inode(parent) {
+            Some(v) => v,
+            None => return Err(Error::from_raw_os_error(libc::ENOENT)),
+        };
+
+        // Parent is whiteout-ed, return ENOENT.
+        if pnode.whiteout.load(Ordering::Relaxed) {
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        let st = pnode.stat64(ctx)?;
+        if utils::is_dir(st) && !pnode.loaded.load(Ordering::Relaxed) {
+            // Parent is expected to be directory, load it first.
+            self.load_directory(ctx, &pnode)?;
+        }
+
+        // Current file or dir.
+        if name.eq(".")  
+            // Root directory has no parent.
+            || (parent == FUSE_ROOT_ID && name.eq("..")) 
+            // Special convention: empty name indicates current dir.
+            || name.is_empty()
+        {
+            return Ok(Arc::clone(&pnode));
+        }
+
+        match pnode.child(name) {
+            // Child is found.
+            Some(v) => Ok(v),
+            None => Err(Error::from_raw_os_error(libc::ENOENT)),
+        }
+    }
+
+    // As a debug function, print all inode numbers in hash table.
+    #[allow(dead_code)]
+    fn debug_print_all_inodes(&self) {
+        self.inodes.read().unwrap().debug_print_all_inodes();
+    }
+
+    fn lookup_node_ignore_enoent(
+        &self,
+        ctx: &Context,
+        parent: u64,
+        name: &str,
+    ) -> Result<Option<Arc<OverlayInode>>> {
+        match self.lookup_node(ctx, parent, name) {
+            Ok(n) => Ok(Some(Arc::clone(&n))),
+            Err(e) => {
+                if let Some(raw_error) = e.raw_os_error() {
+                    if raw_error == libc::ENOENT {
+                        return Ok(None);
+                    }
+                }
+                Err(e)
+            }
+        }
+    }
+
+    // Load entries of the directory from all layers, if node is not directory, return directly.
+    fn load_directory(&self, ctx: &Context, node: &Arc<OverlayInode>) -> Result<()> {
+        if node.loaded.load(Ordering::Relaxed) {
+            return Ok(());
+        }
+
+        // We got all childrens without inode.
+        let childrens = node.scan_childrens(ctx)?;
+
+        // =============== Start Lock Area ===================
+        // Lock OverlayFs inodes.
+        let mut inode_store = self.inodes.write().unwrap();
+        // Lock the OverlayInode and its childrens.
+        let mut node_children = node.childrens.lock().unwrap();
+
+        // Check again in case another 'load_directory' function call gets locks and want to do duplicated work.
+        if node.loaded.load(Ordering::Relaxed) {
+            return Ok(());
+        }
+
+        // Now we have two locks' protection, Fs inodes lock and OverlayInode's childrens lock.
+        for mut child in childrens.into_iter() {
+            // Allocate inode for each child.
+            let ino = inode_store.alloc_inode(&child.path)?;
+
+            let name = child.name.clone();
+            child.inode = ino;
+            // Create bi-directional link between parent and child.
+            child.parent = Mutex::new(Arc::downgrade(node));
+
+            let arc_child = Arc::new(child);
+            node_children.insert(name, arc_child.clone());
+            // Record overlay inode in whole OverlayFs.
+            inode_store.insert_inode(ino, arc_child.clone());
+        }
+
+        node.loaded.store(true, Ordering::Relaxed);
+
+        Ok(())
+    }
+
+    fn forget_one(&self, inode: Inode, count: u64) {
+        if inode == self.root_inode() || inode == 0 {
+            return;
+        }
+
+        let v = match self.get_all_inode(inode) {
+            Some(n) => n,
+            None => {
+                trace!("forget unknown inode: {}", inode);
+                return;
+            }
+        };
+
+        // FIXME: need atomic protection around lookups' load & store. @weizhang555
+        let mut lookups = v.lookups.load(Ordering::Relaxed);
+
+        if lookups < count {
+            lookups = 0;
+        } else {
+            lookups -= count;
+        }
+        v.lookups.store(lookups, Ordering::Relaxed);
+
+        // TODO: use compare_exchange.
+        //v.lookups.compare_exchange(old, new, Ordering::Acquire, Ordering::Relaxed);
+
+        if lookups == 0 {
+            debug!("inode is forgotten: {}, name {}", inode, v.name);
+            let _ = self.remove_inode(inode, None);
+            let parent = v.parent.lock().unwrap();
+
+            if let Some(p) = parent.upgrade() {
+                // remove it from hashmap
+                p.remove_child(v.name.as_str());
+            }
+        }
+    }
+
+    fn do_lookup(&self, ctx: &Context, parent: Inode, name: &str) -> Result<Entry> {
+        let node = self.lookup_node(ctx, parent, name)?;
+
+        if node.whiteout.load(Ordering::Relaxed) {
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        let st = node.stat64(ctx)?;
+
+        if utils::is_dir(st) && !node.loaded.load(Ordering::Relaxed) {
+            self.load_directory(ctx, &node)?;
+        }
+
+        // FIXME: can forget happen between found and increase reference counter?
+        let tmp = node.lookups.fetch_add(1, Ordering::Relaxed);
+        trace!("lookup count: {}", tmp + 1);
+        Ok(Entry {
+            inode: node.inode,
+            generation: 0,
+            attr: st,
+            attr_flags: 0,
+            attr_timeout: self.config.attr_timeout,
+            entry_timeout: self.config.entry_timeout,
+        })
+    }
+
+    fn do_statvfs(&self, ctx: &Context, inode: Inode) -> Result<statvfs64> {
+        match self.get_active_inode(inode) {
+            Some(ovi) => {
+                let all_inodes = ovi.real_inodes.lock().unwrap();
+                let real_inode = all_inodes
+                    .first()
+                    .ok_or(Error::new(ErrorKind::Other, "backend inode not found"))?;
+                real_inode.layer.statfs(ctx, real_inode.inode)
+            }
+            None => Err(Error::from_raw_os_error(libc::ENOENT)),
+        }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn do_readdir(
+        &self,
+        ctx: &Context,
+        inode: Inode,
+        handle: u64,
+        size: u32,
+        offset: u64,
+        is_readdirplus: bool,
+        add_entry: &mut dyn FnMut(DirEntry, Option<Entry>) -> Result<usize>,
+    ) -> Result<()> {
+        trace!(
+            "do_readir: handle: {}, size: {}, offset: {}",
+            handle,
+            size,
+            offset
+        );
+        if size == 0 {
+            return Ok(());
+        }
+
+        // lookup the directory
+        let ovl_inode = match self.handles.lock().unwrap().get(&handle) {
+            Some(dir) => dir.node.clone(),
+            None => {
+                // Try to get data with inode.
+                let node = self.lookup_node(ctx, inode, ".")?;
+
+                let st = node.stat64(ctx)?;
+                if !utils::is_dir(st) {
+                    return Err(Error::from_raw_os_error(libc::ENOTDIR));
+                }
+
+                node.clone()
+            }
+        };
+
+        let mut childrens = Vec::new();
+        //add myself as "."
+        childrens.push((".".to_string(), ovl_inode.clone()));
+
+        //add parent
+        let parent_node = match ovl_inode.parent.lock().unwrap().upgrade() {
+            Some(p) => p.clone(),
+            None => self.root_node(),
+        };
+        childrens.push(("..".to_string(), parent_node));
+
+        for (_, child) in ovl_inode.childrens.lock().unwrap().iter() {
+            // skip whiteout node
+            if child.whiteout.load(Ordering::Relaxed) {
+                continue;
+            }
+            childrens.push((child.name.clone(), child.clone()));
+        }
+
+        let mut len: usize = 0;
+        if offset >= childrens.len() as u64 {
+            return Ok(());
+        }
+
+        for (index, (name, child)) in (0_u64..).zip(childrens.into_iter()) {
+            if index >= offset {
+                // make struct DireEntry and Entry
+                let st = child.stat64(ctx)?;
+                let dir_entry = DirEntry {
+                    ino: st.st_ino,
+                    offset: index + 1,
+                    type_: entry_type_from_mode(st.st_mode) as u32,
+                    name: name.as_bytes(),
+                };
+
+                let entry = if is_readdirplus {
+                    child.lookups.fetch_add(1, Ordering::Relaxed);
+                    Some(Entry {
+                        inode: child.inode,
+                        generation: 0,
+                        attr: st,
+                        attr_flags: 0,
+                        attr_timeout: self.config.attr_timeout,
+                        entry_timeout: self.config.entry_timeout,
+                    })
+                } else {
+                    None
+                };
+                match add_entry(dir_entry, entry) {
+                    Ok(0) => break,
+                    Ok(l) => {
+                        len += l;
+                        if len as u32 >= size {
+                            // no more space, stop here
+                            return Ok(());
+                        }
+                    }
+
+                    Err(e) => {
+                        // when the buffer is still empty, return error, otherwise return the entry already added
+                        if len == 0 {
+                            return Err(e);
+                        } else {
+                            return Ok(());
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    fn do_mkdir(
+        &self,
+        ctx: &Context,
+        parent_node: &Arc<OverlayInode>,
+        name: &str,
+        mode: u32,
+        umask: u32,
+    ) -> Result<()> {
+        if self.upper_layer.is_none() {
+            return Err(Error::from_raw_os_error(libc::EROFS));
+        }
+
+        // Parent node was deleted.
+        if parent_node.whiteout.load(Ordering::Relaxed) {
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        let mut delete_whiteout = false;
+        let mut set_opaque = false;
+        if let Some(n) = self.lookup_node_ignore_enoent(ctx, parent_node.inode, name)? {
+            // Node with same name exists, let's check if it's whiteout.
+            if !n.whiteout.load(Ordering::Relaxed) {
+                return Err(Error::from_raw_os_error(libc::EEXIST));
+            }
+
+            if n.in_upper_layer() {
+                delete_whiteout = true;
+            }
+
+            // Set opaque if child dir has lower layers.
+            if !n.upper_layer_only() {
+                set_opaque = true;
+            }
+        }
+
+        // Copy parent node up if necessary.
+        let pnode = self.copy_node_up(ctx, Arc::clone(parent_node))?;
+
+        let mut new_node = None;
+        let path = format!("{}/{}", pnode.path, name);
+        pnode.handle_upper_inode_locked(&mut |parent_real_inode| -> Result<bool> {
+            let parent_real_inode = match parent_real_inode {
+                Some(inode) => inode,
+                None => {
+                    error!("BUG: parent doesn't have upper inode after copied up");
+                    return Err(Error::from_raw_os_error(libc::EINVAL));
+                }
+            };
+
+            if delete_whiteout {
+                let _ = parent_real_inode.layer.delete_whiteout(
+                    ctx,
+                    parent_real_inode.inode,
+                    utils::to_cstring(name)?.as_c_str(),
+                );
+            }
+            // Allocate inode number.
+            let ino = self.alloc_inode(&path)?;
+            let child_dir = parent_real_inode.mkdir(ctx, name, mode, umask)?;
+            // Set opaque if child dir has lower layers.
+            if set_opaque {
+                parent_real_inode.layer.set_opaque(ctx, child_dir.inode)?;
+            }
+            let ovi = OverlayInode::new_from_real_inode(name, ino, path.clone(), child_dir);
+
+            new_node.replace(ovi);
+            Ok(false)
+        })?;
+
+        // new_node is always 'Some'
+        let arc_node = Arc::new(new_node.unwrap());
+        self.insert_inode(arc_node.inode, arc_node.clone());
+        pnode.insert_child(name, arc_node);
+        Ok(())
+    }
+
+    fn do_mknod(
+        &self,
+        ctx: &Context,
+        parent_node: &Arc<OverlayInode>,
+        name: &str,
+        mode: u32,
+        rdev: u32,
+        umask: u32,
+    ) -> Result<()> {
+        if self.upper_layer.is_none() {
+            return Err(Error::from_raw_os_error(libc::EROFS));
+        }
+
+        // Parent node was deleted.
+        if parent_node.whiteout.load(Ordering::Relaxed) {
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        match self.lookup_node_ignore_enoent(ctx, parent_node.inode, name)? {
+            Some(n) => {
+                // Node with same name exists, let's check if it's whiteout.
+                if !n.whiteout.load(Ordering::Relaxed) {
+                    return Err(Error::from_raw_os_error(libc::EEXIST));
+                }
+
+                // Copy parent node up if necessary.
+                let pnode = self.copy_node_up(ctx, Arc::clone(parent_node))?;
+                pnode.handle_upper_inode_locked(&mut |parent_real_inode| -> Result<bool> {
+                    let parent_real_inode = match parent_real_inode {
+                        Some(inode) => inode,
+                        None => {
+                            error!("BUG: parent doesn't have upper inode after copied up");
+                            return Err(Error::from_raw_os_error(libc::EINVAL));
+                        }
+                    };
+
+                    if n.in_upper_layer() {
+                        let _ = parent_real_inode.layer.delete_whiteout(
+                            ctx,
+                            parent_real_inode.inode,
+                            utils::to_cstring(name)?.as_c_str(),
+                        );
+                    }
+
+                    let child_ri = parent_real_inode.mknod(ctx, name, mode, rdev, umask)?;
+
+                    // Replace existing real inodes with new one.
+                    n.add_upper_inode(child_ri, true);
+                    Ok(false)
+                })?;
+            }
+            None => {
+                // Copy parent node up if necessary.
+                let pnode = self.copy_node_up(ctx, Arc::clone(parent_node))?;
+                let mut new_node = None;
+                let path = format!("{}/{}", pnode.path, name);
+                pnode.handle_upper_inode_locked(&mut |parent_real_inode| -> Result<bool> {
+                    let parent_real_inode = match parent_real_inode {
+                        Some(inode) => inode,
+                        None => {
+                            error!("BUG: parent doesn't have upper inode after copied up");
+                            return Err(Error::from_raw_os_error(libc::EINVAL));
+                        }
+                    };
+
+                    // Allocate inode number.
+                    let ino = self.alloc_inode(&path)?;
+                    let child_ri = parent_real_inode.mknod(ctx, name, mode, rdev, umask)?;
+                    let ovi = OverlayInode::new_from_real_inode(name, ino, path.clone(), child_ri);
+
+                    new_node.replace(ovi);
+                    Ok(false)
+                })?;
+
+                // new_node is always 'Some'
+                let arc_node = Arc::new(new_node.unwrap());
+                self.insert_inode(arc_node.inode, arc_node.clone());
+                pnode.insert_child(name, arc_node);
+            }
+        }
+
+        Ok(())
+    }
+
+    fn do_create(
+        &self,
+        ctx: &Context,
+        parent_node: &Arc<OverlayInode>,
+        name: &str,
+        args: CreateIn,
+    ) -> Result<Option<u64>> {
+        let upper = self
+            .upper_layer
+            .as_ref()
+            .cloned()
+            .ok_or_else(|| Error::from_raw_os_error(libc::EROFS))?;
+
+        // Parent node was deleted.
+        if parent_node.whiteout.load(Ordering::Relaxed) {
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        let mut handle = None;
+        let mut real_ino = 0u64;
+        let new_ovi = match self.lookup_node_ignore_enoent(ctx, parent_node.inode, name)? {
+            Some(n) => {
+                // Node with same name exists, let's check if it's whiteout.
+                if !n.whiteout.load(Ordering::Relaxed) {
+                    return Err(Error::from_raw_os_error(libc::EEXIST));
+                }
+
+                // Copy parent node up if necessary.
+                let pnode = self.copy_node_up(ctx, Arc::clone(parent_node))?;
+                pnode.handle_upper_inode_locked(&mut |parent_real_inode| -> Result<bool> {
+                    let parent_real_inode = match parent_real_inode {
+                        Some(inode) => inode,
+                        None => {
+                            error!("BUG: parent doesn't have upper inode after copied up");
+                            return Err(Error::from_raw_os_error(libc::EINVAL));
+                        }
+                    };
+
+                    if n.in_upper_layer() {
+                        let _ = parent_real_inode.layer.delete_whiteout(
+                            ctx,
+                            parent_real_inode.inode,
+                            utils::to_cstring(name)?.as_c_str(),
+                        );
+                    }
+
+                    let (child_ri, hd) = parent_real_inode.create(ctx, name, args)?;
+                    real_ino = child_ri.inode;
+                    handle = hd;
+
+                    // Replace existing real inodes with new one.
+                    n.add_upper_inode(child_ri, true);
+                    Ok(false)
+                })?;
+                n.clone()
+            }
+            None => {
+                // Copy parent node up if necessary.
+                let pnode = self.copy_node_up(ctx, Arc::clone(parent_node))?;
+                let mut new_node = None;
+                let path = format!("{}/{}", pnode.path, name);
+                pnode.handle_upper_inode_locked(&mut |parent_real_inode| -> Result<bool> {
+                    let parent_real_inode = match parent_real_inode {
+                        Some(inode) => inode,
+                        None => {
+                            error!("BUG: parent doesn't have upper inode after copied up");
+                            return Err(Error::from_raw_os_error(libc::EINVAL));
+                        }
+                    };
+
+                    let (child_ri, hd) = parent_real_inode.create(ctx, name, args)?;
+                    real_ino = child_ri.inode;
+                    handle = hd;
+                    // Allocate inode number.
+                    let ino = self.alloc_inode(&path)?;
+                    let ovi = OverlayInode::new_from_real_inode(name, ino, path.clone(), child_ri);
+
+                    new_node.replace(ovi);
+                    Ok(false)
+                })?;
+
+                // new_node is always 'Some'
+                let arc_node = Arc::new(new_node.unwrap());
+                self.insert_inode(arc_node.inode, arc_node.clone());
+                pnode.insert_child(name, arc_node.clone());
+                arc_node
+            }
+        };
+
+        let final_handle = match handle {
+            Some(hd) => {
+                if self.no_open.load(Ordering::Relaxed) {
+                    None
+                } else {
+                    let handle = self.next_handle.fetch_add(1, Ordering::Relaxed);
+                    let handle_data = HandleData {
+                        node: new_ovi,
+                        real_handle: Some(RealHandle {
+                            layer: upper.clone(),
+                            in_upper_layer: true,
+                            inode: real_ino,
+                            handle: AtomicU64::new(hd),
+                        }),
+                    };
+                    self.handles
+                        .lock()
+                        .unwrap()
+                        .insert(handle, Arc::new(handle_data));
+                    Some(handle)
+                }
+            }
+            None => None,
+        };
+        Ok(final_handle)
+    }
+
+    fn do_link(
+        &self,
+        ctx: &Context,
+        src_node: &Arc<OverlayInode>,
+        new_parent: &Arc<OverlayInode>,
+        name: &str,
+    ) -> Result<()> {
+        if self.upper_layer.is_none() {
+            return Err(Error::from_raw_os_error(libc::EROFS));
+        }
+
+        // Node is whiteout.
+        if src_node.whiteout.load(Ordering::Relaxed) || new_parent.whiteout.load(Ordering::Relaxed)
+        {
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        let st = src_node.stat64(ctx)?;
+        if utils::is_dir(st) {
+            // Directory can't be hardlinked.
+            return Err(Error::from_raw_os_error(libc::EPERM));
+        }
+
+        let src_node = self.copy_node_up(ctx, Arc::clone(src_node))?;
+        let new_parent = self.copy_node_up(ctx, Arc::clone(new_parent))?;
+        let src_ino = src_node.first_layer_inode().2;
+
+        match self.lookup_node_ignore_enoent(ctx, new_parent.inode, name)? {
+            Some(n) => {
+                // Node with same name exists, let's check if it's whiteout.
+                if !n.whiteout.load(Ordering::Relaxed) {
+                    return Err(Error::from_raw_os_error(libc::EEXIST));
+                }
+
+                // Node is definitely a whiteout now.
+                new_parent.handle_upper_inode_locked(&mut |parent_real_inode| -> Result<bool> {
+                    let parent_real_inode = match parent_real_inode {
+                        Some(inode) => inode,
+                        None => {
+                            error!("BUG: parent doesn't have upper inode after copied up");
+                            return Err(Error::from_raw_os_error(libc::EINVAL));
+                        }
+                    };
+
+                    // Whiteout file exists in upper level, let's delete it.
+                    if n.in_upper_layer() {
+                        let _ = parent_real_inode.layer.delete_whiteout(
+                            ctx,
+                            parent_real_inode.inode,
+                            utils::to_cstring(name)?.as_c_str(),
+                        );
+                    }
+
+                    let child_ri = parent_real_inode.link(ctx, src_ino, name)?;
+
+                    // Replace existing real inodes with new one.
+                    n.add_upper_inode(child_ri, true);
+                    Ok(false)
+                })?;
+            }
+            None => {
+                // Copy parent node up if necessary.
+                let mut new_node = None;
+                new_parent.handle_upper_inode_locked(&mut |parent_real_inode| -> Result<bool> {
+                    let parent_real_inode = match parent_real_inode {
+                        Some(inode) => inode,
+                        None => {
+                            error!("BUG: parent doesn't have upper inode after copied up");
+                            return Err(Error::from_raw_os_error(libc::EINVAL));
+                        }
+                    };
+
+                    // Allocate inode number.
+                    let path = format!("{}/{}", new_parent.path, name);
+                    let ino = self.alloc_inode(&path)?;
+                    let child_ri = parent_real_inode.link(ctx, src_ino, name)?;
+                    let ovi = OverlayInode::new_from_real_inode(name, ino, path, child_ri);
+
+                    new_node.replace(ovi);
+                    Ok(false)
+                })?;
+
+                // new_node is always 'Some'
+                let arc_node = Arc::new(new_node.unwrap());
+                self.insert_inode(arc_node.inode, arc_node.clone());
+                new_parent.insert_child(name, arc_node);
+            }
+        }
+
+        Ok(())
+    }
+
+    fn do_symlink(
+        &self,
+        ctx: &Context,
+        linkname: &str,
+        parent_node: &Arc<OverlayInode>,
+        name: &str,
+    ) -> Result<()> {
+        if self.upper_layer.is_none() {
+            return Err(Error::from_raw_os_error(libc::EROFS));
+        }
+
+        // parent was deleted.
+        if parent_node.whiteout.load(Ordering::Relaxed) {
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        match self.lookup_node_ignore_enoent(ctx, parent_node.inode, name)? {
+            Some(n) => {
+                // Node with same name exists, let's check if it's whiteout.
+                if !n.whiteout.load(Ordering::Relaxed) {
+                    return Err(Error::from_raw_os_error(libc::EEXIST));
+                }
+
+                // Copy parent node up if necessary.
+                let pnode = self.copy_node_up(ctx, Arc::clone(parent_node))?;
+                pnode.handle_upper_inode_locked(&mut |parent_real_inode| -> Result<bool> {
+                    let parent_real_inode = match parent_real_inode {
+                        Some(inode) => inode,
+                        None => {
+                            error!("BUG: parent doesn't have upper inode after copied up");
+                            return Err(Error::from_raw_os_error(libc::EINVAL));
+                        }
+                    };
+
+                    if n.in_upper_layer() {
+                        let _ = parent_real_inode.layer.delete_whiteout(
+                            ctx,
+                            parent_real_inode.inode,
+                            utils::to_cstring(name)?.as_c_str(),
+                        );
+                    }
+
+                    let child_ri = parent_real_inode.symlink(ctx, linkname, name)?;
+
+                    // Replace existing real inodes with new one.
+                    n.add_upper_inode(child_ri, true);
+                    Ok(false)
+                })?;
+            }
+            None => {
+                // Copy parent node up if necessary.
+                let pnode = self.copy_node_up(ctx, Arc::clone(parent_node))?;
+                let mut new_node = None;
+                let path = format!("{}/{}", pnode.path, name);
+                pnode.handle_upper_inode_locked(&mut |parent_real_inode| -> Result<bool> {
+                    let parent_real_inode = match parent_real_inode {
+                        Some(inode) => inode,
+                        None => {
+                            error!("BUG: parent doesn't have upper inode after copied up");
+                            return Err(Error::from_raw_os_error(libc::EINVAL));
+                        }
+                    };
+
+                    // Allocate inode number.
+                    let ino = self.alloc_inode(&path)?;
+                    let child_ri = parent_real_inode.symlink(ctx, linkname, name)?;
+                    let ovi = OverlayInode::new_from_real_inode(name, ino, path.clone(), child_ri);
+
+                    new_node.replace(ovi);
+                    Ok(false)
+                })?;
+
+                // new_node is always 'Some'
+                let arc_node = Arc::new(new_node.unwrap());
+                self.insert_inode(arc_node.inode, arc_node.clone());
+                pnode.insert_child(name, arc_node);
+            }
+        }
+
+        Ok(())
+    }
+
+    fn copy_symlink_up(&self, ctx: &Context, node: Arc<OverlayInode>) -> Result<Arc<OverlayInode>> {
+        if node.in_upper_layer() {
+            return Ok(node);
+        }
+
+        let parent_node = if let Some(ref n) = node.parent.lock().unwrap().upgrade() {
+            Arc::clone(n)
+        } else {
+            return Err(Error::new(ErrorKind::Other, "no parent?"));
+        };
+
+        let (self_layer, _, self_inode) = node.first_layer_inode();
+
+        if !parent_node.in_upper_layer() {
+            parent_node.create_upper_dir(ctx, None)?;
+        }
+
+        // Read the linkname from lower layer.
+        let path = self_layer.readlink(ctx, self_inode)?;
+        // Convert path to &str.
+        let path =
+            std::str::from_utf8(&path).map_err(|_| Error::from_raw_os_error(libc::EINVAL))?;
+
+        let mut new_upper_real = None;
+        parent_node.handle_upper_inode_locked(&mut |parent_upper_inode| -> Result<bool> {
+            // We already create upper dir for parent_node above.
+            let parent_real_inode =
+                parent_upper_inode.ok_or_else(|| Error::from_raw_os_error(libc::EROFS))?;
+            new_upper_real.replace(parent_real_inode.symlink(ctx, path, node.name.as_str())?);
+            Ok(false)
+        })?;
+
+        if let Some(real_inode) = new_upper_real {
+            // update upper_inode and first_inode()
+            node.add_upper_inode(real_inode, true);
+        }
+
+        Ok(Arc::clone(&node))
+    }
+
+    // Copy regular file from lower layer to upper layer.
+    // Caller must ensure node doesn't have upper layer.
+    fn copy_regfile_up(&self, ctx: &Context, node: Arc<OverlayInode>) -> Result<Arc<OverlayInode>> {
+        if node.in_upper_layer() {
+            return Ok(node);
+        }
+
+        let parent_node = if let Some(ref n) = node.parent.lock().unwrap().upgrade() {
+            Arc::clone(n)
+        } else {
+            return Err(Error::new(ErrorKind::Other, "no parent?"));
+        };
+
+        let st = node.stat64(ctx)?;
+        let (lower_layer, _, lower_inode) = node.first_layer_inode();
+
+        if !parent_node.in_upper_layer() {
+            parent_node.create_upper_dir(ctx, None)?;
+        }
+
+        // create the file in upper layer using information from lower layer
+        let args = CreateIn {
+            flags: libc::O_WRONLY as u32,
+            mode: st.st_mode,
+            umask: 0,
+            fuse_flags: 0,
+        };
+
+        let mut upper_handle = 0u64;
+        let mut upper_real_inode = None;
+        parent_node.handle_upper_inode_locked(&mut |parent_upper_inode| -> Result<bool> {
+            // We already create upper dir for parent_node.
+            let parent_real_inode = parent_upper_inode.ok_or_else(|| {
+                error!("parent {} has no upper inode", parent_node.inode);
+                Error::from_raw_os_error(libc::EINVAL)
+            })?;
+            let (inode, h) = parent_real_inode.create(ctx, node.name.as_str(), args)?;
+            upper_handle = h.unwrap_or(0);
+            upper_real_inode.replace(inode);
+            Ok(false)
+        })?;
+
+        let (h, _, _) = lower_layer.open(ctx, lower_inode, libc::O_RDONLY as u32, 0)?;
+
+        let lower_handle = h.unwrap_or(0);
+
+        // need to use work directory and then rename file to
+        // final destination for atomic reasons.. not deal with it for now,
+        // use stupid copy at present.
+        // FIXME: this need a lot of work here, ntimes, xattr, etc.
+
+        // Copy from lower real inode to upper real inode.
+        let mut file = TempFile::new().unwrap().into_file();
+        let mut offset: usize = 0;
+        let size = 4 * 1024 * 1024;
+        loop {
+            let ret = lower_layer.read(
+                ctx,
+                lower_inode,
+                lower_handle,
+                &mut file,
+                size,
+                offset as u64,
+                None,
+                0,
+            )?;
+            if ret == 0 {
+                break;
+            }
+
+            offset += ret;
+        }
+        // close handles
+        lower_layer.release(ctx, lower_inode, 0, lower_handle, true, true, None)?;
+
+        file.seek(SeekFrom::Start(0))?;
+        offset = 0;
+
+        while let Some(ref ri) = upper_real_inode {
+            let ret = ri.layer.write(
+                ctx,
+                ri.inode,
+                upper_handle,
+                &mut file,
+                size,
+                offset as u64,
+                None,
+                false,
+                0,
+                0,
+            )?;
+            if ret == 0 {
+                break;
+            }
+
+            offset += ret;
+        }
+
+        // Drop will remove file automatically.
+        drop(file);
+
+        if let Some(ri) = upper_real_inode {
+            if let Err(e) = ri
+                .layer
+                .release(ctx, ri.inode, 0, upper_handle, true, true, None)
+            {
+                // Ignore ENOSYS.
+                if e.raw_os_error() != Some(libc::ENOSYS) {
+                    return Err(e);
+                }
+            }
+
+            // update upper_inode and first_inode()
+            node.add_upper_inode(ri, true);
+        }
+
+        Ok(Arc::clone(&node))
+    }
+
+    fn copy_node_up(&self, ctx: &Context, node: Arc<OverlayInode>) -> Result<Arc<OverlayInode>> {
+        if node.in_upper_layer() {
+            return Ok(node);
+        }
+
+        let st = node.stat64(ctx)?;
+        // directory
+        if utils::is_dir(st) {
+            node.create_upper_dir(ctx, None)?;
+            return Ok(Arc::clone(&node));
+        }
+
+        // For symlink.
+        if st.st_mode & libc::S_IFMT == libc::S_IFLNK {
+            return self.copy_symlink_up(ctx, Arc::clone(&node));
+        }
+
+        // For regular file.
+        self.copy_regfile_up(ctx, Arc::clone(&node))
+    }
+
+    fn do_rm(&self, ctx: &Context, parent: u64, name: &CStr, dir: bool) -> Result<()> {
+        if self.upper_layer.is_none() {
+            return Err(Error::from_raw_os_error(libc::EROFS));
+        }
+
+        // Find parent Overlay Inode.
+        let pnode = self.lookup_node(ctx, parent, "")?;
+        if pnode.whiteout.load(Ordering::Relaxed) {
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        // Find the Overlay Inode for child with <name>.
+        let sname = name.to_string_lossy().to_string();
+        let node = self.lookup_node(ctx, parent, sname.as_str())?;
+        if node.whiteout.load(Ordering::Relaxed) {
+            // already deleted.
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        if dir {
+            self.load_directory(ctx, &node)?;
+            let (count, whiteouts) = node.count_entries_and_whiteout(ctx)?;
+            trace!("entries: {}, whiteouts: {}\n", count, whiteouts);
+            if count > 0 {
+                return Err(Error::from_raw_os_error(libc::ENOTEMPTY));
+            }
+
+            // Delete all whiteouts.
+            if whiteouts > 0 && node.in_upper_layer() {
+                self.empty_node_directory(ctx, Arc::clone(&node))?;
+            }
+
+            trace!("whiteouts deleted!\n");
+        }
+
+        let mut need_whiteout = true;
+        let pnode = self.copy_node_up(ctx, Arc::clone(&pnode))?;
+
+        if node.upper_layer_only() {
+            need_whiteout = false;
+        }
+
+        let mut path_removed = None;
+        if node.in_upper_layer() {
+            pnode.handle_upper_inode_locked(&mut |parent_upper_inode| -> Result<bool> {
+                let parent_real_inode = parent_upper_inode.ok_or_else(|| {
+                    error!(
+                        "BUG: parent {} has no upper inode after copy up",
+                        pnode.inode
+                    );
+                    Error::from_raw_os_error(libc::EINVAL)
+                })?;
+
+                // Parent is opaque, it shadows everything in lower layers so no need to create extra whiteouts.
+                if parent_real_inode.opaque {
+                    need_whiteout = false;
+                }
+                if dir {
+                    parent_real_inode
+                        .layer
+                        .rmdir(ctx, parent_real_inode.inode, name)?;
+                } else {
+                    parent_real_inode
+                        .layer
+                        .unlink(ctx, parent_real_inode.inode, name)?;
+                }
+
+                Ok(false)
+            })?;
+
+            path_removed.replace(node.path.clone());
+        }
+
+        trace!(
+            "Remove inode {} from global hashmap and parent's children hashmap\n",
+            node.inode
+        );
+
+        // lookups decrease by 1.
+        node.lookups.fetch_sub(1, Ordering::Relaxed);
+
+        // remove it from hashmap
+        self.remove_inode(node.inode, path_removed);
+        pnode.remove_child(node.name.as_str());
+
+        if need_whiteout {
+            trace!("do_rm: creating whiteout\n");
+            // pnode is copied up, so it has upper layer.
+            pnode.handle_upper_inode_locked(&mut |parent_upper_inode| -> Result<bool> {
+                let parent_real_inode = parent_upper_inode.ok_or_else(|| {
+                    error!(
+                        "BUG: parent {} has no upper inode after copy up",
+                        pnode.inode
+                    );
+                    Error::from_raw_os_error(libc::EINVAL)
+                })?;
+
+                let child_ri = parent_real_inode.create_whiteout(ctx, sname.as_str())?;
+                let path = format!("{}/{}", pnode.path, sname);
+                let ino = self.alloc_inode(&path)?;
+                let ovi = Arc::new(OverlayInode::new_from_real_inode(
+                    sname.as_str(),
+                    ino,
+                    path.clone(),
+                    child_ri,
+                ));
+
+                self.insert_inode(ino, ovi.clone());
+                pnode.insert_child(sname.as_str(), ovi.clone());
+                Ok(false)
+            })?;
+        }
+
+        Ok(())
+    }
+
+    fn do_fsync(
+        &self,
+        ctx: &Context,
+        inode: Inode,
+        datasync: bool,
+        handle: Handle,
+        syncdir: bool,
+    ) -> Result<()> {
+        // Use O_RDONLY flags which indicates no copy up.
+        let data = self.get_data(ctx, Some(handle), inode, libc::O_RDONLY as u32)?;
+
+        match data.real_handle {
+            // FIXME: need to test if inode matches corresponding handle?
+            None => Err(Error::from_raw_os_error(libc::ENOENT)),
+            Some(ref rh) => {
+                let real_handle = rh.handle.load(Ordering::Relaxed);
+                // TODO: check if it's in upper layer? @weizhang555
+                if syncdir {
+                    rh.layer.fsyncdir(ctx, rh.inode, datasync, real_handle)
+                } else {
+                    rh.layer.fsync(ctx, rh.inode, datasync, real_handle)
+                }
+            }
+        }
+    }
+
+    // Delete everything in the directory only on upper layer, ignore lower layers.
+    fn empty_node_directory(&self, ctx: &Context, node: Arc<OverlayInode>) -> Result<()> {
+        let st = node.stat64(ctx)?;
+        if !utils::is_dir(st) {
+            // This function can only be called on directories.
+            return Err(Error::from_raw_os_error(libc::ENOTDIR));
+        }
+
+        let (layer, in_upper, inode) = node.first_layer_inode();
+        if !in_upper {
+            return Ok(());
+        }
+
+        // Copy node.childrens Hashmap to Vector, the Vector is also used as temp storage,
+        // Without this, Rust won't allow us to remove them from node.childrens.
+        let iter = node
+            .childrens
+            .lock()
+            .unwrap()
+            .iter()
+            .map(|(_, v)| v.clone())
+            .collect::<Vec<_>>();
+
+        for child in iter {
+            // We only care about upper layer, ignore lower layers.
+            if child.in_upper_layer() {
+                if child.whiteout.load(Ordering::Relaxed) {
+                    layer.delete_whiteout(
+                        ctx,
+                        inode,
+                        utils::to_cstring(child.name.as_str())?.as_c_str(),
+                    )?
+                } else {
+                    let s = child.stat64(ctx)?;
+                    let cname = utils::to_cstring(&child.name)?;
+                    if utils::is_dir(s) {
+                        let (count, whiteouts) = child.count_entries_and_whiteout(ctx)?;
+                        if count + whiteouts > 0 {
+                            self.empty_node_directory(ctx, Arc::clone(&child))?;
+                        }
+
+                        layer.rmdir(ctx, inode, cname.as_c_str())?
+                    } else {
+                        layer.unlink(ctx, inode, cname.as_c_str())?;
+                    }
+                }
+
+                // delete the child
+                self.remove_inode(child.inode, Some(child.path.clone()));
+                node.remove_child(child.name.as_str());
+            }
+        }
+
+        Ok(())
+    }
+
+    fn find_real_info_from_handle(
+        &self,
+        handle: Handle,
+    ) -> Result<(Arc<BoxedLayer>, Inode, Handle)> {
+        match self.handles.lock().unwrap().get(&handle) {
+            Some(h) => match h.real_handle {
+                Some(ref rhd) => Ok((
+                    rhd.layer.clone(),
+                    rhd.inode,
+                    rhd.handle.load(Ordering::Relaxed),
+                )),
+                None => Err(Error::from_raw_os_error(libc::ENOENT)),
+            },
+
+            None => Err(Error::from_raw_os_error(libc::ENOENT)),
+        }
+    }
+
+    fn find_real_inode(&self, inode: Inode) -> Result<(Arc<BoxedLayer>, Inode)> {
+        if let Some(n) = self.get_active_inode(inode) {
+            let (first_layer, _, first_inode) = n.first_layer_inode();
+            return Ok((first_layer, first_inode));
+        }
+
+        Err(Error::from_raw_os_error(libc::ENOENT))
+    }
+
+    fn get_data(
+        &self,
+        ctx: &Context,
+        handle: Option<Handle>,
+        inode: Inode,
+        flags: u32,
+    ) -> Result<Arc<HandleData>> {
+        let no_open = self.no_open.load(Ordering::Relaxed);
+        if !no_open {
+            if let Some(h) = handle {
+                if let Some(v) = self.handles.lock().unwrap().get(&h) {
+                    if v.node.inode == inode {
+                        return Ok(Arc::clone(v));
+                    }
+                }
+            }
+        } else {
+            let readonly: bool = flags
+                & (libc::O_APPEND | libc::O_CREAT | libc::O_TRUNC | libc::O_RDWR | libc::O_WRONLY)
+                    as u32
+                == 0;
+
+            // lookup node
+            let node = self.lookup_node(ctx, inode, "")?;
+
+            // whiteout node
+            if node.whiteout.load(Ordering::Relaxed) {
+                return Err(Error::from_raw_os_error(libc::ENOENT));
+            }
+
+            if !readonly {
+                // Check if upper layer exists, return EROFS is not exists.
+                self.upper_layer
+                    .as_ref()
+                    .cloned()
+                    .ok_or_else(|| Error::from_raw_os_error(libc::EROFS))?;
+                // copy up to upper layer
+                self.copy_node_up(ctx, Arc::clone(&node))?;
+            }
+
+            let (layer, in_upper_layer, inode) = node.first_layer_inode();
+            let handle_data = HandleData {
+                node: Arc::clone(&node),
+                real_handle: Some(RealHandle {
+                    layer,
+                    in_upper_layer,
+                    inode,
+                    handle: AtomicU64::new(0),
+                }),
+            };
+            return Ok(Arc::new(handle_data));
+        }
+
+        Err(Error::from_raw_os_error(libc::ENOENT))
+    }
 }
 
-
 impl ZeroCopyReader for File {
-	fn read_to(&mut self, f: &mut dyn FileReadWriteVolatile, count: usize, off: u64) -> Result<usize> {
-		let mut buf = Vec::<u8>::with_capacity(count);
-		unsafe { buf.set_len(count); }
-		let slice = unsafe { FileVolatileSlice::from_raw_ptr(buf.as_mut_ptr(), count) };
-
-		let ret = f.read_at_volatile(slice, off)?;
-		if ret > 0 {
-			let slice = unsafe { FileVolatileSlice::from_raw_ptr(buf.as_mut_ptr(), ret) };
-			f.write_volatile(slice)
-		} else {
-			Ok(0)
-		}
-	}
+    // Copies at most count bytes from self directly into f at offset off
+    // without storing it in any intermediate buffers.
+    fn read_to(
+        &mut self,
+        f: &mut dyn FileReadWriteVolatile,
+        count: usize,
+        off: u64,
+    ) -> Result<usize> {
+        let mut buf = vec![0_u8; count];
+        let slice = unsafe { FileVolatileSlice::from_raw_ptr(buf.as_mut_ptr(), count) };
+
+        // Read from self to slice.
+        let ret = self.read_volatile(slice)?;
+        if ret > 0 {
+            let slice = unsafe { FileVolatileSlice::from_raw_ptr(buf.as_mut_ptr(), ret) };
+            // Write from slice to f at offset off.
+            f.write_at_volatile(slice, off)
+        } else {
+            Ok(0)
+        }
+    }
 }
 
 impl ZeroCopyWriter for File {
-	fn write_from(&mut self, f: &mut dyn FileReadWriteVolatile, count: usize, off: u64) -> Result<usize> {
-		let mut buf = Vec::<u8>::with_capacity(count);
-		unsafe { buf.set_len(count); }
-		let slice = unsafe { FileVolatileSlice::from_raw_ptr(buf.as_mut_ptr(), count) };
-		let ret = f.read_at_volatile(slice, off)?;
-
-		if ret > 0 {
-			let slice = unsafe { FileVolatileSlice::from_raw_ptr(buf.as_mut_ptr(), ret) };
-			self.write_volatile(slice)
-		} else {
-			Ok(0)
-		}
-	}
+    // Copies at most count bytes from f at offset off directly into self
+    // without storing it in any intermediate buffers.
+    fn write_from(
+        &mut self,
+        f: &mut dyn FileReadWriteVolatile,
+        count: usize,
+        off: u64,
+    ) -> Result<usize> {
+        let mut buf = vec![0_u8; count];
+        let slice = unsafe { FileVolatileSlice::from_raw_ptr(buf.as_mut_ptr(), count) };
+        // Read from f at offset off to slice.
+        let ret = f.read_at_volatile(slice, off)?;
+
+        if ret > 0 {
+            let slice = unsafe { FileVolatileSlice::from_raw_ptr(buf.as_mut_ptr(), ret) };
+            // Write from slice to self.
+            self.write_volatile(slice)
+        } else {
+            Ok(0)
+        }
+    }
+
+    fn available_bytes(&self) -> usize {
+        // Max usize
+        usize::MAX
+    }
+}
+
+#[cfg(not(feature = "async-io"))]
+impl BackendFileSystem for OverlayFs {
+    /// mount returns the backend file system root inode entry and
+    /// the largest inode number it has.
+    fn mount(&self) -> Result<(Entry, u64)> {
+        let ctx = Context::default();
+        let entry = self.do_lookup(&ctx, self.root_inode(), "")?;
+        Ok((entry, VFS_MAX_INO))
+    }
+
+    /// Provides a reference to the Any trait. This is useful to let
+    /// the caller have access to the underlying type behind the
+    /// trait.
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
 }
diff --git a/src/overlayfs/plugin.rs b/src/overlayfs/plugin.rs
deleted file mode 100644
index 11480d947..000000000
--- a/src/overlayfs/plugin.rs
+++ /dev/null
@@ -1,92 +0,0 @@
-
-#![allow(missing_docs)]
-
-use std::collections::{HashMap, LinkedList};
-use std::io::Result;
-use std::sync::{Arc};
-use std::io::{Error, ErrorKind};
-use libc;
-
-use self::super::layer::Layer;
-use self::super::PLUGIN_PREFIX;
-use self::super::direct::Direct;
-use self::super::BoxedLayer;
-
-pub type BoxedPlugin = Box<dyn Plugin + Send + Sync>;
-
-/// ! plugin trait
-pub trait Plugin {
-	///! name
-	fn name(&self) -> String;
-	///! load data source
-	fn load(&self, opaque: String, upper: bool) -> Result<LinkedList<Arc<BoxedLayer>>>;
-	///! release plugin
-	fn release(&self) -> Result<()>;
-}
-
-///! plugin manager
-pub struct PluginManager {
-	///! inner data
-	pub plugins: HashMap<String, Arc<Box<dyn Plugin + Send + Sync>>>,
-}
-
-impl PluginManager {
-	///! new
-	pub fn new() -> Self {
-		PluginManager {
-			plugins: HashMap::new(),
-		}
-	}
-
-	///! register a plugin
-	pub fn register(&mut self, name: String, plugin: Arc<Box<dyn Plugin + Send + Sync>>) -> Result<()> {
-		if self.plugins.get(name.as_str()).is_some() {
-			return Err(Error::from_raw_os_error(libc::EEXIST));
-		}
-		self.plugins.insert(name, plugin);
-
-		Ok(())
-	}
-
-	///! find a registerd plugin
-	pub fn get_plugin(&self, name: String) -> Option<Arc<Box<dyn Plugin + Send + Sync>>> {
-		if let Some(ref v) = self.plugins.get(name.as_str()) {
-			Some(Arc::clone(v))
-		} else {
-			None
-		}
-	}
-}
-
-pub fn find_plugin(manager: &PluginManager, name: String) -> Option<Arc<Box<dyn Plugin + Send + Sync>>> {
-	manager.get_plugin(name)
-}
-
-pub fn process_onelayer(manager: &PluginManager, opaque: String, upper: bool) -> Result<LinkedList<Arc<BoxedLayer>>> {
-	if opaque.starts_with(PLUGIN_PREFIX) {
-		// plugin
-		let striped = opaque.strip_prefix(PLUGIN_PREFIX).unwrap();
-		let ps: Vec<&str> = striped.splitn(2, "/").collect();
-		if ps.len() != 2 {
-			error!("invalid upperdir parameters!");
-			return Err(Error::from(ErrorKind::InvalidData));
-		}
-
-		let plugin_name = ps[0];
-		let plugin_params = ps[1];
-		let plugin = match manager.get_plugin(plugin_name.into()) {
-			Some(v) => v,
-			None => {
-				error!("unknown plugin");
-				return Err(Error::from(ErrorKind::InvalidData));
-			}
-		};
-
-		// load layers from plugin
-		return plugin.load(plugin_params.into(), upper);
-
-	} else {
-		// directory
-		return Direct::new(opaque, upper);
-	}
-}
diff --git a/src/overlayfs/sync_io.rs b/src/overlayfs/sync_io.rs
new file mode 100644
index 000000000..57d111f42
--- /dev/null
+++ b/src/overlayfs/sync_io.rs
@@ -0,0 +1,913 @@
+// Copyright (C) 2023 Ant Group. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+use super::*;
+use std::ffi::CStr;
+use std::io::Result;
+
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::Arc;
+use std::time::Duration;
+
+use crate::abi::fuse_abi::{stat64, statvfs64, CreateIn};
+use crate::api::filesystem::{
+    Context, DirEntry, Entry, FileSystem, FsOptions, GetxattrReply, ListxattrReply, OpenOptions,
+    SetattrValid, ZeroCopyReader, ZeroCopyWriter,
+};
+
+use libc;
+use std::io::{Error, ErrorKind};
+
+impl FileSystem for OverlayFs {
+    type Inode = Inode;
+    type Handle = Handle;
+
+    fn init(&self, capable: FsOptions) -> Result<FsOptions> {
+        // use vfs' negotiated capability if imported
+        // other wise, do our own negotiation
+        let mut opts = FsOptions::DO_READDIRPLUS | FsOptions::READDIRPLUS_AUTO;
+
+        if self.config.do_import {
+            self.import()?;
+        }
+
+        if (!self.config.do_import || self.config.writeback)
+            && capable.contains(FsOptions::WRITEBACK_CACHE)
+        {
+            opts |= FsOptions::WRITEBACK_CACHE;
+            self.writeback.store(true, Ordering::Relaxed);
+        }
+
+        if (!self.config.do_import || self.config.no_open)
+            && capable.contains(FsOptions::ZERO_MESSAGE_OPEN)
+        {
+            opts |= FsOptions::ZERO_MESSAGE_OPEN;
+            opts.remove(FsOptions::ATOMIC_O_TRUNC);
+            self.no_open.store(true, Ordering::Relaxed);
+        }
+
+        if (!self.config.do_import || self.config.no_opendir)
+            && capable.contains(FsOptions::ZERO_MESSAGE_OPENDIR)
+        {
+            opts |= FsOptions::ZERO_MESSAGE_OPENDIR;
+            self.no_opendir.store(true, Ordering::Relaxed);
+        }
+
+        if (!self.config.do_import || self.config.killpriv_v2)
+            && capable.contains(FsOptions::HANDLE_KILLPRIV_V2)
+        {
+            opts |= FsOptions::HANDLE_KILLPRIV_V2;
+            self.killpriv_v2.store(true, Ordering::Relaxed);
+        }
+
+        if self.config.perfile_dax && capable.contains(FsOptions::PERFILE_DAX) {
+            opts |= FsOptions::PERFILE_DAX;
+            self.perfile_dax.store(true, Ordering::Relaxed);
+        }
+
+        Ok(opts)
+    }
+
+    fn destroy(&self) {}
+
+    fn statfs(&self, ctx: &Context, inode: Inode) -> Result<statvfs64> {
+        trace!("STATFS: inode: {}\n", inode);
+        self.do_statvfs(ctx, inode)
+    }
+
+    fn lookup(&self, ctx: &Context, parent: Inode, name: &CStr) -> Result<Entry> {
+        let tmp = name.to_string_lossy().to_string();
+        trace!("LOOKUP: parent: {}, name: {}\n", parent, tmp);
+        let result = self.do_lookup(ctx, parent, tmp.as_str());
+        if result.is_ok() {
+            trace!("LOOKUP result: {:?}", result.as_ref().unwrap());
+        }
+        //self.debug_print_all_inodes();
+        result
+    }
+
+    fn forget(&self, _ctx: &Context, inode: Inode, count: u64) {
+        trace!("FORGET: inode: {}, count: {}\n", inode, count);
+        self.forget_one(inode, count);
+        //self.debug_print_all_inodes();
+    }
+
+    fn batch_forget(&self, _ctx: &Context, requests: Vec<(Inode, u64)>) {
+        trace!("BATCH_FORGET: requests: {:?}\n", requests);
+        for (inode, count) in requests {
+            self.forget_one(inode, count);
+        }
+    }
+
+    fn opendir(
+        &self,
+        ctx: &Context,
+        inode: Inode,
+        _flags: u32,
+    ) -> Result<(Option<Handle>, OpenOptions)> {
+        trace!("OPENDIR: inode: {}\n", inode);
+        if self.no_opendir.load(Ordering::Relaxed) {
+            info!("fuse: opendir is not supported.");
+            return Err(Error::from_raw_os_error(libc::ENOSYS));
+        }
+
+        let mut opts = OpenOptions::empty();
+
+        if let CachePolicy::Always = self.config.cache_policy {
+            opts |= OpenOptions::KEEP_CACHE;
+        }
+
+        // lookup node
+        let node = self.lookup_node(ctx, inode, ".")?;
+
+        if node.whiteout.load(Ordering::Relaxed) {
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        let st = node.stat64(ctx)?;
+        if !utils::is_dir(st) {
+            return Err(Error::from_raw_os_error(libc::ENOTDIR));
+        }
+
+        let handle = self.next_handle.fetch_add(1, Ordering::Relaxed);
+
+        self.handles.lock().unwrap().insert(
+            handle,
+            Arc::new(HandleData {
+                node: Arc::clone(&node),
+                real_handle: None,
+            }),
+        );
+
+        Ok((Some(handle), opts))
+    }
+
+    fn releasedir(&self, _ctx: &Context, inode: Inode, _flags: u32, handle: Handle) -> Result<()> {
+        trace!("RELEASEDIR: inode: {}, handle: {}\n", inode, handle);
+        if self.no_opendir.load(Ordering::Relaxed) {
+            info!("fuse: releasedir is not supported.");
+            return Err(Error::from_raw_os_error(libc::ENOSYS));
+        }
+
+        self.handles.lock().unwrap().remove(&handle);
+
+        Ok(())
+    }
+
+    // for mkdir or create file
+    // 1. lookup name, if exists and not whiteout, return EEXIST
+    // 2. not exists and no whiteout, copy up parent node, ususally  a mkdir on upper layer would do the work
+    // 3. find whiteout, if whiteout in upper layer, should set opaque. if in lower layer, just mkdir?
+    fn mkdir(
+        &self,
+        ctx: &Context,
+        parent: Inode,
+        name: &CStr,
+        mode: u32,
+        umask: u32,
+    ) -> Result<Entry> {
+        let sname = name.to_string_lossy().to_string();
+
+        trace!("MKDIR: parent: {}, name: {}\n", parent, sname);
+
+        // no entry or whiteout
+        let pnode = self.lookup_node(ctx, parent, "")?;
+        if pnode.whiteout.load(Ordering::Relaxed) {
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        self.do_mkdir(ctx, &pnode, sname.as_str(), mode, umask)?;
+        let entry = self.do_lookup(ctx, parent, sname.as_str());
+        entry
+    }
+
+    fn rmdir(&self, ctx: &Context, parent: Inode, name: &CStr) -> Result<()> {
+        trace!(
+            "RMDIR: parent: {}, name: {}\n",
+            parent,
+            name.to_string_lossy()
+        );
+        self.do_rm(ctx, parent, name, true)
+    }
+
+    fn readdir(
+        &self,
+        ctx: &Context,
+        inode: Inode,
+        handle: Handle,
+        size: u32,
+        offset: u64,
+        add_entry: &mut dyn FnMut(DirEntry) -> Result<usize>,
+    ) -> Result<()> {
+        trace!("READDIR: inode: {}, handle: {}\n", inode, handle);
+        if self.config.no_readdir {
+            info!("fuse: readdir is not supported.");
+            return Ok(());
+        }
+        self.do_readdir(ctx, inode, handle, size, offset, false, &mut |dir_entry,
+                                                                       _|
+         -> Result<
+            usize,
+        > {
+            add_entry(dir_entry)
+        })
+    }
+
+    fn readdirplus(
+        &self,
+        ctx: &Context,
+        inode: Inode,
+        handle: Handle,
+        size: u32,
+        offset: u64,
+        add_entry: &mut dyn FnMut(DirEntry, Entry) -> Result<usize>,
+    ) -> Result<()> {
+        trace!("READDIRPLUS: inode: {}, handle: {}\n", inode, handle);
+        if self.config.no_readdir {
+            info!("fuse: readdirplus is not supported.");
+            return Ok(());
+        }
+        self.do_readdir(ctx, inode, handle, size, offset, true, &mut |dir_entry,
+                                                                      entry|
+         -> Result<
+            usize,
+        > {
+            match entry {
+                Some(e) => add_entry(dir_entry, e),
+                None => Err(Error::from_raw_os_error(libc::ENOENT)),
+            }
+        })
+    }
+
+    fn open(
+        &self,
+        ctx: &Context,
+        inode: Inode,
+        flags: u32,
+        fuse_flags: u32,
+    ) -> Result<(Option<Handle>, OpenOptions, Option<u32>)> {
+        // open assume file always exist
+        trace!("OPEN: inode: {}, flags: {}\n", inode, flags);
+        if self.no_open.load(Ordering::Relaxed) {
+            info!("fuse: open is not supported.");
+            return Err(Error::from_raw_os_error(libc::ENOSYS));
+        }
+
+        let readonly: bool = flags
+            & (libc::O_APPEND | libc::O_CREAT | libc::O_TRUNC | libc::O_RDWR | libc::O_WRONLY)
+                as u32
+            == 0;
+        // toggle flags
+        let mut flags: i32 = flags as i32;
+
+        flags |= libc::O_NOFOLLOW;
+
+        if self.config.writeback {
+            if flags & libc::O_ACCMODE == libc::O_WRONLY {
+                flags &= !libc::O_ACCMODE;
+                flags |= libc::O_RDWR;
+            }
+
+            if flags & libc::O_APPEND != 0 {
+                flags &= !libc::O_APPEND;
+            }
+        }
+        // lookup node
+        let node = self.lookup_node(ctx, inode, "")?;
+
+        // whiteout node
+        if node.whiteout.load(Ordering::Relaxed) {
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        if !readonly {
+            // copy up to upper layer
+            self.copy_node_up(ctx, Arc::clone(&node))?;
+        }
+
+        // assign a handle in overlayfs and open it
+        let (_l, h, _) = node.open(ctx, flags as u32, fuse_flags)?;
+        match h {
+            None => Err(Error::from_raw_os_error(libc::ENOENT)),
+            Some(handle) => {
+                let hd = self.next_handle.fetch_add(1, Ordering::Relaxed);
+                let (layer, in_upper_layer, inode) = node.first_layer_inode();
+                let handle_data = HandleData {
+                    node: Arc::clone(&node),
+                    real_handle: Some(RealHandle {
+                        layer,
+                        in_upper_layer,
+                        inode,
+                        handle: AtomicU64::new(handle),
+                    }),
+                };
+
+                self.handles
+                    .lock()
+                    .unwrap()
+                    .insert(hd, Arc::new(handle_data));
+
+                let mut opts = OpenOptions::empty();
+                match self.config.cache_policy {
+                    CachePolicy::Never => opts |= OpenOptions::DIRECT_IO,
+                    CachePolicy::Always => opts |= OpenOptions::KEEP_CACHE,
+                    _ => {}
+                }
+
+                trace!("OPEN: returning handle: {}", hd);
+
+                Ok((Some(hd), opts, None))
+            }
+        }
+    }
+
+    fn release(
+        &self,
+        ctx: &Context,
+        _inode: Inode,
+        flags: u32,
+        handle: Handle,
+        flush: bool,
+        flock_release: bool,
+        lock_owner: Option<u64>,
+    ) -> Result<()> {
+        trace!(
+            "RELEASE: inode: {}, flags: {}, handle: {}, flush: {}, flock_release: {}, lock_owner: {:?}\n",
+            _inode,
+            flags,
+            handle,
+            flush,
+            flock_release,
+            lock_owner
+        );
+
+        if self.no_open.load(Ordering::Relaxed) {
+            info!("fuse: release is not supported.");
+            return Err(Error::from_raw_os_error(libc::ENOSYS));
+        }
+
+        if let Some(hd) = self.handles.lock().unwrap().get(&handle) {
+            let rh = if let Some(ref h) = hd.real_handle {
+                h
+            } else {
+                return Err(Error::new(ErrorKind::Other, "no handle"));
+            };
+            let real_handle = rh.handle.load(Ordering::Relaxed);
+            let real_inode = rh.inode;
+            rh.layer.release(
+                ctx,
+                real_inode,
+                flags,
+                real_handle,
+                flush,
+                flock_release,
+                lock_owner,
+            )?;
+        }
+
+        self.handles.lock().unwrap().remove(&handle);
+
+        Ok(())
+    }
+
+    fn create(
+        &self,
+        ctx: &Context,
+        parent: Inode,
+        name: &CStr,
+        args: CreateIn,
+    ) -> Result<(Entry, Option<Handle>, OpenOptions, Option<u32>)> {
+        let sname = name.to_string_lossy().to_string();
+        trace!("CREATE: parent: {}, name: {}\n", parent, sname);
+
+        // Parent doesn't exist.
+        let pnode = self.lookup_node(ctx, parent, "")?;
+        if pnode.whiteout.load(Ordering::Relaxed) {
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        let mut hargs = args;
+        let mut flags: i32 = args.flags as i32;
+        flags |= libc::O_NOFOLLOW;
+        flags &= !libc::O_DIRECT;
+        if self.config.writeback {
+            if flags & libc::O_ACCMODE == libc::O_WRONLY {
+                flags &= !libc::O_ACCMODE;
+                flags |= libc::O_RDWR;
+            }
+
+            if flags & libc::O_APPEND != 0 {
+                flags &= !libc::O_APPEND;
+            }
+        }
+        hargs.flags = flags as u32;
+
+        let final_handle = self.do_create(ctx, &pnode, sname.as_str(), hargs)?;
+        let entry = self.do_lookup(ctx, parent, sname.as_str())?;
+
+        let mut opts = OpenOptions::empty();
+        match self.config.cache_policy {
+            CachePolicy::Never => opts |= OpenOptions::DIRECT_IO,
+            CachePolicy::Always => opts |= OpenOptions::KEEP_CACHE,
+            _ => {}
+        }
+
+        Ok((entry, final_handle, opts, None))
+    }
+
+    fn unlink(&self, ctx: &Context, parent: Inode, name: &CStr) -> Result<()> {
+        trace!(
+            "UNLINK: parent: {}, name: {}\n",
+            parent,
+            name.to_string_lossy()
+        );
+        self.do_rm(ctx, parent, name, false)
+    }
+
+    fn read(
+        &self,
+        ctx: &Context,
+        inode: Inode,
+        handle: Handle,
+        w: &mut dyn ZeroCopyWriter,
+        size: u32,
+        offset: u64,
+        lock_owner: Option<u64>,
+        flags: u32,
+    ) -> Result<usize> {
+        trace!(
+            "READ: inode: {}, handle: {}, size: {}, offset: {}, lock_owner: {:?}, flags: {}\n",
+            inode,
+            handle,
+            size,
+            offset,
+            lock_owner,
+            flags
+        );
+
+        let data = self.get_data(ctx, Some(handle), inode, flags)?;
+
+        match data.real_handle {
+            None => Err(Error::from_raw_os_error(libc::ENOENT)),
+            Some(ref hd) => hd.layer.read(
+                ctx,
+                hd.inode,
+                hd.handle.load(Ordering::Relaxed),
+                w,
+                size,
+                offset,
+                lock_owner,
+                flags,
+            ),
+        }
+    }
+
+    fn write(
+        &self,
+        ctx: &Context,
+        inode: Inode,
+        handle: Handle,
+        r: &mut dyn ZeroCopyReader,
+        size: u32,
+        offset: u64,
+        lock_owner: Option<u64>,
+        delayed_write: bool,
+        flags: u32,
+        fuse_flags: u32,
+    ) -> Result<usize> {
+        trace!(
+            "WRITE: inode: {}, handle: {}, size: {}, offset: {}, lock_owner: {:?}, delayed_write: {}, flags: {}, fuse_flags: {}\n",
+            inode,
+            handle,
+            size,
+            offset,
+            lock_owner,
+            delayed_write,
+            flags,
+            fuse_flags
+        );
+
+        let data = self.get_data(ctx, Some(handle), inode, flags)?;
+
+        match data.real_handle {
+            None => Err(Error::from_raw_os_error(libc::ENOENT)),
+            Some(ref hd) => hd.layer.write(
+                ctx,
+                hd.inode,
+                hd.handle.load(Ordering::Relaxed),
+                r,
+                size,
+                offset,
+                lock_owner,
+                delayed_write,
+                flags,
+                fuse_flags,
+            ),
+        }
+    }
+
+    fn getattr(
+        &self,
+        ctx: &Context,
+        inode: Inode,
+        handle: Option<Handle>,
+    ) -> Result<(stat64, Duration)> {
+        trace!(
+            "GETATTR: inode: {}, handle: {}\n",
+            inode,
+            handle.unwrap_or_default()
+        );
+
+        if !self.no_open.load(Ordering::Relaxed) {
+            if let Some(h) = handle {
+                if let Some(hd) = self.handles.lock().unwrap().get(&h) {
+                    if let Some(ref rh) = hd.real_handle {
+                        let (st, _d) = rh.layer.getattr(
+                            ctx,
+                            rh.inode,
+                            Some(rh.handle.load(Ordering::Relaxed)),
+                        )?;
+                        return Ok((st, self.config.attr_timeout));
+                    }
+                }
+            }
+        }
+
+        let node = self.lookup_node(ctx, inode, "")?;
+        let (layer, _, inode) = node.first_layer_inode();
+        let (st, _) = layer.getattr(ctx, inode, None)?;
+        Ok((st, self.config.attr_timeout))
+    }
+
+    fn setattr(
+        &self,
+        ctx: &Context,
+        inode: Inode,
+        attr: stat64,
+        handle: Option<Handle>,
+        valid: SetattrValid,
+    ) -> Result<(stat64, Duration)> {
+        trace!("SETATTR: inode: {}\n", inode);
+
+        // Check if upper layer exists.
+        self.upper_layer
+            .as_ref()
+            .cloned()
+            .ok_or_else(|| Error::from_raw_os_error(libc::EROFS))?;
+
+        // deal with handle first
+        if !self.no_open.load(Ordering::Relaxed) {
+            if let Some(h) = handle {
+                if let Some(hd) = self.handles.lock().unwrap().get(&h) {
+                    if let Some(ref rhd) = hd.real_handle {
+                        // handle opened in upper layer
+                        if rhd.in_upper_layer {
+                            let (st, _d) = rhd.layer.setattr(
+                                ctx,
+                                rhd.inode,
+                                attr,
+                                Some(rhd.handle.load(Ordering::Relaxed)),
+                                valid,
+                            )?;
+
+                            return Ok((st, self.config.attr_timeout));
+                        }
+                    }
+                }
+            }
+        }
+
+        let mut node = self.lookup_node(ctx, inode, "")?;
+
+        if !node.in_upper_layer() {
+            node = self.copy_node_up(ctx, Arc::clone(&node))?
+        }
+
+        let (layer, _, real_inode) = node.first_layer_inode();
+        let (st, _d) = layer.setattr(ctx, real_inode, attr, None, valid)?;
+        Ok((st, self.config.attr_timeout))
+    }
+
+    fn rename(
+        &self,
+        _ctx: &Context,
+        _olddir: Inode,
+        _odlname: &CStr,
+        _newdir: Inode,
+        _newname: &CStr,
+        _flags: u32,
+    ) -> Result<()> {
+        // complex, implement it later
+        trace!(
+            "RENAME: olddir: {}, oldname: {}, newdir: {}, newname: {}, flags: {}\n",
+            _olddir,
+            _odlname.to_string_lossy(),
+            _newdir,
+            _newname.to_string_lossy(),
+            _flags
+        );
+        Err(Error::from_raw_os_error(libc::EXDEV))
+    }
+
+    fn mknod(
+        &self,
+        ctx: &Context,
+        parent: Inode,
+        name: &CStr,
+        mode: u32,
+        rdev: u32,
+        umask: u32,
+    ) -> Result<Entry> {
+        let sname = name.to_string_lossy().to_string();
+        trace!("MKNOD: parent: {}, name: {}\n", parent, sname);
+
+        // Check if parent exists.
+        let pnode = self.lookup_node(ctx, parent, "")?;
+        if pnode.whiteout.load(Ordering::Relaxed) {
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        self.do_mknod(ctx, &pnode, sname.as_str(), mode, rdev, umask)?;
+        let entry = self.do_lookup(ctx, parent, sname.as_str());
+        entry
+    }
+
+    fn link(&self, ctx: &Context, inode: Inode, newparent: Inode, name: &CStr) -> Result<Entry> {
+        let sname = name.to_string_lossy().to_string();
+        trace!(
+            "LINK: inode: {}, newparent: {}, name: {}\n",
+            inode,
+            newparent,
+            sname.as_str()
+        );
+
+        let node = self.lookup_node(ctx, inode, "")?;
+        if node.whiteout.load(Ordering::Relaxed) {
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        let newpnode = self.lookup_node(ctx, newparent, "")?;
+        if newpnode.whiteout.load(Ordering::Relaxed) {
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        self.do_link(ctx, &node, &newpnode, sname.as_str())?;
+        let entry = self.do_lookup(ctx, newparent, sname.as_str());
+        entry
+    }
+
+    fn symlink(&self, ctx: &Context, linkname: &CStr, parent: Inode, name: &CStr) -> Result<Entry> {
+        // soft link
+        let sname = name.to_string_lossy().into_owned().to_owned();
+        let slinkname = linkname.to_string_lossy().into_owned().to_owned();
+        trace!(
+            "SYMLINK: linkname: {}, parent: {}, name: {}\n",
+            linkname.to_string_lossy(),
+            parent,
+            sname.as_str()
+        );
+
+        let pnode = self.lookup_node(ctx, parent, "")?;
+        self.do_symlink(ctx, slinkname.as_str(), &pnode, sname.as_str())?;
+
+        let entry = self.do_lookup(ctx, parent, sname.as_str());
+        entry
+    }
+
+    fn readlink(&self, ctx: &Context, inode: Inode) -> Result<Vec<u8>> {
+        trace!("READLINK: inode: {}\n", inode);
+
+        let node = self.lookup_node(ctx, inode, "")?;
+
+        if node.whiteout.load(Ordering::Relaxed) {
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        let (layer, _, inode) = node.first_layer_inode();
+        layer.readlink(ctx, inode)
+    }
+
+    fn flush(&self, ctx: &Context, inode: Inode, handle: Handle, lock_owner: u64) -> Result<()> {
+        trace!(
+            "FLUSH: inode: {}, handle: {}, lock_owner: {}\n",
+            inode,
+            handle,
+            lock_owner
+        );
+
+        if self.no_open.load(Ordering::Relaxed) {
+            return Err(Error::from_raw_os_error(libc::ENOSYS));
+        }
+
+        let node = self.lookup_node(ctx, inode, "")?;
+
+        if node.whiteout.load(Ordering::Relaxed) {
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        let (layer, real_inode, real_handle) = self.find_real_info_from_handle(handle)?;
+
+        // FIXME: need to test if inode matches corresponding handle?
+
+        layer.flush(ctx, real_inode, real_handle, lock_owner)
+    }
+
+    fn fsync(&self, ctx: &Context, inode: Inode, datasync: bool, handle: Handle) -> Result<()> {
+        trace!(
+            "FSYNC: inode: {}, datasync: {}, handle: {}\n",
+            inode,
+            datasync,
+            handle
+        );
+
+        self.do_fsync(ctx, inode, datasync, handle, false)
+    }
+
+    fn fsyncdir(&self, ctx: &Context, inode: Inode, datasync: bool, handle: Handle) -> Result<()> {
+        trace!(
+            "FSYNCDIR: inode: {}, datasync: {}, handle: {}\n",
+            inode,
+            datasync,
+            handle
+        );
+
+        self.do_fsync(ctx, inode, datasync, handle, true)
+    }
+
+    fn access(&self, ctx: &Context, inode: Inode, mask: u32) -> Result<()> {
+        trace!("ACCESS: inode: {}, mask: {}\n", inode, mask);
+        let node = self.lookup_node(ctx, inode, "")?;
+
+        if node.whiteout.load(Ordering::Relaxed) {
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        let (layer, real_inode) = self.find_real_inode(inode)?;
+        layer.access(ctx, real_inode, mask)
+    }
+
+    fn setxattr(
+        &self,
+        ctx: &Context,
+        inode: Inode,
+        name: &CStr,
+        value: &[u8],
+        flags: u32,
+    ) -> Result<()> {
+        trace!(
+            "SETXATTR: inode: {}, name: {}, value: {:?}, flags: {}\n",
+            inode,
+            name.to_string_lossy(),
+            value,
+            flags
+        );
+        let node = self.lookup_node(ctx, inode, "")?;
+
+        if node.whiteout.load(Ordering::Relaxed) {
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        if !node.in_upper_layer() {
+            // Copy node up.
+            self.copy_node_up(ctx, Arc::clone(&node))?;
+        }
+
+        let (layer, _, real_inode) = node.first_layer_inode();
+
+        layer.setxattr(ctx, real_inode, name, value, flags)
+
+        // TODO: recreate node since setxattr may made dir opaque. @weizhang555.zw
+    }
+
+    fn getxattr(
+        &self,
+        ctx: &Context,
+        inode: Inode,
+        name: &CStr,
+        size: u32,
+    ) -> Result<GetxattrReply> {
+        trace!(
+            "GETXATTR: inode: {}, name: {}, size: {}\n",
+            inode,
+            name.to_string_lossy(),
+            size
+        );
+        let node = self.lookup_node(ctx, inode, "")?;
+
+        if node.whiteout.load(Ordering::Relaxed) {
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        let (layer, real_inode) = self.find_real_inode(inode)?;
+
+        layer.getxattr(ctx, real_inode, name, size)
+    }
+
+    fn listxattr(&self, ctx: &Context, inode: Inode, size: u32) -> Result<ListxattrReply> {
+        trace!("LISTXATTR: inode: {}, size: {}\n", inode, size);
+        let node = self.lookup_node(ctx, inode, "")?;
+
+        if node.whiteout.load(Ordering::Relaxed) {
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        let (layer, real_inode) = self.find_real_inode(inode)?;
+
+        layer.listxattr(ctx, real_inode, size)
+    }
+
+    fn removexattr(&self, ctx: &Context, inode: Inode, name: &CStr) -> Result<()> {
+        trace!(
+            "REMOVEXATTR: inode: {}, name: {}\n",
+            inode,
+            name.to_string_lossy()
+        );
+        let node = self.lookup_node(ctx, inode, "")?;
+
+        if node.whiteout.load(Ordering::Relaxed) {
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        if !node.in_upper_layer() {
+            // copy node into upper layer
+            self.copy_node_up(ctx, Arc::clone(&node))?;
+        }
+
+        let (layer, _, ino) = node.first_layer_inode();
+        layer.removexattr(ctx, ino, name)
+
+        // TODO: recreate the node since removexattr may remove the opaque xattr. @weizhang555.zw
+    }
+
+    fn fallocate(
+        &self,
+        ctx: &Context,
+        inode: Inode,
+        handle: Handle,
+        mode: u32,
+        offset: u64,
+        length: u64,
+    ) -> Result<()> {
+        trace!(
+            "FALLOCATE: inode: {}, handle: {}, mode: {}, offset: {}, length: {}\n",
+            inode,
+            handle,
+            mode,
+            offset,
+            length
+        );
+        // Use O_RDONLY flags which indicates no copy up.
+        let data = self.get_data(ctx, Some(handle), inode, libc::O_RDONLY as u32)?;
+
+        match data.real_handle {
+            None => Err(Error::from_raw_os_error(libc::ENOENT)),
+            Some(ref rhd) => {
+                if !rhd.in_upper_layer {
+                    // TODO: in lower layer, error out or just success?
+                    return Err(Error::from_raw_os_error(libc::EROFS));
+                }
+                rhd.layer.fallocate(
+                    ctx,
+                    rhd.inode,
+                    rhd.handle.load(Ordering::Relaxed),
+                    mode,
+                    offset,
+                    length,
+                )
+            }
+        }
+    }
+
+    fn lseek(
+        &self,
+        ctx: &Context,
+        inode: Inode,
+        handle: Handle,
+        offset: u64,
+        whence: u32,
+    ) -> Result<u64> {
+        trace!(
+            "LSEEK: inode: {}, handle: {}, offset: {}, whence: {}\n",
+            inode,
+            handle,
+            offset,
+            whence
+        );
+        // can this be on dir? FIXME: assume file for now
+        // we need special process if it can be called on dir
+        let node = self.lookup_node(ctx, inode, "")?;
+
+        if node.whiteout.load(Ordering::Relaxed) {
+            return Err(Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        let st = node.stat64(ctx)?;
+        if utils::is_dir(st) {
+            error!("lseek on directory");
+            return Err(Error::from_raw_os_error(libc::EINVAL));
+        }
+
+        let (layer, real_inode, real_handle) = self.find_real_info_from_handle(handle)?;
+        layer.lseek(ctx, real_inode, real_handle, offset, whence)
+    }
+}
diff --git a/src/overlayfs/utils.rs b/src/overlayfs/utils.rs
new file mode 100644
index 000000000..bf7d050a5
--- /dev/null
+++ b/src/overlayfs/utils.rs
@@ -0,0 +1,14 @@
+// Copyright (C) 2023 Ant Group. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::abi::fuse_abi::stat64;
+use std::ffi::CString;
+use std::io::{self, Error, Result};
+
+pub(super) fn is_dir(st: stat64) -> bool {
+    st.st_mode & libc::S_IFMT == libc::S_IFDIR
+}
+
+pub(super) fn to_cstring(name: &str) -> Result<CString> {
+    CString::new(name).map_err(|e| Error::new(io::ErrorKind::InvalidData, e))
+}
diff --git a/src/passthrough/mod.rs b/src/passthrough/mod.rs
index f4859006e..76d654caa 100644
--- a/src/passthrough/mod.rs
+++ b/src/passthrough/mod.rs
@@ -52,6 +52,7 @@ mod file_handle;
 mod inode_store;
 mod mount_fd;
 mod os_compat;
+mod overlay;
 mod statx;
 mod sync_io;
 mod util;
@@ -980,11 +981,7 @@ mod tests {
     use super::*;
     use crate::abi::fuse_abi::CreateIn;
     use crate::api::filesystem::*;
-    use crate::api::filesystem::{ZeroCopyReader, ZeroCopyWriter};
     use crate::api::{Vfs, VfsOptions};
-    use crate::common::file_buf::FileVolatileSlice;
-    use crate::common::file_traits::FileReadWriteVolatile;
-
     use caps::{CapSet, Capability};
     use log;
     use std::io::{Read, Seek, SeekFrom, Write};
@@ -1484,59 +1481,6 @@ mod tests {
         assert!(!fs.cfg.writeback);
     }
 
-    impl ZeroCopyReader for File {
-        // Copies at most count bytes from self directly into f at offset off
-        // without storing it in any intermediate buffers.
-        fn read_to(
-            &mut self,
-            f: &mut dyn FileReadWriteVolatile,
-            count: usize,
-            off: u64,
-        ) -> io::Result<usize> {
-            let mut buf = vec![0_u8; count];
-            let slice = unsafe { FileVolatileSlice::from_raw_ptr(buf.as_mut_ptr(), count) };
-
-            // Read from self to slice.
-            let ret = self.read_volatile(slice)?;
-            if ret > 0 {
-                let slice = unsafe { FileVolatileSlice::from_raw_ptr(buf.as_mut_ptr(), ret) };
-                // Write from slice to f at offset off.
-                f.write_at_volatile(slice, off)
-            } else {
-                Ok(0)
-            }
-        }
-    }
-
-    impl ZeroCopyWriter for File {
-        // Copies at most count bytes from f at offset off directly into self
-        // without storing it in any intermediate buffers.
-        fn write_from(
-            &mut self,
-            f: &mut dyn FileReadWriteVolatile,
-            count: usize,
-            off: u64,
-        ) -> io::Result<usize> {
-            let mut buf = vec![0_u8; count];
-            let slice = unsafe { FileVolatileSlice::from_raw_ptr(buf.as_mut_ptr(), count) };
-            // Read from f at offset off to slice.
-            let ret = f.read_at_volatile(slice, off)?;
-
-            if ret > 0 {
-                let slice = unsafe { FileVolatileSlice::from_raw_ptr(buf.as_mut_ptr(), ret) };
-                // Write from slice to self.
-                self.write_volatile(slice)
-            } else {
-                Ok(0)
-            }
-        }
-
-        fn available_bytes(&self) -> usize {
-            // Max usize
-            usize::MAX
-        }
-    }
-
     #[test]
     fn test_generic_read_write_noopen() {
         let tmpdir = TempDir::new().expect("Cannot create temporary directory.");
diff --git a/src/passthrough/overlay.rs b/src/passthrough/overlay.rs
new file mode 100644
index 000000000..ec39e78e4
--- /dev/null
+++ b/src/passthrough/overlay.rs
@@ -0,0 +1,14 @@
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE-BSD-3-Clause file.
+
+use super::PassthroughFs;
+use crate::abi::fuse_abi;
+use crate::api::filesystem::Layer;
+
+// Implment Layer trait for PassthroughFs.
+impl Layer for PassthroughFs {
+    // Return root inode of this layer.
+    fn root_inode(&self) -> Self::Inode {
+        fuse_abi::ROOT_ID
+    }
+}
diff --git a/src/passthrough/sync_io.rs b/src/passthrough/sync_io.rs
index 584d2b93d..925bc2b2f 100644
--- a/src/passthrough/sync_io.rs
+++ b/src/passthrough/sync_io.rs
@@ -407,7 +407,12 @@ impl<S: BitmapSlice + Send + Sync> FileSystem for PassthroughFs<S> {
         _flags: u32,
         handle: Handle,
     ) -> io::Result<()> {
-        self.do_release(inode, handle)
+        if self.no_opendir.load(Ordering::Relaxed) {
+            info!("fuse: releasedir is not supported.");
+            Err(io::Error::from_raw_os_error(libc::ENOSYS))
+        } else {
+            self.do_release(inode, handle)
+        }
     }
 
     fn mkdir(
diff --git a/testoverlay/src/main.rs b/testoverlay/src/main.rs
deleted file mode 100644
index fb41aa124..000000000
--- a/testoverlay/src/main.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-extern crate fuse_backend_rs;
-extern crate log;
-extern crate vmm_sys_util;
-extern crate libc;
-extern crate simple_logger;
-extern crate signal_hook;
-#[macro_use]
-extern crate lazy_static;
-
-use std::io::{Result, Error};
-use std::sync::{Arc, Mutex};
-use std::path::Path;
-
-use fuse_backend_rs::overlayfs::{OverlayFs};
-use fuse_backend_rs::overlayfs::config::Config;
-use fuse_backend_rs::overlayfs::plugin::PluginManager;
-use fuse_backend_rs::api::server::Server;
-use fuse_backend_rs::transport::{FuseChannel, FuseSession};
-use fuse_backend_rs::api::{Vfs, VfsOptions};
-use signal_hook::{consts::TERM_SIGNALS, iterator::Signals};
-use std::thread;
-use simple_logger::SimpleLogger;
-use log::LevelFilter;
-
-pub struct FuseServer {
-	server: Arc<Server<Arc<OverlayFs>>>,
-	ch: FuseChannel,
-}
-
-fn main() -> Result<()> {
-	SimpleLogger::new().with_level(LevelFilter::Trace).init().unwrap();
-	let upperdir = String::from("/home/boyang/sources/testoverlay/testdir/upper");
-	let mut lowerdir = Vec::new();
-	lowerdir.push(String::from("/home/boyang/sources/testoverlay/testdir/lower1"));
-	lowerdir.push(String::from("/home/boyang/sources/testoverlay/testdir/lower2"));
-	let workdir = String::from("/home/boyang/sources/testoverlay/testdir/work");
-	let mountpoint = String::from("/home/boyang/sources/testoverlay/testdir/merged");
-
-	let mut config = Config::default();
-	config.upper = upperdir;
-	config.lower = lowerdir;
-	config.work = workdir;
-	config.mountpoint = String::from(mountpoint.as_str());
-	config.do_import = true;
-
-	let manager = PluginManager::new();
-
-	print!("new overlay fs\n");
-	let mut fs = OverlayFs::new(&manager, config)?;
-	print!("init root inode\n");
-	fs.init_root()?;
-
-	// let vfs = Vfs::new(VfsOptions {
-	//	no_open: false,
-	//	no_opendir: false,
-	//	..Default::default()
-	// });
-
-	// vfs.mount(Box::new(fs), "/")?;
-	print!("open fuse session\n");
-	let mut se = FuseSession::new(Path::new(mountpoint.as_str()), "testoverlay", "", false).unwrap();
-	print!("session opened\n");
-	se.mount().unwrap();
-
-	let mut server = FuseServer {
-		server: Arc::new(Server::new(Arc::new(fs))),
-		ch: se.new_channel().unwrap(),
-	};
-
-	let quit = Arc::new(Mutex::new(false));
-	let quit1 = Arc::clone(&quit);
-
-	let handle = thread::spawn(move || {
-		let _ = server.svc_loop(quit1);
-	});
-
-	// main thread
-	let mut signals = Signals::new(TERM_SIGNALS).unwrap();
-	for _sig in signals.forever() {
-		*quit.lock().unwrap() = true;
-		break;
-	}
-
-	let _ = handle.join();
-
-	se.umount().unwrap();
-	se.wake().unwrap();
-
-	Ok(())
-}
-
-impl FuseServer {
-	pub fn svc_loop(&mut self, quit: Arc<Mutex<bool>>) -> Result<()>{
-        let _ebadf = std::io::Error::from_raw_os_error(libc::EBADF);
-		print!("entering server loop\n");
-        loop {
-
-			if *quit.lock().unwrap() {
-				break;
-			}
-
-            if let Some((reader, writer)) = self
-                .ch
-                .get_request()
-                .map_err(|_| std::io::Error::from_raw_os_error(libc::EINVAL))?
-            {
-                if let Err(e) = self
-                    .server
-                    .handle_message(reader, writer.into(), None, None)
-                {
-                    match e {
-                        fuse_backend_rs::Error::EncodeMessage(_ebadf) => {
-                            break;
-                        }
-                        _ => {
-                            print!("Handling fuse message failed");
-                            continue;
-                        }
-                    }
-                }
-            } else {
-                print!("fuse server exits");
-                break;
-            }
-        }
-        Ok(())
-	}
-}
diff --git a/testoverlay/Cargo.toml b/tests/testoverlay/Cargo.toml
similarity index 78%
rename from testoverlay/Cargo.toml
rename to tests/testoverlay/Cargo.toml
index 9aac03820..023c13edd 100644
--- a/testoverlay/Cargo.toml
+++ b/tests/testoverlay/Cargo.toml
@@ -6,7 +6,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-fuse-backend-rs = { path = "../../fuse-backend-overlay.git", features = ["fusedev"] }
+fuse-backend-rs = { path = "../../", features = ["fusedev"] }
 log = ">=0.4.6"
 vmm-sys-util = ">=0.4"
 libc = ">=0.2.68"
diff --git a/tests/testoverlay/src/main.rs b/tests/testoverlay/src/main.rs
new file mode 100644
index 000000000..129a7fb6b
--- /dev/null
+++ b/tests/testoverlay/src/main.rs
@@ -0,0 +1,237 @@
+extern crate fuse_backend_rs;
+extern crate lazy_static;
+extern crate libc;
+extern crate log;
+extern crate signal_hook;
+extern crate simple_logger;
+extern crate vmm_sys_util;
+
+use std::env;
+use std::io::{Error, Result};
+use std::path::Path;
+use std::sync::Arc;
+use std::thread;
+
+use fuse_backend_rs::api::filesystem::Layer;
+use fuse_backend_rs::api::server::Server;
+use fuse_backend_rs::overlayfs::config::Config;
+use fuse_backend_rs::overlayfs::OverlayFs;
+use fuse_backend_rs::passthrough::{self, PassthroughFs};
+use fuse_backend_rs::transport::{FuseChannel, FuseSession};
+use log::LevelFilter;
+use signal_hook::{consts::TERM_SIGNALS, iterator::Signals};
+use simple_logger::SimpleLogger;
+
+#[derive(Debug, Default)]
+pub struct Args {
+    name: String,
+    mountpoint: String,
+    lowerdir: Vec<String>,
+    upperdir: String,
+    workdir: String,
+    log_level: String,
+}
+
+pub struct FuseServer {
+    server: Arc<Server<Arc<OverlayFs>>>,
+    ch: FuseChannel,
+}
+
+type BoxedLayer = Box<dyn Layer<Inode = u64, Handle = u64> + Send + Sync>;
+
+fn new_passthroughfs_layer(rootdir: &str) -> Result<BoxedLayer> {
+    let mut config = passthrough::Config::default();
+    config.root_dir = String::from(rootdir);
+    // enable xattr
+    config.xattr = true;
+    config.do_import = true;
+    let fs = Box::new(PassthroughFs::<()>::new(config)?);
+    fs.import()?;
+    Ok(fs as BoxedLayer)
+}
+
+fn help() {
+    println!(
+        "Usage:\n   testoverlay -o lowerdir=<lower1>:<lower2>:<more>,upperdir=<upper>,workdir=<work> <name> <mountpoint> [-l log_level]\n"
+    );
+}
+
+fn parse_args() -> Result<Args> {
+    let args = env::args().collect::<Vec<String>>();
+    // We expect at least 5 arguments.
+    if args.len() < 5 {
+        help();
+        return Err(std::io::Error::from_raw_os_error(libc::EINVAL));
+    }
+
+    let mut cmd_args = Args {
+        name: "".to_string(),
+        mountpoint: "".to_string(),
+        ..Default::default()
+    };
+
+    let mut i = 0;
+    loop {
+        i += 1;
+        if i >= args.len() {
+            break;
+        }
+        if args[i].as_str() == "-h" {
+            help();
+            return Err(std::io::Error::from_raw_os_error(libc::EINVAL));
+        }
+
+        if args[i].as_str() == "-o" {
+            i += 1;
+            // Parse options.
+            let option = args[i].clone();
+            option.split(",").try_for_each(|value| -> Result<()> {
+                let kv = value.split("=").collect::<Vec<&str>>();
+                if kv.len() != 2 {
+                    println!("unknown option: {}", value);
+                    return Ok(());
+                }
+
+                match kv[0] {
+                    "lowerdir" => {
+                        cmd_args.lowerdir = kv[1]
+                            .split(":")
+                            .map(|s| s.to_string())
+                            .collect::<Vec<String>>();
+                    }
+                    "upperdir" => {
+                        cmd_args.upperdir = kv[1].to_string();
+                    }
+                    "workdir" => {
+                        cmd_args.workdir = kv[1].to_string();
+                    }
+                    _ => {
+                        // Ignore unknown options.
+                        println!("unknown option: {}", kv[0]);
+                    }
+                }
+                Ok(())
+            })?;
+            continue;
+        }
+
+        if args[i].as_str() == "-l" {
+            i += 1;
+            cmd_args.log_level = args[i].clone();
+        }
+
+        if cmd_args.name.is_empty() {
+            cmd_args.name = args[i].clone();
+            continue;
+        } else if cmd_args.mountpoint.is_empty() {
+            cmd_args.mountpoint = args[i].clone();
+            continue;
+        }
+    }
+
+    // All fields should be set.
+    if cmd_args.lowerdir.is_empty() || cmd_args.upperdir.is_empty() || cmd_args.workdir.is_empty() {
+        println!("lowerdir, upperdir and workdir should be set");
+        help();
+        return Err(Error::from_raw_os_error(libc::EINVAL));
+    }
+
+    Ok(cmd_args)
+}
+
+fn set_log(args: &Args) {
+    let log_level = match args.log_level.as_str() {
+        "trace" => LevelFilter::Trace,
+        "debug" => LevelFilter::Debug,
+        "info" => LevelFilter::Info,
+        "warn" => LevelFilter::Warn,
+        "error" => LevelFilter::Error,
+        _ => LevelFilter::Info,
+    };
+
+    SimpleLogger::new().with_level(log_level).init().unwrap();
+}
+
+fn main() -> Result<()> {
+    let args = parse_args()?;
+    println!("args: {:?}", args);
+
+    set_log(&args);
+
+    // let basedir = "/home/zhangwei/program/test-overlay/test2/";
+    let upper_layer = Arc::new(new_passthroughfs_layer(&args.upperdir)?);
+    let mut lower_layers = Vec::new();
+    for lower in args.lowerdir {
+        lower_layers.push(Arc::new(new_passthroughfs_layer(&lower)?));
+    }
+
+    let mut config = Config::default();
+    config.work = args.workdir.clone();
+    config.mountpoint = args.mountpoint.clone();
+    config.do_import = true;
+
+    print!("new overlay fs\n");
+    let fs = OverlayFs::new(Some(upper_layer), lower_layers, config)?;
+    print!("init root inode\n");
+    fs.import()?;
+
+    print!("open fuse session\n");
+    let mut se = FuseSession::new(Path::new(&args.mountpoint), &args.name, "", false).unwrap();
+    print!("session opened\n");
+    se.mount().unwrap();
+
+    let mut server = FuseServer {
+        server: Arc::new(Server::new(Arc::new(fs))),
+        ch: se.new_channel().unwrap(),
+    };
+
+    let handle = thread::spawn(move || {
+        let _ = server.svc_loop();
+    });
+
+    // main thread
+    let mut signals = Signals::new(TERM_SIGNALS).unwrap();
+    for _sig in signals.forever() {
+        break;
+    }
+
+    se.umount().unwrap();
+    se.wake().unwrap();
+
+    let _ = handle.join();
+
+    Ok(())
+}
+
+impl FuseServer {
+    pub fn svc_loop(&mut self) -> Result<()> {
+        let _ebadf = std::io::Error::from_raw_os_error(libc::EBADF);
+        print!("entering server loop\n");
+        loop {
+            if let Some((reader, writer)) = self
+                .ch
+                .get_request()
+                .map_err(|_| std::io::Error::from_raw_os_error(libc::EINVAL))?
+            {
+                if let Err(e) = self
+                    .server
+                    .handle_message(reader, writer.into(), None, None)
+                {
+                    match e {
+                        fuse_backend_rs::Error::EncodeMessage(_ebadf) => {
+                            break;
+                        }
+                        _ => {
+                            print!("Handling fuse message failed");
+                            continue;
+                        }
+                    }
+                }
+            } else {
+                print!("fuse server exits");
+                break;
+            }
+        }
+        Ok(())
+    }
+}

From b6dc040a478c7ebe3ea9afc19bda0b04dc2547c8 Mon Sep 17 00:00:00 2001
From: Wei Zhang <weizhang555.zw@gmail.com>
Date: Thu, 4 Jan 2024 19:26:09 +0800
Subject: [PATCH 3/5] CI: add xfstests

Add xfstests into CI for overlayfs, it will work as Github Actions.

Currently not all test cases can be run, only about half of `generic/*`
for the Fuse Overlay FS, some test cases are expected to fail due to
missing function implementation, little are unexpected due to potential
bugs which will be investigated laterly.

Signed-off-by: Wei Zhang <weizhang555.zw@gmail.com>
---
 .github/workflows/xfstests.yml             | 20 +++++++++
 Makefile                                   |  7 +++
 tests/{testoverlay => overlay}/Cargo.toml  |  2 +-
 tests/{testoverlay => overlay}/src/main.rs |  2 +-
 tests/scripts/xfstests_overlay.exclude     | 24 ++++++++++
 tests/scripts/xfstests_overlay.sh          | 52 ++++++++++++++++++++++
 6 files changed, 105 insertions(+), 2 deletions(-)
 rename tests/{testoverlay => overlay}/Cargo.toml (94%)
 rename tests/{testoverlay => overlay}/src/main.rs (97%)
 create mode 100644 tests/scripts/xfstests_overlay.exclude
 create mode 100755 tests/scripts/xfstests_overlay.sh

diff --git a/.github/workflows/xfstests.yml b/.github/workflows/xfstests.yml
index 2e528dd48..57bec3c0d 100644
--- a/.github/workflows/xfstests.yml
+++ b/.github/workflows/xfstests.yml
@@ -32,3 +32,23 @@ jobs:
         cd $GITHUB_WORKSPACE
         sudo ./tests/scripts/xfstests_pathr.sh
 
+  xfstests_on_overlayfs:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+    - name: Install Rust
+      uses: actions-rs/toolchain@v1
+      with:
+        profile: minimal
+        toolchain: stable
+        override: true
+    - name: Build overlay binary
+      run: |
+        cd tests/overlay
+        cargo build --release
+        sudo install -t /usr/sbin/ -m 700 ./target/release/overlay
+    - name: Setup and run xfstest
+      run: |
+        cd $GITHUB_WORKSPACE
+        sudo ./tests/scripts/xfstests_overlay.sh
diff --git a/Makefile b/Makefile
index 2637aeb1d..bde1a50be 100644
--- a/Makefile
+++ b/Makefile
@@ -54,3 +54,10 @@ smoke-macos: check-macos
 
 docker-smoke:
 	docker run --env RUST_BACKTRACE=1 --rm --privileged --volume ${current_dir}:/fuse-rs rust:1.68 sh -c "rustup component add clippy rustfmt; cd /fuse-rs; make smoke-all"
+
+testoverlay:
+	cd tests/testoverlay && cargo build
+
+# Setup xfstests env and run.
+xfstests:
+	./tests/scripts/xfstests.sh
\ No newline at end of file
diff --git a/tests/testoverlay/Cargo.toml b/tests/overlay/Cargo.toml
similarity index 94%
rename from tests/testoverlay/Cargo.toml
rename to tests/overlay/Cargo.toml
index 023c13edd..751ddd7da 100644
--- a/tests/testoverlay/Cargo.toml
+++ b/tests/overlay/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "testoverlay"
+name = "overlay"
 version = "0.1.0"
 edition = "2021"
 
diff --git a/tests/testoverlay/src/main.rs b/tests/overlay/src/main.rs
similarity index 97%
rename from tests/testoverlay/src/main.rs
rename to tests/overlay/src/main.rs
index 129a7fb6b..b9492506c 100644
--- a/tests/testoverlay/src/main.rs
+++ b/tests/overlay/src/main.rs
@@ -52,7 +52,7 @@ fn new_passthroughfs_layer(rootdir: &str) -> Result<BoxedLayer> {
 
 fn help() {
     println!(
-        "Usage:\n   testoverlay -o lowerdir=<lower1>:<lower2>:<more>,upperdir=<upper>,workdir=<work> <name> <mountpoint> [-l log_level]\n"
+        "Usage:\n   overlay -o lowerdir=<lower1>:<lower2>:<more>,upperdir=<upper>,workdir=<work> <name> <mountpoint> [-l log_level]\n"
     );
 }
 
diff --git a/tests/scripts/xfstests_overlay.exclude b/tests/scripts/xfstests_overlay.exclude
new file mode 100644
index 000000000..db58a8e17
--- /dev/null
+++ b/tests/scripts/xfstests_overlay.exclude
@@ -0,0 +1,24 @@
+# Exclude list for tests that we know are broken in smb3
+#
+generic/011 # Broken: dirstress 5 processes.
+generic/020 # ENOSPC, suppose to be FUSE compatibility issue.
+generic/023 # Rename is not supported currently.
+generic/024 # Rename is not supported currently.
+generic/025 # Rename is not supported currently.
+generic/035 # Rename is not supported currently.
+generic/078 # Rename is not supported currently.
+generic/089 # Rename is not supported currently.
+generic/099 # Suppose to be FUSE compatibility issue.
+generic/184 # Special device isn't supported due to 'nodev' mount option.
+generic/241 # Rename is not supported currently.
+generic/245 # Rename is not supported currently.
+generic/375 # Suppose to be FUSE compatibility issue, about posix acl support
+generic/426 # Suppose to be FUSE compatibility issue: 'open_by_handle'
+generic/434 # Special device isn't supported due to 'nodev' mount option.
+generic/444 # Suppose to be FUSE compatibility issue, about posix acl support
+generic/467 # Suppose to be FUSE compatibility issue: 'open_by_handle'
+generic/477 # Suppose to be FUSE compatibility issue: 'open_by_handle'
+generic/591 # Broken.
+generic/633 # Suppose to be FUSE compatibility issue.
+generic/697 # Suppose to be FUSE compatibility issue.
+generic/736
\ No newline at end of file
diff --git a/tests/scripts/xfstests_overlay.sh b/tests/scripts/xfstests_overlay.sh
new file mode 100755
index 000000000..ca76797d8
--- /dev/null
+++ b/tests/scripts/xfstests_overlay.sh
@@ -0,0 +1,52 @@
+#!/bin/bash
+
+current_dir=$(dirname $(realpath $0))
+
+sudo apt-get update
+sudo apt-get install acl attr automake bc dbench dump e2fsprogs fio gawk \
+    gcc git indent libacl1-dev libaio-dev libcap-dev libgdbm-dev libtool \
+    libtool-bin liburing-dev libuuid1 lvm2 make psmisc python3 quota sed \
+    uuid-dev uuid-runtime xfsprogs linux-headers-$(uname -r) sqlite3
+sudo apt-get install exfatprogs f2fs-tools ocfs2-tools udftools xfsdump \
+    xfslibs-dev
+
+# clone xfstests and install.
+cd /tmp/
+git clone -b v2023.12.10 git://git.kernel.org/pub/scm/fs/xfs/xfstests-dev.git
+cd xfstests-dev
+make
+sudo make install
+# overwrite local config.
+cat >local.config  <<EOF
+export TEST_DEV=testoverlay
+export TEST_DIR=/tmp/testoverlay/merged
+#export SCRATCH_DEV=testoverlay
+#export SCRATCH_MNT=/tmp/test2/merged
+export FSTYP=fuse
+export FUSE_SUBTYP=.testoverlay
+EOF
+
+# create fuse overlay mount script.
+# /tmp/testoverlay must exists.
+sudo cat >/usr/sbin/mount.fuse.testoverlay  <<EOF
+#!/bin/bash
+
+ulimit -n 1048576
+exec /usr/sbin/overlay -o \
+    lowerdir=/tmp/testoverlay/lower2:/tmp/testoverlay/lower1,upperdir=/tmp/testoverlay/upper,workdir=/tmp/testoverlay/work \
+    testoverlay /tmp/testoverlay/merged \
+    1>>/tmp/testoverlay.log 2>&1 &
+sleep 1
+EOF
+sudo chmod +x /usr/sbin/mount.fuse.testoverlay
+
+# create related directories.
+mkdir -p /tmp/testoverlay/{upper,work,merged,lower2,lower1}
+
+echo "====> Start to run xfstests."
+# run tests.
+cd /tmp/xfstests-dev
+# Some tests are not supported by fuse or cannot pass currently.
+sudo ./check -fuse -E $current_dir/xfstests_overlay.exclude
+
+

From 119ea2c46bebd850c69f79c558060372d2090225 Mon Sep 17 00:00:00 2001
From: Wei Zhang <weizhang555.zw@gmail.com>
Date: Tue, 21 Nov 2023 15:11:45 +0800
Subject: [PATCH 4/5] docs: add some documentation for overlayfs

Add basic introduction for overlay fs implementations, also architecture
design are illustrated.

Signed-off-by: Wei Zhang <weizhang555.zw@gmail.com>
---
 docs/images/overlayfs.drawio           | 242 +++++++++++++++++++++++++
 docs/images/overlayfs_dir.png          | Bin 0 -> 192193 bytes
 docs/images/overlayfs_non_dir_file.png | Bin 0 -> 171958 bytes
 docs/images/overlayfs_structs.png      | Bin 0 -> 172698 bytes
 docs/overlayfs.md                      |  60 ++++++
 5 files changed, 302 insertions(+)
 create mode 100644 docs/images/overlayfs.drawio
 create mode 100644 docs/images/overlayfs_dir.png
 create mode 100644 docs/images/overlayfs_non_dir_file.png
 create mode 100644 docs/images/overlayfs_structs.png
 create mode 100644 docs/overlayfs.md

diff --git a/docs/images/overlayfs.drawio b/docs/images/overlayfs.drawio
new file mode 100644
index 000000000..09c5b0b0d
--- /dev/null
+++ b/docs/images/overlayfs.drawio
@@ -0,0 +1,242 @@
+<mxfile host="app.diagrams.net" modified="2023-11-21T07:08:18.556Z" agent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36" etag="ICmSN2QY2xmNnVhRuqBk" version="21.7.5" type="device">
+  <diagram name="第 1 页" id="wSUHaZ1ABxHqT4EEoN6Q">
+    <mxGraphModel dx="1026" dy="597" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="827" pageHeight="1169" math="0" shadow="0">
+      <root>
+        <mxCell id="0" />
+        <mxCell id="1" parent="0" />
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-1" value="Layer&amp;nbsp;&amp;nbsp;" style="rounded=0;whiteSpace=wrap;html=1;align=right;" vertex="1" parent="1">
+          <mxGeometry x="60" y="360" width="600" height="70" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-2" value="RealInode" style="rounded=1;whiteSpace=wrap;html=1;" vertex="1" parent="1">
+          <mxGeometry x="95" y="375" width="100" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-4" value="RealInode" style="rounded=1;whiteSpace=wrap;html=1;" vertex="1" parent="1">
+          <mxGeometry x="414" y="185" width="100" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-5" value="Layer&amp;nbsp;&amp;nbsp;" style="rounded=0;whiteSpace=wrap;html=1;align=right;" vertex="1" parent="1">
+          <mxGeometry x="60" y="270" width="600" height="70" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-6" value="Layer&amp;nbsp;&amp;nbsp;" style="rounded=0;whiteSpace=wrap;html=1;strokeColor=#FF0000;align=right;" vertex="1" parent="1">
+          <mxGeometry x="60" y="170" width="600" height="70" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-10" value="RealInode" style="rounded=1;whiteSpace=wrap;html=1;" vertex="1" parent="1">
+          <mxGeometry x="95" y="185" width="100" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-3" value="RealInode" style="rounded=1;whiteSpace=wrap;html=1;" vertex="1" parent="1">
+          <mxGeometry x="235" y="285" width="100" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-11" value="RealInode" style="rounded=1;whiteSpace=wrap;html=1;" vertex="1" parent="1">
+          <mxGeometry x="390" y="185" width="100" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-15" value="OverlayInode" style="rounded=1;whiteSpace=wrap;html=1;dashed=1;dashPattern=8 8;strokeWidth=1;perimeterSpacing=3;fillStyle=auto;fillColor=none;verticalAlign=top;" vertex="1" parent="1">
+          <mxGeometry x="375" y="130" width="135" height="320" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-13" value="OverlayInode" style="rounded=1;whiteSpace=wrap;html=1;dashed=1;dashPattern=8 8;strokeWidth=1;perimeterSpacing=3;fillStyle=auto;fillColor=none;verticalAlign=top;" vertex="1" parent="1">
+          <mxGeometry x="80" y="130" width="130" height="320" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-14" value="OverlayInode" style="rounded=1;whiteSpace=wrap;html=1;dashed=1;dashPattern=8 8;strokeWidth=1;perimeterSpacing=3;fillStyle=auto;fillColor=none;verticalAlign=top;" vertex="1" parent="1">
+          <mxGeometry x="220" y="130" width="130" height="320" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-16" value="OverlayFs" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=18;" vertex="1" parent="1">
+          <mxGeometry x="240" y="60" width="120" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-18" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=0.031;exitY=0.097;exitDx=0;exitDy=0;exitPerimeter=0;" edge="1" parent="1" source="h7JcLIzoPeIqAFTZNADB-19" target="h7JcLIzoPeIqAFTZNADB-15">
+          <mxGeometry relative="1" as="geometry">
+            <Array as="points">
+              <mxPoint x="520" y="87" />
+              <mxPoint x="440" y="87" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-20" value="open" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" vertex="1" connectable="0" parent="h7JcLIzoPeIqAFTZNADB-18">
+          <mxGeometry x="-0.1249" y="-1" relative="1" as="geometry">
+            <mxPoint as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-19" value="HandleData" style="rounded=1;whiteSpace=wrap;html=1;dashed=1;dashPattern=1 2;strokeWidth=1;perimeterSpacing=3;fillStyle=auto;fillColor=#f5f5f5;verticalAlign=top;fontColor=#333333;strokeColor=#666666;" vertex="1" parent="1">
+          <mxGeometry x="520" y="90" width="90" height="170" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-17" value="RealHandle" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+          <mxGeometry x="530" y="182.5" width="70" height="45" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-21" value="lower" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" vertex="1" parent="1">
+          <mxGeometry x="680" y="290" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-22" value="upper" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" vertex="1" parent="1">
+          <mxGeometry x="680" y="185" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-23" value="lower" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" vertex="1" parent="1">
+          <mxGeometry x="680" y="380" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-24" value="Layer&amp;nbsp;&amp;nbsp;" style="rounded=0;whiteSpace=wrap;html=1;align=right;" vertex="1" parent="1">
+          <mxGeometry x="70" y="870" width="520" height="70" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-27" value="Layer&amp;nbsp;&amp;nbsp;" style="rounded=0;whiteSpace=wrap;html=1;align=right;" vertex="1" parent="1">
+          <mxGeometry x="70" y="780" width="520" height="70" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-28" value="Layer&amp;nbsp;&amp;nbsp;" style="rounded=0;whiteSpace=wrap;html=1;strokeColor=#FF0000;align=right;" vertex="1" parent="1">
+          <mxGeometry x="70" y="690" width="520" height="70" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-32" value="OverlayInode" style="rounded=1;whiteSpace=wrap;html=1;dashed=1;dashPattern=8 8;strokeWidth=1;perimeterSpacing=3;fillStyle=auto;fillColor=none;verticalAlign=top;" vertex="1" parent="1">
+          <mxGeometry x="250" y="580" width="135" height="380" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-40" value="lower" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" vertex="1" parent="1">
+          <mxGeometry x="640" y="795" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-41" value="upper" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" vertex="1" parent="1">
+          <mxGeometry x="640" y="705" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-42" value="lower" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" vertex="1" parent="1">
+          <mxGeometry x="640" y="885" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-33" value="OverlayInode" style="rounded=1;whiteSpace=wrap;html=1;dashed=1;dashPattern=8 8;strokeWidth=1;perimeterSpacing=3;fillStyle=auto;fillColor=none;verticalAlign=top;" vertex="1" parent="1">
+          <mxGeometry x="90" y="580" width="130" height="380" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-29" value="a" style="rounded=1;whiteSpace=wrap;html=1;" vertex="1" parent="1">
+          <mxGeometry x="105" y="795" width="100" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-25" value="a&lt;br&gt;(hidden)" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;dashed=1;dashPattern=1 4;" vertex="1" parent="1">
+          <mxGeometry x="105" y="890" width="100" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-31" value="b" style="rounded=1;whiteSpace=wrap;html=1;" vertex="1" parent="1">
+          <mxGeometry x="267.5" y="705" width="100" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-44" value="b&lt;br&gt;(hidden)" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#f5f5f5;strokeColor=#666666;dashed=1;dashPattern=1 4;fontColor=#333333;" vertex="1" parent="1">
+          <mxGeometry x="265" y="795" width="100" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-45" value="" style="shape=flexArrow;endArrow=classic;html=1;rounded=0;entryX=0.5;entryY=1;entryDx=0;entryDy=0;" edge="1" parent="1" source="h7JcLIzoPeIqAFTZNADB-44" target="h7JcLIzoPeIqAFTZNADB-31">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="255" y="880" as="sourcePoint" />
+            <mxPoint x="305" y="830" as="targetPoint" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-46" value="copy up" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];labelBackgroundColor=#D5E8D4;" vertex="1" connectable="0" parent="h7JcLIzoPeIqAFTZNADB-45">
+          <mxGeometry x="-0.3" y="-1" relative="1" as="geometry">
+            <mxPoint x="-1" y="-4" as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-60" value="Layer&amp;nbsp;&amp;nbsp;" style="rounded=0;whiteSpace=wrap;html=1;align=right;" vertex="1" parent="1">
+          <mxGeometry x="70" y="1370" width="680" height="110" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-61" value="Layer&amp;nbsp;&amp;nbsp;" style="rounded=0;whiteSpace=wrap;html=1;strokeColor=#FF0000;align=right;" vertex="1" parent="1">
+          <mxGeometry x="70" y="1230" width="680" height="110" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-62" value="OverlayInode" style="rounded=1;whiteSpace=wrap;html=1;dashed=1;dashPattern=8 8;strokeWidth=1;perimeterSpacing=3;fillStyle=auto;fillColor=none;verticalAlign=top;" vertex="1" parent="1">
+          <mxGeometry x="310" y="1070" width="180" height="430" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-64" value="upper" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" vertex="1" parent="1">
+          <mxGeometry x="760" y="1269" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-65" value="lower" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" vertex="1" parent="1">
+          <mxGeometry x="760" y="1410" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-66" value="OverlayInode" style="rounded=1;whiteSpace=wrap;html=1;dashed=1;dashPattern=8 8;strokeWidth=1;perimeterSpacing=3;fillStyle=auto;fillColor=none;verticalAlign=top;" vertex="1" parent="1">
+          <mxGeometry x="90" y="1070" width="190" height="430" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-74" value="dir_1" style="swimlane;fontStyle=0;childLayout=stackLayout;horizontal=1;startSize=26;fillColor=#d5e8d4;horizontalStack=0;resizeParent=1;resizeParentMax=0;resizeLast=0;collapsible=1;marginBottom=0;whiteSpace=wrap;html=1;strokeColor=#82b366;" vertex="1" parent="1">
+          <mxGeometry x="115" y="1386" width="140" height="78" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-75" value="a" style="text;strokeColor=none;fillColor=none;align=left;verticalAlign=top;spacingLeft=4;spacingRight=4;overflow=hidden;rotatable=0;points=[[0,0.5],[1,0.5]];portConstraint=eastwest;whiteSpace=wrap;html=1;" vertex="1" parent="h7JcLIzoPeIqAFTZNADB-74">
+          <mxGeometry y="26" width="140" height="26" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-76" value="b" style="text;strokeColor=none;fillColor=none;align=left;verticalAlign=top;spacingLeft=4;spacingRight=4;overflow=hidden;rotatable=0;points=[[0,0.5],[1,0.5]];portConstraint=eastwest;whiteSpace=wrap;html=1;" vertex="1" parent="h7JcLIzoPeIqAFTZNADB-74">
+          <mxGeometry y="52" width="140" height="26" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-78" value="dir_1" style="swimlane;fontStyle=0;childLayout=stackLayout;horizontal=1;startSize=26;fillColor=#d5e8d4;horizontalStack=0;resizeParent=1;resizeParentMax=0;resizeLast=0;collapsible=1;marginBottom=0;whiteSpace=wrap;html=1;strokeColor=#82b366;" vertex="1" parent="1">
+          <mxGeometry x="115" y="1245" width="140" height="78" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-79" value="a" style="text;strokeColor=none;fillColor=none;align=left;verticalAlign=top;spacingLeft=4;spacingRight=4;overflow=hidden;rotatable=0;points=[[0,0.5],[1,0.5]];portConstraint=eastwest;whiteSpace=wrap;html=1;" vertex="1" parent="h7JcLIzoPeIqAFTZNADB-78">
+          <mxGeometry y="26" width="140" height="26" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-80" value="c" style="text;strokeColor=none;fillColor=none;align=left;verticalAlign=top;spacingLeft=4;spacingRight=4;overflow=hidden;rotatable=0;points=[[0,0.5],[1,0.5]];portConstraint=eastwest;whiteSpace=wrap;html=1;" vertex="1" parent="h7JcLIzoPeIqAFTZNADB-78">
+          <mxGeometry y="52" width="140" height="26" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-81" value="dir_1 (merged)" style="swimlane;fontStyle=0;childLayout=stackLayout;horizontal=1;startSize=26;fillColor=#d5e8d4;horizontalStack=0;resizeParent=1;resizeParentMax=0;resizeLast=0;collapsible=1;marginBottom=0;whiteSpace=wrap;html=1;strokeColor=#82b366;" vertex="1" parent="1">
+          <mxGeometry x="115" y="1110" width="140" height="104" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-82" value="a" style="text;strokeColor=none;fillColor=none;align=left;verticalAlign=top;spacingLeft=4;spacingRight=4;overflow=hidden;rotatable=0;points=[[0,0.5],[1,0.5]];portConstraint=eastwest;whiteSpace=wrap;html=1;" vertex="1" parent="h7JcLIzoPeIqAFTZNADB-81">
+          <mxGeometry y="26" width="140" height="26" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-83" value="b" style="text;strokeColor=none;fillColor=none;align=left;verticalAlign=top;spacingLeft=4;spacingRight=4;overflow=hidden;rotatable=0;points=[[0,0.5],[1,0.5]];portConstraint=eastwest;whiteSpace=wrap;html=1;" vertex="1" parent="h7JcLIzoPeIqAFTZNADB-81">
+          <mxGeometry y="52" width="140" height="26" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-84" value="c" style="text;strokeColor=none;fillColor=none;align=left;verticalAlign=top;spacingLeft=4;spacingRight=4;overflow=hidden;rotatable=0;points=[[0,0.5],[1,0.5]];portConstraint=eastwest;whiteSpace=wrap;html=1;" vertex="1" parent="h7JcLIzoPeIqAFTZNADB-81">
+          <mxGeometry y="78" width="140" height="26" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-85" value="dir_2 (opaque)" style="swimlane;fontStyle=0;childLayout=stackLayout;horizontal=1;startSize=26;fillColor=#d5e8d4;horizontalStack=0;resizeParent=1;resizeParentMax=0;resizeLast=0;collapsible=1;marginBottom=0;whiteSpace=wrap;html=1;strokeColor=#82b366;" vertex="1" parent="1">
+          <mxGeometry x="330" y="1258" width="140" height="52" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-86" value="c" style="text;strokeColor=none;fillColor=none;align=left;verticalAlign=top;spacingLeft=4;spacingRight=4;overflow=hidden;rotatable=0;points=[[0,0.5],[1,0.5]];portConstraint=eastwest;whiteSpace=wrap;html=1;" vertex="1" parent="h7JcLIzoPeIqAFTZNADB-85">
+          <mxGeometry y="26" width="140" height="26" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-88" value="dir_2 (hidden)" style="swimlane;fontStyle=0;childLayout=stackLayout;horizontal=1;startSize=26;fillColor=#f5f5f5;horizontalStack=0;resizeParent=1;resizeParentMax=0;resizeLast=0;collapsible=1;marginBottom=0;whiteSpace=wrap;html=1;strokeColor=#666666;fontColor=#333333;" vertex="1" parent="1">
+          <mxGeometry x="330" y="1386" width="140" height="78" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-89" value="a" style="text;strokeColor=none;fillColor=none;align=left;verticalAlign=top;spacingLeft=4;spacingRight=4;overflow=hidden;rotatable=0;points=[[0,0.5],[1,0.5]];portConstraint=eastwest;whiteSpace=wrap;html=1;" vertex="1" parent="h7JcLIzoPeIqAFTZNADB-88">
+          <mxGeometry y="26" width="140" height="26" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-90" value="b" style="text;strokeColor=none;fillColor=none;align=left;verticalAlign=top;spacingLeft=4;spacingRight=4;overflow=hidden;rotatable=0;points=[[0,0.5],[1,0.5]];portConstraint=eastwest;whiteSpace=wrap;html=1;" vertex="1" parent="h7JcLIzoPeIqAFTZNADB-88">
+          <mxGeometry y="52" width="140" height="26" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-95" value="dir_2 (merged)" style="swimlane;fontStyle=0;childLayout=stackLayout;horizontal=1;startSize=26;fillColor=#d5e8d4;horizontalStack=0;resizeParent=1;resizeParentMax=0;resizeLast=0;collapsible=1;marginBottom=0;whiteSpace=wrap;html=1;strokeColor=#82b366;" vertex="1" parent="1">
+          <mxGeometry x="330" y="1110" width="140" height="52" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-96" value="c" style="text;strokeColor=none;fillColor=none;align=left;verticalAlign=top;spacingLeft=4;spacingRight=4;overflow=hidden;rotatable=0;points=[[0,0.5],[1,0.5]];portConstraint=eastwest;whiteSpace=wrap;html=1;" vertex="1" parent="h7JcLIzoPeIqAFTZNADB-95">
+          <mxGeometry y="26" width="140" height="26" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-97" value="OverlayInode" style="rounded=1;whiteSpace=wrap;html=1;dashed=1;dashPattern=8 8;strokeWidth=1;perimeterSpacing=3;fillStyle=auto;fillColor=none;verticalAlign=top;" vertex="1" parent="1">
+          <mxGeometry x="410" y="580" width="130" height="380" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-98" value="c&lt;br&gt;(WHITEOUT)" style="rounded=1;whiteSpace=wrap;html=1;" vertex="1" parent="1">
+          <mxGeometry x="425" y="705" width="100" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-99" value="c&lt;br&gt;(hidden)" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;dashed=1;dashPattern=1 4;" vertex="1" parent="1">
+          <mxGeometry x="425" y="890" width="100" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-102" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=0.5;exitY=1;exitDx=0;exitDy=0;" edge="1" parent="1" source="h7JcLIzoPeIqAFTZNADB-100" target="h7JcLIzoPeIqAFTZNADB-29">
+          <mxGeometry relative="1" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-107" value="read" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" vertex="1" connectable="0" parent="h7JcLIzoPeIqAFTZNADB-102">
+          <mxGeometry x="-0.216" y="1" relative="1" as="geometry">
+            <mxPoint as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-100" value="a" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#d5e8d4;strokeColor=#82b366;" vertex="1" parent="1">
+          <mxGeometry x="105" y="630" width="100" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-105" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;" edge="1" parent="1" source="h7JcLIzoPeIqAFTZNADB-103" target="h7JcLIzoPeIqAFTZNADB-31">
+          <mxGeometry relative="1" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-108" value="write" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" vertex="1" connectable="0" parent="h7JcLIzoPeIqAFTZNADB-105">
+          <mxGeometry x="-0.2571" y="4" relative="1" as="geometry">
+            <mxPoint x="-4" y="-3" as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-103" value="b" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#d5e8d4;strokeColor=#82b366;" vertex="1" parent="1">
+          <mxGeometry x="267.5" y="630" width="100" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-106" value="deleted" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#f5f5f5;strokeColor=#666666;fontColor=#333333;dashed=1;dashPattern=1 4;" vertex="1" parent="1">
+          <mxGeometry x="425" y="630" width="100" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-109" value="OverlayInode" style="rounded=1;whiteSpace=wrap;html=1;dashed=1;dashPattern=8 8;strokeWidth=1;perimeterSpacing=3;fillStyle=auto;fillColor=none;verticalAlign=top;" vertex="1" parent="1">
+          <mxGeometry x="514" y="1070" width="180" height="430" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-112" value="dir_3 (hidden)" style="swimlane;fontStyle=0;childLayout=stackLayout;horizontal=1;startSize=26;fillColor=#f5f5f5;horizontalStack=0;resizeParent=1;resizeParentMax=0;resizeLast=0;collapsible=1;marginBottom=0;whiteSpace=wrap;html=1;strokeColor=#666666;fontColor=#333333;" vertex="1" parent="1">
+          <mxGeometry x="540" y="1386" width="140" height="78" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-113" value="a" style="text;strokeColor=none;fillColor=none;align=left;verticalAlign=top;spacingLeft=4;spacingRight=4;overflow=hidden;rotatable=0;points=[[0,0.5],[1,0.5]];portConstraint=eastwest;whiteSpace=wrap;html=1;" vertex="1" parent="h7JcLIzoPeIqAFTZNADB-112">
+          <mxGeometry y="26" width="140" height="26" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-114" value="b" style="text;strokeColor=none;fillColor=none;align=left;verticalAlign=top;spacingLeft=4;spacingRight=4;overflow=hidden;rotatable=0;points=[[0,0.5],[1,0.5]];portConstraint=eastwest;whiteSpace=wrap;html=1;" vertex="1" parent="h7JcLIzoPeIqAFTZNADB-112">
+          <mxGeometry y="52" width="140" height="26" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-117" value="dir_3&lt;br&gt;(WHITEOUT)" style="rounded=1;whiteSpace=wrap;html=1;" vertex="1" parent="1">
+          <mxGeometry x="554" y="1264" width="100" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="h7JcLIzoPeIqAFTZNADB-118" value="deleted" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#f5f5f5;strokeColor=#666666;fontColor=#333333;dashed=1;dashPattern=1 4;" vertex="1" parent="1">
+          <mxGeometry x="554" y="1116" width="100" height="40" as="geometry" />
+        </mxCell>
+      </root>
+    </mxGraphModel>
+  </diagram>
+</mxfile>
diff --git a/docs/images/overlayfs_dir.png b/docs/images/overlayfs_dir.png
new file mode 100644
index 0000000000000000000000000000000000000000..6ed7acc29b2205fd9f1620375154856b97b3a5b8
GIT binary patch
literal 192193
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
Q1<=Rc<&bmP9@2&X0ICx#Z~y=R

literal 0
HcmV?d00001

diff --git a/docs/images/overlayfs_non_dir_file.png b/docs/images/overlayfs_non_dir_file.png
new file mode 100644
index 0000000000000000000000000000000000000000..74f9abd6ea231223ae672d178abbbf0e9ba74513
GIT binary patch
literal 171958
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

literal 0
HcmV?d00001

diff --git a/docs/images/overlayfs_structs.png b/docs/images/overlayfs_structs.png
new file mode 100644
index 0000000000000000000000000000000000000000..c860ae3cb5b195ba885b44cd2374d5ea7479df08
GIT binary patch
literal 172698
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
R`v@=qfv2mV%Q~loCIFelu805t

literal 0
HcmV?d00001

diff --git a/docs/overlayfs.md b/docs/overlayfs.md
new file mode 100644
index 000000000..4d956f3d7
--- /dev/null
+++ b/docs/overlayfs.md
@@ -0,0 +1,60 @@
+# Architecture of Overlay FS
+
+The implementation of userspace Overlay FS follows [the design of the kernel](https://docs.kernel.org/filesystems/overlayfs.html),
+but it is not a direct port. 
+There are some differences between the kernel implementation and the userspace implementation due to FUSE limitations,
+it's under heavy development to make it more stable and more compatible.
+
+## Basic Struct Definitions
+
+There're some important structs in the implementation of Overlay FS, they are:
+
+* `OverlayFs`: the main struct of the union FS, it's composed of multiple layers, normally one optional writable upper layer and many readonly lower layers.
+* `OverlayInode`: inode struct in OverlayFs, one OverlayInode is composed of many `RealInode` in each layer.
+* `RealInode`: wrapper for backend `inode` in one single layer.
+* `HandleData`: opened file handle in OverlayFs, one OverlayInode reflects to one OverlayInode and one optional `RealHandle` in some layer.
+* `RealHandle`: wrapper for backend opened file handle in one single layer.
+
+Also another trait named `Layer` is introducted to represent a single layer in OverlayFs, only filesystems which implement this trait can be used as a layer in OverlayFs.
+
+Relationship between these structs are illustrated in the following figure:
+
+![OverlayFs Structs](./images/overlayfs_structs.png)
+
+## Non-Directory File
+
+Following kernel Overlay semantics, OverlayFs uses the following rules to handle non-directory files:
+
+* If a file with same name exists in all layers, the topmost file will be choosed, any other files with same name in lower layers will be hidden.
+* If a file in lower filesystem is accessed in a way the requires write-access, such as opening for write access, changing some metadata etc., 
+the file is first copied from the lower filesystem to the upper filesystem (copy_up).
+
+![OverlayFs Non-Directory File](./images/overlayfs_non_dir_file.png)
+
+## Directory
+
+Following kernel Overlay semantics, OverlayFs uses the following rules to handle directories:
+
+* If a directory with same name exists in all layers, the union directory will merge all entries of directory in all layers.
+* If a directory is set as opaque, all entries in lower layers will be hidden.
+* The copy up logic is similar to non-directory file, any write access to a directory will trigger copy up.
+
+![OverlayFs Directory](./images/overlayfs_dir.png)
+
+## Whiteout
+
+A whiteout is a special file in OverlayFs, it indicates a deletion of a file or directory in lower layer.
+whiteout is device file with major number 0 and minor number 0, 
+and the name of whiteout file is the name of file or directory to be deleted.
+
+## Opaque
+
+Opaque is a special flag for directory in OverlayFs, it indicates that all entries of directory in lower layers will be ignored.
+Opaque is implemented by setting one of these xattr to 'y':
+
+* `trusted.overlay.opaque`
+* `user.overlay.opaque`
+* `user.fuseoverlayfs.opaque`
+
+`user.fuseoverlayfs.opaque` is customized flag for our fuse-overlayfs.
+

From cec82c2b6cbf15d4270ed5cd7a77686e5f07e75d Mon Sep 17 00:00:00 2001
From: Wei Zhang <weizhang555.zw@gmail.com>
Date: Tue, 16 Jan 2024 15:08:58 +0800
Subject: [PATCH 5/5] CI: add unionmount-testsuite

Add unionmount-testsuite into CI for Overlay implementation

Signed-off-by: Wei Zhang <weizhang555.zw@gmail.com>
---
 .github/workflows/xfstests.yml           |  21 +++++
 tests/scripts/unionmount_test_overlay.sh | 106 +++++++++++++++++++++++
 2 files changed, 127 insertions(+)
 create mode 100755 tests/scripts/unionmount_test_overlay.sh

diff --git a/.github/workflows/xfstests.yml b/.github/workflows/xfstests.yml
index 57bec3c0d..532ff0b15 100644
--- a/.github/workflows/xfstests.yml
+++ b/.github/workflows/xfstests.yml
@@ -52,3 +52,24 @@ jobs:
       run: |
         cd $GITHUB_WORKSPACE
         sudo ./tests/scripts/xfstests_overlay.sh
+
+  unionmount_testsuite_on_overlayfs:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+    - name: Install Rust
+      uses: actions-rs/toolchain@v1
+      with:
+        profile: minimal
+        toolchain: stable
+        override: true
+    - name: Build overlay binary
+      run: |
+        cd tests/overlay
+        cargo build --release
+        sudo install -t /usr/sbin/ -m 700 ./target/release/overlay
+    - name: Setup and run unionmount testsuite
+      run: |
+        cd $GITHUB_WORKSPACE
+        sudo ./tests/scripts/unionmount_test_overlay.sh
\ No newline at end of file
diff --git a/tests/scripts/unionmount_test_overlay.sh b/tests/scripts/unionmount_test_overlay.sh
new file mode 100755
index 000000000..6268719a4
--- /dev/null
+++ b/tests/scripts/unionmount_test_overlay.sh
@@ -0,0 +1,106 @@
+#!/bin/bash
+
+# create fuse overlay mount script.
+# /tmp/testoverlay must exists.
+sudo cat >/usr/sbin/mount.fuse.testoverlay  <<EOF
+#!/bin/bash
+
+ulimit -n 1048576
+exec /usr/sbin/overlay \$@ -l info 1>>/tmp/testoverlay.log 2>&1 &
+sleep 1
+EOF
+sudo chmod +x /usr/sbin/mount.fuse.testoverlay
+
+
+# clone xfstests and install.
+cd /tmp/
+git clone -b ci-fuse-backend-rs https://github.com/WeiZhang555/unionmount-testsuite.git
+cd unionmount-testsuite
+
+echo "====> Start to run unionmount-testsuite."
+
+mkdir -p /tmp/unionmount/
+touch /tmp/summary
+success=0
+fail=0
+
+for testcase in dir-open-dir \
+dir-open \
+dir-sym1-open \
+dir-sym1-weird-open \
+dir-sym2-open \
+dir-sym2-weird-open \
+dir-weird-open \
+hard-link-dir \
+hard-link \
+hard-link-sym \
+impermissible \
+mkdir \
+noent-creat-excl \
+noent-creat-excl-trunc \
+noent-creat \
+noent-creat-trunc \
+noent-plain \
+noent-trunc \
+open-creat-excl \
+open-creat-excl-trunc \
+open-creat \
+open-creat-trunc \
+open-plain \
+open-trunc \
+readlink \
+rename-exdev \
+rmdir \
+rmtree-new \
+rmtree \
+sym1-creat-excl \
+sym1-creat \
+sym1-plain \
+sym1-trunc \
+sym2-creat-excl \
+sym2-creat \
+sym2-plain \
+sym2-trunc \
+symx-creat-excl \
+symx-creat \
+symx-creat-trunc \
+symx-plain \
+symx-trunc \
+truncate \
+unlink
+# === Some test cases are not supported by unionmount currently ===
+# dir-weird-open-dir
+# rename-dir
+# rename-empty-dir
+# rename-file
+# rename-hard-link
+# rename-mass-2
+# rename-mass-3
+# rename-mass-4
+# rename-mass-5
+# rename-mass-dir
+# rename-mass
+# rename-mass-sym
+# rename-move-dir
+# rename-new-dir
+# rename-new-pop-dir
+# rename-pop-dir
+do
+	UNIONMOUNT_BASEDIR=/tmp/unionmount sudo -E ./run --ov --fuse=testoverlay --xdev $testcase
+	if [ $? -eq 0 ]
+	then
+		echo "===== SUCCESS: " $testcase >> /tmp/summary
+		let success+=1
+	else
+		echo ">>>>>>>> FAIL: " $testcase >> /tmp/summary
+		let fail+=1
+	fi
+done;
+
+cat /tmp/summary && rm /tmp/summary
+echo "Total: success: $success, fail: $fail"
+
+if [ $fail -gt 0 ]
+then
+    exit 1
+fi