kobako 0.29.0 → 0.30.0

data/crates/kobako-runtime/src/filesystem/overlay/file.rs

@@ -0,0 +1,89 @@
+//! A lower Layer's file open to read, which reads the upper's once a copy up
+//! makes one, as overlayfs's `ovl_real_file` looks where the data is at each
+//! call and opens the upper file the first time it finds it there.
+
+use std::sync::Arc;
+
+use super::super::{FileOperations, FilesystemError, Kiocb, OpenHow};
+use super::inode::OverlayFileInode;
+use crate::vfs::{generic_file_llseek, Dentry, Whence};
+
+/// `file`, opened on `real` for the entry `inode` keeps, as `ovl_open` hands out
+/// a file over the real one.
+pub(super) fn ovl_file(
+    file: Box<dyn FileOperations>,
+    real: Arc<Dentry>,
+    inode: Arc<OverlayFileInode>,
+) -> Box<dyn FileOperations> {
+    Box::new(OverlayFile {
+        file,
+        real,
+        inode,
+        upper: None,
+    })
+}
+
+/// A lower Layer's file open to read, as overlayfs's `struct ovl_file`.
+struct OverlayFile {
+    file: Box<dyn FileOperations>,
+    /// The Layer's dentry `file` was opened on.
+    real: Arc<Dentry>,
+    /// The entry this file reads, which says where its data is now.
+    inode: Arc<OverlayFileInode>,
+    /// The upper's file, once a copy up made one and a call found it.
+    upper: Option<Box<dyn FileOperations>>,
+}
+
+impl OverlayFile {
+    /// The file holding the data now, as `ovl_real_file_path` finds it.
+    fn real_file(&mut self) -> Result<&mut dyn FileOperations, FilesystemError> {
+        if self.upper.is_none() {
+            let real = self.inode.path_real();
+            if !Arc::ptr_eq(real.dentry(), &self.real) {
+                let read = OpenHow {
+                    read: true,
+                    ..OpenHow::default()
+                };
+                self.upper = Some(real.open_realfile(&read)?);
+            }
+        }
+        Ok(match &mut self.upper {
+            Some(upper) => upper.as_mut(),
+            None => self.file.as_mut(),
+        })
+    }
+}
+
+impl FileOperations for OverlayFile {
+    /// The view's size answers an end, which is the real file's, as
+    /// `ovl_llseek` seeks the real file.
+    fn llseek(
+        &mut self,
+        dentry: &Dentry,
+        pos: u64,
+        offset: i64,
+        whence: Whence,
+    ) -> Result<u64, FilesystemError> {
+        generic_file_llseek(dentry, pos, offset, whence)
+    }
+
+    fn read_iter(&mut self, iocb: &mut Kiocb, buf: &mut [u8]) -> Result<usize, FilesystemError> {
+        self.real_file()?.read_iter(iocb, buf)
+    }
+
+    /// A file open to read flushes what it reads, as `ovl_fsync` syncs the
+    /// real file.
+    fn fsync(&mut self, datasync: bool) -> Result<(), FilesystemError> {
+        self.real_file()?.fsync(datasync)
+    }
+
+    fn flush(&mut self) -> Result<(), FilesystemError> {
+        self.file.flush()
+    }
+
+    /// A stream stays one through the view, as overlayfs hands a special file's
+    /// open to its real inode.
+    fn is_stream(&self) -> bool {
+        self.file.is_stream()
+    }
+}

data/crates/kobako-runtime/src/filesystem/overlay/inode.rs

