Lines Matching defs:order
134 * 1) Array of largest free order lists (sbi->s_mb_largest_free_orders)
139 * largest free order in the buddy bitmap of the participating group infos of
155 * structures to decide the order in which groups are to be traversed for
159 * >= the order of the request. We directly look at the largest free order list
160 * in the data structure (1) above where largest_free_order = order of the
162 * order of largest_free_order. This allows us to perform CR_POWER2_ALIGNED
181 * linear order which requires O(N) search time for each CR_POWER2_ALIGNED and
192 * 2 blocks and the order of allocation is >= sbi->s_mb_order2_reqs. The
526 static void *mb_find_buddy(struct ext4_buddy *e4b, int order, int *max)
533 if (order > e4b->bd_blkbits + 1) {
538 /* at order 0 we see each particular block */
539 if (order == 0) {
544 bb = e4b->bd_buddy + EXT4_SB(e4b->bd_sb)->s_mb_offsets[order];
545 *max = EXT4_SB(e4b->bd_sb)->s_mb_maxs[order];
683 int order = e4b->bd_blkbits + 1;
700 while (order > 1) {
701 buddy = mb_find_buddy(e4b, order, &max);
703 buddy2 = mb_find_buddy(e4b, order - 1, &max2);
724 for (j = 0; j < (1 << order); j++) {
725 k = (i * (1 << order)) + j;
731 MB_CHECK_ASSERT(e4b->bd_info->bb_counters[order] == count);
732 order--;
823 int order;
829 order = fls(len) - 2;
830 if (order < 0)
832 if (order == MB_NUM_ORDERS(sb))
833 order--;
834 return order;
912 * Find a suitable group of given order from the average fragments list.
915 ext4_mb_find_good_group_avg_frag_lists(struct ext4_allocation_context *ac, int order)
918 struct list_head *frag_list = &sbi->s_mb_avg_fragment_size[order];
919 rwlock_t *frag_list_lock = &sbi->s_mb_avg_fragment_size_locks[order];
944 * order. Updates *new_cr if cr level needs an update.
984 * order we have and proactively trim the goal request length to that order to
996 int i, order, min_order;
1005 * mb_avg_fragment_size_order() returns order in a way that makes
1006 * retrieving back the length using (1 << order) inaccurate. Hence, use
1010 order = fls(ac->ac_g_ex.fe_len) - 1;
1011 min_order = order - sbi->s_mb_best_avail_max_trim_order;
1023 * We consider 1 order less because later we round
1032 for (i = order; i >= min_order; i--) {
1142 * Cache the order of the largest free extent we have available in this block
1154 /* No need to move between order lists? */
1238 int order = 1;
1241 while ((buddy = mb_find_buddy(e4b, order++, &count)))
1740 int order = 1, max;
1746 while (order <= e4b->bd_blkbits + 1) {
1747 bb = mb_find_buddy(e4b, order, &max);
1748 if (!mb_test_bit(block >> order, bb)) {
1749 /* this block is part of buddy of order 'order' */
1750 return order;
1752 order++;
1837 int order = 1;
1838 void *buddy = mb_find_buddy(e4b, order, &max);
1849 * single bit of highest order buddy.
1873 e4b->bd_info->bb_counters[order] += mb_buddy_adjust_border(&first, buddy, -1);
1875 e4b->bd_info->bb_counters[order] += mb_buddy_adjust_border(&last, buddy, 1);
1878 order++;
1880 buddy2 = mb_find_buddy(e4b, order, &max);
1883 e4b->bd_info->bb_counters[order - 1] += last - first + 1;
1958 * zero order checks.
1984 int max, order;
2000 /* find actual order */
2001 order = mb_find_order_for_block(e4b, block);
2002 block = block >> order;
2004 ex->fe_len = 1 << order;
2005 ex->fe_start = block << order;
2014 mb_find_buddy(e4b, order, &max)) {
2019 next = (block + 1) * (1 << order);
2023 order = mb_find_order_for_block(e4b, next);
2025 block = next >> order;
2026 ex->fe_len += 1 << order;
2034 "block=%d, order=%d needed=%d ex=%u/%d/%d@%u",
2035 block, order, needed, ex->fe_group, ex->fe_start,
2388 * The routine scans buddy structures (not bitmap!) from given order
2389 * to max order and tries to find big enough chunk to satisfy the req
2415 "%d free clusters of order %d. But found 0",
2442 * In order to optimize scanning, caller must pass number of
2827 * We search using buddy data only if the order of the request
3602 /* order 0 is regular bitmap */
4576 /* define goal start in order to merge */
4793 int order, i;
4957 order = fls(ac->ac_o_ex.fe_len) - 1;
4958 if (order > PREALLOC_TB_SIZE - 1)
4960 order = PREALLOC_TB_SIZE - 1;
4967 for (i = order; i < PREALLOC_TB_SIZE; i++) {
5860 int order, int total_entries)
5870 list_for_each_entry_rcu(pa, &lg->lg_prealloc_list[order],
5943 int order, added = 0, lg_prealloc_count = 1;
5948 order = fls(pa->pa_free) - 1;
5949 if (order > PREALLOC_TB_SIZE - 1)
5951 order = PREALLOC_TB_SIZE - 1;
5954 list_for_each_entry_rcu(tmp_pa, &lg->lg_prealloc_list[order],
5977 &lg->lg_prealloc_list[order]);
5983 order, lg_prealloc_count);