Lines Matching defs:allocated
1053 * into the newly allocated blocks
1068 ext4_fsblk_t *ablocks = NULL; /* array of allocated blocks */
1105 * Get array to track all allocated blocks.
1292 /* 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
1529 * Search the closest allocated block to the right for *logical
1532 * 1 which means we found an allocated block and ret_ex is valid.
1590 /* next allocated block in this leaf */
1607 * follow it and find the closest allocated
1637 * returns allocated block in subsequent extent or EXT_MAX_BLOCKS.
1639 * allocated block. Thus, index entries have to be consistent
1673 * returns first allocated block from next leaf or EXT_MAX_BLOCKS
1936 * get the next allocated block if the extent in the path
2439 * defer reserved and allocated space accounting to a subsequent call
3344 int allocated = map->m_len;
3365 allocated = ee_len - (map->m_lblk - ee_block);
3399 return err ? err : allocated;
3419 * that are allocated and initialized.
3436 int allocated = 0, max_zeroout = 0;
3522 allocated = map_len;
3568 allocated = map_len;
3571 if (allocated) {
3579 allocated = ee_len - (map->m_lblk - ee_block);
3606 if (max_zeroout && (allocated > split_map.m_len)) {
3607 if (allocated <= max_zeroout) {
3613 cpu_to_le16(allocated - split_map.m_len);
3620 split_map.m_len = allocated;
3638 allocated = map->m_len;
3654 return err ? err : allocated;
3789 unsigned int *allocated)
3850 if (*allocated > map->m_len)
3851 *allocated = map->m_len;
3852 map->m_len = *allocated;
3860 unsigned int allocated, ext4_fsblk_t newblock)
3866 ext_debug(inode, "logical block %llu, max_blocks %u, flags 0x%x, allocated %u\n",
3868 allocated);
3878 allocated, newblock);
3925 * return allocated blocks so that delalloc
3957 allocated = ret;
3963 if (allocated > map->m_len)
3964 allocated = map->m_len;
3965 map->m_len = allocated;
3968 return err ? err : allocated;
3974 * allocated in an extent.
4008 * as a new "allocated" block region. Otherwise, we will return 0 and
4052 * Check for the case where there is already another allocated
4082 * return > 0, number of blocks already mapped/allocated
4083 * if create == 0 and these are pre-allocated blocks
4087 * return = 0, if plain look up failed (blocks have not been allocated)
4100 unsigned int allocated = 0, offset = 0;
4151 allocated = ee_len - (map->m_lblk - ee_block);
4162 inode, map, &path, &allocated);
4167 if (allocated > map->m_len)
4168 allocated = map->m_len;
4169 map->m_len = allocated;
4176 allocated, newblock);
4180 allocated = ret;
4186 * requested block isn't allocated yet;
4221 ar.len = allocated = map->m_len;
4226 /* find neighbour allocated blocks */
4240 ar.len = allocated = map->m_len;
4262 allocated = ext4_ext_get_actual_len(&newex);
4264 allocated = map->m_len;
4279 ar.len = EXT4_NUM_B2C(sbi, offset+allocated);
4299 ar.goal, newblock, ar.len, allocated);
4300 if (ar.len > allocated)
4301 ar.len = allocated;
4320 * free data blocks we just allocated.
4336 * allocation of delayed allocated clusters or direct allocation of
4337 * clusters discovered to be delayed allocated. Once allocated, a
4343 * When allocating delayed allocated clusters, simply
4353 * When allocating non-delayed allocated clusters
4355 * allocated when delalloc has been disabled by
4357 * count by the number of allocated clusters that
4358 * have previously been delayed allocated. Quota
4361 * previously delayed allocated clusters.
4383 allocated = map->m_len;
4390 err ? err : allocated);
4391 return err ? err : allocated;
5126 * All the extents which lies in the range from @start to the last allocated
5803 * that a physical cluster has been allocated for it. Otherwise,
5817 * mapped - no physical clusters have been allocated, and the