Lines Matching refs:start
64 * pa_lstart -> the logical start block for this prealloc space
65 * pa_pstart -> the physical start block for this prealloc space
69 * The inode preallocation space is used looking at the _logical_ start
426 static inline int mb_find_next_zero_bit(void *addr, int max, int start)
431 start += fix;
433 ret = ext4_find_next_zero_bit(addr, tmpmax, start) - fix;
439 static inline int mb_find_next_bit(void *addr, int max, int start)
444 start += fix;
446 ret = ext4_find_next_bit(addr, tmpmax, start) - fix;
1589 /* calc difference from given start */
1631 int start = ex->fe_start;
1637 BUG_ON(start + len > (e4b->bd_sb->s_blocksize << 3));
1641 mb_mark_used_double(e4b, start, len);
1645 if (e4b->bd_info->bb_first_free == start)
1649 if (start != 0)
1650 mlen = !mb_test_bit(start - 1, e4b->bd_bitmap);
1651 if (start + len < EXT4_SB(e4b->bd_sb)->s_mb_maxs[0])
1652 max = !mb_test_bit(start + len, e4b->bd_bitmap);
1660 ord = mb_find_order_for_block(e4b, start);
1662 if (((start >> ord) << ord) == start && len >= (1 << ord)) {
1666 BUG_ON((start >> ord) >= max);
1667 mb_set_bit(start >> ord, buddy);
1669 start += mlen;
1682 mb_set_bit(start >> ord, buddy);
1686 cur = (start >> ord) & ~1U;
1925 ext4_fsblk_t start;
1927 start = ext4_group_first_block_no(ac->ac_sb, e4b->bd_group) +
1930 if (do_div(start, sbi->s_stripe) == 0) {
2291 * ext4_mb_prefetch did not start the I/O.
2392 * searching for the right group start
2490 mb_debug(sb, "lost chunk, group: %u, start: %d, len: %d, lost: %d\n",
2601 .start = ext4_mb_seq_groups_start,
2845 * load too many groups, at some point we should start to use what
3543 ext4_lblk_t start;
3618 start = start_off >> bsbits;
3626 start = max(start, rounddown(ac->ac_o_ex.fe_logical,
3630 if (start + size > EXT_MAX_BLOCKS)
3631 size = EXT_MAX_BLOCKS - start;
3634 if (ar->pleft && start <= ar->lleft) {
3635 size -= ar->lleft + 1 - start;
3636 start = ar->lleft + 1;
3638 if (ar->pright && start + size - 1 >= ar->lright)
3639 size -= start + size - ar->lright;
3648 end = start + size;
3670 if (pa->pa_lstart >= end || pa_end <= start) {
3674 BUG_ON(pa->pa_lstart <= start && pa_end >= end);
3676 /* adjust start or end to be adjacent to this pa */
3678 BUG_ON(pa_end < start);
3679 start = pa_end;
3687 size = end - start;
3697 BUG_ON(!(start >= pa_end || end <= pa->pa_lstart));
3703 if (start + size <= ac->ac_o_ex.fe_logical &&
3704 start > ac->ac_o_ex.fe_logical) {
3706 "start %lu, size %lu, fe_logical %lu",
3707 (unsigned long) start, (unsigned long) size,
3717 ac->ac_g_ex.fe_logical = start;
3720 /* define goal start in order to merge */
3721 if (ar->pright && (ar->lright == (start + size)) &&
3730 if (ar->pleft && (ar->lleft + 1 == start) &&
3740 orig_size, start);
3810 ext4_fsblk_t start;
3815 start = pa->pa_pstart + (ac->ac_o_ex.fe_logical - pa->pa_lstart);
3817 start + EXT4_C2B(sbi, ac->ac_o_ex.fe_len));
3818 len = EXT4_NUM_B2C(sbi, end - start);
3819 ext4_get_group_no_and_offset(ac->ac_sb, start, &ac->ac_b_ex.fe_group,
3825 BUG_ON(start < pa->pa_pstart);
3831 mb_debug(ac->ac_sb, "use %llu/%d from inode pa %p\n", start, len, pa);
4015 ext4_grpblk_t start;
4034 &groupnr, &start);
4040 ext4_set_bits(bitmap, start, len);
4175 * cover original start
4176 * 2. Else, check if best ex can be kept at start of goal and
4177 * still cover original start
4178 * 3. Else, keep the best ex at start of original request.
4644 ext4_grpblk_t start;
4655 NULL, &start);
4657 mb_debug(sb, "PA:%u:%d:%d\n", i, start,
4783 /* start searching from the goal */
5746 * @block: start physical block to add to the block group
5881 * @start: starting block of the free extent in the alloc. group
5885 * Trim "count" blocks starting at "start" in the "group". To assure that no
5890 int start, int count, struct ext4_buddy *e4b)
5898 trace_ext4_trim_extent(sb, group, start, count);
5902 ex.fe_start = start;
5912 ret = ext4_issue_discard(sb, group, start, count, NULL);
5914 mb_free_blocks(NULL, e4b, start, ex.fe_len);
5939 struct ext4_buddy *e4b, ext4_grpblk_t start,
5948 if (start == 0 && max >= last)
5950 origin_start = start;
5951 start = max(e4b->bd_info->bb_first_free, start);
5955 while (start <= max) {
5956 start = mb_find_next_zero_bit(bitmap, max + 1, start);
5957 if (start > max)
5960 next = mb_find_next_bit(bitmap, last + 1, start);
5964 if ((next - start) >= minblocks) {
5965 int ret = ext4_trim_extent(sb, start, next - start, e4b);
5969 count += next - start;
5971 free_count += next - start;
5972 start = next + 1;
5997 * @start: first group block to examine
6013 ext4_grpblk_t start, ext4_grpblk_t max,
6019 trace_ext4_trim_all_free(sb, group, start, max);
6032 ret = ext4_try_to_trim_range(sb, &e4b, start, max, minblocks);
6050 * start: First Byte to trim
6051 * len: number of Bytes to trim from start
6054 * start to start+len. For each such a group ext4_trim_all_free function
6063 uint64_t start, end, minlen, trimmed = 0;
6069 start = range->start >> sb->s_blocksize_bits;
6070 end = start + (range->len >> sb->s_blocksize_bits) - 1;
6075 start >= max_blks ||
6089 if (start < first_data_blk)
6090 start = first_data_blk;
6092 /* Determine first and last group to examine based on start and end */
6093 ext4_get_group_no_and_offset(sb, (ext4_fsblk_t) start,
6152 ext4_grpblk_t start,
6169 start = max(e4b.bd_info->bb_first_free, start);
6173 while (start <= end) {
6174 start = mb_find_next_zero_bit(bitmap, end + 1, start);
6175 if (start > end)
6177 next = mb_find_next_bit(bitmap, end + 1, start);
6180 error = formatter(sb, group, start, next - start, priv);
6185 start = next + 1;