Lines Matching defs:size
163 u64 start, size_t size, size_t compressed_size,
173 size_t cur_size = size;
182 inode_add_bytes(inode, size);
206 btrfs_set_file_extent_ram_bytes(leaf, ei, size);
233 write_extent_buffer(leaf, kaddr + offset, ptr, size);
241 * We align size to sectorsize for inline extents just for simplicity
244 size = ALIGN(size, root->fs_info->sectorsize);
245 ret = btrfs_inode_set_file_extent_range(BTRFS_I(inode), start, size);
348 * And at reserve time, it's always aligned to page size, so
499 * us evaluating the size and assigning it. This is because we lock and
668 * we aren't doing an inline extent round the compressed size
669 * up to a block size boundary so the allocator does sane
677 * compression must free at least one sector size
1039 * size as the original extents. Normally writeback for relocation data
1043 * an extent allocated during COW has exactly the requested size and can
1151 * when we reserved the extent we decremented the extent's size from
1846 u64 size;
1852 size = orig->end - orig->start + 1;
1853 if (size > BTRFS_MAX_EXTENT_SIZE) {
1865 if (count_max_extents(size) >= num_extents)
2105 * btrfs_bio_fits_in_stripe - Checks whether the size of the given bio will fit
2110 * @size - size we want to add to the bio
2118 int btrfs_bio_fits_in_stripe(struct page *page, size_t size, struct bio *bio,
2139 if (geom.len < length + size)
4060 trans->bytes_reserved = block_rsv.size;
4205 * csum items that cross the new i_size are truncated to the new size
4263 * new size is not block aligned since we will be keeping the
4286 * with a 16K leaf size and 128MB extents, you can actually queue
4408 u32 size = (u32)(new_size - found_key.offset);
4410 btrfs_set_file_extent_ram_bytes(leaf, fi, size);
4411 size = btrfs_file_extent_calc_inline_size(size);
4412 btrfs_truncate_item(path, size, 1);
4751 * for. So if we are truncating this file to a larger size we need to insert
4753 * the range between oldsize and size
4755 int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
4764 u64 block_end = ALIGN(size, fs_info->sectorsize);
4771 * If our size started in the middle of a block we need to zero out the
4779 if (size <= hole_start)
4928 * Truncate failed, so fix up the in-memory size. We
4931 * in-memory size to match.
5091 ret = btrfs_block_rsv_refill(root, rsv, rsv->size + delayed_refs_extra,
5099 btrfs_block_rsv_migrate(global_rsv, rsv, rsv->size, 0)) {
5164 rsv->size = btrfs_calc_metadata_size(fs_info, 1);
6730 size_t size;
6737 size = btrfs_file_extent_ram_bytes(leaf, item);
6740 size - extent_offset);
8008 static inline int btrfs_maybe_fsync_end_io(struct kiocb *iocb, ssize_t size,
8024 if (size) {
8026 return generic_write_sync(iocb, size);
8328 * btrfs_page_mkwrite() is not allowed to change the file size as it gets
8337 * truncate_setsize() writes the inode size before removing pages, once we have
8353 loff_t size;
8393 size = i_size_read(inode);
8396 (page_start >= size)) {
8420 if (page->index == ((size - 1) >> PAGE_SHIFT)) {
8421 reserved_space = round_up(size - page_start,
8452 if (page_start + PAGE_SIZE > size)
8453 zero_start = offset_in_page(size);
8536 rsv->size = min_size;
8753 WARN_ON(inode->block_rsv.size);
9817 * clear_offset by our extent size.
10117 * Our swapfile may have had its size extended after the swap header was
10119 * the max size set in the swap header.