Lines Matching defs:ac
1478 static void ext4_mb_use_best_found(struct ext4_allocation_context *ac,
1481 struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
1484 BUG_ON(ac->ac_b_ex.fe_group != e4b->bd_group);
1485 BUG_ON(ac->ac_status == AC_STATUS_FOUND);
1487 ac->ac_b_ex.fe_len = min(ac->ac_b_ex.fe_len, ac->ac_g_ex.fe_len);
1488 ac->ac_b_ex.fe_logical = ac->ac_g_ex.fe_logical;
1489 ret = mb_mark_used(e4b, &ac->ac_b_ex);
1493 ac->ac_f_ex = ac->ac_b_ex;
1495 ac->ac_status = AC_STATUS_FOUND;
1496 ac->ac_tail = ret & 0xffff;
1497 ac->ac_buddy = ret >> 16;
1506 ac->ac_bitmap_page = e4b->bd_bitmap_page;
1507 get_page(ac->ac_bitmap_page);
1508 ac->ac_buddy_page = e4b->bd_buddy_page;
1509 get_page(ac->ac_buddy_page);
1510 /* on allocation we use ac to track the held semaphore */
1511 ac->alloc_semp = e4b->alloc_semp;
1514 if (ac->ac_flags & EXT4_MB_STREAM_ALLOC) {
1516 sbi->s_mb_last_group = ac->ac_f_ex.fe_group;
1517 sbi->s_mb_last_start = ac->ac_f_ex.fe_start;
1526 static void ext4_mb_check_limits(struct ext4_allocation_context *ac,
1530 struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
1531 struct ext4_free_extent *bex = &ac->ac_b_ex;
1532 struct ext4_free_extent *gex = &ac->ac_g_ex;
1536 if (ac->ac_status == AC_STATUS_FOUND)
1541 if (ac->ac_found > sbi->s_mb_max_to_scan &&
1542 !(ac->ac_flags & EXT4_MB_HINT_FIRST)) {
1543 ac->ac_status = AC_STATUS_BREAK;
1553 if ((finish_group || ac->ac_found > sbi->s_mb_min_to_scan)
1560 ext4_mb_use_best_found(ac, e4b);
1566 static void ext4_mb_measure_extent(struct ext4_allocation_context *ac,
1570 struct ext4_free_extent *bex = &ac->ac_b_ex;
1571 struct ext4_free_extent *gex = &ac->ac_g_ex;
1574 BUG_ON(ex->fe_len > EXT4_BLOCKS_PER_GROUP(ac->ac_sb));
1575 BUG_ON(ex->fe_start >= EXT4_BLOCKS_PER_GROUP(ac->ac_sb));
1576 BUG_ON(ac->ac_status != AC_STATUS_CONTINUE);
1578 ac->ac_found++;
1583 if (unlikely(ac->ac_flags & EXT4_MB_HINT_FIRST)) {
1585 ext4_mb_use_best_found(ac, e4b);
1594 ext4_mb_use_best_found(ac, e4b);
1622 ext4_mb_check_limits(ac, e4b, 0);
1626 int ext4_mb_try_best_found(struct ext4_allocation_context *ac,
1629 struct ext4_free_extent ex = ac->ac_b_ex;
1635 err = ext4_mb_load_buddy(ac->ac_sb, group, e4b);
1639 ext4_lock_group(ac->ac_sb, group);
1643 ac->ac_b_ex = ex;
1644 ext4_mb_use_best_found(ac, e4b);
1647 ext4_unlock_group(ac->ac_sb, group);
1654 int ext4_mb_find_by_goal(struct ext4_allocation_context *ac,
1657 ext4_group_t group = ac->ac_g_ex.fe_group;
1660 struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
1663 if (!(ac->ac_flags & EXT4_MB_HINT_TRY_GOAL))
1666 err = ext4_mb_load_buddy(ac->ac_sb, group, e4b);
1670 ext4_lock_group(ac->ac_sb, group);
1671 max = mb_find_extent(e4b, 0, ac->ac_g_ex.fe_start,
1672 ac->ac_g_ex.fe_len, &ex);
1674 if (max >= ac->ac_g_ex.fe_len && ac->ac_g_ex.fe_len == sbi->s_stripe) {
1677 start = ext4_group_first_block_no(ac->ac_sb, e4b->bd_group) +
1681 ac->ac_found++;
1682 ac->ac_b_ex = ex;
1683 ext4_mb_use_best_found(ac, e4b);
1685 } else if (max >= ac->ac_g_ex.fe_len) {
1687 BUG_ON(ex.fe_group != ac->ac_g_ex.fe_group);
1688 BUG_ON(ex.fe_start != ac->ac_g_ex.fe_start);
1689 ac->ac_found++;
1690 ac->ac_b_ex = ex;
1691 ext4_mb_use_best_found(ac, e4b);
1692 } else if (max > 0 && (ac->ac_flags & EXT4_MB_HINT_MERGE)) {
1696 BUG_ON(ex.fe_group != ac->ac_g_ex.fe_group);
1697 BUG_ON(ex.fe_start != ac->ac_g_ex.fe_start);
1698 ac->ac_found++;
1699 ac->ac_b_ex = ex;
1700 ext4_mb_use_best_found(ac, e4b);
1702 ext4_unlock_group(ac->ac_sb, group);
1713 void ext4_mb_simple_scan_group(struct ext4_allocation_context *ac,
1716 struct super_block *sb = ac->ac_sb;
1723 BUG_ON(ac->ac_2order <= 0);
1724 for (i = ac->ac_2order; i <= sb->s_blocksize_bits + 1; i++) {
1734 ac->ac_found++;
1736 ac->ac_b_ex.fe_len = 1 << i;
1737 ac->ac_b_ex.fe_start = k << i;
1738 ac->ac_b_ex.fe_group = e4b->bd_group;
1740 ext4_mb_use_best_found(ac, e4b);
1742 BUG_ON(ac->ac_b_ex.fe_len != ac->ac_g_ex.fe_len);
1757 void ext4_mb_complex_scan_group(struct ext4_allocation_context *ac,
1760 struct super_block *sb = ac->ac_sb;
1771 while (free && ac->ac_status == AC_STATUS_CONTINUE) {
1787 mb_find_extent(e4b, 0, i, ac->ac_g_ex.fe_len, &ex);
1802 ext4_mb_measure_extent(ac, &ex, e4b);
1808 ext4_mb_check_limits(ac, e4b, 1);
1816 void ext4_mb_scan_aligned(struct ext4_allocation_context *ac,
1819 struct super_block *sb = ac->ac_sb;
1841 ac->ac_found++;
1842 ac->ac_b_ex = ex;
1843 ext4_mb_use_best_found(ac, e4b);
1852 static int ext4_mb_good_group(struct ext4_allocation_context *ac,
1856 int flex_size = ext4_flex_bg_size(EXT4_SB(ac->ac_sb));
1857 struct ext4_group_info *grp = ext4_get_group_info(ac->ac_sb, group);
1863 int ret = ext4_mb_init_group(ac->ac_sb, group);
1877 BUG_ON(ac->ac_2order == 0);
1879 if (grp->bb_largest_free_order < ac->ac_2order)
1883 if ((ac->ac_flags & EXT4_MB_HINT_DATA) &&
1890 if ((free / fragments) >= ac->ac_g_ex.fe_len)
1894 if (free >= ac->ac_g_ex.fe_len)
1985 ext4_mb_regular_allocator(struct ext4_allocation_context *ac)
1994 sb = ac->ac_sb;
1998 if (!(ext4_test_inode_flag(ac->ac_inode, EXT4_INODE_EXTENTS)))
2001 BUG_ON(ac->ac_status == AC_STATUS_FOUND);
2004 err = ext4_mb_find_by_goal(ac, &e4b);
2005 if (err || ac->ac_status == AC_STATUS_FOUND)
2008 if (unlikely(ac->ac_flags & EXT4_MB_HINT_GOAL_ONLY))
2012 * ac->ac2_order is set only if the fe_len is a power of 2
2016 i = fls(ac->ac_g_ex.fe_len);
2017 ac->ac_2order = 0;
2027 if ((ac->ac_g_ex.fe_len & (~(1 << (i - 1)))) == 0)
2028 ac->ac_2order = i - 1;
2032 if (ac->ac_flags & EXT4_MB_STREAM_ALLOC) {
2035 ac->ac_g_ex.fe_group = sbi->s_mb_last_group;
2036 ac->ac_g_ex.fe_start = sbi->s_mb_last_start;
2041 cr = ac->ac_2order ? 0 : 1;
2047 for (; cr < 4 && ac->ac_status == AC_STATUS_CONTINUE; cr++) {
2048 ac->ac_criteria = cr;
2053 group = ac->ac_g_ex.fe_group;
2060 if (!ext4_mb_good_group(ac, group, cr))
2073 if (!ext4_mb_good_group(ac, group, cr)) {
2079 ac->ac_groups_scanned++;
2081 ext4_mb_simple_scan_group(ac, &e4b);
2083 !(ac->ac_g_ex.fe_len % sbi->s_stripe))
2084 ext4_mb_scan_aligned(ac, &e4b);
2086 ext4_mb_complex_scan_group(ac, &e4b);
2091 if (ac->ac_status != AC_STATUS_CONTINUE)
2096 if (ac->ac_b_ex.fe_len > 0 && ac->ac_status != AC_STATUS_FOUND &&
2097 !(ac->ac_flags & EXT4_MB_HINT_FIRST)) {
2103 ext4_mb_try_best_found(ac, &e4b);
2104 if (ac->ac_status != AC_STATUS_FOUND) {
2111 ac->ac_b_ex.fe_group = 0;
2112 ac->ac_b_ex.fe_start = 0;
2113 ac->ac_b_ex.fe_len = 0;
2114 ac->ac_status = AC_STATUS_CONTINUE;
2115 ac->ac_flags |= EXT4_MB_HINT_FIRST;
2695 * Check quota and mark chosen space (ac->ac_b_ex) non-free in bitmaps
2699 ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac,
2710 BUG_ON(ac->ac_status != AC_STATUS_FOUND);
2711 BUG_ON(ac->ac_b_ex.fe_len <= 0);
2713 sb = ac->ac_sb;
2717 bitmap_bh = ext4_read_block_bitmap(sb, ac->ac_b_ex.fe_group);
2726 gdp = ext4_get_group_desc(sb, ac->ac_b_ex.fe_group, &gdp_bh);
2730 ext4_debug("using block group %u(%d)\n", ac->ac_b_ex.fe_group,
2737 block = ext4_grp_offs_to_block(sb, &ac->ac_b_ex);
2739 len = ac->ac_b_ex.fe_len;
2747 ext4_lock_group(sb, ac->ac_b_ex.fe_group);
2748 mb_set_bits(bitmap_bh->b_data, ac->ac_b_ex.fe_start,
2749 ac->ac_b_ex.fe_len);
2750 ext4_unlock_group(sb, ac->ac_b_ex.fe_group);
2757 ext4_lock_group(sb, ac->ac_b_ex.fe_group);
2761 for (i = 0; i < ac->ac_b_ex.fe_len; i++) {
2762 BUG_ON(mb_test_bit(ac->ac_b_ex.fe_start + i,
2767 mb_set_bits(bitmap_bh->b_data, ac->ac_b_ex.fe_start,ac->ac_b_ex.fe_len);
2772 ac->ac_b_ex.fe_group, gdp));
2774 len = ext4_free_blks_count(sb, gdp) - ac->ac_b_ex.fe_len;
2776 gdp->bg_checksum = ext4_group_desc_csum(sbi, ac->ac_b_ex.fe_group, gdp);
2778 ext4_unlock_group(sb, ac->ac_b_ex.fe_group);
2779 percpu_counter_sub(&sbi->s_freeblocks_counter, ac->ac_b_ex.fe_len);
2783 if (!(ac->ac_flags & EXT4_MB_DELALLOC_RESERVED))
2789 ac->ac_b_ex.fe_group);
2790 atomic_sub(ac->ac_b_ex.fe_len,
2805 static void ext4_mb_normalize_group_request(struct ext4_allocation_context *ac)
2807 struct super_block *sb = ac->ac_sb;
2808 struct ext4_locality_group *lg = ac->ac_lg;
2812 ac->ac_g_ex.fe_len = EXT4_SB(sb)->s_stripe;
2814 ac->ac_g_ex.fe_len = EXT4_SB(sb)->s_mb_group_prealloc;
2816 current->pid, ac->ac_g_ex.fe_len);
2824 ext4_mb_normalize_request(struct ext4_allocation_context *ac,
2831 struct ext4_inode_info *ei = EXT4_I(ac->ac_inode);
2836 if (!(ac->ac_flags & EXT4_MB_HINT_DATA))
2840 if (unlikely(ac->ac_flags & EXT4_MB_HINT_GOAL_ONLY))
2845 if (ac->ac_flags & EXT4_MB_HINT_NOPREALLOC)
2848 if (ac->ac_flags & EXT4_MB_HINT_GROUP_ALLOC) {
2849 ext4_mb_normalize_group_request(ac);
2853 bsbits = ac->ac_sb->s_blocksize_bits;
2857 size = ac->ac_o_ex.fe_logical + ac->ac_o_ex.fe_len;
2859 if (size < i_size_read(ac->ac_inode))
2860 size = i_size_read(ac->ac_inode);
2886 start_off = ((loff_t)ac->ac_o_ex.fe_logical >>
2890 start_off = ((loff_t)ac->ac_o_ex.fe_logical >>
2893 } else if (NRL_CHECK_SIZE(ac->ac_o_ex.fe_len,
2895 start_off = ((loff_t)ac->ac_o_ex.fe_logical >>
2899 start_off = (loff_t)ac->ac_o_ex.fe_logical << bsbits;
2900 size = ac->ac_o_ex.fe_len << bsbits;
2931 BUG_ON(!(ac->ac_o_ex.fe_logical >= pa_end ||
2932 ac->ac_o_ex.fe_logical < pa->pa_lstart));
2942 if (pa_end <= ac->ac_o_ex.fe_logical) {
2945 } else if (pa->pa_lstart > ac->ac_o_ex.fe_logical) {
2966 if (start + size <= ac->ac_o_ex.fe_logical &&
2967 start > ac->ac_o_ex.fe_logical) {
2970 (unsigned long) ac->ac_o_ex.fe_logical);
2972 BUG_ON(start + size <= ac->ac_o_ex.fe_logical &&
2973 start > ac->ac_o_ex.fe_logical);
2974 BUG_ON(size <= 0 || size > EXT4_BLOCKS_PER_GROUP(ac->ac_sb));
2978 ac->ac_g_ex.fe_logical = start;
2979 ac->ac_g_ex.fe_len = size;
2984 ext4_get_group_no_and_offset(ac->ac_sb, ar->pright - size,
2985 &ac->ac_f_ex.fe_group,
2986 &ac->ac_f_ex.fe_start);
2987 ac->ac_flags |= EXT4_MB_HINT_TRY_GOAL;
2991 ext4_get_group_no_and_offset(ac->ac_sb, ar->pleft + 1,
2992 &ac->ac_f_ex.fe_group,
2993 &ac->ac_f_ex.fe_start);
2994 ac->ac_flags |= EXT4_MB_HINT_TRY_GOAL;
3001 static void ext4_mb_collect_stats(struct ext4_allocation_context *ac)
3003 struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
3005 if (sbi->s_mb_stats && ac->ac_g_ex.fe_len > 1) {
3007 atomic_add(ac->ac_b_ex.fe_len, &sbi->s_bal_allocated);
3008 if (ac->ac_b_ex.fe_len >= ac->ac_o_ex.fe_len)
3010 atomic_add(ac->ac_found, &sbi->s_bal_ex_scanned);
3011 if (ac->ac_g_ex.fe_start == ac->ac_b_ex.fe_start &&
3012 ac->ac_g_ex.fe_group == ac->ac_b_ex.fe_group)
3014 if (ac->ac_found > sbi->s_mb_max_to_scan)
3018 if (ac->ac_op == EXT4_MB_HISTORY_ALLOC)
3019 trace_ext4_mballoc_alloc(ac);
3021 trace_ext4_mballoc_prealloc(ac);
3028 * zeroed out ac->ac_b_ex.fe_len, so group_pa->pa_free is not changed.
3030 static void ext4_discard_allocated_blocks(struct ext4_allocation_context *ac)
3032 struct ext4_prealloc_space *pa = ac->ac_pa;
3036 len = ac->ac_b_ex.fe_len;
3045 static void ext4_mb_use_inode_pa(struct ext4_allocation_context *ac,
3053 start = pa->pa_pstart + (ac->ac_o_ex.fe_logical - pa->pa_lstart);
3054 end = min(pa->pa_pstart + pa->pa_len, start + ac->ac_o_ex.fe_len);
3056 ext4_get_group_no_and_offset(ac->ac_sb, start, &ac->ac_b_ex.fe_group,
3057 &ac->ac_b_ex.fe_start);
3058 ac->ac_b_ex.fe_len = len;
3059 ac->ac_status = AC_STATUS_FOUND;
3060 ac->ac_pa = pa;
3073 static void ext4_mb_use_group_pa(struct ext4_allocation_context *ac,
3076 unsigned int len = ac->ac_o_ex.fe_len;
3078 ext4_get_group_no_and_offset(ac->ac_sb, pa->pa_pstart,
3079 &ac->ac_b_ex.fe_group,
3080 &ac->ac_b_ex.fe_start);
3081 ac->ac_b_ex.fe_len = len;
3082 ac->ac_status = AC_STATUS_FOUND;
3083 ac->ac_pa = pa;
3127 ext4_mb_use_preallocated(struct ext4_allocation_context *ac)
3130 struct ext4_inode_info *ei = EXT4_I(ac->ac_inode);
3136 if (!(ac->ac_flags & EXT4_MB_HINT_DATA))
3145 if (ac->ac_o_ex.fe_logical < pa->pa_lstart ||
3146 ac->ac_o_ex.fe_logical >= pa->pa_lstart + pa->pa_len)
3150 if (!(ext4_test_inode_flag(ac->ac_inode, EXT4_INODE_EXTENTS)) &&
3158 ext4_mb_use_inode_pa(ac, pa);
3160 ac->ac_criteria = 10;
3169 if (!(ac->ac_flags & EXT4_MB_HINT_GROUP_ALLOC))
3173 lg = ac->ac_lg;
3176 order = fls(ac->ac_o_ex.fe_len) - 1;
3181 goal_block = ext4_grp_offs_to_block(ac->ac_sb, &ac->ac_g_ex);
3192 pa->pa_free >= ac->ac_o_ex.fe_len) {
3202 ext4_mb_use_group_pa(ac, cpa);
3203 ac->ac_criteria = 20;
3287 static void ext4_mb_put_pa(struct ext4_allocation_context *ac,
3345 ext4_mb_new_inode_pa(struct ext4_allocation_context *ac)
3347 struct super_block *sb = ac->ac_sb;
3353 BUG_ON(ac->ac_o_ex.fe_len >= ac->ac_b_ex.fe_len);
3354 BUG_ON(ac->ac_status != AC_STATUS_FOUND);
3355 BUG_ON(!S_ISREG(ac->ac_inode->i_mode));
3361 if (ac->ac_b_ex.fe_len < ac->ac_g_ex.fe_len) {
3370 BUG_ON(ac->ac_g_ex.fe_logical > ac->ac_o_ex.fe_logical);
3371 BUG_ON(ac->ac_g_ex.fe_len < ac->ac_o_ex.fe_len);
3376 winl = ac->ac_o_ex.fe_logical - ac->ac_g_ex.fe_logical;
3379 wins = ac->ac_b_ex.fe_len - ac->ac_o_ex.fe_len;
3384 offs = ac->ac_o_ex.fe_logical % ac->ac_b_ex.fe_len;
3388 ac->ac_b_ex.fe_logical = ac->ac_o_ex.fe_logical - win;
3389 BUG_ON(ac->ac_o_ex.fe_logical < ac->ac_b_ex.fe_logical);
3390 BUG_ON(ac->ac_o_ex.fe_len > ac->ac_b_ex.fe_len);
3395 ac->ac_f_ex = ac->ac_b_ex;
3397 pa->pa_lstart = ac->ac_b_ex.fe_logical;
3398 pa->pa_pstart = ext4_grp_offs_to_block(sb, &ac->ac_b_ex);
3399 pa->pa_len = ac->ac_b_ex.fe_len;
3410 trace_ext4_mb_new_inode_pa(ac, pa);
3412 ext4_mb_use_inode_pa(ac, pa);
3415 ei = EXT4_I(ac->ac_inode);
3416 grp = ext4_get_group_info(sb, ac->ac_b_ex.fe_group);
3419 pa->pa_inode = ac->ac_inode;
3421 ext4_lock_group(sb, ac->ac_b_ex.fe_group);
3423 ext4_unlock_group(sb, ac->ac_b_ex.fe_group);
3436 ext4_mb_new_group_pa(struct ext4_allocation_context *ac)
3438 struct super_block *sb = ac->ac_sb;
3444 BUG_ON(ac->ac_o_ex.fe_len >= ac->ac_b_ex.fe_len);
3445 BUG_ON(ac->ac_status != AC_STATUS_FOUND);
3446 BUG_ON(!S_ISREG(ac->ac_inode->i_mode));
3455 ac->ac_f_ex = ac->ac_b_ex;
3457 pa->pa_pstart = ext4_grp_offs_to_block(sb, &ac->ac_b_ex);
3459 pa->pa_len = ac->ac_b_ex.fe_len;
3470 trace_ext4_mb_new_group_pa(ac, pa);
3472 ext4_mb_use_group_pa(ac, pa);
3475 grp = ext4_get_group_info(sb, ac->ac_b_ex.fe_group);
3476 lg = ac->ac_lg;
3482 ext4_lock_group(sb, ac->ac_b_ex.fe_group);
3484 ext4_unlock_group(sb, ac->ac_b_ex.fe_group);
3493 static int ext4_mb_new_preallocation(struct ext4_allocation_context *ac)
3497 if (ac->ac_flags & EXT4_MB_HINT_GROUP_ALLOC)
3498 err = ext4_mb_new_group_pa(ac);
3500 err = ext4_mb_new_inode_pa(ac);
3515 struct ext4_allocation_context *ac)
3533 if (ac) {
3534 ac->ac_sb = sb;
3535 ac->ac_inode = pa->pa_inode;
3548 if (ac) {
3549 ac->ac_b_ex.fe_group = group;
3550 ac->ac_b_ex.fe_start = bit;
3551 ac->ac_b_ex.fe_len = next - bit;
3552 ac->ac_b_ex.fe_logical = 0;
3553 trace_ext4_mballoc_discard(ac);
3556 trace_ext4_mb_release_inode_pa(sb, ac, pa, grp_blk_start + bit,
3581 struct ext4_allocation_context *ac)
3587 trace_ext4_mb_release_group_pa(sb, ac, pa);
3594 if (ac) {
3595 ac->ac_sb = sb;
3596 ac->ac_inode = NULL;
3597 ac->ac_b_ex.fe_group = group;
3598 ac->ac_b_ex.fe_start = bit;
3599 ac->ac_b_ex.fe_len = pa->pa_len;
3600 ac->ac_b_ex.fe_logical = 0;
3601 trace_ext4_mballoc_discard(ac);
3623 struct ext4_allocation_context *ac;
3652 ac = kmem_cache_alloc(ext4_ac_cachep, GFP_NOFS);
3653 if (ac)
3654 ac->ac_sb = sb;
3709 ext4_mb_release_group_pa(&e4b, pa, ac);
3711 ext4_mb_release_inode_pa(&e4b, bitmap_bh, pa, ac);
3719 if (ac)
3720 kmem_cache_free(ext4_ac_cachep, ac);
3732 struct ext4_allocation_context *ac;
3748 ac = kmem_cache_alloc(ext4_ac_cachep, GFP_NOFS);
3749 if (ac) {
3750 ac->ac_sb = sb;
3751 ac->ac_inode = inode;
3818 ext4_mb_release_inode_pa(&e4b, bitmap_bh, pa, ac);
3827 if (ac)
3828 kmem_cache_free(ext4_ac_cachep, ac);
3838 static void ext4_mb_show_ac(struct ext4_allocation_context *ac)
3840 struct super_block *sb = ac->ac_sb;
3849 ac->ac_status, ac->ac_flags);
3852 (unsigned long)ac->ac_o_ex.fe_group,
3853 (unsigned long)ac->ac_o_ex.fe_start,
3854 (unsigned long)ac->ac_o_ex.fe_len,
3855 (unsigned long)ac->ac_o_ex.fe_logical,
3856 (unsigned long)ac->ac_g_ex.fe_group,
3857 (unsigned long)ac->ac_g_ex.fe_start,
3858 (unsigned long)ac->ac_g_ex.fe_len,
3859 (unsigned long)ac->ac_g_ex.fe_logical,
3860 (unsigned long)ac->ac_b_ex.fe_group,
3861 (unsigned long)ac->ac_b_ex.fe_start,
3862 (unsigned long)ac->ac_b_ex.fe_len,
3863 (unsigned long)ac->ac_b_ex.fe_logical,
3864 (int)ac->ac_criteria);
3865 printk(KERN_ERR "EXT4-fs: %lu scanned, %d found\n", ac->ac_ex_scanned,
3866 ac->ac_found);
3895 static inline void ext4_mb_show_ac(struct ext4_allocation_context *ac)
3908 static void ext4_mb_group_or_file(struct ext4_allocation_context *ac)
3910 struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
3911 int bsbits = ac->ac_sb->s_blocksize_bits;
3914 if (!(ac->ac_flags & EXT4_MB_HINT_DATA))
3917 if (unlikely(ac->ac_flags & EXT4_MB_HINT_GOAL_ONLY))
3920 size = ac->ac_o_ex.fe_logical + ac->ac_o_ex.fe_len;
3921 isize = (i_size_read(ac->ac_inode) + ac->ac_sb->s_blocksize - 1)
3926 (atomic_read(&ac->ac_inode->i_writecount) == 0)) {
3927 ac->ac_flags |= EXT4_MB_HINT_NOPREALLOC;
3934 ac->ac_flags |= EXT4_MB_STREAM_ALLOC;
3938 BUG_ON(ac->ac_lg != NULL);
3944 ac->ac_lg = __this_cpu_ptr(sbi->s_locality_groups);
3947 ac->ac_flags |= EXT4_MB_HINT_GROUP_ALLOC;
3950 mutex_lock(&ac->ac_lg->lg_mutex);
3954 ext4_mb_initialize_context(struct ext4_allocation_context *ac,
3980 memset(ac, 0, sizeof(struct ext4_allocation_context));
3981 ac->ac_b_ex.fe_logical = ar->logical;
3982 ac->ac_status = AC_STATUS_CONTINUE;
3983 ac->ac_sb = sb;
3984 ac->ac_inode = ar->inode;
3985 ac->ac_o_ex.fe_logical = ar->logical;
3986 ac->ac_o_ex.fe_group = group;
3987 ac->ac_o_ex.fe_start = block;
3988 ac->ac_o_ex.fe_len = len;
3989 ac->ac_g_ex.fe_logical = ar->logical;
3990 ac->ac_g_ex.fe_group = group;
3991 ac->ac_g_ex.fe_start = block;
3992 ac->ac_g_ex.fe_len = len;
3993 ac->ac_flags = ar->flags;
3997 ext4_mb_group_or_file(ac);
3999 mb_debug(1, "init ac: %u blocks @ %u, goal %u, flags %x, 2^%d, "
4002 (unsigned) ar->goal, ac->ac_flags, ac->ac_2order,
4019 struct ext4_allocation_context *ac;
4024 ac = kmem_cache_alloc(ext4_ac_cachep, GFP_NOFS);
4025 if (ac)
4026 ac->ac_sb = sb;
4078 ext4_mb_release_group_pa(&e4b, pa, ac);
4085 if (ac)
4086 kmem_cache_free(ext4_ac_cachep, ac);
4098 static void ext4_mb_add_n_trim(struct ext4_allocation_context *ac)
4101 struct super_block *sb = ac->ac_sb;
4102 struct ext4_locality_group *lg = ac->ac_lg;
4103 struct ext4_prealloc_space *tmp_pa, *pa = ac->ac_pa;
4148 static int ext4_mb_release_context(struct ext4_allocation_context *ac)
4150 struct ext4_prealloc_space *pa = ac->ac_pa;
4155 pa->pa_pstart += ac->ac_b_ex.fe_len;
4156 pa->pa_lstart += ac->ac_b_ex.fe_len;
4157 pa->pa_free -= ac->ac_b_ex.fe_len;
4158 pa->pa_len -= ac->ac_b_ex.fe_len;
4162 if (ac->alloc_semp)
4163 up_read(ac->alloc_semp);
4176 ext4_mb_add_n_trim(ac);
4178 ext4_mb_put_pa(ac, ac->ac_sb, pa);
4180 if (ac->ac_bitmap_page)
4181 page_cache_release(ac->ac_bitmap_page);
4182 if (ac->ac_buddy_page)
4183 page_cache_release(ac->ac_buddy_page);
4184 if (ac->ac_flags & EXT4_MB_HINT_GROUP_ALLOC)
4185 mutex_unlock(&ac->ac_lg->lg_mutex);
4186 ext4_mb_collect_stats(ac);
4215 struct ext4_allocation_context *ac = NULL;
4260 ac = kmem_cache_alloc(ext4_ac_cachep, GFP_NOFS);
4261 if (!ac) {
4267 *errp = ext4_mb_initialize_context(ac, ar);
4273 ac->ac_op = EXT4_MB_HISTORY_PREALLOC;
4274 if (!ext4_mb_use_preallocated(ac)) {
4275 ac->ac_op = EXT4_MB_HISTORY_ALLOC;
4276 ext4_mb_normalize_request(ac, ar);
4279 *errp = ext4_mb_regular_allocator(ac);
4286 if (ac->ac_status == AC_STATUS_FOUND &&
4287 ac->ac_o_ex.fe_len < ac->ac_b_ex.fe_len)
4288 ext4_mb_new_preallocation(ac);
4290 if (likely(ac->ac_status == AC_STATUS_FOUND)) {
4291 *errp = ext4_mb_mark_diskspace_used(ac, handle, reserv_blks);
4297 ext4_mb_release_context(ac);
4298 ac->ac_b_ex.fe_group = 0;
4299 ac->ac_b_ex.fe_start = 0;
4300 ac->ac_b_ex.fe_len = 0;
4301 ac->ac_status = AC_STATUS_CONTINUE;
4305 ext4_discard_allocated_blocks(ac);
4307 block = ext4_grp_offs_to_block(sb, &ac->ac_b_ex);
4308 ar->len = ac->ac_b_ex.fe_len;
4311 freed = ext4_mb_discard_preallocations(sb, ac->ac_o_ex.fe_len);
4318 ac->ac_b_ex.fe_len = 0;
4320 ext4_mb_show_ac(ac);
4322 ext4_mb_release_context(ac);
4324 if (ac)
4325 kmem_cache_free(ext4_ac_cachep, ac);
4450 struct ext4_allocation_context *ac = NULL;
4505 ac = kmem_cache_alloc(ext4_ac_cachep, GFP_NOFS);
4506 if (ac) {
4507 ac->ac_inode = inode;
4508 ac->ac_sb = sb;
4568 if (ac) {
4569 ac->ac_b_ex.fe_group = block_group;
4570 ac->ac_b_ex.fe_start = bit;
4571 ac->ac_b_ex.fe_len = count;
4572 trace_ext4_mballoc_free(ac);
4644 if (ac)
4645 kmem_cache_free(ext4_ac_cachep, ac);