Lines Matching full:we

3 Umount propagation starts with a set of mounts we are already going to
4 take out.  Ideally, we would like to add all downstream cognates to
39 is in the set, it will be resolved.  However, we rely upon umount_tree()
51 We are given a closed set U and we want to find all mounts that have
64 subtrees of U, in which case we'd end up examining the same candidates
70 Note that if we run into a candidate we'd already seen, it must've been
73 if we find a child already added to the set, we know that everything
93 	keep walking Propagation(p) from q until we find something
96 would get rid of that problem, but we need a sane implementation of
99 skip_them() being "repeat the forward-and-up part until we get NULL
100 or something that isn't a peer of the one we are skipping".
117 subsets of S.  If we had a way to find a forbidden mount or show that
118 there's none, we could use it to find the maximal non-shifting subset
126 So in principle we could go through elements of S, checking if they
129 forbidden at the time we checked, they won't become forbidden later.
150 Note that if m does not belong to S or has no children outside of S we
196 the maximal non-shifting subset, since we were removing only forbidden
203 that chain is forbidden, so nothing gets removed from it.  We need to
205 Trim(), otherwise we will end up with worst-case time being quadratic by
207 outer loop - we need to iterate through all elements of a shrinking set.
208 That would be trivial if we never removed more than one element at a time
209 (linked list, with list_for_each_entry_safe for iterator), but we may
210 need to remove more than one entry, possibly including the ones we have
250 visited element, we are guaranteed that remaining iterations will see
255 	It's easy to deal with, if we can afford setting marks on
256 elements of S; we would mark all elements already visited by
261 several ways, depending upon the representation we choose for our set.
262 One useful observation is that we are given a closed subset in S - the
271 S that do not belong to U.  That set ('candidates') is all we need
274 all of them).  Then we could have Trim_ancestors() only remove the mark,
279 	Assuming that representation we get the following:
322 * we get no more than O(#S) calls of Trim_one()
332 	In the end we may have some elements excluded from S by
333 Trim_ancestors() still stuck on the list.  We could do a separate
335 but it's easier to leave that until the next phase - there we will
340 equivalent to checking if it's marked as a candidate; we'll never see
343 	What's more, if we see that children(m) is empty and m is not
344 locked, we can immediately move m into the committed subset (remove
345 from the parent's list of children, etc.).  That's one fewer mount we'll
346 have to look into when we check the list of children of its parent *and*
347 when we get to building the non-revealing subset.
370 // S is a disjoint union of a non-revealing set U (the ones we are committed
427 After we'd calculated the final set, we still need to deal with
429 we need to reparent such child.
445 For the 2nd and 3rd steps we want to separate the set into growing
447 terms of the pseudocode above) and everything we are still not sure about
448 ("candidates").  It means that for the output of the 1st step we'd like
450 For the 4th step we would like the additions to U separate from the
463 words, it's the candidates we have already decided to unmount.	Its role
467 For gather_candidates() we'll need to maintain both candidates (S -
469 all elements we encounter, putting the ones not already in the original
470 set into the list of candidates.  When we are done, strip that flag from
476 All elements of the original set are marked with MNT_UMOUNT and we'll
478 to set in the end.  Let's set MNT_UMOUNT at the time we add an element
480 let's keep that name.  It also gives us another predicate we need -