arch/arm/mm/dma-mapping.c

711

size_t sz = folio_size(folio) - offset;

arch/arm/mm/flush.c

208

folio_size(folio));

arch/arm/mm/nommu.c

174

__cpuc_flush_dcache_area(folio_address(folio), folio_size(folio));

arch/arm64/mm/flush.c

59

folio_size(folio));

arch/microblaze/include/asm/cacheflush.h

81

flush_dcache_range(addr, addr + folio_size(folio));

arch/nios2/mm/cacheflush.c

172

__flush_dcache(start, start + folio_size(folio));

arch/nios2/mm/cacheflush.c

196

flush_icache_range(start, start + folio_size(folio));

arch/s390/kernel/uv.c

356

lend = lstart + folio_size(folio) - 1;

arch/sh/mm/cache-sh7705.c

187

__flush_purge_region(folio_address(folio), folio_size(folio));

arch/sh/mm/cache.c

154

folio_size(folio));

arch/sh/mm/cache.c

174

folio_size(folio));

block/blk-lib.c

213

len = min_t(sector_t, folio_size(zero_folio),

drivers/dma-buf/udmabuf.c

342

size_t fsize = folio_size(folios[cur_folio]);

drivers/gpu/drm/panthor/panthor_mmu.c

2114

return folio_size(page_folio(pg)) >= SZ_2M;

fs/affs/file.c

539

BUG_ON(to > folio_size(folio));

fs/affs/file.c

638

to = folio_size(folio);

fs/affs/file.c

641

folio_zero_segment(folio, to, folio_size(folio));

fs/affs/file.c

683

err = affs_do_read_folio_ofs(folio, folio_size(folio), 1);

fs/btrfs/accessors.c

60

const int part = eb->folio_size - oif; \

fs/btrfs/accessors.c

90

const int part = eb->folio_size - oif; \

fs/btrfs/compression.c

1093

ASSERT(dest_pgoff + destlen <= folio_size(dest_folio) && destlen <= sectorsize);

fs/btrfs/compression.c

419

u64 folio_sz = folio_size(folio);

fs/btrfs/compression.c

445

cur += folio_size(folio);

fs/btrfs/compression.c

462

page_end = (pg_index << PAGE_SHIFT) + folio_size(folio) - 1;

fs/btrfs/compression.c

492

zeros = folio_size(folio) - zero_offset;

fs/btrfs/ctree.c

764

const int unit_size = eb->folio_size;

fs/btrfs/defrag.c

893

ordered = btrfs_lookup_ordered_range(inode, lock_start, folio_size(folio));

fs/btrfs/extent_io.c

1004

const u64 end = start + folio_size(folio) - 1;

fs/btrfs/extent_io.c

1028

folio_size(folio) - zero_offset);

fs/btrfs/extent_io.c

1341

const u64 end = start + folio_size(folio) - 1;

fs/btrfs/extent_io.c

1375

ASSERT(start >= folio_start && start + len <= folio_start + folio_size(folio));

fs/btrfs/extent_io.c

1393

ASSERT(start >= folio_start && start < folio_start + folio_size(folio));

fs/btrfs/extent_io.c

1429

const u64 page_end = page_start + folio_size(folio) - 1;

fs/btrfs/extent_io.c

1735

const u64 folio_end = folio_start + folio_size(folio);

fs/btrfs/extent_io.c

1743

start, len, folio_start, folio_size(folio));

fs/btrfs/extent_io.c

1852

folio_invalidate(folio, 0, folio_size(folio));

fs/btrfs/extent_io.c

1858

folio_zero_range(folio, pg_offset, folio_size(folio) - pg_offset);

fs/btrfs/extent_io.c

1900

folio_size(folio), bio_ctrl, i_size);

fs/btrfs/extent_io.c

2758

u64 end = start + folio_size(folio) - 1;

fs/btrfs/extent_io.c

2790

u64 end = start + folio_size(folio) - 1;

fs/btrfs/extent_io.c

2835

u64 end = start + folio_size(folio) - 1;

fs/btrfs/extent_io.c

3358

