2 * Copyright (c) 2013-2015 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@dragonflybsd.org>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 * The cluster module collects multiple chains representing the same
36 * information from different nodes into a single entity. It allows direct
37 * access to media data as long as it is not blockref array data (which
38 * will obviously have to be different at each node).
40 * This module also handles I/O dispatch, status rollup, and various
41 * mastership arrangements including quorum operations. It effectively
42 * presents one topology to the vnops layer.
44 * Many of the API calls mimic chain API calls but operate on clusters
45 * instead of chains. Please see hammer2_chain.c for more complete code
46 * documentation of the API functions.
48 * WARNING! This module is *extremely* complex. It must issue asynchronous
49 * locks and I/O, do quorum and/or master-slave processing, and
50 * it must operate properly even if some nodes are broken (which
51 * can also mean indefinite locks).
55 * Cluster operations can be broken down into three pieces:
57 * (1) Chain locking and data retrieval.
59 * - Most complex functions, quorum management on transaction ids.
61 * - Locking and data accesses must be internally asynchronous.
63 * - Validate and manage cache coherency primitives (cache state
64 * is stored in chain topologies but must be validated by these
67 * (2) Lookups and Scans
68 * hammer2_cluster_lookup()
69 * hammer2_cluster_next()
71 * - Depend on locking & data retrieval functions, but still complex.
73 * - Must do quorum management on transaction ids.
75 * - Lookup and Iteration ops Must be internally asynchronous.
77 * (3) Modifying Operations
78 * hammer2_cluster_create()
80 * - Can usually punt on failures, operation continues unless quorum
81 * is lost. If quorum is lost, must wait for resynchronization
82 * (depending on the management mode).
84 * - Must disconnect node on failures (also not flush), remount, and
87 * - Network links (via kdmsg) are relatively easy to issue as the
88 * complex underworkings of hammer2_chain.c don't have to messed
89 * with (the protocol is at a higher level than block-level).
91 * - Multiple local disk nodes (i.e. block devices) are another matter.
92 * Chain operations have to be dispatched to per-node threads (xN)
93 * because we can't asynchronize potentially very complex chain
94 * operations in hammer2_chain.c (it would be a huge mess).
96 * (these threads are also used to terminate incoming kdmsg ops from
99 * - Single-node filesystems do not use threads and will simply call
100 * hammer2_chain.c functions directly. This short-cut is handled
101 * at the base of each cluster function.
103 #include <sys/cdefs.h>
104 #include <sys/param.h>
105 #include <sys/systm.h>
106 #include <sys/types.h>
107 #include <sys/lock.h>
108 #include <sys/uuid.h>
113 * Returns the bref type of the cluster's foucs.
115 * If the cluster is errored, returns HAMMER2_BREF_TYPE_EMPTY (0).
116 * The cluster must be locked.
119 hammer2_cluster_type(hammer2_cluster_t *cluster)
121 if (cluster->error == 0) {
122 KKASSERT(cluster->focus != NULL);
123 return(cluster->focus->bref.type);
129 * Returns non-zero if the cluster's focus is flagged as being modified.
131 * If the cluster is errored, returns 0.
135 hammer2_cluster_modified(hammer2_cluster_t *cluster)
137 if (cluster->error == 0) {
138 KKASSERT(cluster->focus != NULL);
139 return((cluster->focus->flags & HAMMER2_CHAIN_MODIFIED) != 0);
145 * Returns the bref of the cluster's focus, sans any data-offset information
146 * (since offset information is per-node and wouldn't be useful).
148 * Callers use this function to access modify_tid, mirror_tid, type,
151 * If the cluster is errored, returns an empty bref.
152 * The cluster must be locked.
155 hammer2_cluster_bref(hammer2_cluster_t *cluster, hammer2_blockref_t *bref)
157 if (cluster->error == 0) {
158 KKASSERT(cluster->focus != NULL);
159 *bref = cluster->focus->bref;
162 bzero(bref, sizeof(*bref));
167 * Create a degenerate cluster with one ref from a single locked chain.
168 * The returned cluster will be focused on the chain and inherit its
171 * The chain's lock and reference are transfered to the new cluster, so
172 * the caller should not try to unlock the chain separately.
177 hammer2_cluster_from_chain(hammer2_chain_t *chain)
179 hammer2_cluster_t *cluster;
181 cluster = kmalloc(sizeof(*cluster), M_HAMMER2, M_WAITOK | M_ZERO);
182 cluster->array[0].chain = chain;
183 cluster->array[0].flags = HAMMER2_CITEM_FEMOD;
184 cluster->nchains = 1;
185 cluster->focus = chain;
186 cluster->focus_index = 0;
187 cluster->pmp = chain->pmp;
189 cluster->error = chain->error;
190 cluster->flags = HAMMER2_CLUSTER_LOCKED |
191 HAMMER2_CLUSTER_WRHARD |
192 HAMMER2_CLUSTER_RDHARD |
193 HAMMER2_CLUSTER_MSYNCED |
194 HAMMER2_CLUSTER_SSYNCED;
200 * Add a reference to a cluster and its underlying chains.
202 * We must also ref the underlying chains in order to allow ref/unlock
203 * sequences to later re-lock.
206 hammer2_cluster_ref(hammer2_cluster_t *cluster)
208 atomic_add_int(&cluster->refs, 1);
212 * Drop the caller's reference to the cluster. When the ref count drops to
213 * zero this function frees the cluster and drops all underlying chains.
215 * In-progress read I/Os are typically detached from the cluster once the
216 * first one returns (the remaining stay attached to the DIOs but are then
217 * ignored and drop naturally).
220 hammer2_cluster_drop(hammer2_cluster_t *cluster)
222 hammer2_chain_t *chain;
225 KKASSERT(cluster->refs > 0);
226 if (atomic_fetchadd_int(&cluster->refs, -1) == 1) {
227 cluster->focus = NULL; /* safety XXX chg to assert */
228 cluster->focus_index = 0;
230 for (i = 0; i < cluster->nchains; ++i) {
231 chain = cluster->array[i].chain;
233 hammer2_chain_drop(chain);
234 cluster->array[i].chain = NULL; /* safety */
237 cluster->nchains = 0; /* safety */
239 kfree(cluster, M_HAMMER2);
240 /* cluster is invalid */
245 * Lock a cluster. Cluster must already be referenced. Focus is maintained.
247 * WARNING! This function expects the caller to handle resolution of the
248 * cluster. We never re-resolve the cluster in this function,
249 * because it might be used to temporarily unlock/relock a cparent
250 * in an iteration or recursrion, and the cparents elements do not
254 hammer2_cluster_lock(hammer2_cluster_t *cluster, int how)
256 hammer2_chain_t *chain;
259 /* cannot be on inode-embedded cluster template, must be on copy */
260 KKASSERT(cluster->refs > 0);
261 KKASSERT((cluster->flags & HAMMER2_CLUSTER_INODE) == 0);
262 if (cluster->flags & HAMMER2_CLUSTER_LOCKED) {
263 panic("hammer2_cluster_lock: cluster %p already locked!\n",
266 atomic_set_int(&cluster->flags, HAMMER2_CLUSTER_LOCKED);
269 * Lock chains and resolve state.
271 for (i = 0; i < cluster->nchains; ++i) {
272 chain = cluster->array[i].chain;
275 hammer2_chain_lock(chain, how);
280 * Calculate the clustering state for the cluster and set its focus.
281 * This routine must be called with care. For example, it should not
282 * normally be called after relocking a non-leaf cluster because parent
283 * clusters help iterations and each element might be at a slightly different
284 * indirect node (each node's topology is independently indexed).
286 * HAMMER2_CITEM_FEMOD flags which elements can be modified by normal
287 * operations. Typically this is only set on a quorum of MASTERs or
288 * on a SOFT_MASTER. Also as a degenerate case on SUPROOT. If a SOFT_MASTER
289 * is present, this bit is *not* set on a quorum of MASTERs. The
290 * synchronization code ignores this bit, but all hammer2_cluster_*() calls
291 * that create/modify/delete elements use it.
293 * The chains making up the cluster may be narrowed down based on quorum
294 * acceptability, and if RESOLVE_RDONLY is specified the chains can be
295 * narrowed down to a single chain as long as the entire subtopology is known
296 * to be intact. So, for example, we can narrow a read-only op to a single
297 * fast SLAVE but if we focus a CACHE chain we must still retain at least
298 * a SLAVE to ensure that the subtopology can be accessed.
300 * RESOLVE_RDONLY operations are effectively as-of so the quorum does not need
301 * to be maintained once the topology is validated as-of the top level of
304 * If a failure occurs the operation must be aborted by higher-level code and
308 hammer2_cluster_resolve(hammer2_cluster_t *cluster)
310 hammer2_chain_t *chain;
311 hammer2_chain_t *focus;
313 hammer2_tid_t quorum_tid;
314 hammer2_tid_t last_best_quorum_tid;
326 cluster->focus = NULL;
339 KKASSERT(pmp != NULL || cluster->nchains == 0);
340 nquorum = pmp ? pmp->pfs_nmasters / 2 + 1 : 0;
346 * NOTE: A NULL chain is not necessarily an error, it could be
347 * e.g. a lookup failure or the end of an iteration.
350 for (i = 0; i < cluster->nchains; ++i) {
351 chain = cluster->array[i].chain;
352 if (chain && chain->error) {
353 if (cluster->focus == NULL || cluster->focus == chain) {
354 /* error will be overridden by valid focus */
355 cluster->error = chain->error;
359 * Must count total masters and slaves whether the
360 * chain is errored or not.
362 switch (cluster->pmp->pfs_types[i]) {
363 case HAMMER2_PFSTYPE_MASTER:
366 case HAMMER2_PFSTYPE_SLAVE:
372 switch (cluster->pmp->pfs_types[i]) {
373 case HAMMER2_PFSTYPE_MASTER:
376 case HAMMER2_PFSTYPE_SLAVE:
379 case HAMMER2_PFSTYPE_SOFT_MASTER:
380 nflags |= HAMMER2_CLUSTER_WRSOFT;
381 nflags |= HAMMER2_CLUSTER_RDSOFT;
384 case HAMMER2_PFSTYPE_SOFT_SLAVE:
385 nflags |= HAMMER2_CLUSTER_RDSOFT;
387 case HAMMER2_PFSTYPE_SUPROOT:
389 * Degenerate cluster representing the super-root
390 * topology on a single device. Fake stuff so
391 * cluster ops work as expected.
393 nflags |= HAMMER2_CLUSTER_WRHARD;
394 nflags |= HAMMER2_CLUSTER_RDHARD;
395 cluster->focus_index = i;
396 cluster->focus = chain;
397 cluster->error = chain ? chain->error : 0;
407 * Resolve masters. Calculate nmasters for the highest matching
408 * TID, if a quorum cannot be attained try the next lower matching
409 * TID until we exhaust TIDs.
411 * NOTE: A NULL chain is not necessarily an error, it could be
412 * e.g. a lookup failure or the end of an iteration.
415 last_best_quorum_tid = HAMMER2_TID_MAX;
416 quorum_tid = 0; /* fix gcc warning */
418 while (nmasters < nquorum && last_best_quorum_tid != 0) {
422 for (i = 0; i < cluster->nchains; ++i) {
423 if (cluster->pmp->pfs_types[i] !=
424 HAMMER2_PFSTYPE_MASTER) {
427 chain = cluster->array[i].chain;
429 if (cluster->array[i].flags & HAMMER2_CITEM_INVALID) {
431 * Invalid as in unsynchronized, cannot be
432 * used to calculate the quorum.
434 } else if (chain == NULL && quorum_tid == 0) {
436 * NULL chain on master matches NULL chains
440 } else if (quorum_tid < last_best_quorum_tid &&
442 (quorum_tid < chain->bref.modify_tid ||
445 * Better TID located, reset nmasters count.
448 quorum_tid = chain->bref.modify_tid;
450 quorum_tid == chain->bref.modify_tid) {
452 * TID matches current collection.
457 if (nmasters >= nquorum)
459 last_best_quorum_tid = quorum_tid;
465 * NOTE: A NULL chain is not necessarily an error, it could be
466 * e.g. a lookup failure or the end of an iteration.
469 for (i = 0; i < cluster->nchains; ++i) {
470 cluster->array[i].flags &= ~HAMMER2_CITEM_FEMOD;
471 chain = cluster->array[i].chain;
472 if (chain && chain->error) {
473 if (cluster->focus == NULL || cluster->focus == chain) {
474 /* error will be overridden by valid focus */
475 cluster->error = chain->error;
480 switch (cluster->pmp->pfs_types[i]) {
481 case HAMMER2_PFSTYPE_MASTER:
483 * We must have enough up-to-date masters to reach
484 * a quorum and the master modify_tid must match
485 * the quorum's modify_tid.
487 * Do not select an errored or out-of-sync master.
489 if (cluster->array[i].flags & HAMMER2_CITEM_INVALID) {
490 nflags |= HAMMER2_CLUSTER_UNHARD;
491 } else if (nmasters >= nquorum &&
492 (chain == NULL || chain->error == 0) &&
493 ((chain == NULL && quorum_tid == 0) ||
494 (chain != NULL && quorum_tid ==
495 chain->bref.modify_tid))) {
496 nflags |= HAMMER2_CLUSTER_WRHARD;
497 nflags |= HAMMER2_CLUSTER_RDHARD;
499 cluster->array[i].flags |=
502 if (cluster->focus == NULL ||
503 focus_pfs_type == HAMMER2_PFSTYPE_SLAVE) {
504 focus_pfs_type = HAMMER2_PFSTYPE_MASTER;
505 cluster->focus_index = i;
506 cluster->focus = chain; /* NULL ok */
507 cluster->error = chain ? chain->error :
510 } else if (chain == NULL || chain->error == 0) {
511 nflags |= HAMMER2_CLUSTER_UNHARD;
514 case HAMMER2_PFSTYPE_SLAVE:
516 * We must have enough up-to-date masters to reach
517 * a quorum and the slave modify_tid must match the
518 * quorum's modify_tid.
520 * Do not select an errored slave.
522 if (cluster->array[i].flags & HAMMER2_CITEM_INVALID) {
523 nflags |= HAMMER2_CLUSTER_UNHARD;
524 } else if (nmasters >= nquorum &&
525 (chain == NULL || chain->error == 0) &&
526 ((chain == NULL && quorum_tid == 0) ||
527 (chain && quorum_tid ==
528 chain->bref.modify_tid))) {
530 nflags |= HAMMER2_CLUSTER_RDHARD;
532 /* XXX optimize for RESOLVE_RDONLY */
533 if (cluster->focus == NULL) {
534 focus_pfs_type = HAMMER2_PFSTYPE_SLAVE;
535 cluster->focus_index = i;
536 cluster->focus = chain; /* NULL ok */
537 cluster->error = chain ? chain->error :
541 } else if (chain == NULL || chain->error == 0) {
542 nflags |= HAMMER2_CLUSTER_UNSOFT;
545 case HAMMER2_PFSTYPE_SOFT_MASTER:
547 * Directly mounted soft master always wins. There
548 * should be only one.
550 KKASSERT(focus_pfs_type != HAMMER2_PFSTYPE_SOFT_MASTER);
551 cluster->focus_index = i;
552 cluster->focus = chain;
553 cluster->error = chain ? chain->error : 0;
554 focus_pfs_type = HAMMER2_PFSTYPE_SOFT_MASTER;
555 cluster->array[i].flags |= HAMMER2_CITEM_FEMOD;
557 case HAMMER2_PFSTYPE_SOFT_SLAVE:
559 * Directly mounted soft slave always wins. There
560 * should be only one.
562 KKASSERT(focus_pfs_type != HAMMER2_PFSTYPE_SOFT_SLAVE);
563 if (focus_pfs_type != HAMMER2_PFSTYPE_SOFT_MASTER) {
564 cluster->focus_index = i;
565 cluster->focus = chain;
566 cluster->error = chain ? chain->error : 0;
567 focus_pfs_type = HAMMER2_PFSTYPE_SOFT_SLAVE;
570 case HAMMER2_PFSTYPE_SUPROOT:
572 * spmp (degenerate case)
575 cluster->focus_index = i;
576 cluster->focus = chain;
577 cluster->error = chain ? chain->error : 0;
578 focus_pfs_type = HAMMER2_PFSTYPE_SUPROOT;
579 cluster->array[i].flags |= HAMMER2_CITEM_FEMOD;
587 * Focus now set, adjust ddflag. Skip this pass if the focus
588 * is bad or if we are at the PFS root (the bref won't match at
589 * the PFS root, obviously).
591 focus = cluster->focus;
594 (cluster->focus->bref.type == HAMMER2_BREF_TYPE_INODE);
599 if (cluster->focus->flags & HAMMER2_CHAIN_PFSBOUNDARY)
605 * Validate the elements that were not marked invalid. They should
608 for (i = 0; i < cluster->nchains; ++i) {
611 chain = cluster->array[i].chain;
617 if (cluster->array[i].flags & HAMMER2_CITEM_INVALID)
620 ddflag = (chain->bref.type == HAMMER2_BREF_TYPE_INODE);
621 if (chain->bref.type != focus->bref.type ||
622 chain->bref.key != focus->bref.key ||
623 chain->bref.keybits != focus->bref.keybits ||
624 chain->bref.modify_tid != focus->bref.modify_tid ||
625 chain->bytes != focus->bytes ||
626 ddflag != cluster->ddflag) {
627 cluster->array[i].flags |= HAMMER2_CITEM_INVALID;
628 if (hammer2_debug & 1)
629 kprintf("cluster_resolve: matching modify_tid failed "
630 "bref test: idx=%d type=%02x/%02x "
631 "key=%016jx/%d-%016jx/%d "
632 "mod=%016jx/%016jx bytes=%u/%u\n",
634 chain->bref.type, focus->bref.type,
635 chain->bref.key, chain->bref.keybits,
636 focus->bref.key, focus->bref.keybits,
637 chain->bref.modify_tid, focus->bref.modify_tid,
638 chain->bytes, focus->bytes);
639 if (hammer2_debug & 0x4000)
640 panic("cluster_resolve");
641 /* flag issue and force resync? */
647 nflags |= HAMMER2_CLUSTER_NOSOFT;
649 nflags |= HAMMER2_CLUSTER_NOHARD;
652 * Set SSYNCED or MSYNCED for slaves and masters respectively if
653 * all available nodes (even if 0 are available) are fully
654 * synchronized. This is used by the synchronization thread to
655 * determine if there is work it could potentially accomplish.
657 if (nslaves == ttlslaves)
658 nflags |= HAMMER2_CLUSTER_SSYNCED;
659 if (nmasters == ttlmasters)
660 nflags |= HAMMER2_CLUSTER_MSYNCED;
663 * Determine if the cluster was successfully locked for the
664 * requested operation and generate an error code. The cluster
665 * will not be locked (or ref'd) if an error is returned.
667 atomic_set_int(&cluster->flags, nflags);
668 atomic_clear_int(&cluster->flags, HAMMER2_CLUSTER_ZFLAGS & ~nflags);
672 * This is used by the XOPS subsystem to calculate the state of
673 * the collection and tell hammer2_xop_collect() what to do with it.
674 * The collection can be in various states of desynchronization, the
675 * caller specifically wants to resolve the passed-in key.
678 * 0 - Quorum agreement, key is valid
680 * ENOENT - Quorum agreement, end of scan
682 * ESRCH - Quorum agreement, key is INVALID (caller should
685 * EIO - Quorum agreement but all elements had errors.
687 * EDEADLK - No quorum agreement possible for key, a repair
688 * may be needed. Caller has to decide what to do,
689 * possibly iterating the key or generating an EIO.
691 * EINPROGRESS - No quorum agreement yet, but agreement is still
692 * possible if caller waits for more responses. Caller
693 * should not iterate key.
695 * XXX needs to handle SOFT_MASTER and SOFT_SLAVE
698 hammer2_cluster_check(hammer2_cluster_t *cluster, hammer2_key_t key, int flags)
700 hammer2_chain_t *chain;
701 hammer2_chain_t *focus;
703 hammer2_tid_t quorum_tid;
704 hammer2_tid_t last_best_quorum_tid;
709 int nmasters_keymatch;
712 int umasters; /* unknown masters (still in progress) */
717 cluster->focus = NULL;
723 nmasters_keymatch = 0;
731 KKASSERT(pmp != NULL || cluster->nchains == 0);
732 nquorum = pmp ? pmp->pfs_nmasters / 2 + 1 : 0;
738 * NOTE: A NULL chain is not necessarily an error, it could be
739 * e.g. a lookup failure or the end of an iteration.
742 for (i = 0; i < cluster->nchains; ++i) {
743 cluster->array[i].flags &= ~HAMMER2_CITEM_FEMOD;
744 cluster->array[i].flags |= HAMMER2_CITEM_INVALID;
746 chain = cluster->array[i].chain;
747 if (chain && chain->error) {
748 if (cluster->focus == NULL || cluster->focus == chain) {
749 /* error will be overridden by valid focus */
750 cluster->error = chain->error;
754 * Must count total masters and slaves whether the
755 * chain is errored or not.
757 switch (cluster->pmp->pfs_types[i]) {
758 case HAMMER2_PFSTYPE_MASTER:
761 case HAMMER2_PFSTYPE_SLAVE:
767 switch (cluster->pmp->pfs_types[i]) {
768 case HAMMER2_PFSTYPE_MASTER:
771 case HAMMER2_PFSTYPE_SLAVE:
774 case HAMMER2_PFSTYPE_SOFT_MASTER:
775 nflags |= HAMMER2_CLUSTER_WRSOFT;
776 nflags |= HAMMER2_CLUSTER_RDSOFT;
779 case HAMMER2_PFSTYPE_SOFT_SLAVE:
780 nflags |= HAMMER2_CLUSTER_RDSOFT;
782 case HAMMER2_PFSTYPE_SUPROOT:
784 * Degenerate cluster representing the super-root
785 * topology on a single device. Fake stuff so
786 * cluster ops work as expected.
788 nflags |= HAMMER2_CLUSTER_WRHARD;
789 nflags |= HAMMER2_CLUSTER_RDHARD;
790 cluster->focus_index = i;
791 cluster->focus = chain;
792 cluster->error = chain ? chain->error : 0;
802 * Resolve nmasters - master nodes fully match
804 * Resolve umasters - master nodes operation still
807 * Resolve nmasters_keymatch - master nodes match the passed-in
808 * key and may or may not match
809 * the quorum-agreed tid.
811 * The quorum-agreed TID is the highest matching TID.
813 last_best_quorum_tid = HAMMER2_TID_MAX;
814 quorum_tid = 0; /* fix gcc warning */
816 while (nmasters < nquorum && last_best_quorum_tid != 0) {
820 for (i = 0; i < cluster->nchains; ++i) {
821 /* XXX SOFT smpresent handling */
822 if (cluster->pmp->pfs_types[i] !=
823 HAMMER2_PFSTYPE_MASTER) {
827 chain = cluster->array[i].chain;
830 * Skip elements still in progress. umasters keeps
831 * track of masters that might still be in-progress.
833 if (chain == NULL && (cluster->array[i].flags &
834 HAMMER2_CITEM_NULL) == 0) {
842 if (flags & HAMMER2_CHECK_NULL) {
848 (key == (hammer2_key_t)-1 ||
849 chain->bref.key == key)) {
851 if (quorum_tid < last_best_quorum_tid &&
852 (quorum_tid < chain->bref.modify_tid ||
855 * Better TID located, reset
859 quorum_tid = chain->bref.modify_tid;
861 if (quorum_tid == chain->bref.modify_tid) {
863 * TID matches current collection.
866 if (chain->error == 0) {
867 cluster->focus = chain;
868 cluster->focus_index = i;
873 if (nmasters >= nquorum)
875 last_best_quorum_tid = quorum_tid;
879 kprintf("nmasters %d/%d nmaster_keymatch=%d umasters=%d\n",
880 nmasters, nquorum, nmasters_keymatch, umasters);
884 * Early return if we do not have enough masters.
886 if (nmasters < nquorum) {
887 if (nmasters + umasters >= nquorum)
889 if (nmasters_keymatch < nquorum)
895 * Validated end of scan.
897 if (flags & HAMMER2_CHECK_NULL)
901 * If we have a NULL focus at this point the agreeing quorum all
904 if (cluster->focus == NULL)
910 * We have quorum agreement, validate elements, not end of scan.
912 for (i = 0; i < cluster->nchains; ++i) {
913 chain = cluster->array[i].chain;
915 chain->bref.key != key ||
916 chain->bref.modify_tid != quorum_tid) {
920 switch (cluster->pmp->pfs_types[i]) {
921 case HAMMER2_PFSTYPE_MASTER:
922 cluster->array[i].flags |= HAMMER2_CITEM_FEMOD;
923 cluster->array[i].flags &= ~HAMMER2_CITEM_INVALID;
924 nflags |= HAMMER2_CLUSTER_WRHARD;
925 nflags |= HAMMER2_CLUSTER_RDHARD;
927 case HAMMER2_PFSTYPE_SLAVE:
929 * We must have enough up-to-date masters to reach
930 * a quorum and the slave modify_tid must match the
931 * quorum's modify_tid.
933 * Do not select an errored slave.
935 cluster->array[i].flags &= ~HAMMER2_CITEM_INVALID;
936 nflags |= HAMMER2_CLUSTER_RDHARD;
939 case HAMMER2_PFSTYPE_SOFT_MASTER:
941 * Directly mounted soft master always wins. There
942 * should be only one.
944 cluster->array[i].flags |= HAMMER2_CITEM_FEMOD;
945 cluster->array[i].flags &= ~HAMMER2_CITEM_INVALID;
947 case HAMMER2_PFSTYPE_SOFT_SLAVE:
949 * Directly mounted soft slave always wins. There
950 * should be only one.
954 cluster->array[i].flags &= ~HAMMER2_CITEM_INVALID;
956 case HAMMER2_PFSTYPE_SUPROOT:
958 * spmp (degenerate case)
960 cluster->array[i].flags |= HAMMER2_CITEM_FEMOD;
961 cluster->array[i].flags &= ~HAMMER2_CITEM_INVALID;
969 * Focus now set, adjust ddflag. Skip this pass if the focus
970 * is bad or if we are at the PFS root (the bref won't match at
971 * the PFS root, obviously).
973 focus = cluster->focus;
976 (cluster->focus->bref.type == HAMMER2_BREF_TYPE_INODE);
981 if (cluster->focus->flags & HAMMER2_CHAIN_PFSBOUNDARY)
987 * Validate the elements that were not marked invalid. They should
990 for (i = 0; i < cluster->nchains; ++i) {
993 chain = cluster->array[i].chain;
999 if (cluster->array[i].flags & HAMMER2_CITEM_INVALID)
1002 ddflag = (chain->bref.type == HAMMER2_BREF_TYPE_INODE);
1003 if (chain->bref.type != focus->bref.type ||
1004 chain->bref.key != focus->bref.key ||
1005 chain->bref.keybits != focus->bref.keybits ||
1006 chain->bref.modify_tid != focus->bref.modify_tid ||
1007 chain->bytes != focus->bytes ||
1008 ddflag != cluster->ddflag) {
1009 cluster->array[i].flags |= HAMMER2_CITEM_INVALID;
1010 if (hammer2_debug & 1)
1011 kprintf("cluster_resolve: matching modify_tid failed "
1012 "bref test: idx=%d type=%02x/%02x "
1013 "key=%016jx/%d-%016jx/%d "
1014 "mod=%016jx/%016jx bytes=%u/%u\n",
1016 chain->bref.type, focus->bref.type,
1017 chain->bref.key, chain->bref.keybits,
1018 focus->bref.key, focus->bref.keybits,
1019 chain->bref.modify_tid, focus->bref.modify_tid,
1020 chain->bytes, focus->bytes);
1021 if (hammer2_debug & 0x4000)
1022 panic("cluster_resolve");
1023 /* flag issue and force resync? */
1029 nflags |= HAMMER2_CLUSTER_NOSOFT;
1030 if (ttlmasters == 0)
1031 nflags |= HAMMER2_CLUSTER_NOHARD;
1034 * Set SSYNCED or MSYNCED for slaves and masters respectively if
1035 * all available nodes (even if 0 are available) are fully
1036 * synchronized. This is used by the synchronization thread to
1037 * determine if there is work it could potentially accomplish.
1039 if (nslaves == ttlslaves)
1040 nflags |= HAMMER2_CLUSTER_SSYNCED;
1041 if (nmasters == ttlmasters)
1042 nflags |= HAMMER2_CLUSTER_MSYNCED;
1045 * Determine if the cluster was successfully locked for the
1046 * requested operation and generate an error code. The cluster
1047 * will not be locked (or ref'd) if an error is returned.
1049 atomic_set_int(&cluster->flags, nflags);
1050 atomic_clear_int(&cluster->flags, HAMMER2_CLUSTER_ZFLAGS & ~nflags);
1056 * This is used by the sync thread to force non-NULL elements of a copy
1057 * of the pmp->iroot cluster to be good which is required to prime the
1061 hammer2_cluster_forcegood(hammer2_cluster_t *cluster)
1065 for (i = 0; i < cluster->nchains; ++i) {
1066 if (cluster->array[i].chain)
1067 cluster->array[i].flags &= ~HAMMER2_CITEM_INVALID;
1072 * Copy a cluster, returned a ref'd cluster. All underlying chains
1073 * are also ref'd, but not locked. Focus state is also copied.
1075 * Original cluster does not have to be locked but usually is.
1076 * New cluster will not be flagged as locked.
1078 * Callers using this function to initialize a new cluster from an inode
1079 * generally lock and resolve the resulting cluster.
1081 * Callers which use this function to save/restore a cluster structure
1082 * generally retain the focus state and do not re-resolve it. Caller should
1083 * not try to re-resolve internal (cparent) node state during an iteration
1084 * as the individual tracking elements of cparent in an iteration may not
1085 * match even though they are correct.
1088 hammer2_cluster_copy(hammer2_cluster_t *ocluster)
1090 hammer2_pfs_t *pmp = ocluster->pmp;
1091 hammer2_cluster_t *ncluster;
1092 hammer2_chain_t *chain;
1095 ncluster = kmalloc(sizeof(*ncluster), M_HAMMER2, M_WAITOK | M_ZERO);
1096 ncluster->pmp = pmp;
1097 ncluster->nchains = ocluster->nchains;
1100 for (i = 0; i < ocluster->nchains; ++i) {
1101 chain = ocluster->array[i].chain;
1102 ncluster->array[i].chain = chain;
1103 ncluster->array[i].flags = ocluster->array[i].flags;
1105 hammer2_chain_ref(chain);
1107 ncluster->focus_index = ocluster->focus_index;
1108 ncluster->focus = ocluster->focus;
1109 ncluster->flags = ocluster->flags & ~(HAMMER2_CLUSTER_LOCKED |
1110 HAMMER2_CLUSTER_INODE);
1116 * Unlock a cluster. Refcount and focus is maintained.
1119 hammer2_cluster_unlock(hammer2_cluster_t *cluster)
1121 hammer2_chain_t *chain;
1124 if ((cluster->flags & HAMMER2_CLUSTER_LOCKED) == 0) {
1125 kprintf("hammer2_cluster_unlock: cluster %p not locked\n",
1128 KKASSERT(cluster->flags & HAMMER2_CLUSTER_LOCKED);
1129 KKASSERT(cluster->refs > 0);
1130 atomic_clear_int(&cluster->flags, HAMMER2_CLUSTER_LOCKED);
1132 for (i = 0; i < cluster->nchains; ++i) {
1133 chain = cluster->array[i].chain;
1135 hammer2_chain_unlock(chain);
1139 /************************************************************************
1141 ************************************************************************
1144 * WARNING! blockref[] array data is not universal. These functions should
1145 * only be used to access universal data.
1147 * NOTE! The rdata call will wait for at least one of the chain I/Os to
1148 * complete if necessary. The I/O's should have already been
1149 * initiated by the cluster_lock/chain_lock operation.
1151 * The cluster must already be in a modified state before wdata
1152 * is called. The data will already be available for this case.
1154 const hammer2_media_data_t *
1155 hammer2_cluster_rdata(hammer2_cluster_t *cluster)
1157 KKASSERT(cluster->focus != NULL);
1158 return(cluster->focus->data);
1161 hammer2_media_data_t *
1162 hammer2_cluster_wdata(hammer2_cluster_t *cluster)
1164 KKASSERT(cluster->focus != NULL);
1165 KKASSERT(hammer2_cluster_modified(cluster));
1166 return(cluster->focus->data);