24  *	1) allocation and free requests that start at the dmap
48  *	free block count, allocation group level free block counts).
115  * binary buddy of free bits within the character.
281 	/* free the memory for the in-memory bmap. */  in dbUnmount()
344  * FUNCTION:	free the specified block range from the working block
347  *		the blocks will be free from the working map one dmap
389 	 * free the blocks a dmap at a time.  in dbFree()
412 		/* free the blocks. */  in dbFree()
434  * FUNCTION:	update the allocation state (free or allocate) of the
442  *	free	- 'true' if block range is to be freed from the persistent
454 	     int free, s64 blkno, s64 nblocks, struct tblock * tblk)  in dbUpdatePMap()  argument
527 				/* update (free or allocate) the bits  in dbUpdatePMap()
532 				if (free)  in dbUpdatePMap()
548 				/* update (free or allocate) the bits  in dbUpdatePMap()
551 				if (free)  in dbUpdatePMap()
615  *		average free space.  It is the preferred group that we target
643 	/* determine the average number of free blocks within the ags. */  in dbNextAG()
656 	 * average free space.  in dbNextAG()
694  * FUNCTION:	attempt to allocate a specified number of contiguous free
779 	 * will start looking for free space starting at this point.  in dbAlloc()
795 		 * AG with sufficient free space.  in dbAlloc()
1077  *	nblocks	-  number of contiguous free blocks of the range.
1116 	 * is free.  in dbAllocNext()
1122 	 * if the block range is free.  not all bits of the first and  in dbAllocNext()
1126 	 * the actual bits to determine if they are free.  a single pass  in dbAllocNext()
1129 	 * tree will be examined to determine if the blocks are free. a  in dbAllocNext()
1130 	 * single leaf may describe the free space of multiple dmap  in dbAllocNext()
1144 			/* check if the bits are free.  in dbAllocNext()
1160 			 * if the blocks are free.  in dbAllocNext()
1163 				/* does the leaf describe any free space ?  in dbAllocNext()
1193  * FUNCTION:	attempt to allocate a number of contiguous free blocks near
1197  *		check the next four contiguous leaves for sufficient free
1198  *		space.  if sufficient free space is found, we'll allocate
1199  *		the desired free space.
1205  *	nblocks	-  actual number of contiguous free blocks desired.
1206  *	l2nb	-  log2 number of contiguous free blocks desired.
1238 	/* examine the leaves for sufficient free space.  in dbAllocNear()
1241 		/* does the leaf describe sufficient free space ?  in dbAllocNear()
1251 		/* if not all bits of the dmap word are free, get the  in dbAllocNear()
1253 		 * string of free bits and adjust the block number with the  in dbAllocNear()
1276  *		free blocks within the specified allocation group.
1280  *		find the required free space, if available.  we start the
1282  *		distinctly describes the allocation group's free space
1284  *		free space is not mixed in with that of any other group).
1287  *		describe the allocation group's free space.  at this height,
1288  *		the allocation group's free space may be represented by 1
1291  *		sufficient free space.  if sufficient free space is found,
1293  *		has free space.  once we have made it to the leaf, we
1297  *		sufficient free space and we allocate at this dmap.
1304  *		allocation group is completely free and we go to the first
1308  *		control pages to indicate no free space (NOFREE) within
1314  *	nblocks	-  actual number of contiguous free blocks desired.
1315  *	l2nb	-  log2 number of contiguous free blocks desired.
1350 	 * group size or if the allocation group is completely free. if  in dbAllocAG()
1358 	 * if the allocation group is completely free, dbAllocCtl() is  in dbAllocAG()
1361 	 * pages for free space when we know that free space exists.  second,  in dbAllocAG()
1363 	 * has no free space if the allocation group is part (not the first  in dbAllocAG()
1375 				  "dbAllocCtl failed in free AG\n");  in dbAllocAG()
1397 	 * the allocation group, looking for sufficient free space.  to begin,  in dbAllocAG()
1410 	 * subtrees for sufficient free space, starting with the leftmost  in dbAllocAG()
1414 		/* is there sufficient free space ?  in dbAllocAG()
1419 		/* sufficient free space found in a subtree. now search down  in dbAllocAG()
1421 		 * free space.  in dbAllocAG()
1465 			 * contains or starts off the free space.  in dbAllocAG()
1503  *		free blocks anywhere in the file system.
1505  *		dbAllocAny() attempts to find the sufficient free space by
1507  *		highest level (i.e. L0, L1, L2) control page.  if free space
1508  *		large enough to satisfy the desired free space is found, the
1509  *		desired free space is allocated.
1513  *	nblocks	 -  actual number of contiguous free blocks desired.
1514  *	l2nb	 -  log2 number of contiguous free blocks desired.
1531 	 * down the dmap control levels for sufficient free space.  in dbAllocAny()
1532 	 * if free space is found, dbFindCtl() returns the starting  in dbAllocAny()
1534 	 * range of free space.  in dbAllocAny()
1553  * FUNCTION:	attempt to discard (TRIM) all free blocks of specific AG
1559  *		3) mark the blocks free again
1623 			/* the whole ag is free, trim now */  in dbDiscardAG()
1667  *		contiguous free blocks large enough to satisfy an allocation
1668  *		request for the specified number of free blocks.
1670  *		if sufficient contiguous free blocks are found, this routine
1672  *		contains or starts a range of contiqious free blocks that
1678  *	l2nb	-  log2 number of contiguous free blocks desired.
1681  *		   that contains or starts a range of contiguous free blocks.
1701 	 * sufficient free blocks.  in dbFindCtl()
1722 		 * sufficient free space.  if sufficient free space is found,  in dbFindCtl()
1724 		 * free space was found.  in dbFindCtl()
1744 		 * the dmap control page (i.e. the leaf) at which free  in dbFindCtl()
1771  *		free space.  the result of successful searches by these
1773  *		the dmaps themselves containing the desired contiguous free
1774  *		space or starting a contiguous free space of desired size
1787  *		upon the dmap's dmtree to find the requested contiguous free
1789  *		requested free space will start at the first block of the
1794  *	nblocks	 -  actual number of contiguous free blocks to allocate.
1795  *	l2nb	 -  log2 number of contiguous free blocks to allocate.
1859 		/* the dmap better be all free.  in dbAllocCtl()
1864 				  "the dmap is not all free\n");  in dbAllocCtl()
1916 		/* free the blocks is this dmap.  in dbAllocCtl()
1973 	 * free space.  if sufficient free space is found, dbFindLeaf()  in dbAllocDmapLev()
1974 	 * returns the index of the leaf at which free space was found.  in dbAllocDmapLev()
1983 	 * to the leaf at which free space was found.  in dbAllocDmapLev()
1987 	/* if not all bits of the dmap word are free, get the starting  in dbAllocDmapLev()
1988 	 * bit number within the dmap word of the required string of free  in dbAllocDmapLev()
2010  *		block range causes the maximum string of free blocks within
2035 	/* save the current value of the root (i.e. maximum free string)  in dbAllocDmap()
2066  *		causes the maximum string of free blocks within the dmap to
2074  *	dp	-  pointer to dmap to free the block range from.
2090 	/* save the current value of the root (i.e. maximum free string)  in dbFreeDmap()
2095 	/* free the specified (blocks) bits */  in dbFreeDmap()
2174 	 * dmap words will be marked as free in a single shot and the leaves  in dbAllocBits()
2175 	 * will be updated. a single leaf may describe the free space of  in dbAllocBits()
2250 	/* update the free count for this dmap */  in dbAllocBits()
2255 	/* if this allocation group is completely free,  in dbAllocBits()
2263 	/* update the free count for the allocation group and map */  in dbAllocBits()
2274  * FUNCTION:	free a specified block range from a dmap.
2285  *	dp	-  pointer to dmap to free bits from.
2311 	/* free the bits of the dmaps words corresponding to the block range.  in dbFreeBits()
2319 	 * be marked as free in a single shot and the leaves will be updated. a  in dbFreeBits()
2320 	 * single leaf may describe the free space of multiple dmap words,  in dbFreeBits()
2338 			/* free (zero) the appropriate bits within this  in dbFreeBits()
2356 			 * words and free (zero) the bits of these words.  in dbFreeBits()
2393 	/* update the free count for this dmap.  in dbFreeBits()
2399 	/* update the free count for the allocation group and  in dbFreeBits()
2406 	/* check if this allocation group is not completely free and  in dbFreeBits()
2440  *		maximum string of free blocks (i.e. a change in the root
2508 	 * maximum l2 free string described by this dmapctl).  in dbAdjCtl()
2596 			 * of the maximum free buddy system.  in dbAdjCtl()
2601 					  "the maximum free buddy is not the old root\n");  in dbAdjCtl()
2934  * FUNCTION:	search a dmtree_t for sufficient free blocks, returning
2935  *		the index of a leaf describing the free blocks if
2936  *		sufficient free blocks are found.
2940  *		free space.
2944  *	l2nb	- log2 number of free blocks to search for.
2946  *		  describing at least l2nb free blocks if sufficient
2947  *		  free blocks are found.
2952  *	-ENOSPC	- insufficient free blocks.
2963 	 * sufficient free space.  in dbFindLeaf()
2968 	/* sufficient free space available. now search down the tree  in dbFindLeaf()
2970 	 * describes sufficient free space.  in dbFindLeaf()
2978 			/* sufficient free space found.  move to the next  in dbFindLeaf()
2996 	 * free space.  in dbFindLeaf()
3007  * FUNCTION:	find a specified number of binary buddy free bits within a
3010  *		this routine searches the bitmap value for (1 << l2nb) free
3015  *	l2nb	-  number of free bits specified as a log2 number.
3018  *	starting bit number of free bits.
3031 	 * free bits) and compute the mask.  in dbFindBits()
3036 	/* scan the word for nb free bits at nb alignments.  in dbFindBits()
3054  * FUNCTION:	determine the largest binary buddy string of free
3061  *	largest binary buddy of free bits within a dmap word.
3067 	/* check if the wmap word is all free. if so, the  in dbMaxBud()
3068 	 * free buddy size is BUDMIN.  in dbMaxBud()
3073 	/* check if the wmap word is half free. if so, the  in dbMaxBud()
3074 	 * free buddy size is BUDMIN-1.  in dbMaxBud()
3079 	/* not all free or half free. determine the free buddy  in dbMaxBud()
3261 	/* save the current value of the root (i.e. maximum free string)  in dbAllocDmapBU()
3283 	 * dmap words will be marked as free in a single shot and the leaves  in dbAllocDmapBU()
3284 	 * will be updated. a single leaf may describe the free space of  in dbAllocDmapBU()
3320 	/* update the free count for this dmap */  in dbAllocDmapBU()
3328 	/* if this allocation group is completely free,  in dbAllocDmapBU()
3336 	/* update the free count for the allocation group and map */  in dbAllocDmapBU()
3659 	 * (the leftmost ag with average free space in it);  in dbFinalizeBmap()
3676 	/* determine how many free blocks are in the active  in dbFinalizeBmap()
3677 	 * allocation groups plus the average number of free blocks  in dbFinalizeBmap()
3683 	/* if the preferred allocation group has not average free space.  in dbFinalizeBmap()
3685 	 * group with average free space.  in dbFinalizeBmap()
3726  *		at entry, the bitmaps had been initialized as free (ZEROS);
3762 	 * free the bits corresponding to the block range (ZEROS):  in dbInitDmap()
3769 		/* number of bits to free in the word */  in dbInitDmap()
3774 			/* free (set to 0) from the bitmap word */  in dbInitDmap()
3783 			/* free (set to 0) contiguous bitmap words */  in dbInitDmap()
3835  *	treemax	- will be filled in with max free for this dmap
3837  * RETURNS:	max free string at the root of the tree
3883  * RETURNS: max free string at the root of the tree
3893 	/* Determine the maximum free string possible for the leaves */  in dbInitTree()
3901 	 * can be combined if both buddies have a maximum free of l2min;  in dbInitTree()
3903 	 * a maximum free of l2min+1.  in dbInitTree()
3906 	 * the next maximum free (current free + 1).  in dbInitTree()
3908 	 * yields maximum free.  in dbInitTree()
3919 			/* coalesce if both adjacent buddies are max free */  in dbInitTree()
3931 	 * the higher level parent node are compared for a maximum free and  in dbInitTree()