if (folio_size(existing_folio) != eb->folio_size) {

fs/btrfs/extent_io.c

3386

eb->folio_size = folio_size(eb->folios[i]);

fs/btrfs/extent_io.c

3970

const int unit_size = eb->folio_size;

fs/btrfs/extent_io.c

4010

const int unit_size = eb->folio_size;

fs/btrfs/extent_io.c

4050

const int unit_size = eb->folio_size;

fs/btrfs/extent_io.c

4120

const int unit_size = eb->folio_size;

fs/btrfs/extent_io.c

4169

const int unit_size = eb->folio_size;

fs/btrfs/extent_io.c

4200

const int unit_size = src->folio_size;

fs/btrfs/extent_io.c

4222

const int unit_size = dst->folio_size;

fs/btrfs/extent_io.c

4395

const int unit_size = dst->folio_size;

fs/btrfs/extent_io.c

558

btrfs_folio_set_lock(fs_info, folio, folio_pos(folio), folio_size(folio));

fs/btrfs/extent_io.c

711

eb->folio_size = PAGE_SIZE;

fs/btrfs/extent_io.c

798

ASSERT(pg_offset + size <= folio_size(folio));

fs/btrfs/extent_io.h

131

ASSERT(eb->folio_size);

fs/btrfs/extent_io.h

132

return start & (eb->folio_size - 1);

fs/btrfs/extent_io.h

89

u32 folio_size;

fs/btrfs/file.c

1863

size_t fsize = folio_size(folio);

fs/btrfs/file.c

1875

page_end = page_start + folio_size(folio) - 1;

fs/btrfs/file.c

1982

if (page_start + folio_size(folio) > size)

fs/btrfs/file.c

1988

folio_zero_range(folio, zero_start, folio_size(folio) - zero_start);

fs/btrfs/fs.h

1069

return folio_size(folio) >> fs_info->sectorsize_bits;

fs/btrfs/inode.c

1162

folio_size(async_chunk->locked_folio) - 1;

fs/btrfs/inode.c

2871

folio_size(folio));

fs/btrfs/inode.c

2900

btrfs_delalloc_release_extents(inode, folio_size(folio));

fs/btrfs/inode.c

2902

page_start, folio_size(folio),

fs/btrfs/inode.c

2960

folio_size(folio), !ret);

fs/btrfs/inode.c

3034

btrfs_folio_set_checked(fs_info, folio, folio_pos(folio), folio_size(folio));

fs/btrfs/inode.c

3465

ASSERT(offset_in_folio(folio, paddr) + blocksize <= folio_size(folio));

fs/btrfs/inode.c

7631

folio_size(folio), NULL);

fs/btrfs/inode.c

7680

u64 page_end = page_start + folio_size(folio) - 1;

fs/btrfs/inode.c

7712

if (!(offset == 0 && length == folio_size(folio))) {

fs/btrfs/inode.c

7832

btrfs_folio_clear_checked(fs_info, folio, folio_pos(folio), folio_size(folio));

fs/btrfs/inode.c

882

ASSERT(folio_size(fi.folio) == min_folio_size);

fs/btrfs/inode.c

900

folio_zero_range(last_folio, foffset, folio_size(last_folio) - foffset);

fs/btrfs/lzo.c

137

const u32 fsize = folio_size(*out_folio);

fs/btrfs/lzo.c

419

folio_size(cur_folio) - offset_in_folio(cur_folio, *cur_in));

fs/btrfs/lzo.c

450

ASSERT(folio_size(fi.folio) == btrfs_min_folio_size(fs_info));

fs/btrfs/raid56.c

3059

ASSERT(foffset <= folio_size(data_folios[findex]));

fs/btrfs/raid56.c

3060

if (foffset == folio_size(data_folios[findex])) {

fs/btrfs/relocation.c

2849

folio_end = folio_start + folio_size(folio) - 1;

fs/btrfs/relocation.c

2898

folio_start, folio_size(folio))) {

fs/btrfs/scrub.c

708

ASSERT(offset_in_folio(folio, offset) + fs_info->sectorsize <= folio_size(folio));

fs/btrfs/send.c

5231

cur_len = min_t(unsigned int, end - cur, folio_size(folio) - pg_offset);

fs/btrfs/subpage.c

192

start, len, folio_pos(folio), folio_size(folio));

fs/btrfs/subpage.c

90

bfs = btrfs_alloc_folio_state(fs_info, folio_size(folio), type);

fs/btrfs/subpage.h

112

return fs_info->sectorsize < folio_size(folio);

fs/btrfs/zlib.c

136

