2019-07-18 22:09:14 +00:00
|
|
|
// Copyright 2019 The gVisor Authors.
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
// you may not use this file except in compliance with the License.
|
|
|
|
// You may obtain a copy of the License at
|
|
|
|
//
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
//
|
|
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
// See the License for the specific language governing permissions and
|
|
|
|
// limitations under the License.
|
|
|
|
|
|
|
|
package vfs
|
|
|
|
|
|
|
|
import (
|
|
|
|
"sync/atomic"
|
|
|
|
|
2020-01-10 06:00:42 +00:00
|
|
|
"gvisor.dev/gvisor/pkg/sync"
|
2019-07-18 22:09:14 +00:00
|
|
|
"gvisor.dev/gvisor/pkg/syserror"
|
|
|
|
)
|
|
|
|
|
2020-04-21 19:16:42 +00:00
|
|
|
// Dentry represents a node in a Filesystem tree at which a file exists.
|
2019-07-18 22:09:14 +00:00
|
|
|
//
|
|
|
|
// Dentries are reference-counted. Unless otherwise specified, all Dentry
|
|
|
|
// methods require that a reference is held.
|
|
|
|
//
|
|
|
|
// Dentry is loosely analogous to Linux's struct dentry, but:
|
|
|
|
//
|
|
|
|
// - VFS does not associate Dentries with inodes. gVisor interacts primarily
|
|
|
|
// with filesystems that are accessed through filesystem APIs (as opposed to
|
|
|
|
// raw block devices); many such APIs support only paths and file descriptors,
|
|
|
|
// and not inodes. Furthermore, when parties outside the scope of VFS can
|
|
|
|
// rename inodes on such filesystems, VFS generally cannot "follow" the rename,
|
|
|
|
// both due to synchronization issues and because it may not even be able to
|
2019-11-25 23:20:25 +00:00
|
|
|
// name the destination path; this implies that it would in fact be incorrect
|
2019-07-18 22:09:14 +00:00
|
|
|
// for Dentries to be associated with inodes on such filesystems. Consequently,
|
|
|
|
// operations that are inode operations in Linux are FilesystemImpl methods
|
|
|
|
// and/or FileDescriptionImpl methods in gVisor's VFS. Filesystems that do
|
|
|
|
// support inodes may store appropriate state in implementations of DentryImpl.
|
|
|
|
//
|
|
|
|
// - VFS does not require that Dentries are instantiated for all paths accessed
|
|
|
|
// through VFS, only those that are tracked beyond the scope of a single
|
|
|
|
// Filesystem operation. This includes file descriptions, mount points, mount
|
|
|
|
// roots, process working directories, and chroots. This avoids instantiation
|
|
|
|
// of Dentries for operations on mutable remote filesystems that can't actually
|
|
|
|
// cache any state in the Dentry.
|
|
|
|
//
|
2020-04-21 19:16:42 +00:00
|
|
|
// - VFS does not track filesystem structure (i.e. relationships between
|
|
|
|
// Dentries), since both the relevant state and synchronization are
|
|
|
|
// filesystem-specific.
|
|
|
|
//
|
2019-07-18 22:09:14 +00:00
|
|
|
// - For the reasons above, VFS is not directly responsible for managing Dentry
|
|
|
|
// lifetime. Dentry reference counts only indicate the extent to which VFS
|
|
|
|
// requires Dentries to exist; Filesystems may elect to cache or discard
|
|
|
|
// Dentries with zero references.
|
2020-02-14 21:39:51 +00:00
|
|
|
//
|
|
|
|
// +stateify savable
|
2019-07-18 22:09:14 +00:00
|
|
|
type Dentry struct {
|
2020-04-21 19:16:42 +00:00
|
|
|
// mu synchronizes deletion/invalidation and mounting over this Dentry.
|
|
|
|
mu sync.Mutex `state:"nosave"`
|
2019-07-18 22:09:14 +00:00
|
|
|
|
2020-04-21 19:16:42 +00:00
|
|
|
// dead is true if the file represented by this Dentry has been deleted (by
|
|
|
|
// CommitDeleteDentry or CommitRenameReplaceDentry) or invalidated (by
|
|
|
|
// InvalidateDentry). dead is protected by mu.
|
|
|
|
dead bool
|
2019-07-18 22:09:14 +00:00
|
|
|
|
|
|
|
// mounts is the number of Mounts for which this Dentry is Mount.point.
|
|
|
|
// mounts is accessed using atomic memory operations.
|
|
|
|
mounts uint32
|
|
|
|
|
|
|
|
// impl is the DentryImpl associated with this Dentry. impl is immutable.
|
|
|
|
// This should be the last field in Dentry.
|
|
|
|
impl DentryImpl
|
|
|
|
}
|
|
|
|
|
|
|
|
// Init must be called before first use of d.
|
|
|
|
func (d *Dentry) Init(impl DentryImpl) {
|
|
|
|
d.impl = impl
|
|
|
|
}
|
|
|
|
|
|
|
|
// Impl returns the DentryImpl associated with d.
|
|
|
|
func (d *Dentry) Impl() DentryImpl {
|
|
|
|
return d.impl
|
|
|
|
}
|
|
|
|
|
|
|
|
// DentryImpl contains implementation details for a Dentry. Implementations of
|
|
|
|
// DentryImpl should contain their associated Dentry by value as their first
|
|
|
|
// field.
|
|
|
|
type DentryImpl interface {
|
|
|
|
// IncRef increments the Dentry's reference count. A Dentry with a non-zero
|
|
|
|
// reference count must remain coherent with the state of the filesystem.
|
Minor VFS2 interface changes.
- Remove the Filesystem argument from DentryImpl.*Ref(); in general DentryImpls
that need the Filesystem for reference counting will probably also need it
for other interface methods that don't plumb Filesystem, so it's easier to
just store a pointer to the filesystem in the DentryImpl.
- Add a pointer to the VirtualFilesystem to Filesystem, which is needed by the
gofer client to disown dentries for cache eviction triggered by dentry
reference count changes.
- Rename FilesystemType.NewFilesystem to GetFilesystem; in some cases (e.g.
sysfs, cgroupfs) it's much cleaner for there to be only one Filesystem that
is used by all mounts, and in at least one case (devtmpfs) it's visibly
incorrect not to do so, so NewFilesystem doesn't always actually create and
return a *new* Filesystem.
- Require callers of FileDescription.Init() to increment Mount/Dentry
references. This is because the gofer client may, in the OpenAt() path, take
a reference on a dentry with 0 references, which is safe due to
synchronization that is outside the scope of this CL, and it would be safer
to still have its implementation of DentryImpl.IncRef() check for an
increment for 0 references in other cases.
- Add FileDescription.TryIncRef. This is used by the gofer client to take
references on "special file descriptions" (FDs for files such as pipes,
sockets, and devices), which use per-FD handles (fids) instead of
dentry-shared handles, for sync() and syncfs().
PiperOrigin-RevId: 282473364
2019-11-26 02:09:15 +00:00
|
|
|
IncRef()
|
2019-07-18 22:09:14 +00:00
|
|
|
|
|
|
|
// TryIncRef increments the Dentry's reference count and returns true. If
|
|
|
|
// the Dentry's reference count is zero, TryIncRef may do nothing and
|
|
|
|
// return false. (It is also permitted to succeed if it can restore the
|
|
|
|
// guarantee that the Dentry is coherent with the state of the filesystem.)
|
|
|
|
//
|
|
|
|
// TryIncRef does not require that a reference is held on the Dentry.
|
Minor VFS2 interface changes.
- Remove the Filesystem argument from DentryImpl.*Ref(); in general DentryImpls
that need the Filesystem for reference counting will probably also need it
for other interface methods that don't plumb Filesystem, so it's easier to
just store a pointer to the filesystem in the DentryImpl.
- Add a pointer to the VirtualFilesystem to Filesystem, which is needed by the
gofer client to disown dentries for cache eviction triggered by dentry
reference count changes.
- Rename FilesystemType.NewFilesystem to GetFilesystem; in some cases (e.g.
sysfs, cgroupfs) it's much cleaner for there to be only one Filesystem that
is used by all mounts, and in at least one case (devtmpfs) it's visibly
incorrect not to do so, so NewFilesystem doesn't always actually create and
return a *new* Filesystem.
- Require callers of FileDescription.Init() to increment Mount/Dentry
references. This is because the gofer client may, in the OpenAt() path, take
a reference on a dentry with 0 references, which is safe due to
synchronization that is outside the scope of this CL, and it would be safer
to still have its implementation of DentryImpl.IncRef() check for an
increment for 0 references in other cases.
- Add FileDescription.TryIncRef. This is used by the gofer client to take
references on "special file descriptions" (FDs for files such as pipes,
sockets, and devices), which use per-FD handles (fids) instead of
dentry-shared handles, for sync() and syncfs().
PiperOrigin-RevId: 282473364
2019-11-26 02:09:15 +00:00
|
|
|
TryIncRef() bool
|
2019-07-18 22:09:14 +00:00
|
|
|
|
|
|
|
// DecRef decrements the Dentry's reference count.
|
Minor VFS2 interface changes.
- Remove the Filesystem argument from DentryImpl.*Ref(); in general DentryImpls
that need the Filesystem for reference counting will probably also need it
for other interface methods that don't plumb Filesystem, so it's easier to
just store a pointer to the filesystem in the DentryImpl.
- Add a pointer to the VirtualFilesystem to Filesystem, which is needed by the
gofer client to disown dentries for cache eviction triggered by dentry
reference count changes.
- Rename FilesystemType.NewFilesystem to GetFilesystem; in some cases (e.g.
sysfs, cgroupfs) it's much cleaner for there to be only one Filesystem that
is used by all mounts, and in at least one case (devtmpfs) it's visibly
incorrect not to do so, so NewFilesystem doesn't always actually create and
return a *new* Filesystem.
- Require callers of FileDescription.Init() to increment Mount/Dentry
references. This is because the gofer client may, in the OpenAt() path, take
a reference on a dentry with 0 references, which is safe due to
synchronization that is outside the scope of this CL, and it would be safer
to still have its implementation of DentryImpl.IncRef() check for an
increment for 0 references in other cases.
- Add FileDescription.TryIncRef. This is used by the gofer client to take
references on "special file descriptions" (FDs for files such as pipes,
sockets, and devices), which use per-FD handles (fids) instead of
dentry-shared handles, for sync() and syncfs().
PiperOrigin-RevId: 282473364
2019-11-26 02:09:15 +00:00
|
|
|
DecRef()
|
2019-07-18 22:09:14 +00:00
|
|
|
}
|
|
|
|
|
Minor VFS2 interface changes.
- Remove the Filesystem argument from DentryImpl.*Ref(); in general DentryImpls
that need the Filesystem for reference counting will probably also need it
for other interface methods that don't plumb Filesystem, so it's easier to
just store a pointer to the filesystem in the DentryImpl.
- Add a pointer to the VirtualFilesystem to Filesystem, which is needed by the
gofer client to disown dentries for cache eviction triggered by dentry
reference count changes.
- Rename FilesystemType.NewFilesystem to GetFilesystem; in some cases (e.g.
sysfs, cgroupfs) it's much cleaner for there to be only one Filesystem that
is used by all mounts, and in at least one case (devtmpfs) it's visibly
incorrect not to do so, so NewFilesystem doesn't always actually create and
return a *new* Filesystem.
- Require callers of FileDescription.Init() to increment Mount/Dentry
references. This is because the gofer client may, in the OpenAt() path, take
a reference on a dentry with 0 references, which is safe due to
synchronization that is outside the scope of this CL, and it would be safer
to still have its implementation of DentryImpl.IncRef() check for an
increment for 0 references in other cases.
- Add FileDescription.TryIncRef. This is used by the gofer client to take
references on "special file descriptions" (FDs for files such as pipes,
sockets, and devices), which use per-FD handles (fids) instead of
dentry-shared handles, for sync() and syncfs().
PiperOrigin-RevId: 282473364
2019-11-26 02:09:15 +00:00
|
|
|
// IncRef increments d's reference count.
|
|
|
|
func (d *Dentry) IncRef() {
|
|
|
|
d.impl.IncRef()
|
2019-07-18 22:09:14 +00:00
|
|
|
}
|
|
|
|
|
Minor VFS2 interface changes.
- Remove the Filesystem argument from DentryImpl.*Ref(); in general DentryImpls
that need the Filesystem for reference counting will probably also need it
for other interface methods that don't plumb Filesystem, so it's easier to
just store a pointer to the filesystem in the DentryImpl.
- Add a pointer to the VirtualFilesystem to Filesystem, which is needed by the
gofer client to disown dentries for cache eviction triggered by dentry
reference count changes.
- Rename FilesystemType.NewFilesystem to GetFilesystem; in some cases (e.g.
sysfs, cgroupfs) it's much cleaner for there to be only one Filesystem that
is used by all mounts, and in at least one case (devtmpfs) it's visibly
incorrect not to do so, so NewFilesystem doesn't always actually create and
return a *new* Filesystem.
- Require callers of FileDescription.Init() to increment Mount/Dentry
references. This is because the gofer client may, in the OpenAt() path, take
a reference on a dentry with 0 references, which is safe due to
synchronization that is outside the scope of this CL, and it would be safer
to still have its implementation of DentryImpl.IncRef() check for an
increment for 0 references in other cases.
- Add FileDescription.TryIncRef. This is used by the gofer client to take
references on "special file descriptions" (FDs for files such as pipes,
sockets, and devices), which use per-FD handles (fids) instead of
dentry-shared handles, for sync() and syncfs().
PiperOrigin-RevId: 282473364
2019-11-26 02:09:15 +00:00
|
|
|
// TryIncRef increments d's reference count and returns true. If d's reference
|
|
|
|
// count is zero, TryIncRef may instead do nothing and return false.
|
|
|
|
func (d *Dentry) TryIncRef() bool {
|
|
|
|
return d.impl.TryIncRef()
|
2019-07-18 22:09:14 +00:00
|
|
|
}
|
|
|
|
|
Minor VFS2 interface changes.
- Remove the Filesystem argument from DentryImpl.*Ref(); in general DentryImpls
that need the Filesystem for reference counting will probably also need it
for other interface methods that don't plumb Filesystem, so it's easier to
just store a pointer to the filesystem in the DentryImpl.
- Add a pointer to the VirtualFilesystem to Filesystem, which is needed by the
gofer client to disown dentries for cache eviction triggered by dentry
reference count changes.
- Rename FilesystemType.NewFilesystem to GetFilesystem; in some cases (e.g.
sysfs, cgroupfs) it's much cleaner for there to be only one Filesystem that
is used by all mounts, and in at least one case (devtmpfs) it's visibly
incorrect not to do so, so NewFilesystem doesn't always actually create and
return a *new* Filesystem.
- Require callers of FileDescription.Init() to increment Mount/Dentry
references. This is because the gofer client may, in the OpenAt() path, take
a reference on a dentry with 0 references, which is safe due to
synchronization that is outside the scope of this CL, and it would be safer
to still have its implementation of DentryImpl.IncRef() check for an
increment for 0 references in other cases.
- Add FileDescription.TryIncRef. This is used by the gofer client to take
references on "special file descriptions" (FDs for files such as pipes,
sockets, and devices), which use per-FD handles (fids) instead of
dentry-shared handles, for sync() and syncfs().
PiperOrigin-RevId: 282473364
2019-11-26 02:09:15 +00:00
|
|
|
// DecRef decrements d's reference count.
|
|
|
|
func (d *Dentry) DecRef() {
|
|
|
|
d.impl.DecRef()
|
2019-07-18 22:09:14 +00:00
|
|
|
}
|
|
|
|
|
2020-04-21 19:16:42 +00:00
|
|
|
// IsDead returns true if d has been deleted or invalidated by its owning
|
|
|
|
// filesystem.
|
|
|
|
func (d *Dentry) IsDead() bool {
|
|
|
|
d.mu.Lock()
|
|
|
|
defer d.mu.Unlock()
|
|
|
|
return d.dead
|
2019-12-21 00:43:34 +00:00
|
|
|
}
|
|
|
|
|
2020-04-21 19:16:42 +00:00
|
|
|
func (d *Dentry) isMounted() bool {
|
|
|
|
return atomic.LoadUint32(&d.mounts) != 0
|
2019-07-18 22:09:14 +00:00
|
|
|
}
|
|
|
|
|
2020-04-21 19:16:42 +00:00
|
|
|
// The following functions are exported so that filesystem implementations can
|
|
|
|
// use them. The vfs package, and users of VFS, should not call these
|
|
|
|
// functions.
|
2019-12-23 21:17:29 +00:00
|
|
|
|
2019-07-18 22:09:14 +00:00
|
|
|
// PrepareDeleteDentry must be called before attempting to delete the file
|
|
|
|
// represented by d. If PrepareDeleteDentry succeeds, the caller must call
|
|
|
|
// AbortDeleteDentry or CommitDeleteDentry depending on the deletion's outcome.
|
|
|
|
func (vfs *VirtualFilesystem) PrepareDeleteDentry(mntns *MountNamespace, d *Dentry) error {
|
2019-11-25 23:20:25 +00:00
|
|
|
vfs.mountMu.Lock()
|
|
|
|
if mntns.mountpoints[d] != 0 {
|
|
|
|
vfs.mountMu.Unlock()
|
2019-07-18 22:09:14 +00:00
|
|
|
return syserror.EBUSY
|
|
|
|
}
|
2019-11-25 23:20:25 +00:00
|
|
|
d.mu.Lock()
|
|
|
|
vfs.mountMu.Unlock()
|
|
|
|
// Return with d.mu locked to block attempts to mount over it; it will be
|
|
|
|
// unlocked by AbortDeleteDentry or CommitDeleteDentry.
|
2019-07-18 22:09:14 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// AbortDeleteDentry must be called after PrepareDeleteDentry if the deletion
|
|
|
|
// fails.
|
2019-11-25 23:20:25 +00:00
|
|
|
func (vfs *VirtualFilesystem) AbortDeleteDentry(d *Dentry) {
|
|
|
|
d.mu.Unlock()
|
2019-07-18 22:09:14 +00:00
|
|
|
}
|
|
|
|
|
2020-04-21 19:16:42 +00:00
|
|
|
// CommitDeleteDentry must be called after PrepareDeleteDentry if the deletion
|
|
|
|
// succeeds.
|
2019-07-18 22:09:14 +00:00
|
|
|
func (vfs *VirtualFilesystem) CommitDeleteDentry(d *Dentry) {
|
2020-04-21 19:16:42 +00:00
|
|
|
d.dead = true
|
2019-11-25 23:20:25 +00:00
|
|
|
d.mu.Unlock()
|
|
|
|
if d.isMounted() {
|
2020-04-21 19:16:42 +00:00
|
|
|
vfs.forgetDeadMountpoint(d)
|
2019-11-25 23:20:25 +00:00
|
|
|
}
|
2019-07-18 22:09:14 +00:00
|
|
|
}
|
|
|
|
|
2020-04-21 19:16:42 +00:00
|
|
|
// InvalidateDentry is called when d ceases to represent the file it formerly
|
|
|
|
// did for reasons outside of VFS' control (e.g. d represents the local state
|
|
|
|
// of a file on a remote filesystem on which the file has already been
|
|
|
|
// deleted).
|
|
|
|
func (vfs *VirtualFilesystem) InvalidateDentry(d *Dentry) {
|
2019-11-25 23:20:25 +00:00
|
|
|
d.mu.Lock()
|
2020-04-21 19:16:42 +00:00
|
|
|
d.dead = true
|
|
|
|
d.mu.Unlock()
|
|
|
|
if d.isMounted() {
|
|
|
|
vfs.forgetDeadMountpoint(d)
|
|
|
|
}
|
2019-11-25 23:20:25 +00:00
|
|
|
}
|
|
|
|
|
2019-07-18 22:09:14 +00:00
|
|
|
// PrepareRenameDentry must be called before attempting to rename the file
|
|
|
|
// represented by from. If to is not nil, it represents the file that will be
|
|
|
|
// replaced or exchanged by the rename. If PrepareRenameDentry succeeds, the
|
|
|
|
// caller must call AbortRenameDentry, CommitRenameReplaceDentry, or
|
|
|
|
// CommitRenameExchangeDentry depending on the rename's outcome.
|
|
|
|
//
|
2020-04-21 19:16:42 +00:00
|
|
|
// Preconditions: If to is not nil, it must be a child Dentry from the same
|
|
|
|
// Filesystem. from != to.
|
2019-07-18 22:09:14 +00:00
|
|
|
func (vfs *VirtualFilesystem) PrepareRenameDentry(mntns *MountNamespace, from, to *Dentry) error {
|
2019-11-25 23:20:25 +00:00
|
|
|
vfs.mountMu.Lock()
|
|
|
|
if mntns.mountpoints[from] != 0 {
|
|
|
|
vfs.mountMu.Unlock()
|
2019-07-18 22:09:14 +00:00
|
|
|
return syserror.EBUSY
|
|
|
|
}
|
|
|
|
if to != nil {
|
2019-11-25 23:20:25 +00:00
|
|
|
if mntns.mountpoints[to] != 0 {
|
|
|
|
vfs.mountMu.Unlock()
|
2019-07-18 22:09:14 +00:00
|
|
|
return syserror.EBUSY
|
|
|
|
}
|
2019-11-25 23:20:25 +00:00
|
|
|
to.mu.Lock()
|
2019-07-18 22:09:14 +00:00
|
|
|
}
|
2019-11-25 23:20:25 +00:00
|
|
|
from.mu.Lock()
|
|
|
|
vfs.mountMu.Unlock()
|
|
|
|
// Return with from.mu and to.mu locked, which will be unlocked by
|
2019-07-18 22:09:14 +00:00
|
|
|
// AbortRenameDentry, CommitRenameReplaceDentry, or
|
|
|
|
// CommitRenameExchangeDentry.
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// AbortRenameDentry must be called after PrepareRenameDentry if the rename
|
|
|
|
// fails.
|
2019-11-25 23:20:25 +00:00
|
|
|
func (vfs *VirtualFilesystem) AbortRenameDentry(from, to *Dentry) {
|
|
|
|
from.mu.Unlock()
|
|
|
|
if to != nil {
|
|
|
|
to.mu.Unlock()
|
|
|
|
}
|
2019-07-18 22:09:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// CommitRenameReplaceDentry must be called after the file represented by from
|
|
|
|
// is renamed without RENAME_EXCHANGE. If to is not nil, it represents the file
|
|
|
|
// that was replaced by from.
|
|
|
|
//
|
|
|
|
// Preconditions: PrepareRenameDentry was previously called on from and to.
|
2020-04-21 19:16:42 +00:00
|
|
|
func (vfs *VirtualFilesystem) CommitRenameReplaceDentry(from, to *Dentry) {
|
2019-11-25 23:20:25 +00:00
|
|
|
from.mu.Unlock()
|
|
|
|
if to != nil {
|
2020-04-21 19:16:42 +00:00
|
|
|
to.dead = true
|
2019-11-25 23:20:25 +00:00
|
|
|
to.mu.Unlock()
|
|
|
|
if to.isMounted() {
|
2020-04-21 19:16:42 +00:00
|
|
|
vfs.forgetDeadMountpoint(to)
|
2019-11-25 23:20:25 +00:00
|
|
|
}
|
|
|
|
}
|
2019-07-18 22:09:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// CommitRenameExchangeDentry must be called after the files represented by
|
|
|
|
// from and to are exchanged by rename(RENAME_EXCHANGE).
|
|
|
|
//
|
|
|
|
// Preconditions: PrepareRenameDentry was previously called on from and to.
|
|
|
|
func (vfs *VirtualFilesystem) CommitRenameExchangeDentry(from, to *Dentry) {
|
2019-11-25 23:20:25 +00:00
|
|
|
from.mu.Unlock()
|
|
|
|
to.mu.Unlock()
|
|
|
|
}
|
|
|
|
|
2020-04-21 19:16:42 +00:00
|
|
|
// forgetDeadMountpoint is called when a mount point is deleted or invalidated
|
|
|
|
// to umount all mounts using it in all other mount namespaces.
|
2019-11-25 23:20:25 +00:00
|
|
|
//
|
2020-04-21 19:16:42 +00:00
|
|
|
// forgetDeadMountpoint is analogous to Linux's
|
2019-11-25 23:20:25 +00:00
|
|
|
// fs/namespace.c:__detach_mounts().
|
2020-04-21 19:16:42 +00:00
|
|
|
func (vfs *VirtualFilesystem) forgetDeadMountpoint(d *Dentry) {
|
2019-11-25 23:20:25 +00:00
|
|
|
var (
|
|
|
|
vdsToDecRef []VirtualDentry
|
|
|
|
mountsToDecRef []*Mount
|
|
|
|
)
|
|
|
|
vfs.mountMu.Lock()
|
|
|
|
vfs.mounts.seq.BeginWrite()
|
|
|
|
for mnt := range vfs.mountpoints[d] {
|
|
|
|
vdsToDecRef, mountsToDecRef = vfs.umountRecursiveLocked(mnt, &umountRecursiveOptions{}, vdsToDecRef, mountsToDecRef)
|
|
|
|
}
|
|
|
|
vfs.mounts.seq.EndWrite()
|
|
|
|
vfs.mountMu.Unlock()
|
|
|
|
for _, vd := range vdsToDecRef {
|
|
|
|
vd.DecRef()
|
|
|
|
}
|
|
|
|
for _, mnt := range mountsToDecRef {
|
Minor VFS2 interface changes.
- Remove the Filesystem argument from DentryImpl.*Ref(); in general DentryImpls
that need the Filesystem for reference counting will probably also need it
for other interface methods that don't plumb Filesystem, so it's easier to
just store a pointer to the filesystem in the DentryImpl.
- Add a pointer to the VirtualFilesystem to Filesystem, which is needed by the
gofer client to disown dentries for cache eviction triggered by dentry
reference count changes.
- Rename FilesystemType.NewFilesystem to GetFilesystem; in some cases (e.g.
sysfs, cgroupfs) it's much cleaner for there to be only one Filesystem that
is used by all mounts, and in at least one case (devtmpfs) it's visibly
incorrect not to do so, so NewFilesystem doesn't always actually create and
return a *new* Filesystem.
- Require callers of FileDescription.Init() to increment Mount/Dentry
references. This is because the gofer client may, in the OpenAt() path, take
a reference on a dentry with 0 references, which is safe due to
synchronization that is outside the scope of this CL, and it would be safer
to still have its implementation of DentryImpl.IncRef() check for an
increment for 0 references in other cases.
- Add FileDescription.TryIncRef. This is used by the gofer client to take
references on "special file descriptions" (FDs for files such as pipes,
sockets, and devices), which use per-FD handles (fids) instead of
dentry-shared handles, for sync() and syncfs().
PiperOrigin-RevId: 282473364
2019-11-26 02:09:15 +00:00
|
|
|
mnt.DecRef()
|
2019-11-25 23:20:25 +00:00
|
|
|
}
|
2019-07-18 22:09:14 +00:00
|
|
|
}
|