Lines Matching defs:allocated
1049 * into the newly allocated blocks
1064 ext4_fsblk_t *ablocks = NULL; /* array of allocated blocks */
1101 * Get array to track all allocated blocks.
1290 /* free all allocated blocks in error case */
1418 /* we use already allocated block for index block,
1464 * search the closest allocated block to the left for *logical
1466 * if *logical is the smallest allocated block, the function
1528 * Search the closest allocated block to the right for *logical
1531 * 1 which means we found an allocated block and ret_ex is valid.
1589 /* next allocated block in this leaf */
1606 * follow it and find the closest allocated
1636 * returns allocated block in subsequent extent or EXT_MAX_BLOCKS.
1638 * allocated block. Thus, index entries have to be consistent
1672 * returns first allocated block from next leaf or EXT_MAX_BLOCKS
1935 * get the next allocated block if the extent in the path
2411 * defer reserved and allocated space accounting to a subsequent call
3314 int allocated = map->m_len;
3335 allocated = ee_len - (map->m_lblk - ee_block);
3368 return err ? err : allocated;
3388 * that are allocated and initialized.
3405 int allocated = 0, max_zeroout = 0;
3491 allocated = map_len;
3537 allocated = map_len;
3540 if (allocated) {
3548 allocated = ee_len - (map->m_lblk - ee_block);
3575 if (max_zeroout && (allocated > split_map.m_len)) {
3576 if (allocated <= max_zeroout) {
3582 cpu_to_le16(allocated - split_map.m_len);
3589 split_map.m_len = allocated;
3607 allocated = map->m_len;
3622 return err ? err : allocated;
3757 unsigned int *allocated)
3818 if (*allocated > map->m_len)
3819 *allocated = map->m_len;
3820 map->m_len = *allocated;
3828 unsigned int allocated, ext4_fsblk_t newblock)
3834 ext_debug(inode, "logical block %llu, max_blocks %u, flags 0x%x, allocated %u\n",
3836 allocated);
3846 allocated, newblock);
3893 * return allocated blocks so that delalloc
3925 allocated = ret;
3931 if (allocated > map->m_len)
3932 allocated = map->m_len;
3933 map->m_len = allocated;
3936 return err ? err : allocated;
3942 * allocated in an extent.
3976 * as a new "allocated" block region. Otherwise, we will return 0 and
4020 * Check for the case where there is already another allocated
4113 * return > 0, number of blocks already mapped/allocated
4114 * if create == 0 and these are pre-allocated blocks
4118 * return = 0, if plain look up failed (blocks have not been allocated)
4131 unsigned int allocated = 0, offset = 0;
4182 allocated = ee_len - (map->m_lblk - ee_block);
4193 inode, map, &path, &allocated);
4198 if (allocated > map->m_len)
4199 allocated = map->m_len;
4200 map->m_len = allocated;
4207 allocated, newblock);
4211 allocated = ret;
4217 * requested block isn't allocated yet;
4242 ar.len = allocated = map->m_len;
4247 /* find neighbour allocated blocks */
4261 ar.len = allocated = map->m_len;
4283 allocated = ext4_ext_get_actual_len(&newex);
4285 allocated = map->m_len;
4300 ar.len = EXT4_NUM_B2C(sbi, offset+allocated);
4320 ar.goal, newblock, ar.len, allocated);
4321 if (ar.len > allocated)
4322 ar.len = allocated;
4341 * free data blocks we just allocated.
4357 * allocation of delayed allocated clusters or direct allocation of
4358 * clusters discovered to be delayed allocated. Once allocated, a
4364 * When allocating delayed allocated clusters, simply
4374 * When allocating non-delayed allocated clusters
4376 * allocated when delalloc has been disabled by
4378 * count by the number of allocated clusters that
4379 * have previously been delayed allocated. Quota
4382 * previously delayed allocated clusters.
4404 allocated = map->m_len;
4410 err ? err : allocated);
4411 return err ? err : allocated;
5147 * All the extents which lies in the range from @start to the last allocated
5789 * that a physical cluster has been allocated for it. Otherwise,
5803 * mapped - no physical clusters have been allocated, and the