copy_length = min(folio_size(folio) - offset,

fs/btrfs/zlib.c

256

if (!bio_add_folio(bio, out_folio, folio_size(out_folio), 0)) {

fs/btrfs/zlib.c

294

if (!bio_add_folio(bio, out_folio, folio_size(out_folio), 0)) {

fs/btrfs/zlib.c

313

ASSERT(cur_len <= folio_size(out_folio));

fs/btrfs/zlib.c

362

ASSERT(folio_size(fi.folio) == min_folio_size);

fs/btrfs/zlib.c

424

ASSERT(folio_size(fi.folio) == min_folio_size);

fs/btrfs/zstd.c

480

if (!bio_add_folio(bio, out_folio, folio_size(out_folio), 0)) {

fs/btrfs/zstd.c

554

if (!bio_add_folio(bio, out_folio, folio_size(out_folio), 0)) {

fs/btrfs/zstd.c

603

ASSERT(folio_size(fi.folio) == min_folio_size);

fs/buffer.c

1579

BUG_ON(offset >= folio_size(folio));

fs/buffer.c

1639

BUG_ON(stop > folio_size(folio) || stop < length);

fs/buffer.c

1670

if (length == folio_size(folio))

fs/buffer.c

2120

BUG_ON(to > folio_size(folio));

fs/buffer.c

2354

to = min(folio_size(folio) - from, count);

fs/buffer.c

2356

if (from < blocksize && to > folio_size(folio) - blocksize)

fs/buffer.c

2631

end = folio_size(folio);

fs/buffer.c

2749

folio_size(folio));

fs/buffer.c

930

offset = folio_size(folio);

fs/ceph/addr.c

1171

folio_invalidate(folio, 0, folio_size(folio));

fs/ceph/addr.c

1374

ceph_wbc->len += folio_size(folio);

fs/ceph/addr.c

149

if (offset != 0 || length != folio_size(folio)) {

fs/ceph/addr.c

2064

if (off + folio_size(folio) <= size)

fs/ceph/addr.c

2065

len = folio_size(folio);

fs/ceph/addr.c

2251

if (len > folio_size(folio))

fs/ceph/addr.c

2252

len = folio_size(folio);

fs/ceph/addr.c

728

loff_t len = folio_size(folio);

fs/ceph/addr.c

765

folio_invalidate(folio, 0, folio_size(folio));

fs/ceph/addr.c

812

WARN_ON_ONCE(len > folio_size(folio));

fs/ecryptfs/mmap.c

172

folio_size(folio), inode);

fs/ecryptfs/mmap.c

188

folio->index, 0, folio_size(folio),

fs/erofs/fileio.c

93

unsigned int cur = 0, end = folio_size(folio), len, attached = 0;

fs/erofs/fscache.c

217

folio_pos(folio), folio_size(folio));

fs/erofs/fscache.c

229

folio_pos(folio), folio_size(folio));

fs/erofs/fscache.c

331

folio_pos(folio), folio_size(folio));

fs/erofs/zdata.c

1015

unsigned int end = folio_size(folio), split = 0, cur, pgs;

fs/erofs/zdata.c

656

DBG_BUGON(stop > folio_size(folio) || stop < length);

fs/erofs/zdata.c

658

if (offset == 0 && stop == folio_size(folio))

fs/ext2/dir.c

107

unsigned limit = folio_size(folio);

fs/ext2/dir.c

506

kaddr += folio_size(folio) - reclen;

fs/ext4/inline.c

562

folio_zero_segment(folio, 0, folio_size(folio));

fs/ext4/inode.c

1182

BUG_ON(to > folio_size(folio));

fs/ext4/inode.c

1184

WARN_ON_ONCE(blocksize > folio_size(folio));

fs/ext4/inode.c

1763

folio_size(folio));

fs/ext4/inode.c

2059

mpd->start_pos += folio_size(folio);

fs/ext4/inode.c

2086

len = folio_size(folio);

fs/ext4/inode.c

2584

size_t len = folio_size(folio);

fs/ext4/inode.c

3406

if (offset == 0 && length == folio_size(folio))

fs/ext4/inode.c

5753

folio_size(folio) - offset);

fs/ext4/inode.c

6617

len = folio_size(folio);

fs/ext4/inode.c

6698

len = folio_size(folio);

fs/ext4/mballoc.c

1395

