Quelle pnode.c Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
*  linux/fs/pnode.c
*
* (C) Copyright IBM Corporation 2005.
* Author : Ram Pai (linuxram@us.ibm.com)
*/
#include <linux/mnt_namespace.h>
#include <linux/mount.h>
#include <linux/fs.h>
#include <linux/nsproxy.h>
#include <uapi/linux/mount.h>
#include "internal.h"
#include "pnode.h"

/* return the next shared peer mount of @p */
static inline struct mount *next_peer(struct mount *p)
{
return list_entry(p->mnt_share.next, struct mount, mnt_share);
}

static inline struct mount *first_slave(struct mount *p)
{
return hlist_entry(p->mnt_slave_list.first, struct mount, mnt_slave);
}

static inline struct mount *next_slave(struct mount *p)
{
return hlist_entry(p->mnt_slave.next, struct mount, mnt_slave);
}

static struct mount *get_peer_under_root(struct mount *mnt,
      struct mnt_namespace *ns,
      const struct path *root)
{
struct mount *m = mnt;

do {
  /* Check the namespace first for optimization */
  if (m->mnt_ns == ns && is_path_reachable(m, m->mnt.mnt_root, root))
   return m;

  m = next_peer(m);
} while (m != mnt);

return NULL;
}

/*
* Get ID of closest dominating peer group having a representative
* under the given root.
*
* Caller must hold namespace_sem
*/
int get_dominating_id(struct mount *mnt, const struct path *root)
{
struct mount *m;

for (m = mnt->mnt_master; m != NULL; m = m->mnt_master) {
  struct mount *d = get_peer_under_root(m, mnt->mnt_ns, root);
  if (d)
   return d->mnt_group_id;
}

return 0;
}

static inline bool will_be_unmounted(struct mount *m)
{
return m->mnt.mnt_flags & MNT_UMOUNT;
}

static struct mount *propagation_source(struct mount *mnt)
{
do {
  struct mount *m;
  for (m = next_peer(mnt); m != mnt; m = next_peer(m)) {
   if (!will_be_unmounted(m))
    return m;
  }
  mnt = mnt->mnt_master;
} while (mnt && will_be_unmounted(mnt));
return mnt;
}

static void transfer_propagation(struct mount *mnt, struct mount *to)
{
struct hlist_node *p = NULL, *n;
struct mount *m;

hlist_for_each_entry_safe(m, n, &mnt->mnt_slave_list, mnt_slave) {
  m->mnt_master = to;
  if (!to)
   hlist_del_init(&m->mnt_slave);
  else
   p = &m->mnt_slave;
}
if (p)
  hlist_splice_init(&mnt->mnt_slave_list, p, &to->mnt_slave_list);
}

/*
* EXCL[namespace_sem]
*/
void change_mnt_propagation(struct mount *mnt, int type)
{
struct mount *m = mnt->mnt_master;

if (type == MS_SHARED) {
  set_mnt_shared(mnt);
  return;
}
if (IS_MNT_SHARED(mnt)) {
  if (type == MS_SLAVE || !hlist_empty(&mnt->mnt_slave_list))
   m = propagation_source(mnt);
  if (list_empty(&mnt->mnt_share)) {
   mnt_release_group_id(mnt);
  } else {
   list_del_init(&mnt->mnt_share);
   mnt->mnt_group_id = 0;
  }
  CLEAR_MNT_SHARED(mnt);
  transfer_propagation(mnt, m);
}
hlist_del_init(&mnt->mnt_slave);
if (type == MS_SLAVE) {
  mnt->mnt_master = m;
  if (m)
   hlist_add_head(&mnt->mnt_slave, &m->mnt_slave_list);
} else {
  mnt->mnt_master = NULL;
  if (type == MS_UNBINDABLE)
   mnt->mnt_t_flags |= T_UNBINDABLE;
  else
   mnt->mnt_t_flags &= ~T_UNBINDABLE;
}
}

static struct mount *__propagation_next(struct mount *m,
      struct mount *origin)
{
while (1) {
  struct mount *master = m->mnt_master;

  if (master == origin->mnt_master) {
   struct mount *next = next_peer(m);
   return (next == origin) ? NULL : next;
  } else if (m->mnt_slave.next)
   return next_slave(m);

  /* back at master */
  m = master;
}
}

/*
* get the next mount in the propagation tree.
* @m: the mount seen last
* @origin: the original mount from where the tree walk initiated
*
* Note that peer groups form contiguous segments of slave lists.
* We rely on that in get_source() to be able to find out if
* vfsmount found while iterating with propagation_next() is
* a peer of one we'd found earlier.
*/
static struct mount *propagation_next(struct mount *m,
      struct mount *origin)
{
/* are there any slaves of this mount? */
if (!IS_MNT_NEW(m) && !hlist_empty(&m->mnt_slave_list))
  return first_slave(m);

return __propagation_next(m, origin);
}

