Lines Matching full:allocation
19 * SERIALIZATION of the Block Allocation Map.
21 * the working state of the block allocation map is accessed in
24 * 1) allocation and free requests that start at the dmap
28 * 2) allocation requests that start at dmap control page
46 * the working state of the block allocation map also includes read/
48 * free block count, allocation group level free block counts).
53 * accesses to the persistent state of the block allocation map (limited
139 * FUNCTION: initializate the block allocation map.
252 * FUNCTION: terminate the block allocation map in preparation for
341 * allocation map.
430 * FUNCTION: update the allocation state (free or allocate) of the
431 * specified block range in the persistent block allocation map.
607 * FUNCTION: find the preferred allocation group for new allocations.
609 * Within the allocation groups, we maintain a preferred
610 * allocation group which consists of a group with at least
612 * new inode allocation towards. The tie-in between inode
613 * allocation and block allocation occurs as we allocate the
615 * as the allocation hint for this block.
618 * an allocation group, as this will lead to fragmentation.
626 * the preferred allocation group number.
691 * blocks from the working allocation block map.
693 * the block allocation policy uses hints and a multi-step
696 * for allocation requests smaller than the number of blocks
703 * if no blocks are available in the dmap or the allocation
705 * within the same allocation group as contains the hint. if
710 * for allocation requests larger than the allocation group
715 * hint - allocation hint.
757 * allocation group size, try to allocate anywhere. in dbAlloc()
768 * If no hint, let dbNextAG recommend an allocation group in dbAlloc()
784 /* check if blkno crosses over into a new allocation group. in dbAlloc()
786 * allocation group. in dbAlloc()
796 /* check if the allocation request size can be satisfied from a in dbAlloc()
813 /* first, try to satisfy the allocation request with the in dbAlloc()
831 * Someone else is writing in this allocation in dbAlloc()
839 /* next, try to satisfy the allocation request with blocks in dbAlloc()
852 /* try to satisfy the allocation request with blocks within in dbAlloc()
868 /* try to satisfy the allocation request with blocks within in dbAlloc()
869 * the same allocation group as the hint. in dbAlloc()
880 * Let dbNextAG recommend a preferred allocation group in dbAlloc()
885 /* Try to allocate within this allocation group. if that fails, try to in dbAlloc()
934 * allocation request size must be satisfied from a single dmap. in dbAllocExact()
973 * FUNCTION: attempt to extend a current allocation by a specified
976 * this routine attempts to satisfy the allocation request
977 * by first trying to extend the existing allocation in
979 * immediately following the current allocation. if these
982 * to cover the existing allocation plus the additional
986 * ip - pointer to in-core inode requiring allocation.
987 * blkno - starting block of the current allocation.
989 * allocation.
990 * addnblocks - number of blocks to add to the allocation.
992 * of the existing allocation if the existing allocation
994 * range if the existing allocation could not be extended
1008 /* try to extend the allocation in place. in dbReAlloc()
1018 /* could not extend the allocation in place, so allocate a in dbReAlloc()
1021 * existing allocation plus the additional blocks.) in dbReAlloc()
1031 * FUNCTION: attempt to extend a current allocation by a specified
1034 * this routine attempts to satisfy the allocation request
1035 * by first trying to extend the existing allocation in
1037 * immediately following the current allocation.
1040 * ip - pointer to in-core inode requiring allocation.
1041 * blkno - starting block of the current allocation.
1043 * allocation.
1044 * addnblocks - number of blocks to add to the allocation.
1069 /* get the last block of the current allocation */ in dbExtend()
1073 * the existing allocation. in dbExtend()
1087 /* we'll attempt to extend the current allocation in place by in dbExtend()
1089 * following the current allocation. we only try to extend the in dbExtend()
1090 * current allocation in place if the number of additional blocks in dbExtend()
1091 * can fit into a dmap, the last block of the current allocation in dbExtend()
1093 * inplace extension is not on an allocation group boundary. in dbExtend()
1114 * current allocation. in dbExtend()
1340 * free blocks within the specified allocation group.
1342 * unless the allocation group size is equal to the number
1346 * distinctly describes the allocation group's free space
1347 * (i.e. the highest level at which the allocation group's
1351 * describe the allocation group's free space. at this height,
1352 * the allocation group's free space may be represented by 1
1353 * or two sub-trees, depending on the allocation group size.
1363 * if the allocation group size is equal to the dmap size,
1364 * we'll start at the dmap corresponding to the allocation
1365 * group and attempt the allocation at this level.
1368 * allocation group is completely free and we go to the first
1369 * dmap of the allocation group to do the allocation. this is
1370 * done because the allocation group may be part (not the first
1373 * the allocation group.
1377 * agno - allocation group number.
1399 /* allocation request should not be for more than the in dbAllocAG()
1400 * allocation group size. in dbAllocAG()
1404 "allocation request is larger than the allocation group size\n"); in dbAllocAG()
1408 /* determine the starting block number of the allocation in dbAllocAG()
1413 /* check if the allocation group size is the minimum allocation in dbAllocAG()
1414 * group size or if the allocation group is completely free. if in dbAllocAG()
1415 * the allocation group size is the minimum size of BPERDMAP (i.e. in dbAllocAG()
1417 * that fully describes the allocation group since the allocation in dbAllocAG()
1422 * if the allocation group is completely free, dbAllocCtl() is in dbAllocAG()
1426 * the dmap control pages may indicate that the allocation group in dbAllocAG()
1427 * has no free space if the allocation group is part (not the first in dbAllocAG()
1445 * allocation group. in dbAllocAG()
1461 * the allocation group, looking for sufficient free space. to begin, in dbAllocAG()
1462 * determine how many allocation groups are represented in a dmap in dbAllocAG()
1464 * fully describes an allocation group. next, determine the starting in dbAllocAG()
1465 * tree index of this allocation group within the control page. in dbAllocAG()
1471 /* dmap control page trees fan-out by 4 and a single allocation in dbAllocAG()
1554 /* no space in the allocation group. release the buffer and in dbAllocAG()
1729 * contiguous free blocks large enough to satisfy an allocation
1842 * specifically, this occurs when allocating from an allocation
1858 * blkno - starting block number of the dmap to start the allocation
1878 /* check if the allocation request is confined to a single dmap. in dbAllocCtl()
1900 /* allocation request involving multiple dmaps. it must start on in dbAllocCtl()
1949 /* something failed in handling an allocation request involving in dbAllocCtl()
1951 * allocation that has already happened for this request. if in dbAllocCtl()
1952 * we fail in backing out the allocation, we'll mark the file in dbAllocCtl()
2064 * FUNCTION: adjust the disk allocation map to reflect the allocation
2068 * through a call to dbAllocBits(). if the allocation of the
2108 * backout the bit allocation (thus making everything consistent). in dbAllocDmap()
2120 * FUNCTION: adjust the disk allocation map to reflect the allocation
2189 * state allocation of the specified block range. it directly
2294 /* update the leaf to reflect the allocation. in dbAllocBits()
2298 * allocation (size). in dbAllocBits()
2314 /* if this allocation group is completely free, in dbAllocBits()
2315 * update the maximum allocation group number if this allocation in dbAllocBits()
2322 /* update the free count for the allocation group and map */ in dbAllocBits()
2336 * state allocation of the specified block range. it directly
2458 /* update the free count for the allocation group and in dbFreeBits()
2465 /* check if this allocation group is not completely free and in dbFreeBits()
2466 * if it is currently the maximum (rightmost) allocation group. in dbFreeBits()
2467 * if so, establish the new maximum allocation group number by in dbFreeBits()
2468 * searching left for the first allocation group with allocation. in dbFreeBits()
2480 /* re-establish the allocation group preference if the in dbFreeBits()
2481 * current preference is right of the maximum allocation in dbFreeBits()
2500 * of the lower level object's dmtree) due to the allocation
2505 * starting block number of the block range whose allocation
2521 * the allocation or deallocation of this block range that
2525 * alloc - 'true' if adjustment is due to an allocation.
2572 /* check if this is a control page update for an allocation. in dbAdjCtl()
2585 * first allocation out of an allocation group that in dbAdjCtl()
2735 * any required splits. in some cases, however, allocation
2740 * is required are rare and are limited to the first allocation
2741 * within an allocation group which is a part (not first part)
3233 * allocation map.
3377 /* if this allocation group is completely free, in dbAllocDmapBU()
3378 * update the highest active allocation group number in dbAllocDmapBU()
3379 * if this allocation group is the new max. in dbAllocDmapBU()
3385 /* update the free count for the allocation group and map */ in dbAllocDmapBU()
3397 * backout the bit allocation (thus making everything consistent). in dbAllocDmapBU()
3716 /* determine how many blocks are in the inactive allocation in dbFinalizeBmap()
3726 * allocation groups plus the average number of free blocks in dbFinalizeBmap()
3732 /* if the preferred allocation group has not average free space. in dbFinalizeBmap()
4036 * FUNCTION: Determine log2(allocation group size) from aggregate size
4041 * RETURNS: log2(allocation group size) in aggregate blocks
4071 * FUNCTION: compute number of blocks the block allocation map file