Lines Matching defs:allocated
46 struct ext4_ext_path *path, int flags, unsigned int *allocated);
1050 * into the newly allocated blocks
1065 ext4_fsblk_t *ablocks = NULL; /* array of allocated blocks */
1102 * Get array to track all allocated blocks.
1291 /* free all allocated blocks in error case */
1419 /* we use already allocated block for index block,
1461 * search the closest allocated block to the left for *logical
1463 * if *logical is the smallest allocated block, the function
1525 * Search the closest allocated block to the right for *logical
1528 * 1 which means we found an allocated block and ret_ex is valid.
1586 /* next allocated block in this leaf */
1603 * follow it and find the closest allocated
1634 * returns allocated block in subsequent extent or EXT_MAX_BLOCKS.
1636 * allocated block. Thus, index entries have to be consistent
1670 * returns first allocated block from next leaf or EXT_MAX_BLOCKS
1959 * get the next allocated block if the extent in the path
2459 * defer reserved and allocated space accounting to a subsequent call
3414 unsigned int *allocated, bool *did_zeroout)
3520 if (allocated) {
3522 *allocated = ee_len - (map->m_lblk - ee_block);
3524 *allocated = map->m_len;
3553 * that are allocated and initialized.
3559 int flags, unsigned int *allocated)
3609 *allocated = 0;
3654 *allocated = map_len;
3700 *allocated = map_len;
3703 if (*allocated) {
3713 *allocated = ee_len - (map->m_lblk - ee_block);
3738 if (max_zeroout && (*allocated > split_map.m_len)) {
3739 if (*allocated <= max_zeroout) {
3745 cpu_to_le16(*allocated - split_map.m_len);
3752 split_map.m_len = *allocated;
3770 *allocated = map->m_len;
3813 * allocated pointer. Return an extent path pointer on success, or an error
3820 int flags, unsigned int *allocated)
3857 allocated, &did_zeroout);
3940 unsigned int *allocated)
3985 if (*allocated > map->m_len)
3986 *allocated = map->m_len;
3987 map->m_len = *allocated;
3995 unsigned int *allocated, ext4_fsblk_t newblock)
3999 ext_debug(inode, "logical block %llu, max_blocks %u, flags 0x%x, allocated %u\n",
4001 *allocated);
4011 *allocated, newblock);
4036 * return allocated blocks so that delalloc
4051 flags, allocated);
4056 * shouldn't get a 0 allocated when converting an unwritten extent
4059 if (unlikely(*allocated == 0)) {
4060 EXT4_ERROR_INODE(inode, "unexpected allocated == 0, m_len = %u",
4071 if (*allocated > map->m_len)
4072 *allocated = map->m_len;
4073 map->m_len = *allocated;
4085 * allocated in an extent.
4119 * as a new "allocated" block region. Otherwise, we will return 0 and
4163 * Check for the case where there is already another allocated
4259 * return > 0, number of blocks already mapped/allocated
4260 * if flags doesn't contain EXT4_GET_BLOCKS_CREATE and these are pre-allocated blocks
4264 * return = 0, if plain look up failed (blocks have not been allocated)
4277 unsigned int allocated = 0, offset = 0;
4327 allocated = ee_len - (map->m_lblk - ee_block);
4338 inode, map, path, flags, &allocated);
4345 if (allocated > map->m_len)
4346 allocated = map->m_len;
4347 map->m_len = allocated;
4354 &allocated, newblock);
4362 * requested block isn't allocated yet;
4387 ar.len = allocated = map->m_len;
4392 /* find neighbour allocated blocks */
4407 ar.len = allocated = map->m_len;
4430 allocated = ext4_ext_get_actual_len(&newex);
4432 allocated = map->m_len;
4447 ar.len = EXT4_NUM_B2C(sbi, offset+allocated);
4467 ar.goal, newblock, ar.len, allocated);
4468 if (ar.len > allocated)
4469 ar.len = allocated;
4487 * is inconsistent, we'll just leak allocated blocks to avoid
4493 * free data blocks we just allocated.
4519 allocated = map->m_len;
4539 err ? err : allocated);
4540 return err ? err : allocated;
4685 * already successfully allocated blocks.
5376 * All the extents which lies in the range from @start to the last allocated
5944 * that a physical cluster has been allocated for it. Otherwise,
5958 * mapped - no physical clusters have been allocated, and the
6289 unsigned int *allocated)
6292 flags, allocated);