57 		 * scrub so that we can tell userspace if we fixed the problem.  in xrep_attempt()
70 		 * We tried harder but still couldn't grab all the resources  in xrep_attempt()
71 		 * we needed to fix it.  The corruption has not been fixed,  in xrep_attempt()
81  * Complain about unfixable problems in the filesystem.  We don't log
98  * Repair probe -- userspace uses this to probe if we're willing to repair a
123 	/* Keep the AG header buffers locked so we can keep going. */  in xrep_roll_ag_trans()
132 	 * Roll the transaction.  We still own the buffer and the buffer lock  in xrep_roll_ag_trans()
135 	 * kernel.  If it succeeds, we join them to the new transaction and  in xrep_roll_ag_trans()
155  * reservation can be critical, and we must have enough space (factoring
170  * Figure out how many blocks to reserve for an AG repair.  We calculate the
171  * worst case estimate for the number of blocks we'd need to rebuild one of
242 	 * Figure out how many blocks we'd need worst case to rebuild  in xrep_calc_ag_resblks()
243 	 * each type of btree.  Note that we can only rebuild the  in xrep_calc_ag_resblks()
261 		 * Guess how many blocks we need to rebuild the rmapbt.  in xrep_calc_ag_resblks()
262 		 * For non-reflink filesystems we can't have more records than  in xrep_calc_ag_resblks()
264 		 * more than one rmap record per AG block.  We don't know how  in xrep_calc_ag_resblks()
265 		 * many rmaps there could be in the AG, so we start off with  in xrep_calc_ag_resblks()
266 		 * what we hope is an generous over-estimation.  in xrep_calc_ag_resblks()
370  * When a space btree is corrupt, we don't bother trying to fix it.  Instead,
371  * we scan secondary space metadata to derive the records that should be in
373  * Note that for rebuilding the rmapbt we scan all the primary data to
377  * old broken structure.  For primary metadata we use the rmap data to collect
378  * every extent with a matching rmap owner (bitmap); we then iterate all other
380  * cannot be removed (sublist).  We then subtract sublist from bitmap to
384  * For rmapbt reconstructions we must use different tactics for extent
385  * collection.  First we iterate all primary metadata (this excludes the old
388  * sublist.  As with the other btrees we subtract sublist from bitmap, and the
394  * Now that we've constructed a new btree to replace the damaged one, we want
395  * to dispose of the blocks that (we think) the old btree was using.
396  * Previously, we used the rmapbt to collect the extents (bitmap) with the
397  * rmap owner corresponding to the tree we rebuilt, collected extents for any
407  * If there is one rmap record, we can free the block, which removes the
413  * If there are no rmap records at all, we also free the block.  If the btree
420  * the btree we're trying to rebuild and the block is indeed owned by another
428  * we're not looking.  We also assume that the caller already invalidated any
433  * Invalidate buffers for per-AG btree blocks we're dumping.  This function
434  * is not intended for use with file data repairs; we have bunmapi for that.
449 	 * lets us look for one buffer at a time, so we have to look one block  in xrep_invalidate_blocks()
451 	 * because we never own those; and if we can't TRYLOCK the buffer we  in xrep_invalidate_blocks()
504 	 * Since we're "freeing" a lost block onto the AGFL, we have to  in xrep_put_freelist()
543 	 * If we are repairing per-inode metadata, we need to read in the AGF  in xrep_reap_block()
544 	 * buffer.  Otherwise, we're repairing a per-AG structure, so reuse  in xrep_reap_block()
556 	/* Can we find any other rmappings? */  in xrep_reap_block()
565 	 * we were the only owner of the block, so free the extent, which will  in xrep_reap_block()
570 	 * because the buffer cache doesn't detect aliasing problems, so we  in xrep_reap_block()
647  * level higher than what we've already seen, remember the block and the
649  * we return the highest block we've found for each btree description; those
692 	 * have a matching magic and uuid.  We don't want to pull these blocks  in xrep_findroot_block()
693 	 * in as part of a tree root, so we have to filter out the AGFL stuff  in xrep_findroot_block()
694 	 * here.  If the AGFL looks insane we'll just refuse to repair.  in xrep_findroot_block()
706 	 * Read the buffer into memory so that we can see if it's a match for  in xrep_findroot_block()
707 	 * our btree type.  We have no clue if it is beforehand, and we want to  in xrep_findroot_block()
719 	 * Note: If we never match a btree type with this buffer, it will be  in xrep_findroot_block()
728 	/* Ensure the block magic matches the btree type we're looking for. */  in xrep_findroot_block()
736 	 * this btree type, we know this block doesn't match the btree and we  in xrep_findroot_block()
740 	 * the block for us, so we can move on to checking if this is a root  in xrep_findroot_block()
745 	 * and structure match this btree type then we'll move on to checking  in xrep_findroot_block()
757 		 * Read verifiers can reference b_ops, so we set the pointer  in xrep_findroot_block()
758 		 * here.  If the verifier fails we'll reset the buffer state  in xrep_findroot_block()
759 		 * to what it was before we touched the buffer.  in xrep_findroot_block()
770 		 * Some read verifiers will (re)set b_ops, so we must be  in xrep_findroot_block()
777 	 * type.  We don't need the caller to try the other tree types.  in xrep_findroot_block()
785 	 * If the level matches the root we found previously, throw away both  in xrep_findroot_block()
788 	 * If level is lower in the tree than the root we found previously,  in xrep_findroot_block()
800 	 * This is the highest block in the tree that we've found so far.  in xrep_findroot_block()
801 	 * Update the btree height to reflect what we've learned from this  in xrep_findroot_block()
825  * Do any of the blocks in this rmap record match one of the btrees we're
898 /* Force a quotacheck the next time we mount. */
921  * We cannot allow the dquot code to allocate an on-disk dquot block here
922  * because we're already in transaction context with the inode locked.  The