@@ -0,0 +1,106 @@
+//! The entries of an Overlay's view as it keeps them on their inodes, as
+//! overlayfs keeps an `ovl_inode` for each: a directory's Layers' directories, or
+//! where anything else stands in a Layer, with the lock a copy up of the entry
+//! holds. A directory and a file keep apart what `ovl_inode` holds together, so
+//! each answers only what it has.
+//!
+//! The runtime records one inode for each dentry it reaches, so every handle
+//! of an entry reaches the same state, and a removal or a replacement
+//! through the runtime leaves the next lookup an inode, and so a state, of
+//! its own.
+
+use std::any::Any;
+use std::sync::{Arc, Mutex, MutexGuard, PoisonError};
+
+use super::path::OverlayPath;
+use super::stack::{Level, UPPER};
+use crate::locking::RwSemaphore;
+use crate::vfs::{Dentry, Inode};
+
+/// A directory of the view.
+pub(super) struct OverlayDirInode {
+    /// Each Layer's directory it stands for.
+    level: Mutex<Level>,
+    /// The lock a copy up of it holds, as overlayfs's `ovl_inode_lock`, so two
+    /// calls never copy it up at once.
+    pub(super) lock: Arc<RwSemaphore>,
+}
+
+/// A file of the view, or anything else that is no directory.
+pub(super) struct OverlayFileInode {
+    /// The Layer and its dentry a lookup found it at, or a copy up made, as
+    /// `struct ovl_entry` holds each real dentry with its layer, so it answers
+    /// from there even once its name is gone from the view.
+    real: Mutex<OverlayPath>,
+    /// The lock a copy up of it holds, as overlayfs's `ovl_inode_lock`.
+    pub(super) lock: Arc<RwSemaphore>,
+}
+
+fn lock<T>(held: &Mutex<T>) -> MutexGuard<'_, T> {
+    held.lock().unwrap_or_else(PoisonError::into_inner)
+}
+
+impl OverlayDirInode {
+    /// A directory standing for `level`, as `ovl_inode_params` carries it.
+    pub(super) fn new(level: Level) -> Self {
+        Self {
+            level: Mutex::new(level),
+            lock: Arc::default(),
+        }
+    }
+
+    /// What `inode` keeps, where it is a directory's.
+    pub(super) fn of(inode: &Inode) -> Option<Arc<Self>> {
+        inode.private().get()?.clone().downcast().ok()
+    }
+
+    pub(super) fn level(&self) -> Level {
+        lock(&self.level).clone()
+    }
+
+    /// The upper now holds `dir` as this directory, made or found there by a
+    /// copy up, as overlayfs's `ovl_inode_update` records the upper dentry, so
+    /// every handle of it asks the upper too.
+    pub(super) fn inode_update(&self, dir: &OverlayPath) {
+        lock(&self.level)[UPPER] = Some(dir.clone());
+    }
+}
+
+impl OverlayFileInode {
+    /// An entry answering through `real`, as `ovl_inode_params` carries it.
+    pub(super) fn new(real: OverlayPath) -> Self {
+        Self {
+            real: Mutex::new(real),
+            lock: Arc::default(),
+        }
+    }
+
+    /// What `inode` keeps, where it is no directory's.
+    pub(super) fn of(inode: &Inode) -> Option<Arc<Self>> {
+        inode.private().get()?.clone().downcast().ok()
+    }
+
+    /// The Layer's dentry this answers through.
+    pub(super) fn real(&self) -> Arc<Dentry> {
+        lock(&self.real).dentry().clone()
+    }
+
+    /// The Layer and its dentry this answers through, as `ovl_path_real` finds
+    /// the real path.
+    pub(super) fn path_real(&self) -> OverlayPath {
+        lock(&self.real).clone()
+    }
+
+    /// This file's data now stands at `real`, in the upper, as
+    /// `ovl_dentry_set_upper_alias` records a copy up.
+    pub(super) fn set_real(&self, real: OverlayPath) {
+        *lock(&self.real) = real;
+    }
+}
+
+/// Keep on `inode` what its lookup found, as `ovl_inode_init` takes it from
+/// `ovl_lookup` under the directory's lock, so a name moved meanwhile cannot
+/// have the entry stand for another.
+pub(super) fn ovl_inode_init<T: Any + Send + Sync>(inode: &Inode, kept: T) {
+    inode.private().get_or_init(|| Arc::new(kept));
+}

data/crates/kobako-runtime/src/filesystem/overlay/path.rs