blocks_per_folio = folio_size(folio) / blocksize;

fs/ext4/mballoc.c

1564

WARN_ON_ONCE(folio_size(folio) < sb->s_blocksize);

fs/ext4/mballoc.c

1582

WARN_ON_ONCE(folio_size(folio) < sb->s_blocksize);

fs/ext4/move_extent.c

227

move_len = umin(folio_pos(folio[0]) + folio_size(folio[0]) - orig_pos,

fs/ext4/move_extent.c

228

folio_pos(folio[1]) + folio_size(folio[1]) - donor_pos);

fs/ext4/page-io.c

482

if (len < folio_size(folio))

fs/ext4/page-io.c

483

folio_zero_segment(folio, len, folio_size(folio));

fs/ext4/readpage.c

250

blocks_per_folio = folio_size(folio) >> blkbits;

fs/ext4/readpage.c

295

folio_size(folio));

fs/ext4/readpage.c

329

folio_size(folio));

fs/f2fs/compress.c

1248

folio_zero_segment(folio, offset, folio_size(folio));

fs/f2fs/compress.c

1982

folio_address(cfolio), folio_size(folio));

fs/f2fs/data.c

1066

if (!bio_add_folio(io->bio, bio_folio, folio_size(bio_folio), 0)) {

fs/f2fs/data.c

1073

folio_size(fio->folio));

fs/f2fs/data.c

1334

folio_zero_segment(folio, 0, folio_size(folio));

fs/f2fs/data.c

1443

folio_zero_segment(folio, 0, folio_size(folio));

fs/f2fs/data.c

2217

folio_zero_segment(folio, 0, folio_size(folio));

fs/f2fs/data.c

2300

folio_zero_segment(folio, 0, folio_size(folio));

fs/f2fs/data.c

2713

folio_zero_segment(folio, 0, folio_size(folio));

fs/f2fs/data.c

3125

folio_zero_segment(folio, offset, folio_size(folio));

fs/f2fs/data.c

3943

if (len == folio_size(folio) || folio_test_uptodate(folio))

fs/f2fs/data.c

3948

folio_zero_segment(folio, len, folio_size(folio));

fs/f2fs/data.c

3953

folio_zero_segment(folio, 0, folio_size(folio));

fs/f2fs/data.c

4047

(offset || length != folio_size(folio)))

fs/f2fs/data.c

4061

if (offset || length != folio_size(folio))

fs/f2fs/data.c

766

bio_add_folio_nofail(bio, data_folio, folio_size(data_folio), 0);

fs/f2fs/data.c

823

bio_add_folio_nofail(bio, folio, folio_size(folio), 0);

fs/f2fs/data.c

863

bio_add_folio(*bio, folio, folio_size(folio), 0)) {

fs/f2fs/data.c

971

wbc_account_cgroup_owner(fio->io_wbc, folio, folio_size(folio));

fs/f2fs/file.c

175

folio_zero_segment(folio, offset, folio_size(folio));

fs/f2fs/file.c

765

folio_zero_segment(folio, offset, folio_size(folio));

fs/f2fs/inline.c

134

folio_zero_segment(folio, 0, folio_size(folio));

fs/f2fs/inline.c

91

folio_zero_segment(folio, MAX_INLINE_DATA(inode), folio_size(folio));

fs/f2fs/super.c

3147

tocopy = min(folio_size(folio) - offset, toread);

fs/f2fs/super.c

3862

if (!bio_add_folio(bio, folio, folio_size(folio), 0))

fs/fuse/dev.c

1003

if (cs->len != folio_size(oldfolio))

fs/fuse/dev.c

1124

size = folio_size(folio);

fs/fuse/dev.c

1815

nr_bytes = min(num, folio_size(folio) - folio_offset);

fs/fuse/dev.c

1820

(nr_bytes == folio_size(folio) || file_size == end)) {

fs/fuse/dev.c

1821

folio_zero_segment(folio, nr_bytes, folio_size(folio));

fs/fuse/dev.c

1919

nr_bytes = min(folio_size(folio) - folio_offset, num);

fs/fuse/dir.c

1818

struct fuse_folio_desc desc = { .length = folio_size(folio) - 1 };

fs/fuse/file.c

1221

if (count >= folio_size(folio) - offset)

fs/fuse/file.c

1222

count -= folio_size(folio) - offset;

fs/fuse/file.c

1273

bytes = min(folio_size(folio) - folio_offset, num);

fs/fuse/file.c

1303

if (offset == folio_size(folio))

fs/fuse/file.c

1307

if (tmp == folio_size(folio))

fs/gfs2/aops.c

114

gfs2_trans_add_databufs(ip->i_gl, folio, 0, folio_size(folio));

fs/gfs2/aops.c

204

size += folio_size(fbatch->folios[i]);

fs/gfs2/aops.c

467

chunk = min(size - copied, folio_size(folio) - offset);

fs/gfs2/aops.c

610

int partial_page = (offset || length < folio_size(folio));

fs/gfs2/aops.c

86

folio_size(folio));