static struct mount *skip_propagation_subtree(struct mount *m,
      struct mount *origin)
{
/*
* Advance m past everything that gets propagation from it.
*/
struct mount *p = __propagation_next(m, origin);

while (p && peers(m, p))
  p = __propagation_next(p, origin);

return p;
}

static struct mount *next_group(struct mount *m, struct mount *origin)
{
while (1) {
  while (1) {
   struct mount *next;
   if (!IS_MNT_NEW(m) && !hlist_empty(&m->mnt_slave_list))
    return first_slave(m);
   next = next_peer(m);
   if (m->mnt_group_id == origin->mnt_group_id) {
    if (next == origin)
     return NULL;
   } else if (m->mnt_slave.next != &next->mnt_slave)
    break;
   m = next;
  }
  /* m is the last peer */
  while (1) {
   struct mount *master = m->mnt_master;
   if (m->mnt_slave.next)
    return next_slave(m);
   m = next_peer(master);
   if (master->mnt_group_id == origin->mnt_group_id)
    break;
   if (master->mnt_slave.next == &m->mnt_slave)
    break;
   m = master;
  }
  if (m == origin)
   return NULL;
}
}

static bool need_secondary(struct mount *m, struct mountpoint *dest_mp)
{
/* skip ones added by this propagate_mnt() */
if (IS_MNT_NEW(m))
  return false;
/* skip if mountpoint isn't visible in m */
if (!is_subdir(dest_mp->m_dentry, m->mnt.mnt_root))
  return false;
/* skip if m is in the anon_ns */
if (is_anon_ns(m->mnt_ns))
  return false;
return true;
}

static struct mount *find_master(struct mount *m,
    struct mount *last_copy,
    struct mount *original)
{
struct mount *p;

// ascend until there's a copy for something with the same master
for (;;) {
  p = m->mnt_master;
  if (!p || IS_MNT_MARKED(p))
   break;
  m = p;
}
while (!peers(last_copy, original)) {
  struct mount *parent = last_copy->mnt_parent;
  if (parent->mnt_master == p) {
   if (!peers(parent, m))
    last_copy = last_copy->mnt_master;
   break;
  }
  last_copy = last_copy->mnt_master;
}
return last_copy;
}

/**
* propagate_mnt() - create secondary copies for tree attachment
* @dest_mnt:    destination mount.
* @dest_mp:     destination mountpoint.
* @source_mnt:  source mount.
* @tree_list:   list of secondaries to be attached.
*
* Create secondary copies for attaching a tree with root @source_mnt
* at mount @dest_mnt with mountpoint @dest_mp.  Link all new mounts
* into a propagation graph.  Set mountpoints for all secondaries,
* link their roots into @tree_list via ->mnt_hash.
*/
int propagate_mnt(struct mount *dest_mnt, struct mountpoint *dest_mp,
    struct mount *source_mnt, struct hlist_head *tree_list)
{
struct mount *m, *n, *copy, *this;
int err = 0, type;

if (dest_mnt->mnt_master)
  SET_MNT_MARK(dest_mnt->mnt_master);

/* iterate over peer groups, depth first */
for (m = dest_mnt; m && !err; m = next_group(m, dest_mnt)) {
  if (m == dest_mnt) { // have one for dest_mnt itself
   copy = source_mnt;
   type = CL_MAKE_SHARED;
   n = next_peer(m);
   if (n == m)
    continue;
  } else {
   type = CL_SLAVE;
   /* beginning of peer group among the slaves? */
   if (IS_MNT_SHARED(m))
    type |= CL_MAKE_SHARED;
   n = m;
  }
  do {
   if (!need_secondary(n, dest_mp))
    continue;
   if (type & CL_SLAVE) // first in this peer group
    copy = find_master(n, copy, source_mnt);
   this = copy_tree(copy, copy->mnt.mnt_root, type);
   if (IS_ERR(this)) {
    err = PTR_ERR(this);
    break;
   }
   read_seqlock_excl(&mount_lock);
   mnt_set_mountpoint(n, dest_mp, this);
   read_sequnlock_excl(&mount_lock);
   if (n->mnt_master)
    SET_MNT_MARK(n->mnt_master);
   copy = this;
   hlist_add_head(&this->mnt_hash, tree_list);
   err = count_mounts(n->mnt_ns, this);
   if (err)
    break;
   type = CL_MAKE_SHARED;
  } while ((n = next_peer(n)) != m);
}

hlist_for_each_entry(n, tree_list, mnt_hash) {
  m = n->mnt_parent;
  if (m->mnt_master)
   CLEAR_MNT_MARK(m->mnt_master);
}
if (dest_mnt->mnt_master)
  CLEAR_MNT_MARK(dest_mnt->mnt_master);
return err;
}