@@ -0,0 +1,285 @@
+//! One Layer's directory as an Overlay holds it: the directory and its
+//! dentry in the Layer's Filesystem, as overlayfs's `ovl_path` pairs a
+//! layer with its dentry. A name is found, and the directory held while one
+//! is made, removed, or moved, through the VFS's `lookup_one_unlocked`,
+//! `start_creating`, `start_removing`, and `__start_renaming`, and an entry
+//! made, removed, or moved through its `vfs_mkdir`, `vfs_create`, `vfs_rmdir`,
+//! `vfs_unlink`, and `vfs_rename`, as overlayfs's are, so the VFS checks what
+//! stands there and the Layer's dentries follow each change. Each Layer is
+//! asked its own permission as the Overlay's creator, as overlayfs asks
+//! `inode_permission` of the real inode before it searches or opens one.
+
+use std::any::Any;
+use std::sync::Arc;
+
+use super::super::tmpfs::TmpfsFile;
+use super::super::{
+    DirEntry, FileOperations, FileType, Filesystem, FilesystemError, Iattr, InodeOperations, Kstat,
+    Lookup, OpenHow, SetTime, Tmpfs,
+};
+use crate::locking::RwSemaphoreGuard;
+use crate::vfs::{
+    __start_renaming, inode_permission, lookup_one_unlocked, may_create_dentry, notify_change,
+    start_creating, start_removing, vfs_create, vfs_mkdir, vfs_rename, vfs_rmdir, vfs_unlink, Cred,
+    Dentry, DirContext, DirEmit, Mask, RenameFlag,
+};
+
+/// The change setting what `stat` reports of its times, as
+/// `ovl_set_timestamps` sets `ATTR_ATIME_SET` and `ATTR_MTIME_SET`.
+pub(super) fn timestamps(stat: &Kstat) -> Iattr<'static> {
+    Iattr::times(stat.atime.map(SetTime::At), stat.mtime.map(SetTime::At))
+}
+
+/// The attribute marking a directory opaque, and its value, as
+/// overlayfs's `OVL_XATTR_OPAQUE`.
+const OPAQUE_XATTR: &str = "trusted.overlay.opaque";
+const OPAQUE: &[u8] = b"y";
+
+#[derive(Clone)]
+pub(super) struct OverlayPath {
+    filesystem: Arc<Filesystem>,
+    dentry: Arc<Dentry>,
+    /// Who every call on a Layer is made as, whoever asked the view, as overlayfs
+    /// overrides the caller's creds with `ofs->creator_cred`.
+    creator_cred: Arc<Cred>,
+}
+
+impl OverlayPath {
+    /// The root of the Layer `filesystem` stands for.
+    pub(super) fn root(filesystem: &Arc<Filesystem>, creator_cred: &Arc<Cred>) -> Self {
+        Self {
+            dentry: filesystem.s_root(),
+            filesystem: filesystem.clone(),
+            creator_cred: creator_cred.clone(),
+        }
+    }
+
+    /// Where this directory stands in its Layer.
+    pub(super) fn dentry(&self) -> &Arc<Dentry> {
+        &self.dentry
+    }
+
+    /// Whether what this Layer holds at `name`, if it holds a dentry there, is
+    /// `real`, as `ovl_matches_upper` compares what stands in the upper.
+    pub(super) fn matches_real(&self, name: &str, real: &Arc<Dentry>) -> bool {
+        let held = self.filesystem.dentries().lookup(&self.dentry, name);
+        held.is_none_or(|held| Arc::ptr_eq(&held, real))
+    }
+
+    /// The dentry of `name` as this directory stores it, what stands there
+    /// recorded on it.
+    fn lookup_real(&self, name: &str) -> Result<Arc<Dentry>, FilesystemError> {
+        lookup_one_unlocked(&self.creator_cred, &self.filesystem, &self.dentry, name)
+    }
+
+    /// This directory held for making `name`, and its dentry.
+    fn start_creating(
+        &self,
+        name: &str,
+    ) -> Result<(RwSemaphoreGuard, Arc<Dentry>), FilesystemError> {
+        start_creating(&self.creator_cred, &self.filesystem, &self.dentry, name)
+    }
+
+    /// This directory held for removing what stands at `name`, and its dentry.
+    fn start_removing(
+        &self,
+        name: &str,
+    ) -> Result<(RwSemaphoreGuard, Arc<Dentry>), FilesystemError> {
+        start_removing(&self.creator_cred, &self.filesystem, &self.dentry, name)
+    }
+
+    fn inode_lock_shared(&self) -> Result<RwSemaphoreGuard, FilesystemError> {
+        self.dentry.inode_lock_shared()
+    }
+
+    fn inode_lock(&self) -> Result<RwSemaphoreGuard, FilesystemError> {
+        self.dentry.inode_lock()
+    }
+
+    /// This directory as a Tmpfs, the one kind holding an Overlay's marks.
+    fn tmpfs(&self) -> Option<Arc<Tmpfs>> {
+        let ops: Arc<dyn Any + Send + Sync> = self.dentry.inode_ops().ok()?;
+        ops.downcast().ok()
+    }
+
+    /// This directory of the upper, which is always a Tmpfs.
+    fn upper(&self) -> Result<Arc<Tmpfs>, FilesystemError> {
+        self.tmpfs().ok_or(FilesystemError::ReadOnlyFilesystem)
+    }
+
+    /// Whether a whiteout stands at `name`, as `ovl_is_whiteout` reads the
+    /// entry; a Layer that is no Tmpfs holds none.
+    pub(super) fn is_whiteout(&self, name: &str) -> bool {
+        self.tmpfs().is_some_and(|tmpfs| tmpfs.is_whiteout(name))
+    }
+
+    /// Whether `dentry`, found in this directory, stands for a whiteout, as
+    /// `ovl_is_whiteout` reads a dentry, a character device being one only in a
+    /// Tmpfs, whose marks an Overlay reads.
+    pub(super) fn is_whiteout_dentry(&self, dentry: &Dentry) -> bool {
+        dentry.kind() == Ok(FileType::Chrdev) && self.tmpfs().is_some()
+    }
+
+    /// Whether this directory hides the Layers below it.
+    pub(super) fn is_opaque(&self) -> bool {
+        self.tmpfs()
+            .and_then(|tmpfs| tmpfs.getxattr(OPAQUE_XATTR))
+            .is_some_and(|value| value == OPAQUE)
+    }
+
+    pub(super) fn set_opaque(&self) -> Result<(), FilesystemError> {
+        let _held = self.inode_lock()?;
+        self.upper()?.setxattr(OPAQUE_XATTR, OPAQUE)
+    }
+
+    pub(super) fn do_whiteout(&self, name: &str) -> Result<(), FilesystemError> {
+        let (_held, dentry) = self.start_creating(name)?;
+        may_create_dentry(&self.creator_cred, &self.filesystem, &self.dentry, &dentry)?;
+        self.upper()?.whiteout(name)
+    }
+
+    /// Move `from` here to `to` in `target` as `renameat2` does with
+    /// `flag`.
+    pub(super) fn do_rename(
+        &self,
+        from: &str,
+        target: &OverlayPath,
+        to: &str,
+        flag: Option<RenameFlag>,
+    ) -> Result<(), FilesystemError> {
+        let rd = __start_renaming(
+            &self.filesystem,
+            (&self.dentry, from),
+            (&target.dentry, to),
+            flag,
+        )?;
+        vfs_rename(&self.creator_cred, &self.filesystem, &rd)
+    }
+
+    pub(super) fn do_tmpfile(&self) -> Result<TmpfsFile, FilesystemError> {
+        self.upper()?.tmpfile()
+    }
+
+    /// Name `file` here, answering the dentry of what was linked, as
+    /// `ovl_do_link` leaves it on the dentry it was handed, so nothing landing at
+    /// the name afterwards is taken for it.
+    pub(super) fn do_link(
+        &self,
+        file: &TmpfsFile,
+        name: &str,
+    ) -> Result<Arc<Dentry>, FilesystemError> {
+        let (_held, dentry) = self.start_creating(name)?;
+        may_create_dentry(&self.creator_cred, &self.filesystem, &self.dentry, &dentry)?;
+        let upper = self.upper()?;
+        upper.link(file, name)?;
+        if let Lookup::Found(inode) = upper.lookup(&dentry)? {
+            dentry.add(Some(inode));
+        }
+        Ok(dentry)
+    }
+
+    /// Set this directory's times to those `stat` reports, as
+    /// `ovl_set_timestamps` hands `notify_change` the upper dentry.
+    pub(super) fn set_timestamps(&self, stat: &Kstat) -> Result<(), FilesystemError> {
+        let held = self.dentry.inode_lock()?;
+        notify_change(&self.dentry, &held, &timestamps(stat))
+    }
+
+    /// `name` as this directory stores it and the dentry standing there, `None`
+    /// where nothing does, as `ovl_lookup_single` asks a layer once for a name.
+    pub(super) fn lookup_single(
+        &self,
+        name: &str,
+    ) -> Result<Option<(String, Arc<Dentry>)>, FilesystemError> {
+        let dentry = self.lookup_real(name)?;
+        Ok(dentry.inode().is_some().then(|| (dentry.name(), dentry)))
+    }
+
+    /// The directory `dentry` names beneath this one.
+    pub(super) fn beneath(&self, dentry: Arc<Dentry>) -> Self {
+        Self {
+            dentry,
+            ..self.clone()
+        }
+    }
+
+    /// Make the file `name`, holding the directory, as `ovl_do_create` does.
+    pub(super) fn do_create(&self, name: &str) -> Result<(), FilesystemError> {
+        let (_held, child) = self.start_creating(name)?;
+        vfs_create(&self.creator_cred, &self.filesystem, &self.dentry, &child)
+    }
+
+    /// The directory standing at `name`, a link there refused as a loop, as
+    /// `ovl_lookup` follows no link in a Layer.
+    pub(super) fn open_dir(&self, name: &str) -> Result<Self, FilesystemError> {
+        let dentry = self.lookup_real(name)?;
+        let inode = dentry.inode().ok_or(FilesystemError::NotFound)?;
+        match inode.kind() {
+            FileType::Dir => Ok(self.beneath(dentry)),
+            FileType::Symlink => Err(FilesystemError::FilesystemLoop),
+            _ => Err(FilesystemError::NotADirectory),
+        }
+    }
+
+    pub(super) fn getattr(&self) -> Result<Kstat, FilesystemError> {
+        self.dentry.getattr()
+    }
+
+    pub(super) fn getattr_at(&self, name: &str) -> Result<Kstat, FilesystemError> {
+        self.lookup_real(name)?.getattr()
+    }
+
+    /// This directory opened, kept open for whoever holds it, as overlayfs's
+    /// `ovl_dir_open` opens the real directory.
+    pub(super) fn open_real(&self) -> Result<Box<dyn FileOperations>, FilesystemError> {
+        self.open_realfile(&OpenHow {
+            read: true,
+            ..OpenHow::default()
+        })
+    }
+
+    /// What this dentry names opened as `how` asks, once its Layer lets the
+    /// Overlay's creator open it so, as `ovl_open_realfile` asks
+    /// `inode_permission` for `MAY_OPEN` and the access before it opens.
+    pub(super) fn open_realfile(
+        &self,
+        how: &OpenHow,
+    ) -> Result<Box<dyn FileOperations>, FilesystemError> {
+        let mut mask = Mask::OPEN;
+        if how.read {
+            mask = mask | Mask::READ;
+        }
+        if how.write {
+            mask = mask | Mask::WRITE;
+        }
+        inode_permission(&self.creator_cred, &self.filesystem, &self.dentry, mask)?;
+        self.dentry.open(how)
+    }
+
+    pub(super) fn entries(&self) -> Result<Vec<DirEntry>, FilesystemError> {
+        let _held = self.inode_lock_shared()?;
+        let mut entries = Vec::new();
+        let mut actor = |emit: &DirEmit<'_>| {
+            entries.push(emit.to_dir_entry());
+            true
+        };
+        self.open_real()?
+            .iterate_shared(&self.dentry, &mut DirContext::new(2, &mut actor))?;
+        Ok(entries)
+    }
+
+    pub(super) fn do_mkdir(&self, name: &str) -> Result<(), FilesystemError> {
+        let (_held, child) = self.start_creating(name)?;
+        vfs_mkdir(&self.creator_cred, &self.filesystem, &self.dentry, &child)
+    }
+
+    pub(super) fn do_rmdir(&self, name: &str) -> Result<(), FilesystemError> {
+        let (_held, victim) = self.start_removing(name)?;
+        vfs_rmdir(&self.creator_cred, &self.filesystem, &self.dentry, &victim)
+    }
+
+    pub(super) fn do_unlink(&self, name: &str) -> Result<(), FilesystemError> {
+        let (_held, victim) = self.start_removing(name)?;
+        vfs_unlink(&self.creator_cred, &self.filesystem, &self.dentry, &victim)
+    }
+}