fs/gfs2/bmap.c

64

memset(kaddr + dsize, 0, folio_size(folio) - dsize);

fs/gfs2/file.c

451

if (size - pos < folio_size(folio))

fs/gfs2/file.c

454

length = folio_size(folio);

fs/gfs2/lops.c

568

if (off == folio_size(folio))

fs/hfs/btree.c

102

len = min_t(size_t, folio_size(folio), sb->s_blocksize);

fs/hfs/btree.c

86

folio_zero_range(folio, 0, folio_size(folio));

fs/hfs/btree.c

91

size = folio_size(folio);

fs/hostfs/hostfs_kern.c

409

size_t count = folio_size(folio);

fs/hostfs/hostfs_kern.c

476

if (!folio_test_uptodate(folio) && err == folio_size(folio))

fs/iomap/buffered-io.c

1757

atomic_set(&ifs->write_bytes_pending, folio_size(folio));

fs/iomap/buffered-io.c

1851

folio_zero_segment(folio, poff, folio_size(folio));

fs/iomap/buffered-io.c

1863

u64 end_pos = pos + folio_size(folio);

fs/iomap/buffered-io.c

1874

trace_iomap_writeback_folio(inode, pos, folio_size(folio));

fs/iomap/buffered-io.c

1918

iomap_clear_range_dirty(folio, 0, folio_size(folio));

fs/iomap/buffered-io.c

1932

size_t bytes_not_submitted = folio_size(folio) -

fs/iomap/buffered-io.c

296

size_t plen = min_t(loff_t, folio_size(folio) - poff, length);

fs/iomap/buffered-io.c

392

iomap_set_range_uptodate(folio, offset, folio_size(folio) - offset);

fs/iomap/buffered-io.c

448

ifs->read_bytes_pending = folio_size(folio);

fs/iomap/buffered-io.c

481

ifs->read_bytes_pending -= folio_size(folio) - bytes_submitted;

fs/iomap/buffered-io.c

516

size_t folio_len = folio_size(folio);

fs/iomap/buffered-io.c

592

.len = folio_size(folio),

fs/iomap/buffered-io.c

696

count = min(folio_size(folio) - from, count);

fs/iomap/buffered-io.c

733

folio_size(folio));

fs/iomap/buffered-io.c

756

