Lines Matching defs:size
505 size_t size, size_t compressed_size,
517 size_t cur_size = size;
547 btrfs_set_file_extent_ram_bytes(leaf, ei, size);
572 write_extent_buffer(leaf, kaddr, ptr, size);
580 * We align size to sectorsize for inline extents just for simplicity
584 ALIGN(size, root->fs_info->sectorsize));
596 if (update_i_size && size > i_size) {
597 i_size_write(&inode->vfs_inode, size);
598 i_size = size;
612 static noinline int cow_file_range_inline(struct btrfs_inode *inode, u64 size,
622 u64 data_len = (compressed_size ?: size);
630 * size.
632 if (size < i_size_read(&inode->vfs_inode) ||
633 size > fs_info->sectorsize ||
662 size, compressed_size, compress_type,
672 btrfs_update_inode_bytes(inode, size, drop_args.bytes_found);
687 * And at reserve time, it's always aligned to page size, so
861 * us evaluating the size and assigning it. This is because we lock and
1002 * We aren't doing an inline extent. Round the compressed size up to a
1003 * block size boundary so the allocator does sane things.
1139 * compressed size, how could it work for uncompressed size
1140 * which requires larger size? So here we directly go error
1306 * Due to the page size limit, for subpage we can only trigger the
1359 * size as the original extents. Normally writeback for relocation data
1363 * an extent allocated during COW has exactly the requested size and can
1535 * extent's size from the data space_info's bytes_may_use counter and
2291 u64 size;
2297 size = orig->end - orig->start + 1;
2298 if (size > fs_info->max_extent_size) {
2310 if (count_max_extents(fs_info, size) >= num_extents)
4514 trans->bytes_reserved = block_rsv.size;
4863 * for. So if we are truncating this file to a larger size we need to insert
4865 * the range between oldsize and size
4867 int btrfs_cont_expand(struct btrfs_inode *inode, loff_t oldsize, loff_t size)
4875 u64 block_end = ALIGN(size, fs_info->sectorsize);
4882 * If our size started in the middle of a block we need to zero out the
4890 if (size <= hole_start)
5038 * Truncate failed, so fix up the in-memory size. We
5041 * in-memory size to match.
5185 ret = btrfs_block_rsv_refill(fs_info, rsv, rsv->size + delayed_refs_extra,
5188 ret = btrfs_block_rsv_refill(fs_info, rsv, rsv->size,
5266 rsv->size = btrfs_calc_metadata_size(fs_info, 1);
7464 * Cap the size of reads to that usually seen in buffered I/O as we need
8095 * btrfs_page_mkwrite() is not allowed to change the file size as it gets
8104 * truncate_setsize() writes the inode size before removing pages, once we have
8119 loff_t size;
8160 size = i_size_read(inode);
8163 (page_start >= size)) {
8192 if (page->index == ((size - 1) >> PAGE_SHIFT)) {
8193 reserved_space = round_up(size - page_start,
8223 if (page_start + PAGE_SIZE > size)
8224 zero_start = offset_in_page(size);
8313 rsv->size = min_size;
8350 * size is not block aligned since we will be keeping the last
8441 * all. This means the truncate operation did not change the file size,
8442 * or changed it to a smaller size but there was only an implicit hole
8552 WARN_ON(inode->block_rsv.size);
9608 * clear_offset by our extent size.
9813 * The LZO format depends on the sector size. 64K is the maximum
9814 * sector size that we support.
10228 /* The sector size must match for LZO. */
10250 /* The extent size must be sane. */
10259 * size, but the buffered I/O path falls back to no compression for such
10279 * up the extent size and set i_size to the unaligned end.
10534 * Our swapfile may have had its size extended after the swap header was
10536 * the max size set in the swap header.
10863 * @start: Start offset of the file range, should be sector size aligned.
10865 * sector size aligned.