data/crates/kobako-runtime/src/filesystem/overlay/stack/copy_up.rs

@@ -0,0 +1,135 @@
+//! Making what a change needs in the upper from what a lower Layer shows,
+//! as overlayfs's `copy_up.c` copies a file or a directory up: whole and
+//! with the lower one's times before it is named, and leaving the times
+//! of the directory it lands in as they were.
+
+use std::sync::Arc;
+
+use super::super::super::{FileType, FilesystemError, OpenHow};
+use super::super::inode::OverlayFileInode;
+use super::super::path::{timestamps, OverlayPath};
+use super::{copy_whole, OverlayFs, ViewDir, UPPER};
+use crate::vfs::{Dentry, RenameFlag};
+
+impl OverlayFs {
+    /// The directory `dir` in the upper, made there along with each directory
+    /// above it that so far shows only from another Layer, as overlayfs's
+    /// `ovl_copy_up_flags` climbs the dentry's parents in a loop to copy up the
+    /// topmost first, however deep the Layer's tree is.
+    pub(in super::super) fn upper_dir(
+        &self,
+        dir: &ViewDir,
+    ) -> Result<OverlayPath, FilesystemError> {
+        let mut unmade = Vec::new();
+        let mut at = dir.clone();
+        let mut made = loop {
+            if let Some(held) = at.level()[UPPER].clone() {
+                break held;
+            }
+            let next = self.dir(&at.dentry.parent())?;
+            unmade.push(at);
+            at = next;
+        };
+        while let Some(dir) = unmade.pop() {
+            made = self.copy_up_dir(&dir, &made)?;
+        }
+        Ok(made)
+    }
+
+    /// The directory `dir` in the upper, beneath `parent` there. It is made in
+    /// the workdir with the lower one's times and moved into place, as
+    /// `ovl_copy_up_workdir` does. Another call may have copied it up while this
+    /// one waited, as `ovl_already_copied_up_locked` checks; what else stands at
+    /// the name is no copy of this directory, and refuses the move.
+    fn copy_up_dir(
+        &self,
+        dir: &ViewDir,
+        parent: &OverlayPath,
+    ) -> Result<OverlayPath, FilesystemError> {
+        let name = dir.dentry.name();
+        let _held = dir.inode.lock.down_write()?;
+        let level = dir.level();
+        if let Some(held) = &level[UPPER] {
+            return Ok(held.clone());
+        }
+        let lower = level
+            .iter()
+            .flatten()
+            .next()
+            .ok_or(FilesystemError::NotFound)?
+            .getattr()?;
+        let (work, temp) = self.tempname()?;
+        work.do_mkdir(&temp)?;
+        let made = work
+            .open_dir(&temp)
+            .and_then(|made| made.set_timestamps(&lower));
+        let parent_times = parent.getattr()?;
+        let moved =
+            made.and_then(|()| work.do_rename(&temp, parent, &name, Some(RenameFlag::NoReplace)));
+        if let Err(err) = moved {
+            let _ = work.do_rmdir(&temp);
+            return Err(err);
+        }
+        let _ = parent.set_timestamps(&parent_times);
+        let made = parent.open_dir(&name)?;
+        dir.inode.inode_update(&made);
+        Ok(made)
+    }
+
+    /// Whether `real`, a Layer's dentry, stands in the upper Tmpfs, in its
+    /// workdir too, where a removal leaves a file something still holds.
+    pub(in super::super) fn is_in_upper(&self, real: &Arc<Dentry>) -> bool {
+        self.work
+            .as_ref()
+            .is_some_and(|work| real.is_subdir(&work.dentry().parent()))
+    }
+
+    /// Copy the file `child` names in `dir` up from the Layer its inode keeps,
+    /// as overlayfs's `ovl_copy_up_tmpfile` does: the copy is made with no
+    /// name, filled, given the lower file's times, and only then named, so a
+    /// copy that fails part way is never seen. A `truncate` copy up leaves the
+    /// bytes behind, as `ovl_copy_up_one` sets its size to zero for `O_TRUNC`,
+    /// since the open is about to empty it. Only a file copies up, as
+    /// overlayfs's `ovl_copy_up_data` only reads a regular file, so a special
+    /// file is never opened. A file whose name is gone from the view has no
+    /// place to land.
+    pub(in super::super) fn copy_up_file(
+        &self,
+        dir: &ViewDir,
+        child: &Dentry,
+        truncate: bool,
+    ) -> Result<(), FilesystemError> {
+        let name = child.name();
+        let target_dir = self.upper_dir(dir)?;
+        let inode = child
+            .inode()
+            .as_deref()
+            .and_then(OverlayFileInode::of)
+            .ok_or(FilesystemError::NotFound)?;
+        let _held = inode.lock.down_write()?;
+        let real = inode.path_real();
+        // Another call may have copied it up while this one waited, as
+        // overlayfs's `ovl_already_copied_up_locked` checks.
+        if self.is_in_upper(real.dentry()) {
+            return Ok(());
+        }
+        let lower = real.getattr()?;
+        if lower.file_type != FileType::RegFile {
+            return Err(FilesystemError::PermissionDenied);
+        }
+        let mut copy = target_dir.do_tmpfile()?;
+        if !truncate {
+            let mut source = real.open_realfile(&OpenHow {
+                read: true,
+                ..OpenHow::default()
+            })?;
+            copy_whole(source.as_mut(), &mut copy)?;
+        }
+        copy.setattr(&timestamps(&lower));
+        let parent_times = target_dir.getattr()?;
+        let linked = target_dir.do_link(&copy, &name)?;
+        let _ = target_dir.set_timestamps(&parent_times);
+        inode.set_real(target_dir.beneath(linked));
+        Ok(())
+    }
+}