if (offset == 0 && len == folio_size(folio)) {

fs/iomap/buffered-io.c

767

size_t len = folio_size(folio);

fs/iomap/buffered-io.c

918

size_t fsize = folio_size(folio);

fs/iomap/direct-io.c

300

int nr_vecs = max(1, i_blocksize(inode) / folio_size(zero_folio));

fs/iomap/direct-io.c

321

unsigned int io_len = min(len, folio_size(zero_folio));

fs/jbd2/transaction.c

2435

int partial_page = (offset || length < folio_size(folio));

fs/jbd2/transaction.c

2445

BUG_ON(stop > folio_size(folio) || stop < length);

fs/jfs/jfs_metapage.c

492

xlen = (folio_size(folio) - offset) >> inode->i_blkbits;

fs/jfs/jfs_metapage.c

667

BUG_ON(offset || length < folio_size(folio));

fs/libfs.c

937

folio_zero_range(folio, 0, folio_size(folio));

fs/libfs.c

957

if (!folio_test_uptodate(folio) && (len != folio_size(folio))) {

fs/libfs.c

961

from + len, folio_size(folio));

fs/minix/dir.c

326

memset(kaddr, 0, folio_size(folio));

fs/mpage.c

156

const unsigned blocks_per_folio = folio_size(folio) >> blkbits;

fs/mpage.c

269

folio_zero_segment(folio, first_hole << blkbits, folio_size(folio));

fs/mpage.c

461

const unsigned blocks_per_folio = folio_size(folio) >> blkbits;

fs/mpage.c

576

length = folio_size(folio);

fs/mpage.c

587

folio_zero_segment(folio, length, folio_size(folio));

fs/mpage.c

611

wbc_account_cgroup_owner(wbc, folio, folio_size(folio));

fs/netfs/buffered_read.c

407

size_t flen = folio_size(folio);

fs/netfs/buffered_read.c

509

folio_pos(folio), folio_size(folio),

fs/netfs/buffered_read.c

562

size_t plen = folio_size(folio);

fs/netfs/buffered_read.c

664

folio_pos(folio), folio_size(folio),

fs/netfs/buffered_read.c

722

size_t flen = folio_size(folio);

fs/netfs/buffered_write.c

185

flen = folio_size(folio);

fs/netfs/iterator.c

219

flen = folio_size(folio);

fs/netfs/misc.c

215

size_t flen = folio_size(folio);

fs/netfs/read_pgpriv2.c

195

fsize = folio_size(folio);

fs/netfs/read_pgpriv2.c

22

size_t fsize = folio_size(folio), flen = fsize;

fs/netfs/rolling_buffer.c

158

ssize_t size = folio_size(folio);

fs/netfs/write_collect.c

150

fsize = folio_size(folio);

fs/netfs/write_issue.c

329

size_t fsize = folio_size(folio), flen = fsize, foff = 0;

fs/netfs/write_issue.c

710

size_t fsize = folio_size(folio), flen;

fs/netfs/write_issue.c

717

flen = folio_size(folio);

fs/nfs/file.c

304

size_t end = folio_size(folio);

fs/nfs/file.c

443

size_t fsize = folio_size(folio);

fs/nfs/file.c

491

if (offset != 0 || length < folio_size(folio))

fs/nfs/file.c

566

folio_size(folio), ret);

fs/nfs/internal.h

878

return folio_size(folio);

fs/nfs/read.c

292

size_t fsize = folio_size(folio);

fs/nfs/read.c

371

size_t len = folio_size(folio);

fs/nfs/read.c

57

folio_zero_segment(folio, 0, folio_size(folio));

fs/nfs/write.c

2037

size_t len = folio_size(folio);

fs/nfs/write.c

2071

size_t len = folio_size(folio);

fs/nilfs2/dir.c

116

size_t limit = folio_size(folio);

fs/nilfs2/dir.c

457

kaddr += folio_size(folio) - reclen;

fs/nilfs2/dir.c

528

char *kaddr = (char *)((unsigned long)dir & ~(folio_size(folio) - 1));

fs/ntfs3/attrib.c

1400

size_t len = min(data_size - vbo, folio_size(folio));

fs/ntfs3/frecord.c

1899

folio_zero_range(folio, 0, folio_size(folio));

fs/ntfs3/inode.c

591

u32 f_size = folio_size(folio);

fs/ntfs3/inode.c

685

folio_zero_range(folio, 0, folio_size(folio));

fs/ntfs3/inode.c

986

u32 f_size = folio_size(folio);

fs/ocfs2/alloc.c

6888

size_t to = folio_size(folio);

fs/ocfs2/aops.c

1972

folio_size(wc->w_target_folio));

fs/ocfs2/aops.c

1989

BUG_ON(from > folio_size(folio) ||

fs/ocfs2/aops.c

1990

to > folio_size(folio) ||

fs/ocfs2/aops.c

1999

to = folio_size(folio);

fs/ocfs2/aops.c

225

if (size > folio_size(folio) ||

fs/ocfs2/aops.c

303

folio_zero_segment(folio, 0, folio_size(folio));

fs/ocfs2/file.c

790

zero_to = folio_size(folio);

fs/orangefs/inode.c

273

bvec_set_folio(&bv, folio, folio_size(folio), 0);

fs/orangefs/inode.c

274

iov_iter_bvec(&iter, ITER_DEST, &bv, 1, folio_size(folio));

fs/orangefs/inode.c

277

folio_size(folio), inode->i_size, NULL, NULL, file);

fs/orangefs/inode.c

45

wlen = folio_size(folio);

fs/orangefs/inode.c

95

folio_size(ow->folios[i]) - start, start);

fs/smb/client/cifsfs.c

