Blame view
fs/pnode.c
8.86 KB
07b20889e [PATCH] beginning... |
1 2 3 4 5 6 7 8 |
/* * linux/fs/pnode.c * * (C) Copyright IBM Corporation 2005. * Released under GPL v2. * Author : Ram Pai (linuxram@us.ibm.com) * */ |
6b3286ed1 [PATCH] rename st... |
9 |
#include <linux/mnt_namespace.h> |
07b20889e [PATCH] beginning... |
10 11 |
#include <linux/mount.h> #include <linux/fs.h> |
6d59e7f58 [PATCH] move a bu... |
12 |
#include "internal.h" |
07b20889e [PATCH] beginning... |
13 |
#include "pnode.h" |
03e06e68f [PATCH] introduce... |
14 15 16 17 18 |
/* return the next shared peer mount of @p */ static inline struct vfsmount *next_peer(struct vfsmount *p) { return list_entry(p->mnt_share.next, struct vfsmount, mnt_share); } |
5afe00221 [PATCH] handling ... |
19 20 21 22 23 24 25 26 27 |
static inline struct vfsmount *first_slave(struct vfsmount *p) { return list_entry(p->mnt_slave_list.next, struct vfsmount, mnt_slave); } static inline struct vfsmount *next_slave(struct vfsmount *p) { return list_entry(p->mnt_slave.next, struct vfsmount, mnt_slave); } |
97e7e0f71 [patch 7/7] vfs: ... |
28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 |
/* * Return true if path is reachable from root * * namespace_sem is held, and mnt is attached */ static bool is_path_reachable(struct vfsmount *mnt, struct dentry *dentry, const struct path *root) { while (mnt != root->mnt && mnt->mnt_parent != mnt) { dentry = mnt->mnt_mountpoint; mnt = mnt->mnt_parent; } return mnt == root->mnt && is_subdir(dentry, root->dentry); } static struct vfsmount *get_peer_under_root(struct vfsmount *mnt, struct mnt_namespace *ns, const struct path *root) { struct vfsmount *m = mnt; do { /* Check the namespace first for optimization */ if (m->mnt_ns == ns && is_path_reachable(m, m->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 vfsmount *mnt, const struct path *root) { struct vfsmount *m; for (m = mnt->mnt_master; m != NULL; m = m->mnt_master) { struct vfsmount *d = get_peer_under_root(m, mnt->mnt_ns, root); if (d) return d->mnt_group_id; } return 0; } |
a58b0eb8e [PATCH] introduce... |
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 |
static int do_make_slave(struct vfsmount *mnt) { struct vfsmount *peer_mnt = mnt, *master = mnt->mnt_master; struct vfsmount *slave_mnt; /* * slave 'mnt' to a peer mount that has the * same root dentry. If none is available than * slave it to anything that is available. */ while ((peer_mnt = next_peer(peer_mnt)) != mnt && peer_mnt->mnt_root != mnt->mnt_root) ; if (peer_mnt == mnt) { peer_mnt = next_peer(mnt); if (peer_mnt == mnt) peer_mnt = NULL; } |
719f5d7f0 [patch 4/7] vfs: ... |
96 97 |
if (IS_MNT_SHARED(mnt) && list_empty(&mnt->mnt_share)) mnt_release_group_id(mnt); |
a58b0eb8e [PATCH] introduce... |
98 |
list_del_init(&mnt->mnt_share); |
719f5d7f0 [patch 4/7] vfs: ... |
99 |
mnt->mnt_group_id = 0; |
a58b0eb8e [PATCH] introduce... |
100 101 102 103 104 105 106 |
if (peer_mnt) master = peer_mnt; if (master) { list_for_each_entry(slave_mnt, &mnt->mnt_slave_list, mnt_slave) slave_mnt->mnt_master = master; |
1bfba4e8e [PATCH] core: use... |
107 |
list_move(&mnt->mnt_slave, &master->mnt_slave_list); |
a58b0eb8e [PATCH] introduce... |
108 109 110 111 112 |
list_splice(&mnt->mnt_slave_list, master->mnt_slave_list.prev); INIT_LIST_HEAD(&mnt->mnt_slave_list); } else { struct list_head *p = &mnt->mnt_slave_list; while (!list_empty(p)) { |
b5e618181 Introduce a handy... |
113 |
slave_mnt = list_first_entry(p, |
a58b0eb8e [PATCH] introduce... |
114 115 116 117 118 119 120 |
struct vfsmount, mnt_slave); list_del_init(&slave_mnt->mnt_slave); slave_mnt->mnt_master = NULL; } } mnt->mnt_master = master; CLEAR_MNT_SHARED(mnt); |
a58b0eb8e [PATCH] introduce... |
121 122 |
return 0; } |
07b20889e [PATCH] beginning... |
123 124 |
void change_mnt_propagation(struct vfsmount *mnt, int type) { |
03e06e68f [PATCH] introduce... |
125 |
if (type == MS_SHARED) { |
b90fa9ae8 [PATCH] shared mo... |
126 |
set_mnt_shared(mnt); |
a58b0eb8e [PATCH] introduce... |
127 128 129 130 131 132 |
return; } do_make_slave(mnt); if (type != MS_SLAVE) { list_del_init(&mnt->mnt_slave); mnt->mnt_master = NULL; |
9676f0c63 [PATCH] unbindabl... |
133 134 |
if (type == MS_UNBINDABLE) mnt->mnt_flags |= MNT_UNBINDABLE; |
0b03cfb25 MNT_UNBINDABLE fix |
135 136 |
else mnt->mnt_flags &= ~MNT_UNBINDABLE; |
03e06e68f [PATCH] introduce... |
137 |
} |
07b20889e [PATCH] beginning... |
138 |
} |
b90fa9ae8 [PATCH] shared mo... |
139 140 141 142 143 144 145 146 147 |
/* * get the next mount in the propagation tree. * @m: the mount seen last * @origin: the original mount from where the tree walk initiated */ static struct vfsmount *propagation_next(struct vfsmount *m, struct vfsmount *origin) { |
5afe00221 [PATCH] handling ... |
148 149 150 151 152 153 154 |
/* are there any slaves of this mount? */ if (!IS_MNT_NEW(m) && !list_empty(&m->mnt_slave_list)) return first_slave(m); while (1) { struct vfsmount *next; struct vfsmount *master = m->mnt_master; |
bf066c7db [PATCH] shared mo... |
155 |
if (master == origin->mnt_master) { |
5afe00221 [PATCH] handling ... |
156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 |
next = next_peer(m); return ((next == origin) ? NULL : next); } else if (m->mnt_slave.next != &master->mnt_slave_list) return next_slave(m); /* back at master */ m = master; } } /* * return the source mount to be used for cloning * * @dest the current destination mount * @last_dest the last seen destination mount * @last_src the last seen source mount * @type return CL_SLAVE if the new mount has to be * cloned as a slave. */ static struct vfsmount *get_source(struct vfsmount *dest, struct vfsmount *last_dest, struct vfsmount *last_src, int *type) { struct vfsmount *p_last_src = NULL; struct vfsmount *p_last_dest = NULL; |
53b3531bb [PATCH] s/;;/;/g |
182 |
*type = CL_PROPAGATION; |
5afe00221 [PATCH] handling ... |
183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 |
if (IS_MNT_SHARED(dest)) *type |= CL_MAKE_SHARED; while (last_dest != dest->mnt_master) { p_last_dest = last_dest; p_last_src = last_src; last_dest = last_dest->mnt_master; last_src = last_src->mnt_master; } if (p_last_dest) { do { p_last_dest = next_peer(p_last_dest); } while (IS_MNT_NEW(p_last_dest)); } if (dest != p_last_dest) { *type |= CL_SLAVE; return last_src; } else return p_last_src; |
b90fa9ae8 [PATCH] shared mo... |
205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 |
} /* * mount 'source_mnt' under the destination 'dest_mnt' at * dentry 'dest_dentry'. And propagate that mount to * all the peer and slave mounts of 'dest_mnt'. * Link all the new mounts into a propagation tree headed at * source_mnt. Also link all the new mounts using ->mnt_list * headed at source_mnt's ->mnt_list * * @dest_mnt: destination mount. * @dest_dentry: destination dentry. * @source_mnt: source mount. * @tree_list : list of heads of trees to be attached. */ int propagate_mnt(struct vfsmount *dest_mnt, struct dentry *dest_dentry, struct vfsmount *source_mnt, struct list_head *tree_list) { struct vfsmount *m, *child; int ret = 0; struct vfsmount *prev_dest_mnt = dest_mnt; struct vfsmount *prev_src_mnt = source_mnt; LIST_HEAD(tmp_list); LIST_HEAD(umount_list); for (m = propagation_next(dest_mnt, dest_mnt); m; m = propagation_next(m, dest_mnt)) { |
5afe00221 [PATCH] handling ... |
232 233 |
int type; struct vfsmount *source; |
b90fa9ae8 [PATCH] shared mo... |
234 235 236 |
if (IS_MNT_NEW(m)) continue; |
5afe00221 [PATCH] handling ... |
237 |
source = get_source(m, prev_dest_mnt, prev_src_mnt, &type); |
b90fa9ae8 [PATCH] shared mo... |
238 |
|
5afe00221 [PATCH] handling ... |
239 |
if (!(child = copy_tree(source, source->mnt_root, type))) { |
b90fa9ae8 [PATCH] shared mo... |
240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 |
ret = -ENOMEM; list_splice(tree_list, tmp_list.prev); goto out; } if (is_subdir(dest_dentry, m->mnt_root)) { mnt_set_mountpoint(m, dest_dentry, child); list_add_tail(&child->mnt_hash, tree_list); } else { /* * This can happen if the parent mount was bind mounted * on some subdirectory of a shared/slave mount. */ list_add_tail(&child->mnt_hash, &tmp_list); } prev_dest_mnt = m; prev_src_mnt = child; } out: spin_lock(&vfsmount_lock); while (!list_empty(&tmp_list)) { |
4e1b36fb4 [PATCH] umount_tr... |
261 |
child = list_first_entry(&tmp_list, struct vfsmount, mnt_hash); |
a05964f39 [PATCH] shared mo... |
262 |
umount_tree(child, 0, &umount_list); |
b90fa9ae8 [PATCH] shared mo... |
263 264 265 266 267 |
} spin_unlock(&vfsmount_lock); release_mounts(&umount_list); return ret; } |
a05964f39 [PATCH] shared mo... |
268 269 270 271 272 273 |
/* * return true if the refcount is greater than count */ static inline int do_refcount_check(struct vfsmount *mnt, int count) { |
7c4b93d82 [PATCH] count gho... |
274 |
int mycount = atomic_read(&mnt->mnt_count) - mnt->mnt_ghosts; |
a05964f39 [PATCH] shared mo... |
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 |
return (mycount > count); } /* * 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. */ int propagate_mount_busy(struct vfsmount *mnt, int refcnt) { struct vfsmount *m, *child; struct vfsmount *parent = mnt->mnt_parent; int ret = 0; if (mnt == parent) return do_refcount_check(mnt, refcnt); /* * 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; for (m = propagation_next(parent, parent); m; m = propagation_next(m, parent)) { child = __lookup_mnt(m, mnt->mnt_mountpoint, 0); if (child && list_empty(&child->mnt_mounts) && (ret = do_refcount_check(child, 1))) break; } return ret; } /* * NOTE: unmounting 'mnt' naturally propagates to all other mounts its * parent propagates to. */ static void __propagate_umount(struct vfsmount *mnt) { struct vfsmount *parent = mnt->mnt_parent; struct vfsmount *m; BUG_ON(parent == mnt); for (m = propagation_next(parent, parent); m; m = propagation_next(m, parent)) { struct vfsmount *child = __lookup_mnt(m, mnt->mnt_mountpoint, 0); /* * umount the child only if the child has no * other children */ |
1bfba4e8e [PATCH] core: use... |
333 334 |
if (child && list_empty(&child->mnt_mounts)) list_move_tail(&child->mnt_hash, &mnt->mnt_hash); |
a05964f39 [PATCH] shared mo... |
335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 |
} } /* * collect all mounts that receive propagation from the mount in @list, * and return these additional mounts in the same list. * @list: the list of mounts to be unmounted. */ int propagate_umount(struct list_head *list) { struct vfsmount *mnt; list_for_each_entry(mnt, list, mnt_hash) __propagate_umount(mnt); return 0; } |