65 		 * scrub so that we can tell userspace if we fixed the problem.  in xrep_attempt()
83 		 * We tried harder but still couldn't grab all the resources  in xrep_attempt()
84 		 * we needed to fix it.  The corruption has not been fixed,  in xrep_attempt()
90 		 * EAGAIN tells the caller to re-scrub, so we cannot return  in xrep_attempt()
99  * Complain about unfixable problems in the filesystem.  We don't log
116  * Repair probe -- userspace uses this to probe if we're willing to repair a
142 	 * Keep the AG header buffers locked while we roll the transaction.  in xrep_roll_ag_trans()
143 	 * Ensure that both AG buffers are dirty and held when we roll the  in xrep_roll_ag_trans()
161 	 * Roll the transaction.  We still hold the AG header buffers locked  in xrep_roll_ag_trans()
187 	 * Keep the AG header buffers locked while we complete deferred work  in xrep_defer_finish()
188 	 * items.  Ensure that both AG buffers are dirty and held when we roll  in xrep_defer_finish()
206 	 * Finish all deferred work items.  We still hold the AG header buffers  in xrep_defer_finish()
217 	 * Release the hold that we set above because defer_finish won't do  in xrep_defer_finish()
231  * reservation can be critical, and we must have enough space (factoring
246  * Figure out how many blocks to reserve for an AG repair.  We calculate the
247  * worst case estimate for the number of blocks we'd need to rebuild one of
319 	 * Figure out how many blocks we'd need worst case to rebuild  in xrep_calc_ag_resblks()
320 	 * each type of btree.  Note that we can only rebuild the  in xrep_calc_ag_resblks()
338 		 * Guess how many blocks we need to rebuild the rmapbt.  in xrep_calc_ag_resblks()
339 		 * For non-reflink filesystems we can't have more records than  in xrep_calc_ag_resblks()
341 		 * more than one rmap record per AG block.  We don't know how  in xrep_calc_ag_resblks()
342 		 * many rmaps there could be in the AG, so we start off with  in xrep_calc_ag_resblks()
343 		 * what we hope is an generous over-estimation.  in xrep_calc_ag_resblks()
363  * When a space btree is corrupt, we don't bother trying to fix it.  Instead,
364  * we scan secondary space metadata to derive the records that should be in
366  * Note that for rebuilding the rmapbt we scan all the primary data to
370  * old broken structure.  For primary metadata we use the rmap data to collect
371  * every extent with a matching rmap owner (bitmap); we then iterate all other
373  * cannot be removed (sublist).  We then subtract sublist from bitmap to
377  * For rmapbt reconstructions we must use different tactics for extent
378  * collection.  First we iterate all primary metadata (this excludes the old
381  * sublist.  As with the other btrees we subtract sublist from bitmap, and the
425  * level higher than what we've already seen, remember the block and the
427  * we return the highest block we've found for each btree description; those
470 	 * have a matching magic and uuid.  We don't want to pull these blocks  in xrep_findroot_block()
471 	 * in as part of a tree root, so we have to filter out the AGFL stuff  in xrep_findroot_block()
472 	 * here.  If the AGFL looks insane we'll just refuse to repair.  in xrep_findroot_block()
484 	 * Read the buffer into memory so that we can see if it's a match for  in xrep_findroot_block()
485 	 * our btree type.  We have no clue if it is beforehand, and we want to  in xrep_findroot_block()
497 	 * Note: If we never match a btree type with this buffer, it will be  in xrep_findroot_block()
506 	/* Ensure the block magic matches the btree type we're looking for. */  in xrep_findroot_block()
514 	 * this btree type, we know this block doesn't match the btree and we  in xrep_findroot_block()
518 	 * the block for us, so we can move on to checking if this is a root  in xrep_findroot_block()
523 	 * and structure match this btree type then we'll move on to checking  in xrep_findroot_block()
535 		 * Read verifiers can reference b_ops, so we set the pointer  in xrep_findroot_block()
536 		 * here.  If the verifier fails we'll reset the buffer state  in xrep_findroot_block()
537 		 * to what it was before we touched the buffer.  in xrep_findroot_block()
548 		 * Some read verifiers will (re)set b_ops, so we must be  in xrep_findroot_block()
555 	 * type.  We don't need the caller to try the other tree types.  in xrep_findroot_block()
563 	 * If the level matches the root we found previously, throw away both  in xrep_findroot_block()
566 	 * If level is lower in the tree than the root we found previously,  in xrep_findroot_block()
578 	 * This is the highest block in the tree that we've found so far.  in xrep_findroot_block()
579 	 * Update the btree height to reflect what we've learned from this  in xrep_findroot_block()
603  * Do any of the blocks in this rmap record match one of the btrees we're
676 /* Force a quotacheck the next time we mount. */
701  * We cannot allow the dquot code to allocate an on-disk dquot block here
702  * because we're already in transaction context with the inode locked.  The