1314

size = folio_size(folio);

fs/smb/client/smb2ops.c

4683

size_t fsize = folio_size(folio);

fs/squashfs/file.c

499

folio_zero_segment(folio, 0, folio_size(folio));

fs/ubifs/file.c

1030

folio_zero_segment(folio, len, folio_size(folio));

fs/ubifs/file.c

119

folio_zero_range(folio, 0, folio_size(folio));

fs/ubifs/file.c

1291

if (offset || length < folio_size(folio))

fs/ubifs/file.c

242

if (pos == folio_pos(folio) && len >= folio_size(folio))

fs/ubifs/file.c

434

if (pos == folio_pos(folio) && len >= folio_size(folio)) {

fs/ubifs/file.c

555

if (len == folio_size(folio))

fs/ubifs/file.c

608

folio_zero_range(folio, 0, folio_size(folio));

fs/ubifs/file.c

988

int err, len = folio_size(folio);

fs/ufs/dir.c

115

unsigned limit = folio_size(folio);

fs/ufs/dir.c

330

kaddr += folio_size(folio) - reclen;

fs/ufs/dir.c

553

memset(kaddr, 0, folio_size(folio));

fs/vboxsf/file.c

280

u32 nwrite = folio_size(folio);

fs/vboxsf/file.c

331

if (!folio_test_uptodate(folio) && nwritten == folio_size(folio))

fs/xfs/scrub/trace.h

1177

__entry->folio_bytes = folio_size(si->folio);

fs/xfs/scrub/xfile.c

149

len = min_t(ssize_t, count, folio_size(folio) - offset);

fs/xfs/scrub/xfile.c

210

len = min_t(ssize_t, count, folio_size(folio) - offset);

fs/xfs/scrub/xfile.c

280

if (len > folio_size(folio) - offset_in_folio(folio, pos)) {

fs/xfs/scrub/xfile.c

309

trace_xfile_put_folio(xf, folio_pos(folio), folio_size(folio));

fs/xfs/xfs_file.c

1905

unsigned int len = folio_size(page_folio(vmf->page));

fs/xfs/xfs_trace.h

6368

__entry->bufsize = folio_size(folio);

fs/xfs/xfs_verify_media.c

348

min(bbcount << SECTOR_SHIFT, folio_size(folio)),

include/linux/bio.h

290

fi->length = min(folio_size(fi->folio) - fi->offset, fi->_seg_count);

include/linux/bio.h

301

fi->length = min(folio_size(fi->folio), fi->_seg_count);

include/linux/fsverity.h

289

return fsverity_verify_blocks(vi, folio, folio_size(folio), 0);

include/linux/highmem.h

502

VM_BUG_ON(dst_off + len > folio_size(dst_folio));

include/linux/highmem.h

503

VM_BUG_ON(src_off + len > folio_size(src_folio));

include/linux/highmem.h

577

VM_BUG_ON(offset + len > folio_size(folio));

include/linux/highmem.h

605

VM_BUG_ON(offset + len > folio_size(folio));

include/linux/highmem.h

642

size_t len = folio_size(folio) - offset;

include/linux/highmem.h

680

VM_BUG_ON(offset + len > folio_size(folio));

include/linux/highmem.h

723

len = min(len, folio_size(folio) - offset);

include/linux/hugetlb.h

863

return size_to_hstate(folio_size(folio));

include/linux/iov_iter.h

225

flen = min(folio_size(folio) - offset, len);

include/linux/mm.h

2794

#define offset_in_folio(folio, p) ((unsigned long)(p) & (folio_size(folio) - 1))

include/linux/nfs_page.h

223

return folio_size(folio);

include/linux/pagemap.h

1558

return folio_size(folio);

include/linux/pagemap.h

1581

return folio_size(folio) >> inode->i_blkbits;

include/linux/sunrpc/xdr.h

300

xdr_set_scratch_buffer(xdr, folio_address(folio), folio_size(folio));

io_uring/rsrc.c

1331

unsigned long folio_size = 1 << imu->folio_shift;

io_uring/rsrc.c

1332

unsigned long folio_mask = folio_size - 1;

io_uring/rsrc.c

1366

folio_size - offset);

io_uring/rsrc.c

748

if (folio_size(folio) != (1UL << data->folio_shift) ||

lib/buildid.c

117

folio_sz = folio_size(r->folio);

lib/buildid.c

129

folio_sz = folio_size(r->folio);

lib/buildid.c

45

file_off < r->folio_off + folio_size(r->folio))

lib/iov_iter.c

1858

len = min(folio_size(folio) - folio_offset, left);

lib/scatterlist.c

1361

len = min_t(size_t, maxsize, folio_size(folio) - offset);

mm/damon/ops-common.c

286

folio_sz = folio_size(folio);

mm/damon/paddr.c

187

*sz_filter_passed += folio_size(folio) / addr_unit;

mm/damon/paddr.c

198

addr += folio_size(folio);

mm/damon/paddr.c

228

*sz_filter_passed += folio_size(folio) / addr_unit;

mm/damon/paddr.c

236

addr += folio_size(folio);

mm/damon/paddr.c

276

*sz_filter_passed += folio_size(folio) / addr_unit;

mm/damon/paddr.c

282

addr += folio_size(folio);

mm/damon/paddr.c

310

*sz_filter_passed += folio_size(folio) / addr_unit;

mm/damon/paddr.c

311

addr += folio_size(folio);

mm/damon/paddr.c

79

*folio_sz = folio_size(folio);

mm/damon/vaddr.c

473

*priv->folio_sz = folio_size(folio);

mm/damon/vaddr.c

889

*sz_filter_passed += folio_size(folio);

mm/damon/vaddr.c

914

*sz_filter_passed += folio_size(folio);

mm/filemap.c

2538

if (pos == 0 && count >= folio_size(folio))

mm/filemap.c

2838

size_t fsize = folio_size(folio);

mm/filemap.c

3011

size = min(size, folio_size(folio) - offset);

mm/filemap.c

3172

} while (offset < folio_size(folio));

