sys/vfs/hammer2/hammer2_flush.c

   1 /*
   2  * Copyright (c) 2011-2013 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@dragonflybsd.org>
   6  * by Venkatesh Srinivas <vsrinivas@dragonflybsd.org>
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in
  16  *    the documentation and/or other materials provided with the
  17  *    distribution.
  18  * 3. Neither the name of The DragonFly Project nor the names of its
  19  *    contributors may be used to endorse or promote products derived
  20  *    from this software without specific, prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  25  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  26  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  27  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  28  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  29  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  30  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  31  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  32  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35
  36 #include <sys/cdefs.h>
  37 #include <sys/param.h>
  38 #include <sys/systm.h>
  39 #include <sys/types.h>
  40 #include <sys/lock.h>
  41 #include <sys/uuid.h>
  42
  43 #include "hammer2.h"
  44
  45 /*
  46  * Recursively flush the specified chain.  The chain is locked and
  47  * referenced by the caller and will remain so on return.  The chain
  48  * will remain referenced throughout but can temporarily lose its
  49  * lock during the recursion to avoid unnecessarily stalling user
  50  * processes.
  51  */
  52 struct hammer2_flush_info {
  53         hammer2_mount_t *hmp;
  54         hammer2_chain_t *parent;
  55         hammer2_trans_t *trans;
  56         int             depth;
  57         int             diddeferral;
  58         struct flush_deferral_list flush_list;
  59         hammer2_tid_t   sync_tid;       /* flush synchronization point */
  60         hammer2_tid_t   mirror_tid;     /* collect mirror TID updates */
  61 };
  62
  63 typedef struct hammer2_flush_info hammer2_flush_info_t;
  64
  65 static void hammer2_chain_flush_core(hammer2_flush_info_t *info,
  66                                 hammer2_chain_t *chain);
  67 static int hammer2_chain_flush_scan1(hammer2_chain_t *child, void *data);
  68 static int hammer2_chain_flush_scan2(hammer2_chain_t *child, void *data);
  69
  70 /*
  71  * Transaction support functions for writing to the filesystem.
  72  *
  73  * Initializing a new transaction allocates a transaction ID.  We
  74  * don't bother marking the volume header MODIFIED.  Instead, the volume
  75  * will be synchronized at a later time as part of a larger flush sequence.
  76  *
  77  * Non-flush transactions can typically run concurrently.  However if
  78  * there are non-flush transaction both before AND after a flush trans,
  79  * the transactions after stall until the ones before finish.
  80  *
  81  * Non-flush transactions occuring after a flush pointer can run concurrently
  82  * with that flush.  They only have to wait for transactions prior to the
  83  * flush trans to complete before they unstall.
  84  *
  85  * WARNING! Modifications to the root volume cannot dup the root volume
  86  *          header to handle synchronization points, so alloc_tid can
  87  *          wind up (harmlessly) more advanced on flush.
  88  *
  89  * WARNING! Operations which might call inode_duplicate()/chain_duplicate()
  90  *          depend heavily on having a unique sync_tid to avoid duplication
  91  *          collisions (which key off of delete_tid).
  92  */
  93 void
  94 hammer2_trans_init(hammer2_trans_t *trans, hammer2_mount_t *hmp,
  95                    hammer2_inode_t *ip, int flags)
  96 {
  97         hammer2_trans_t *scan;
  98
  99         bzero(trans, sizeof(*trans));
 100         trans->hmp = hmp;
 101
 102         hammer2_voldata_lock(hmp);
 103         trans->sync_tid = hmp->voldata.alloc_tid++;
 104         trans->flags = flags;
 105         trans->td = curthread;
 106         trans->tmp_ip = ip;
 107         trans->tmp_bpref = 0;
 108         TAILQ_INSERT_TAIL(&hmp->transq, trans, entry);
 109
 110         if (flags & HAMMER2_TRANS_ISFLUSH) {
 111                 /*
 112                  * If we are a flush we have to wait for all transactions
 113                  * prior to our flush synchronization point to complete
 114                  * before we can start our flush.
 115                  */
 116                 ++hmp->flushcnt;
 117                 if (hmp->curflush == NULL) {
 118                         hmp->curflush = trans;
 119                         hmp->topo_flush_tid = trans->sync_tid;
 120                 }
 121                 while (TAILQ_FIRST(&hmp->transq) != trans) {
 122                         lksleep(&trans->sync_tid, &hmp->voldatalk,
 123                                 0, "h2syncw", hz);
 124                 }
 125
 126                 /*
 127                  * Once we become the running flush we can wakeup anyone
 128                  * who blocked on us.
 129                  */
 130                 scan = trans;
 131                 while ((scan = TAILQ_NEXT(scan, entry)) != NULL) {
 132                         if (scan->flags & HAMMER2_TRANS_ISFLUSH)
 133                                 break;
 134                         if (scan->blocked == 0)
 135                                 break;
 136                         scan->blocked = 0;
 137                         wakeup(&scan->blocked);
 138                 }
 139         } else {
 140                 /*
 141                  * If we are not a flush but our sync_tid is after a
 142                  * stalled flush, we have to wait until that flush unstalls
 143                  * (that is, all transactions prior to that flush complete),
 144                  * but then we can run concurrently with that flush.
 145                  *
 146                  * (flushcnt check only good as pre-condition, otherwise it
 147                  *  may represent elements queued after us after we block).
 148                  */
 149                 if (hmp->flushcnt > 1 ||
 150                     (hmp->curflush &&
 151                      TAILQ_FIRST(&hmp->transq) != hmp->curflush)) {
 152                         trans->blocked = 1;
 153                         while (trans->blocked) {
 154                                 lksleep(&trans->blocked, &hmp->voldatalk,
 155                                         0, "h2trans", hz);
 156                         }
 157                 }
 158         }
 159         hammer2_voldata_unlock(hmp, 0);
 160 }
 161
 162 void
 163 hammer2_trans_done(hammer2_trans_t *trans)
 164 {
 165         hammer2_mount_t *hmp = trans->hmp;
 166         hammer2_trans_t *scan;
 167
 168         hammer2_voldata_lock(hmp);
 169         TAILQ_REMOVE(&hmp->transq, trans, entry);
 170         if (trans->flags & HAMMER2_TRANS_ISFLUSH) {
 171                 /*
 172                  * If we were a flush we have to adjust curflush to the
 173                  * next flush.
 174                  *
 175                  * flush_tid is used to partition copy-on-write operations
 176                  * (mostly duplicate-on-modify ops), which is what allows
 177                  * us to execute a flush concurrent with modifying operations
 178                  * with higher TIDs.
 179                  */
 180                 --hmp->flushcnt;
 181                 if (hmp->flushcnt) {
 182                         TAILQ_FOREACH(scan, &hmp->transq, entry) {
 183                                 if (scan->flags & HAMMER2_TRANS_ISFLUSH)
 184                                         break;
 185                         }
 186                         KKASSERT(scan);
 187                         hmp->curflush = scan;
 188                         hmp->topo_flush_tid = scan->sync_tid;
 189                 } else {
 190                         /*
 191                          * Theoretically we don't have to clear flush_tid
 192                          * here since the flush will have synchronized
 193                          * all operations <= flush_tid already.  But for
 194                          * now zero-it.
 195                          */
 196                         hmp->curflush = NULL;
 197                         hmp->topo_flush_tid = 0;
 198                 }
 199         } else {
 200                 /*
 201                  * If we are not a flush but a flush is now at the head
 202                  * of the queue and we were previously blocking it,
 203                  * we can now unblock it.
 204                  */
 205                 if (hmp->flushcnt &&
 206                     (scan = TAILQ_FIRST(&hmp->transq)) != NULL &&
 207                     trans->sync_tid < scan->sync_tid &&
 208                     (scan->flags & HAMMER2_TRANS_ISFLUSH)) {
 209                         wakeup(&scan->sync_tid);
 210                 }
 211         }
 212         hammer2_voldata_unlock(hmp, 0);
 213
 214         trans->hmp = NULL;
 215 }
 216
 217 /*
 218  * Flush the chain and all modified sub-chains through the specified
 219  * synchronization point (sync_tid), propagating parent chain modifications
 220  * and mirror_tid updates back up as needed.  Since we are recursing downward
 221  * we do not have to deal with the complexities of multi-homed chains (chains
 222  * with multiple parents).
 223  *
 224  * Caller must have interlocked against any non-flush-related modifying
 225  * operations in progress whos modify_tid values are less than or equal
 226  * to the passed sync_tid.
 227  *
 228  * Caller must have already vetted synchronization points to ensure they
 229  * are properly flushed.  Only snapshots and cluster flushes can create
 230  * these sorts of synchronization points.
 231  *
 232  * This routine can be called from several places but the most important
 233  * is from the hammer2_vop_reclaim() function.  We want to try to completely
 234  * clean out the inode structure to prevent disconnected inodes from
 235  * building up and blowing out the kmalloc pool.  However, it is not actually
 236  * necessary to flush reclaimed inodes to maintain HAMMER2's crash recovery
 237  * capability.
 238  *
 239  * chain is locked on call and will remain locked on return.  If a flush
 240  * occured, the chain's MOVED bit will be set indicating that its parent
 241  * (which is not part of the flush) should be updated.
 242  */
 243 void
 244 hammer2_chain_flush(hammer2_trans_t *trans, hammer2_chain_t *chain)
 245 {
 246         hammer2_chain_t *scan;
 247         hammer2_chain_core_t *core;
 248         hammer2_flush_info_t info;
 249
 250         /*
 251          * Execute the recursive flush and handle deferrals.
 252          *
 253          * Chains can be ridiculously long (thousands deep), so to
 254          * avoid blowing out the kernel stack the recursive flush has a
 255          * depth limit.  Elements at the limit are placed on a list
 256          * for re-execution after the stack has been popped.
 257          */
 258         bzero(&info, sizeof(info));
 259         TAILQ_INIT(&info.flush_list);
 260         info.hmp = trans->hmp;
 261         info.trans = trans;
 262         info.sync_tid = trans->sync_tid;
 263         info.mirror_tid = 0;
 264
 265         core = chain->core;
 266
 267         for (;;) {
 268                 /*
 269                  * Unwind deep recursions which had been deferred.  This
 270                  * can leave MOVED set for these chains, which will be
 271                  * handled when we [re]flush chain after the unwind.
 272                  */
 273                 while ((scan = TAILQ_FIRST(&info.flush_list)) != NULL) {
 274                         KKASSERT(scan->flags & HAMMER2_CHAIN_DEFERRED);
 275                         TAILQ_REMOVE(&info.flush_list, scan, flush_node);
 276                         atomic_clear_int(&scan->flags, HAMMER2_CHAIN_DEFERRED);
 277
 278                         /*
 279                          * Now that we've popped back up we can do a secondary
 280                          * recursion on the deferred elements.
 281                          */
 282                         if (hammer2_debug & 0x0040)
 283                                 kprintf("defered flush %p\n", scan);
 284                         hammer2_chain_lock(scan, HAMMER2_RESOLVE_MAYBE);
 285                         hammer2_chain_flush(trans, scan);
 286                         hammer2_chain_unlock(scan);
 287                         hammer2_chain_drop(scan);       /* ref from deferral */
 288                 }
 289
 290                 /*
 291                  * Flush pass1 on root.
 292                  */
 293                 info.diddeferral = 0;
 294                 hammer2_chain_flush_core(&info, chain);
 295 #if FLUSH_DEBUG
 296                 kprintf("flush_core_done parent=<base> chain=%p.%d %08x\n",
 297                         chain, chain->bref.type, chain->flags);
 298 #endif
 299
 300                 /*
 301                  * Only loop if deep recursions have been deferred.
 302                  */
 303                 if (TAILQ_EMPTY(&info.flush_list))
 304                         break;
 305         }
 306 }
 307
 308 /*
 309  * This is the core of the chain flushing code.  The chain is locked by the
 310  * caller and remains locked on return.  This function is keyed off of
 311  * the SUBMODIFIED bit but must make fine-grained choices based on the
 312  * synchronization point we are flushing to.
 313  *
 314  * If the flush accomplished any work chain will be flagged MOVED
 315  * indicating a copy-on-write propagation back up is required.
 316  * Deep sub-nodes may also have been entered onto the deferral list.
 317  * MOVED is never set on the volume root.
 318  *
 319  * NOTE: modify_tid is different from MODIFIED.  modify_tid is updated
 320  *       only when a chain is specifically modified, and not updated
 321  *       for copy-on-write propagations.  MODIFIED is set on any modification
 322  *       including copy-on-write propagations.
 323  */
 324 static void
 325 hammer2_chain_flush_core(hammer2_flush_info_t *info, hammer2_chain_t *chain)
 326 {
 327         hammer2_mount_t *hmp;
 328         hammer2_blockref_t *bref;
 329         hammer2_off_t pbase;
 330         hammer2_tid_t saved_sync;
 331         hammer2_trans_t *trans = info->trans;
 332         hammer2_chain_core_t *core;
 333         size_t bbytes;
 334         size_t boff;
 335         char *bdata;
 336         struct buf *bp;
 337         int error;
 338         int wasmodified;
 339         int diddeferral = 0;
 340
 341         hmp = info->hmp;
 342
 343 #if FLUSH_DEBUG
 344         if (info->parent)
 345                 kprintf("flush_core %p->%p.%d %08x (%s)\n",
 346                         info->parent, chain, chain->bref.type,
 347                         chain->flags,
 348                         ((chain->bref.type == HAMMER2_BREF_TYPE_INODE) ?
 349                                 chain->data->ipdata.filename : "?"));
 350         else
 351                 kprintf("flush_core NULL->%p.%d %08x (%s)\n",
 352                         chain, chain->bref.type,
 353                         chain->flags,
 354                         ((chain->bref.type == HAMMER2_BREF_TYPE_INODE) ?
 355                                 chain->data->ipdata.filename : "?"));
 356 #endif
 357         /*
 358          * Ignore chains modified beyond the current flush point.  These
 359          * will be treated as if they did not exist.
 360          */
 361         if (chain->modify_tid > info->sync_tid)
 362                 return;
 363
 364         /*
 365          * Deleted chains which have not been destroyed must be retained,
 366          * and we probably have to recurse to clean-up any sub-trees.
 367          * However, restricted flushes can stop processing here because
 368          * the chain cleanup will be handled by a later normal flush.
 369          *
 370          * The MODIFIED bit can likely be cleared in this situation and we
 371          * will do so later on in this procedure.
 372          */
 373         if (chain->delete_tid <= info->sync_tid) {
 374                 if (trans->flags & HAMMER2_TRANS_RESTRICTED)
 375                         return;
 376         }
 377
 378         saved_sync = info->sync_tid;
 379         core = chain->core;
 380
 381         /*
 382          * If SUBMODIFIED is set we recurse the flush and adjust the
 383          * blockrefs accordingly.
 384          *
 385          * NOTE: Looping on SUBMODIFIED can prevent a flush from ever
 386          *       finishing in the face of filesystem activity.
 387          */
 388         if (chain->flags & HAMMER2_CHAIN_SUBMODIFIED) {
 389                 hammer2_chain_t *saved_parent;
 390                 hammer2_tid_t saved_mirror;
 391
 392                 /*
 393                  * Clear SUBMODIFIED to catch races.  Note that any child
 394                  * with MODIFIED, DELETED, or MOVED set during Scan2, after
 395                  * it processes the child, will cause SUBMODIFIED to be
 396                  * re-set.
 397                  * child has to be flushed SUBMODIFIED will wind up being
 398                  * set again (for next time), but this does not stop us from
 399                  * synchronizing block updates which occurred.
 400                  *
 401                  * We don't want to set our chain to MODIFIED gratuitously.
 402                  *
 403                  * We need an extra ref on chain because we are going to
 404                  * release its lock temporarily in our child loop.
 405                  */
 406                 atomic_clear_int(&chain->flags, HAMMER2_CHAIN_SUBMODIFIED);
 407                 hammer2_chain_ref(chain);
 408
 409                 /*
 410                  * Run two passes.  The first pass handles MODIFIED and
 411                  * SUBMODIFIED chains and recurses while the second pass
 412                  * handles MOVED chains on the way back up.
 413                  *
 414                  * If the stack gets too deep we defer scan1, but must
 415                  * be sure to still run scan2 if on the next loop the
 416                  * deferred chain has been flushed and now needs MOVED
 417                  * handling on the way back up.
 418                  *
 419                  * Scan1 is recursive.
 420                  *
 421                  * NOTE: The act of handling a modified/submodified chain can
 422                  *       cause the MOVED Flag to be set.  It can also be set
 423                  *       via hammer2_chain_delete() and in other situations.
 424                  *
 425                  * NOTE: RB_SCAN() must be used instead of RB_FOREACH()
 426                  *       because children can be physically removed during
 427                  *       the scan.
 428                  */
 429                 saved_parent = info->parent;
 430                 saved_mirror = info->mirror_tid;
 431                 info->parent = chain;
 432                 info->mirror_tid = chain->bref.mirror_tid;
 433
 434                 if (info->depth == HAMMER2_FLUSH_DEPTH_LIMIT) {
 435                         if ((chain->flags & HAMMER2_CHAIN_DEFERRED) == 0) {
 436                                 hammer2_chain_ref(chain);
 437                                 TAILQ_INSERT_TAIL(&info->flush_list,
 438                                                   chain, flush_node);
 439                                 atomic_set_int(&chain->flags,
 440                                                HAMMER2_CHAIN_DEFERRED);
 441                         }
 442                         diddeferral = 1;
 443                 } else {
 444                         info->diddeferral = 0;
 445                         spin_lock(&core->cst.spin);
 446                         RB_SCAN(hammer2_chain_tree, &chain->core->rbtree,
 447                                 NULL, hammer2_chain_flush_scan1, info);
 448                         spin_unlock(&core->cst.spin);
 449                         diddeferral += info->diddeferral;
 450                 }
 451
 452                 /*
 453                  * Handle successfully flushed children who are in the MOVED
 454                  * state on the way back up the recursion.  This can have
 455                  * the side-effect of clearing MOVED.
 456                  *
 457                  * We execute this even if there were deferrals to try to
 458                  * keep the chain topology cleaner.
 459                  *
 460                  * Scan2 is non-recursive.
 461                  */
 462                 if (diddeferral) {
 463                         atomic_set_int(&chain->flags,
 464                                        HAMMER2_CHAIN_SUBMODIFIED);
 465                 } else {
 466 #if FLUSH_DEBUG
 467                         kprintf("scan2_start parent %p %08x\n",
 468                                 chain, chain->flags);
 469 #endif
 470                         spin_lock(&core->cst.spin);
 471                         RB_SCAN(hammer2_chain_tree, &core->rbtree,
 472                                 NULL, hammer2_chain_flush_scan2, info);
 473                         spin_unlock(&core->cst.spin);
 474 #if FLUSH_DEBUG
 475                         kprintf("scan2_stop  parent %p %08x\n",
 476                                 chain, chain->flags);
 477 #endif
 478                 }
 479                 chain->bref.mirror_tid = info->mirror_tid;
 480                 info->mirror_tid = saved_mirror;
 481                 info->parent = saved_parent;
 482                 hammer2_chain_drop(chain);
 483         }
 484
 485         /*
 486          * Restore sync_tid in case it was restricted by a delete/duplicate.
 487          */
 488         info->sync_tid = saved_sync;
 489
 490         /*
 491          * Rollup diddeferral for caller.  Note direct assignment, not +=.
 492          */
 493         info->diddeferral = diddeferral;
 494
 495         /*
 496          * Do not flush chain if there were any deferrals.  It will be
 497          * retried later after the deferrals are independently handled.
 498          */
 499         if (diddeferral) {
 500                 if (hammer2_debug & 0x0008) {
 501                         kprintf("%*.*s} %p/%d %04x (deferred)",
 502                                 info->depth, info->depth, "",
 503                                 chain, chain->refs, chain->flags);
 504                 }
 505                 return;
 506         }
 507
 508         /*
 509          * If we encounter a deleted chain within our flush we can clear
 510          * the MODIFIED bit and avoid flushing it whether it has been
 511          * destroyed or not.
 512          */
 513         if (chain->delete_tid <= info->sync_tid) {
 514                 if (chain->flags & HAMMER2_CHAIN_MODIFIED) {
 515                         if (chain->bp) {
 516                                 if (chain->bytes == chain->bp->b_bufsize)
 517                                         chain->bp->b_flags |= B_INVAL|B_RELBUF;
 518                         }
 519                         atomic_clear_int(&chain->flags, HAMMER2_CHAIN_MODIFIED);
 520                         hammer2_chain_drop(chain);
 521                 }
 522                 return;
 523         }
 524 #if 0
 525         if ((chain->flags & HAMMER2_CHAIN_DESTROYED) &&
 526             (chain->flags & HAMMER2_CHAIN_DELETED) &&
 527             (trans->flags & HAMMER2_TRANS_RESTRICTED) == 0) {
 528                 /*
 529                  * Throw-away the MODIFIED flag
 530                  */
 531                 if (chain->flags & HAMMER2_CHAIN_MODIFIED) {
 532                         if (chain->bp) {
 533                                 if (chain->bytes == chain->bp->b_bufsize)
 534                                         chain->bp->b_flags |= B_INVAL|B_RELBUF;
 535                         }
 536                         atomic_clear_int(&chain->flags, HAMMER2_CHAIN_MODIFIED);
 537                         hammer2_chain_drop(chain);
 538                 }
 539                 return;
 540         }
 541 #endif
 542
 543         /*
 544          * A degenerate flush might not have flushed anything and thus not
 545          * processed modified blocks on the way back up.  Detect the case.
 546          *
 547          * Note that MOVED can be set without MODIFIED being set due to
 548          * a deletion, in which case it is handled by Scan2 later on.
 549          *
 550          * Both bits can be set along with DELETED due to a deletion if
 551          * modified data within the synchronization zone and the chain
 552          * was then deleted beyond the zone, in which case we still have
 553          * to flush for synchronization point consistency.  Otherwise though
 554          * DELETED and MODIFIED are treated as separate flags.
 555          */
 556         if ((chain->flags & HAMMER2_CHAIN_MODIFIED) == 0)
 557                 return;
 558
 559         /*
 560          * Issue flush.
 561          *
 562          * A DESTROYED node that reaches this point must be flushed for
 563          * synchronization point consistency.
 564          */
 565
 566         /*
 567          * Update mirror_tid, clear MODIFIED, and set MOVED.
 568          *
 569          * The caller will update the parent's reference to this chain
 570          * by testing MOVED as long as the modification was in-bounds.
 571          *
 572          * MOVED is never set on the volume root as there is no parent
 573          * to adjust.
 574          */
 575         if (chain->bref.mirror_tid < info->sync_tid)
 576                 chain->bref.mirror_tid = info->sync_tid;
 577         wasmodified = (chain->flags & HAMMER2_CHAIN_MODIFIED) != 0;
 578         atomic_clear_int(&chain->flags, HAMMER2_CHAIN_MODIFIED);
 579         if (chain == &hmp->vchain)
 580                 kprintf("(FLUSHED VOLUME HEADER)\n");
 581         if (chain == &hmp->fchain)
 582                 kprintf("(FLUSHED FREEMAP HEADER)\n");
 583
 584         if ((chain->flags & HAMMER2_CHAIN_MOVED) ||
 585             chain == &hmp->vchain ||
 586             chain == &hmp->fchain) {
 587                 /*
 588                  * Drop the ref from the MODIFIED bit we cleared.
 589                  */
 590                 if (wasmodified)
 591                         hammer2_chain_drop(chain);
 592         } else {
 593                 /*
 594                  * If we were MODIFIED we inherit the ref from clearing
 595                  * that bit, otherwise we need another ref.
 596                  */
 597                 if (wasmodified == 0)
 598                         hammer2_chain_ref(chain);
 599                 atomic_set_int(&chain->flags, HAMMER2_CHAIN_MOVED);
 600         }
 601
 602         /*
 603          * If this is part of a recursive flush we can go ahead and write
 604          * out the buffer cache buffer and pass a new bref back up the chain
 605          * via the MOVED bit.
 606          *
 607          * Volume headers are NOT flushed here as they require special
 608          * processing.
 609          */
 610         switch(chain->bref.type) {
 611         case HAMMER2_BREF_TYPE_FREEMAP:
 612                 hammer2_modify_volume(hmp);
 613                 break;
 614         case HAMMER2_BREF_TYPE_VOLUME:
 615                 /*
 616                  * We should flush the free block table before we calculate
 617                  * CRCs and copy voldata -> volsync.
 618                  */
 619                 hammer2_chain_lock(&hmp->fchain, HAMMER2_RESOLVE_ALWAYS);
 620                 if (hmp->fchain.flags & (HAMMER2_CHAIN_MODIFIED |
 621                                          HAMMER2_CHAIN_SUBMODIFIED)) {
 622                         /* this will modify vchain as a side effect */
 623                         hammer2_chain_flush(info->trans, &hmp->fchain);
 624                 }
 625                 hammer2_chain_unlock(&hmp->fchain);
 626
 627                 /*
 628                  * The volume header is flushed manually by the syncer, not
 629                  * here.  All we do is adjust the crc's.
 630                  */
 631                 KKASSERT(chain->data != NULL);
 632                 KKASSERT(chain->bp == NULL);
 633                 kprintf("volume header mirror_tid %jd\n",
 634                         hmp->voldata.mirror_tid);
 635
 636                 hmp->voldata.icrc_sects[HAMMER2_VOL_ICRC_SECT1]=
 637                         hammer2_icrc32(
 638                                 (char *)&hmp->voldata +
 639                                  HAMMER2_VOLUME_ICRC1_OFF,
 640                                 HAMMER2_VOLUME_ICRC1_SIZE);
 641                 hmp->voldata.icrc_sects[HAMMER2_VOL_ICRC_SECT0]=
 642                         hammer2_icrc32(
 643                                 (char *)&hmp->voldata +
 644                                  HAMMER2_VOLUME_ICRC0_OFF,
 645                                 HAMMER2_VOLUME_ICRC0_SIZE);
 646                 hmp->voldata.icrc_volheader =
 647                         hammer2_icrc32(
 648                                 (char *)&hmp->voldata +
 649                                  HAMMER2_VOLUME_ICRCVH_OFF,
 650                                 HAMMER2_VOLUME_ICRCVH_SIZE);
 651                 hmp->volsync = hmp->voldata;
 652                 atomic_set_int(&chain->flags, HAMMER2_CHAIN_VOLUMESYNC);
 653                 break;
 654         case HAMMER2_BREF_TYPE_DATA:
 655                 /*
 656                  * Data elements have already been flushed via the logical
 657                  * file buffer cache.  Their hash was set in the bref by
 658                  * the vop_write code.
 659                  *
 660                  * Make sure any device buffer(s) have been flushed out here.
 661                  * (there aren't usually any to flush).
 662                  */
 663                 bbytes = chain->bytes;
 664                 pbase = chain->bref.data_off & ~(hammer2_off_t)(bbytes - 1);
 665                 boff = chain->bref.data_off & HAMMER2_OFF_MASK & (bbytes - 1);
 666
 667                 bp = getblk(hmp->devvp, pbase, bbytes, GETBLK_NOWAIT, 0);
 668                 if (bp) {
 669                         if ((bp->b_flags & (B_CACHE | B_DIRTY)) ==
 670                             (B_CACHE | B_DIRTY)) {
 671                                 cluster_awrite(bp);
 672                         } else {
 673                                 bp->b_flags |= B_RELBUF;
 674                                 brelse(bp);
 675                         }
 676                 }
 677                 break;
 678         case HAMMER2_BREF_TYPE_INDIRECT:
 679                 /*
 680                  * Indirect blocks may be in an INITIAL state.  Use the
 681                  * chain_lock() call to ensure that the buffer has been
 682                  * instantiated (even though it is already locked the buffer
 683                  * might not have been instantiated).
 684                  *
 685                  * Only write the buffer out if it is dirty, it is possible
 686                  * the operating system had already written out the buffer.
 687                  */
 688                 hammer2_chain_lock(chain, HAMMER2_RESOLVE_ALWAYS);
 689                 KKASSERT(chain->bp != NULL);
 690
 691                 bp = chain->bp;
 692                 if ((chain->flags & HAMMER2_CHAIN_DIRTYBP) ||
 693                     (bp->b_flags & B_DIRTY)) {
 694                         bdwrite(chain->bp);
 695                 } else {
 696                         brelse(chain->bp);
 697                 }
 698                 chain->bp = NULL;
 699                 chain->data = NULL;
 700                 hammer2_chain_unlock(chain);
 701                 break;
 702         case HAMMER2_BREF_TYPE_FREEMAP_NODE:
 703         case HAMMER2_BREF_TYPE_FREEMAP_LEAF:
 704                 /*
 705                  * Device-backed.  Buffer will be flushed by the sync
 706                  * code XXX.
 707                  */
 708                 break;
 709         default:
 710                 /*
 711                  * Embedded elements have to be flushed out.
 712                  * (Basically just BREF_TYPE_INODE).
 713                  */
 714                 KKASSERT(chain->data != NULL);
 715                 KKASSERT(chain->bp == NULL);
 716                 bref = &chain->bref;
 717
 718                 KKASSERT((bref->data_off & HAMMER2_OFF_MASK) != 0);
 719                 KKASSERT(HAMMER2_DEC_CHECK(chain->bref.methods) ==
 720                          HAMMER2_CHECK_ISCSI32);
 721
 722                 if (chain->bp == NULL) {
 723                         /*
 724                          * The data is embedded, we have to acquire the
 725                          * buffer cache buffer and copy the data into it.
 726                          */
 727                         if ((bbytes = chain->bytes) < HAMMER2_MINIOSIZE)
 728                                 bbytes = HAMMER2_MINIOSIZE;
 729                         pbase = bref->data_off & ~(hammer2_off_t)(bbytes - 1);
 730                         boff = bref->data_off & HAMMER2_OFF_MASK & (bbytes - 1);
 731
 732                         /*
 733                          * The getblk() optimization can only be used if the
 734                          * physical block size matches the request.
 735                          */
 736                         if (chain->bytes == bbytes) {
 737                                 bp = getblk(hmp->devvp, pbase, bbytes, 0, 0);
 738                                 error = 0;
 739                         } else {
 740                                 error = bread(hmp->devvp, pbase, bbytes, &bp);
 741                                 KKASSERT(error == 0);
 742                         }
 743                         bdata = (char *)bp->b_data + boff;
 744
 745                         /*
 746                          * Copy the data to the buffer, mark the buffer
 747                          * dirty, and convert the chain to unmodified.
 748                          */
 749                         bcopy(chain->data, bdata, chain->bytes);
 750                         bp->b_flags |= B_CLUSTEROK;
 751                         bdwrite(bp);
 752                         bp = NULL;
 753                         chain->bref.check.iscsi32.value =
 754                                 hammer2_icrc32(chain->data, chain->bytes);
 755                         if (chain->bref.type == HAMMER2_BREF_TYPE_INODE)
 756                                 ++hammer2_iod_meta_write;
 757                         else
 758                                 ++hammer2_iod_indr_write;
 759                 } else {
 760                         chain->bref.check.iscsi32.value =
 761                                 hammer2_icrc32(chain->data, chain->bytes);
 762                 }
 763         }
 764 }
 765
 766 /*
 767  * Flush helper scan1 (recursive)
 768  *
 769  * Flushes the children of the caller's chain (parent) and updates
 770  * the blockref, restricted by sync_tid.
 771  *
 772  * Ripouts during the loop should not cause any problems.  Because we are
 773  * flushing to a synchronization point, modification races will occur after
 774  * sync_tid and do not have to be flushed anyway.
 775  *
 776  * It is also ok if the parent is chain_duplicate()'d while unlocked because
 777  * the delete/duplication will install a delete_tid that is still larger than
 778  * our current sync_tid.
 779  */
 780 static int
 781 hammer2_chain_flush_scan1(hammer2_chain_t *child, void *data)
 782 {
 783         hammer2_flush_info_t *info = data;
 784         hammer2_trans_t *trans = info->trans;
 785         hammer2_chain_t *parent = info->parent;
 786         /*hammer2_mount_t *hmp = info->hmp;*/
 787         int diddeferral;
 788
 789         /*
 790          * We should only need to recurse if SUBMODIFIED is set, but as
 791          * a safety also recurse if MODIFIED is also set.
 792          *
 793          * Return early if neither bit is set.  We must re-assert the
 794          * SUBMODIFIED flag in the parent if any child covered by the
 795          * parent (via delete_tid) is skipped.
 796          */
 797         if ((child->flags & (HAMMER2_CHAIN_MODIFIED |
 798                              HAMMER2_CHAIN_SUBMODIFIED)) == 0) {
 799                 return (0);
 800         }
 801         if (child->modify_tid > trans->sync_tid) {
 802                 if (parent->delete_tid > trans->sync_tid) {
 803                         atomic_set_int(&parent->flags,
 804                                        HAMMER2_CHAIN_SUBMODIFIED);
 805                 }
 806                 return (0);
 807         }
 808
 809         hammer2_chain_ref(child);
 810         spin_unlock(&parent->core->cst.spin);
 811
 812         /*
 813          * The caller has added a ref to the parent so we can temporarily
 814          * unlock it in order to lock the child.  Re-check the flags before
 815          * continuing.
 816          */
 817         hammer2_chain_unlock(parent);
 818         hammer2_chain_lock(child, HAMMER2_RESOLVE_MAYBE);
 819
 820         if ((child->flags & (HAMMER2_CHAIN_MODIFIED |
 821                              HAMMER2_CHAIN_SUBMODIFIED)) == 0) {
 822                 hammer2_chain_unlock(child);
 823                 hammer2_chain_drop(child);
 824                 hammer2_chain_lock(parent, HAMMER2_RESOLVE_MAYBE);
 825                 spin_lock(&parent->core->cst.spin);
 826                 return (0);
 827         }
 828         if (child->modify_tid > trans->sync_tid) {
 829                 hammer2_chain_unlock(child);
 830                 hammer2_chain_drop(child);
 831                 hammer2_chain_lock(parent, HAMMER2_RESOLVE_MAYBE);
 832                 spin_lock(&parent->core->cst.spin);
 833                 if (parent->delete_tid > trans->sync_tid) {
 834                         atomic_set_int(&parent->flags,
 835                                        HAMMER2_CHAIN_SUBMODIFIED);
 836                 }
 837                 return (0);
 838         }
 839
 840         /*
 841          * The DESTROYED flag can only be initially set on an unreferenced
 842          * deleted inode and will propagate downward via the mechanic below.
 843          * Such inode chains have been deleted for good and should no longer
 844          * be subject to delete/duplication.
 845          *
 846          * This optimization allows the inode reclaim (destroy unlinked file
 847          * on vnode reclamation after last close) to be flagged by just
 848          * setting HAMMER2_CHAIN_DESTROYED at the top level and then will
 849          * cause the chains to be terminated and related buffers to be
 850          * invalidated and not flushed out.
 851          *
 852          * We have to be careful not to propagate the DESTROYED flag if
 853          * the destruction occurred after our flush sync_tid.
 854          */
 855         if ((parent->flags & HAMMER2_CHAIN_DESTROYED) &&
 856             (child->flags & HAMMER2_CHAIN_DELETED) &&
 857             (child->flags & HAMMER2_CHAIN_DESTROYED) == 0) {
 858                 atomic_set_int(&child->flags, HAMMER2_CHAIN_DESTROYED |
 859                                               HAMMER2_CHAIN_SUBMODIFIED);
 860         }
 861
 862         /*
 863          * Recurse and collect deferral data.
 864          */
 865         diddeferral = info->diddeferral;
 866         ++info->depth;
 867         hammer2_chain_flush_core(info, child);
 868 #if FLUSH_DEBUG
 869         kprintf("flush_core_done parent=%p flags=%08x child=%p.%d %08x\n",
 870                 parent, parent->flags, child, child->bref.type, child->flags);
 871 #endif
 872         --info->depth;
 873         info->diddeferral += diddeferral;
 874
 875         if (child->flags & HAMMER2_CHAIN_SUBMODIFIED)
 876                 atomic_set_int(&parent->flags, HAMMER2_CHAIN_SUBMODIFIED);
 877
 878         hammer2_chain_unlock(child);
 879         hammer2_chain_drop(child);
 880
 881         hammer2_chain_lock(parent, HAMMER2_RESOLVE_MAYBE);
 882
 883         spin_lock(&parent->core->cst.spin);
 884         return (0);
 885 }
 886
 887 /*
 888  * Flush helper scan2 (non-recursive)
 889  *
 890  * This pass on a chain's children propagates any MOVED or DELETED
 891  * elements back up the chain towards the root after those elements have
 892  * been fully flushed.  Unlike scan1, this function is NOT recursive and
 893  * the parent remains locked across the entire scan.
 894  *
 895  * NOTE!  We must re-set SUBMODIFIED on the parent(s) as appropriate, and
 896  *        due to the above conditions it is possible to do this and still
 897  *        have some children flagged MOVED depending on the synchronization.
 898  *
 899  * NOTE!  A deletion is a visbility issue, there can still be referenced to
 900  *        deleted elements (for example, to an unlinked file which is still
 901  *        open), and there can also be multiple chains pointing to the same
 902  *        bref where some are deleted and some are not (for example due to
 903  *        a rename).   So a chain marked for deletion is basically considered
 904  *        to be live until it is explicitly destroyed or until its ref-count
 905  *        reaches zero (also implying that MOVED and MODIFIED are clear).
 906  */
 907 static int
 908 hammer2_chain_flush_scan2(hammer2_chain_t *child, void *data)
 909 {
 910         hammer2_flush_info_t *info = data;
 911         hammer2_chain_t *parent = info->parent;
 912         hammer2_chain_core_t *above = child->above;
 913         hammer2_mount_t *hmp = info->hmp;
 914         hammer2_trans_t *trans = info->trans;
 915         hammer2_blockref_t *base;
 916         int count;
 917
 918         /*
 919          * Inodes with stale children that have been converted to DIRECTDATA
 920          * mode (file extension or hardlink conversion typically) need to
 921          * skipped right now before we start messing with a non-existant
 922          * block table.
 923          */
 924 #if 0
 925         if (parent->bref.type == HAMMER2_BREF_TYPE_INODE &&
 926             (parent->data->ipdata.op_flags & HAMMER2_OPFLAG_DIRECTDATA)) {
 927 #if FLUSH_DEBUG
 928                 kprintf("B");
 929 #endif
 930                 goto finalize;
 931         }
 932 #endif
 933
 934         /*
 935          * Ignore children created after our flush point, treating them as
 936          * if they did not exist).  These children will not cause the parent
 937          * to be updated.
 938          *
 939          * When we encounter such children and the parent chain has not been
 940          * deleted, delete/duplicated, or delete/duplicated-for-move, then
 941          * the parent may be used to funnel through several flush points.
 942          * We must re-set the SUBMODIFIED flag in the parent to ensure that
 943          * those flushes have visbility.  A simple test of delete_tid suffices
 944          * to determine if the parent spans beyond our current flush.
 945          */
 946         if (child->modify_tid > trans->sync_tid) {
 947 #if FLUSH_DEBUG
 948                 kprintf("E");
 949 #endif
 950                 goto finalize;
 951         }
 952
 953         /*
 954          * Ignore children which have not changed.  The parent's block table
 955          * is already correct.
 956          */
 957         if ((child->flags & HAMMER2_CHAIN_MOVED) == 0) {
 958 #if FLUSH_DEBUG
 959                 kprintf("D");
 960 #endif
 961                 goto finalize;
 962         }
 963
 964
 965         hammer2_chain_ref(child);
 966         spin_unlock(&above->cst.spin);
 967
 968         /*
 969          * The MOVED bit implies an additional reference which prevents
 970          * the child from being destroyed out from under our operation
 971          * so we can lock the child safely without worrying about it
 972          * getting ripped up (?).
 973          *
 974          * We can only update parents where child->parent matches.  The
 975          * child->parent link will migrate along the chain but the flush
 976          * order must be enforced absolutely.  Parent reflushed after the
 977          * child has passed them by should skip due to the modify_tid test.
 978          */
 979         hammer2_chain_lock(child, HAMMER2_RESOLVE_NEVER);
 980
 981         /*
 982          * The parent's blockref to the child must be deleted or updated.
 983          *
 984          * This point is not reached on successful DESTROYED optimizations
 985          * but can be reached on recursive deletions and restricted flushes.
 986          *
 987          * Because flushes are ordered we do not have to make a
 988          * modify/duplicate of indirect blocks.  That is, the flush
 989          * code does not have to kmalloc or duplicate anything.  We
 990          * can adjust the indirect block table in-place and reuse the
 991          * chain.  It IS possible that the chain has already been duplicated
 992          * or may wind up being duplicated on-the-fly by modifying code
 993          * on the frontend.  We simply use the original and ignore such
 994          * chains.  However, it does mean we can't clear the MOVED bit.
 995          *
 996          * XXX recursive deletions not optimized.
 997          */
 998         hammer2_chain_modify(trans, &parent,
 999                              HAMMER2_MODIFY_NO_MODIFY_TID |
1000                              HAMMER2_MODIFY_ASSERTNOCOPY);
1001
1002         switch(parent->bref.type) {
1003         case HAMMER2_BREF_TYPE_INODE:
1004                 /*
1005                  * XXX Should assert that OPFLAG_DIRECTDATA is 0 once we
1006                  * properly duplicate the inode headers and do proper flush
1007                  * range checks (all the children should be beyond the flush
1008                  * point).  For now just don't sync the non-applicable
1009                  * children.
1010                  *
1011                  * XXX Can also occur due to hardlink consolidation.  We
1012                  * set OPFLAG_DIRECTDATA to prevent the indirect and data
1013                  * blocks from syncing ot the hardlink pointer.
1014                  */
1015 #if 0
1016                 KKASSERT((parent->data->ipdata.op_flags &
1017                           HAMMER2_OPFLAG_DIRECTDATA) == 0);
1018 #endif
1019 #if 0
1020                 if (parent->data->ipdata.op_flags &
1021                     HAMMER2_OPFLAG_DIRECTDATA) {
1022                         base = NULL;
1023                 } else
1024 #endif
1025                 {
1026                         base = &parent->data->ipdata.u.blockset.blockref[0];
1027                         count = HAMMER2_SET_COUNT;
1028                 }
1029                 break;
1030         case HAMMER2_BREF_TYPE_INDIRECT:
1031         case HAMMER2_BREF_TYPE_FREEMAP_NODE:
1032                 if (parent->data) {
1033                         base = &parent->data->npdata.blockref[0];
1034                 } else {
1035                         base = NULL;
1036                         KKASSERT(child->flags & HAMMER2_CHAIN_DELETED);
1037                 }
1038                 count = parent->bytes / sizeof(hammer2_blockref_t);
1039                 break;
1040         case HAMMER2_BREF_TYPE_VOLUME:
1041                 base = &hmp->voldata.sroot_blockset.blockref[0];
1042                 count = HAMMER2_SET_COUNT;
1043                 break;
1044         case HAMMER2_BREF_TYPE_FREEMAP:
1045                 base = &parent->data->npdata.blockref[0];
1046                 count = HAMMER2_SET_COUNT;
1047                 break;
1048         default:
1049                 base = NULL;
1050                 count = 0;
1051                 panic("hammer2_chain_get: "
1052                       "unrecognized blockref type: %d",
1053                       parent->bref.type);
1054         }
1055
1056         /*
1057          * Update the parent's blockref table and propagate mirror_tid.
1058          *
1059          * NOTE! Children with modify_tid's beyond our flush point are
1060          *       considered to not exist for the purposes of updating the
1061          *       parent's blockref array.
1062          *
1063          * NOTE! Updates to a parent's blockref table do not adjust the
1064          *       parent's bref.modify_tid, only its bref.mirror_tid.
1065          */
1066         KKASSERT(child->index >= 0);
1067         if (child->delete_tid <= trans->sync_tid) {
1068                 if (base) {
1069                         KKASSERT(child->index < count);
1070                         bzero(&base[child->index], sizeof(child->bref));
1071                         if (info->mirror_tid < child->delete_tid)
1072                                 info->mirror_tid = child->delete_tid;
1073                 }
1074         } else {
1075                 if (base) {
1076                         KKASSERT(child->index < count);
1077                         base[child->index] = child->bref;
1078                         if (info->mirror_tid < child->modify_tid)
1079                                 info->mirror_tid = child->modify_tid;
1080                 }
1081         }
1082
1083         if (info->mirror_tid < child->bref.mirror_tid) {
1084                 info->mirror_tid = child->bref.mirror_tid;
1085         }
1086         if ((parent->bref.type == HAMMER2_BREF_TYPE_VOLUME ||
1087              parent->bref.type == HAMMER2_BREF_TYPE_FREEMAP) &&
1088             hmp->voldata.mirror_tid < child->bref.mirror_tid) {
1089                 hmp->voldata.mirror_tid = child->bref.mirror_tid;
1090         }
1091
1092         /*
1093          * When can we safely clear the MOVED flag?  Flushes down duplicate
1094          * paths can occur out of order, for example if an inode is moved
1095          * as part of a hardlink consolidation or if an inode is moved into
1096          * an indirect block indexed before the inode.
1097          *
1098          * Only clear MOVED once all possible parents have been flushed.
1099          */
1100         if (child->flags & HAMMER2_CHAIN_MOVED) {
1101                 hammer2_chain_t *scan;
1102                 int ok = 1;
1103
1104                 spin_lock(&above->cst.spin);
1105                 for (scan = above->first_parent;
1106                      scan;
1107                      scan = scan->next_parent) {
1108                         /*
1109                          * XXX weird code also checked at the top of scan2,
1110                          *     I would like to fix this by detaching the core
1111                          *     on initial hardlink consolidation (1->2 nlinks).
1112                          */
1113 #if 0
1114                         if (scan->bref.type == HAMMER2_BREF_TYPE_INODE &&
1115                             (scan->data->ipdata.op_flags &
1116                              HAMMER2_OPFLAG_DIRECTDATA)) {
1117                                 continue;
1118                         }
1119 #endif
1120                         if (scan->flags & HAMMER2_CHAIN_SUBMODIFIED) {
1121                                 ok = 0;
1122                                 break;
1123                         }
1124                 }
1125                 spin_unlock(&above->cst.spin);
1126                 if (ok) {
1127                         atomic_clear_int(&child->flags, HAMMER2_CHAIN_MOVED);
1128                         hammer2_chain_drop(child);      /* flag */
1129                 }
1130         }
1131
1132         /*
1133          * Unlock the child.  This can wind up dropping the child's
1134          * last ref, removing it from the parent's RB tree, and deallocating
1135          * the structure.  The RB_SCAN() our caller is doing handles the
1136          * situation.
1137          */
1138         hammer2_chain_unlock(child);
1139         hammer2_chain_drop(child);
1140         spin_lock(&above->cst.spin);
1141 #if FLUSH_DEBUG
1142         kprintf("F");
1143 #endif
1144
1145         /*
1146          * The parent cleared SUBMODIFIED prior to the scan.  If the child
1147          * still requires a flush (possibly due to being outside the current
1148          * synchronization zone), we must re-set SUBMODIFIED on the way back
1149          * up.
1150          */
1151 finalize:
1152 #if FLUSH_DEBUG
1153         kprintf("G child %p 08x\n", child, child->flags);
1154 #endif
1155         return (0);
1156 }