/*
* return true if the refcount is greater than count
*/
static inline int do_refcount_check(struct mount *mnt, int count)
{
return mnt_get_count(mnt) > count;
}

/**
* propagation_would_overmount - check whether propagation from @from
*                               would overmount @to
* @from: shared mount
* @to:   mount to check
* @mp:   future mountpoint of @to on @from
*
* If @from propagates mounts to @to, @from and @to must either be peers
* or one of the masters in the hierarchy of masters of @to must be a
* peer of @from.
*
* If the root of the @to mount is equal to the future mountpoint @mp of
* the @to mount on @from then @to will be overmounted by whatever is
* propagated to it.
*
* Context: This function expects namespace_lock() to be held and that
*          @mp is stable.
* Return: If @from overmounts @to, true is returned, false if not.
*/
bool propagation_would_overmount(const struct mount *from,
     const struct mount *to,
     const struct mountpoint *mp)
{
if (!IS_MNT_SHARED(from))
  return false;

if (to->mnt.mnt_root != mp->m_dentry)
  return false;

for (const struct mount *m = to; m; m = m->mnt_master) {
  if (peers(from, m))
   return true;
}

return false;
}

/*
* check if the mount 'mnt' can be unmounted successfully.
* @mnt: the mount to be checked for unmount
* NOTE: unmounting 'mnt' would naturally propagate to all
* other mounts its parent propagates to.
* Check if any of these mounts that **do not have submounts**
* have more references than 'refcnt'. If so return busy.
*
* vfsmount lock must be held for write
*/
int propagate_mount_busy(struct mount *mnt, int refcnt)
{
struct mount *parent = mnt->mnt_parent;

/*
* quickly check if the current mount can be unmounted.
* If not, we don't have to go checking for all other
* mounts
*/
if (!list_empty(&mnt->mnt_mounts) || do_refcount_check(mnt, refcnt))
  return 1;

if (mnt == parent)
  return 0;

for (struct mount *m = propagation_next(parent, parent); m;
        m = propagation_next(m, parent)) {
  struct list_head *head;
  struct mount *child = __lookup_mnt(&m->mnt, mnt->mnt_mountpoint);

  if (!child)
   continue;

  head = &child->mnt_mounts;
  if (!list_empty(head)) {
   /*
* a mount that covers child completely wouldn't prevent
* it being pulled out; any other would.
*/
   if (!list_is_singular(head) || !child->overmount)
    continue;
  }
  if (do_refcount_check(child, 1))
   return 1;
}
return 0;
}

/*
* Clear MNT_LOCKED when it can be shown to be safe.
*
* mount_lock lock must be held for write
*/
void propagate_mount_unlock(struct mount *mnt)
{
struct mount *parent = mnt->mnt_parent;
struct mount *m, *child;

BUG_ON(parent == mnt);

for (m = propagation_next(parent, parent); m;
   m = propagation_next(m, parent)) {
  child = __lookup_mnt(&m->mnt, mnt->mnt_mountpoint);
  if (child)
   child->mnt.mnt_flags &= ~MNT_LOCKED;
}
}

static inline bool is_candidate(struct mount *m)
{
return m->mnt_t_flags & T_UMOUNT_CANDIDATE;
}

static void umount_one(struct mount *m, struct list_head *to_umount)
{
m->mnt.mnt_flags |= MNT_UMOUNT;
list_del_init(&m->mnt_child);
move_from_ns(m);
list_add_tail(&m->mnt_list, to_umount);
}

static void remove_from_candidate_list(struct mount *m)
{
m->mnt_t_flags &= ~(T_MARKED | T_UMOUNT_CANDIDATE);
list_del_init(&m->mnt_list);
}

static void gather_candidates(struct list_head *set,
         struct list_head *candidates)
{
struct mount *m, *p, *q;

list_for_each_entry(m, set, mnt_list) {
  if (is_candidate(m))
   continue;
  m->mnt_t_flags |= T_UMOUNT_CANDIDATE;
  p = m->mnt_parent;
  q = propagation_next(p, p);
  while (q) {
   struct mount *child = __lookup_mnt(&q->mnt,
          m->mnt_mountpoint);
   if (child) {
    /*
* We might've already run into this one.  That
* must've happened on earlier iteration of the
* outer loop; in that case we can skip those
* parents that get propagation from q - there
* will be nothing new on those as well.
*/
    if (is_candidate(child)) {
     q = skip_propagation_subtree(q, p);
     continue;
    }
    child->mnt_t_flags |= T_UMOUNT_CANDIDATE;
    if (!will_be_unmounted(child))
     list_add(&child->mnt_list, candidates);
   }
   q = propagation_next(q, p);
  }
}
list_for_each_entry(m, set, mnt_list)
  m->mnt_t_flags &= ~T_UMOUNT_CANDIDATE;
}