mm/filemap.c

3183

return folio_size(folio);

mm/filemap.c

3771

(addr0 & PMD_MASK) == ((addr0 + folio_size(folio) - 1) & PMD_MASK)) {

mm/filemap.c

4330

if (bytes > folio_size(folio) - offset)

mm/filemap.c

4331

bytes = folio_size(folio) - offset;

mm/hugetlb.c

1600

h = size_to_hstate(folio_size(folio));

mm/hugetlb.c

5316

folio_size(folio));

mm/internal.h

1092

return !(addr < start || end - addr < folio_size(folio));

mm/memfd_luo.c

190

folio_zero_range(folio, 0, folio_size(folio));

mm/memory.c

6021

end = min3(addr_start + folio_size(folio), pt_start + PMD_SIZE,

mm/memory.c

7337

const unsigned long base_addr = ALIGN_DOWN(addr_hint, folio_size(folio));

mm/memory.c

7373

unsigned long addr = ALIGN_DOWN(addr_hint, folio_size(dst));

mm/nommu.c

103

return folio_size(folio);

mm/page_io.c

399

bvec_set_folio(&sio->bvec[sio->pages], folio, folio_size(folio), 0);

mm/page_io.c

400

sio->len += folio_size(folio);

mm/page_io.c

418

bio_add_folio_nofail(&bio, folio, folio_size(folio), 0);

mm/page_io.c

438

bio_add_folio_nofail(bio, folio, folio_size(folio), 0);

mm/page_io.c

533

folio_zero_range(folio, 0, folio_size(folio));

mm/page_io.c

561

bvec_set_folio(&sio->bvec[sio->pages], folio, folio_size(folio), 0);

mm/page_io.c

562

sio->len += folio_size(folio);

mm/page_io.c

580

bio_add_folio_nofail(&bio, folio, folio_size(folio), 0);

mm/page_io.c

602

bio_add_folio_nofail(bio, folio, folio_size(folio), 0);

mm/page_isolation.c

57

h = size_to_hstate(folio_size(folio));

mm/secretmem.c

155

folio_zero_segment(folio, 0, folio_size(folio));

mm/shmem.c

1674

folio_zero_range(folio, 0, folio_size(folio));

mm/shmem.c

3352

if (copied < folio_size(folio)) {

mm/shmem.c

3355

from + copied, folio_size(folio));

mm/shmem.c

3421

fsize = folio_size(folio);

mm/truncate.c

160

folio_invalidate(folio, 0, folio_size(folio));

mm/truncate.c

220

size_t size = folio_size(folio);

mm/truncate.c

878

folio_size(folio));