/*
* We know that some child of @m can't be unmounted.  In all places where the
* chain of descent of @m has child not overmounting the root of parent,
* the parent can't be unmounted either.
*/
static void trim_ancestors(struct mount *m)
{
struct mount *p;

for (p = m->mnt_parent; is_candidate(p); m = p, p = p->mnt_parent) {
  if (IS_MNT_MARKED(m)) // all candidates beneath are overmounts
   return;
  SET_MNT_MARK(m);
  if (m != p->overmount)
   p->mnt_t_flags &= ~T_UMOUNT_CANDIDATE;
}
}

/*
* Find and exclude all umount candidates forbidden by @m
* (see Documentation/filesystems/propagate_umount.txt)
* If we can immediately tell that @m is OK to unmount (unlocked
* and all children are already committed to unmounting) commit
* to unmounting it.
* Only @m itself might be taken from the candidates list;
* anything found by trim_ancestors() is marked non-candidate
* and left on the list.
*/
static void trim_one(struct mount *m, struct list_head *to_umount)
{
bool remove_this = false, found = false, umount_this = false;
struct mount *n;

if (!is_candidate(m)) { // trim_ancestors() left it on list
  remove_from_candidate_list(m);
  return;
}

list_for_each_entry(n, &m->mnt_mounts, mnt_child) {
  if (!is_candidate(n)) {
   found = true;
   if (n != m->overmount) {
    remove_this = true;
    break;
   }
  }
}
if (found) {
  trim_ancestors(m);
} else if (!IS_MNT_LOCKED(m) && list_empty(&m->mnt_mounts)) {
  remove_this = true;
  umount_this = true;
}
if (remove_this) {
  remove_from_candidate_list(m);
  if (umount_this)
   umount_one(m, to_umount);
}
}

static void handle_locked(struct mount *m, struct list_head *to_umount)
{
struct mount *cutoff = m, *p;

if (!is_candidate(m)) { // trim_ancestors() left it on list
  remove_from_candidate_list(m);
  return;
}
for (p = m; is_candidate(p); p = p->mnt_parent) {
  remove_from_candidate_list(p);
  if (!IS_MNT_LOCKED(p))
   cutoff = p->mnt_parent;
}
if (will_be_unmounted(p))
  cutoff = p;
while (m != cutoff) {
  umount_one(m, to_umount);
  m = m->mnt_parent;
}
}

/*
* @m is not to going away, and it overmounts the top of a stack of mounts
* that are going away.  We know that all of those are fully overmounted
* by the one above (@m being the topmost of the chain), so @m can be slid
* in place where the bottom of the stack is attached.
*
* NOTE: here we temporarily violate a constraint - two mounts end up with
* the same parent and mountpoint; that will be remedied as soon as we
* return from propagate_umount() - its caller (umount_tree()) will detach
* the stack from the parent it (and now @m) is attached to.  umount_tree()
* might choose to keep unmounted pieces stuck to each other, but it always
* detaches them from the mounts that remain in the tree.
*/
static void reparent(struct mount *m)
{
struct mount *p = m;
struct mountpoint *mp;

do {
  mp = p->mnt_mp;
  p = p->mnt_parent;
} while (will_be_unmounted(p));

mnt_change_mountpoint(p, mp, m);
mnt_notify_add(m);
}

/**
* propagate_umount - apply propagation rules to the set of mounts for umount()
* @set: the list of mounts to be unmounted.
*
* Collect all mounts that receive propagation from the mount in @set and have
* no obstacles to being unmounted.  Add these additional mounts to the set.
*
* See Documentation/filesystems/propagate_umount.txt if you do anything in
* this area.
*
* Locks held:
* mount_lock (write_seqlock), namespace_sem (exclusive).
*/
void propagate_umount(struct list_head *set)
{
struct mount *m, *p;
LIST_HEAD(to_umount); // committed to unmounting
LIST_HEAD(candidates); // undecided umount candidates

// collect all candidates
gather_candidates(set, &candidates);

// reduce the set until it's non-shifting
list_for_each_entry_safe(m, p, &candidates, mnt_list)
  trim_one(m, &to_umount);

// ... and non-revealing
while (!list_empty(&candidates)) {
  m = list_first_entry(&candidates,struct mount, mnt_list);
  handle_locked(m, &to_umount);
}

// now to_umount consists of all acceptable candidates
// deal with reparenting of surviving overmounts on those
list_for_each_entry(m, &to_umount, mnt_list) {
  struct mount *over = m->overmount;
  if (over && !will_be_unmounted(over))
   reparent(over);
}

// and fold them into the set
list_splice_tail_init(&to_umount, set);
}

quality90%

¤ Dauer der Verarbeitung: 0.35 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.