block/bdev.c

143

loff_t size = i_size_read(BD_INODE(bdev));

block/fops.c

443

loff_t isize = i_size_read(inode);

block/fops.c

550

loff_t isize = i_size_read(wpc->inode);

block/fops.c

608

retval = fixed_size_llseek(file, offset, whence, i_size_read(bd_inode));

drivers/accel/habanalabs/common/hldio.c

100

if (inode->i_blocks << sb->s_blocksize_bits < i_size_read(inode)) {

drivers/block/loop.c

146

loopsize = i_size_read(file->f_mapping->host);

drivers/block/zram/zram_drv.c

768

nr_pages = i_size_read(inode) >> PAGE_SHIFT;

drivers/md/md-bitmap.c

1348

if (file && i_size_read(file->f_mapping->host) < store->bytes) {

drivers/md/md-bitmap.c

1351

(unsigned long) i_size_read(file->f_mapping->host),

drivers/md/md-bitmap.c

860

loff_t isize = i_size_read(bitmap->storage.file->f_mapping->host);

drivers/nvme/target/io-cmd-file.c

18

ns->size = i_size_read(ns->file->f_mapping->host);

drivers/target/target_core_file.c

163

dev_size = (i_size_read(file->f_mapping->host) -

drivers/target/target_core_file.c

816

dev_size = i_size_read(i);

drivers/usb/gadget/function/storage_common.c

225

size = i_size_read(inode);

fs/9p/cache.c

70

i_size_read(&v9inode->netfs.inode));

fs/9p/vfs_addr.c

83

if (pos + total >= i_size_read(rreq->inode))

fs/9p/vfs_dir.c

230

i_size = i_size_read(inode);

fs/9p/vfs_inode.c

1076

iattr->ia_size != i_size_read(inode)) {

fs/9p/vfs_inode_dotl.c

578

i_size_read(inode)) {

fs/affs/inode.c

241

attr->ia_size != i_size_read(inode)) {

fs/afs/dir.c

100

loff_t i_size = i_size_read(&dvnode->netfs.inode);

fs/afs/dir.c

134

unsigned long long i_size = i_size_read(&dvnode->netfs.inode);

fs/afs/dir.c

196

unsigned long long i_size = i_size_read(&dvnode->netfs.inode);

fs/afs/dir.c

2215

i_size_read(&dvnode->netfs.inode));

fs/afs/dir.c

239

i_size = i_size_read(&dvnode->netfs.inode);

fs/afs/dir.c

274

i_size = i_size_read(&dvnode->netfs.inode);

fs/afs/dir.c

317

i_size = i_size_read(&dvnode->netfs.inode);

fs/afs/dir.c

497

unsigned long long i_size = i_size_read(dir);

fs/afs/dir_edit.c

254

i_size = i_size_read(&vnode->netfs.inode);

fs/afs/dir_edit.c

407

i_size = i_size_read(&vnode->netfs.inode);

fs/afs/dir_edit.c

540

i_size = i_size_read(&vnode->netfs.inode);

fs/afs/dir_edit.c

612

i_size = i_size_read(&dvnode->netfs.inode);

fs/afs/dir_search.c

42

unsigned long long i_size = i_size_read(&iter->dvnode->netfs.inode);

fs/afs/file.c

189

i_size = i_size_read(&vnode->netfs.inode);

fs/afs/file.c

433

i_size = i_size_read(&vnode->netfs.inode);

fs/afs/inode.c

347

if (change_size || status->size > i_size_read(inode)) {

fs/afs/inode.c

553

i_size_read(&vnode->netfs.inode)));

fs/afs/inode.c

793

loff_t old_i_size = i_size_read(inode);

fs/afs/inode.c

859

i_size = i_size_read(inode);

fs/afs/internal.h

977

i_size_read(&vnode->netfs.inode), flags);

fs/afs/mntpt.c

125

loff_t size = i_size_read(d_inode(mntpt));

fs/btrfs/block-group.c

3382

i_size_read(inode)) {

fs/btrfs/block-group.c

3387

if (i_size_read(inode) > 0) {

fs/btrfs/compression.c

378

u64 isize = i_size_read(inode);

fs/btrfs/compression.c

407

end_index = (i_size_read(inode) - 1) >> PAGE_SHIFT;

fs/btrfs/defrag.c

1362

u64 isize = i_size_read(&inode->vfs_inode);

fs/btrfs/defrag.c

245

if (cur >= i_size_read(&inode->vfs_inode)) {

fs/btrfs/defrag.c

799

if (em_end >= i_size_read(inode))

fs/btrfs/direct-io.c

344

if (start + len > i_size_read(inode))

fs/btrfs/direct-io.c

816

if (iocb->ki_pos + iov_iter_count(from) <= i_size_read(inode) && IS_NOSEC(inode))

fs/btrfs/direct-io.c

859

pos + iov_iter_count(from) > i_size_read(inode)) {

fs/btrfs/extent-io-tree.c

69

isize = i_size_read(&inode->vfs_inode);

fs/btrfs/extent_io.c

1007

u64 last_byte = i_size_read(inode);

fs/btrfs/extent_io.c

1352

if (folio_pos(folio) < i_size_read(vfs_inode))

fs/btrfs/extent_io.c

1841

loff_t i_size = i_size_read(&inode->vfs_inode);

fs/btrfs/extent_io.c

2636

loff_t i_size = i_size_read(inode);

fs/btrfs/extent_io.c

2736

if (start < i_size_read(vfs_inode))

fs/btrfs/extent_io.c

583

if (bbio->file_offset < i_size_read(inode))

fs/btrfs/extent_io.c

599

loff_t i_size = i_size_read(inode);

fs/btrfs/fiemap.c

445

const u64 i_size = i_size_read(&inode->vfs_inode);

fs/btrfs/fiemap.c

822

const u64 i_size = i_size_read(&inode->vfs_inode);

fs/btrfs/file-item.c

52

i_size = new_i_size ?: i_size_read(&inode->vfs_inode);

fs/btrfs/file.c

1079

oldsize = i_size_read(inode);

fs/btrfs/file.c

1373

old_isize = i_size_read(inode);

fs/btrfs/file.c

1920

size = i_size_read(&inode->vfs_inode);

fs/btrfs/file.c

2865

if (mode & FALLOC_FL_KEEP_SIZE || end <= i_size_read(inode))

fs/btrfs/file.c

2868

range_start = round_down(i_size_read(inode), root->fs_info->sectorsize);

fs/btrfs/file.c

3157

ret = btrfs_cont_expand(BTRFS_I(inode), i_size_read(inode),

fs/btrfs/file.c

3538

const loff_t i_size = i_size_read(&inode->vfs_inode);

fs/btrfs/file.c

3833

iocb->ki_pos >= i_size_read(file_inode(iocb->ki_filp)))

fs/btrfs/file.c

80

loff_t isize = i_size_read(&inode->vfs_inode);

fs/btrfs/free-space-cache.c

1285

btrfs_unlock_extent(&BTRFS_I(inode)->io_tree, 0, i_size_read(inode) - 1,

fs/btrfs/free-space-cache.c

1383

if (!i_size_read(inode))

fs/btrfs/free-space-cache.c

1411

btrfs_lock_extent(&BTRFS_I(inode)->io_tree, 0, i_size_read(inode) - 1,

fs/btrfs/free-space-cache.c

1452

i_size = i_size_read(inode);

fs/btrfs/free-space-cache.c

1472

btrfs_unlock_extent(&BTRFS_I(inode)->io_tree, 0, i_size_read(inode) - 1,

fs/btrfs/free-space-cache.c

373

last_index = (i_size_read(inode) - 1) >> PAGE_SHIFT;

fs/btrfs/free-space-cache.c

383

num_pages = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

fs/btrfs/free-space-cache.c

752

if (!i_size_read(inode))

fs/btrfs/inode.c

2823

if (start >= i_size_read(&inode->vfs_inode) &&

fs/btrfs/inode.c

4222

round_up(i_size_read(vfs_inode), fs_info->sectorsize));

fs/btrfs/inode.c

5389

loff_t oldsize = i_size_read(inode);

fs/btrfs/inode.c

558

i_size = i_size_read(&inode->vfs_inode);

fs/btrfs/inode.c

608

if (size < i_size_read(&inode->vfs_inode))

fs/btrfs/inode.c

717

u64 size = min_t(u64, i_size_read(&inode->vfs_inode), end + 1);

fs/btrfs/inode.c

985

i_size = i_size_read(&inode->vfs_inode);

fs/btrfs/reflink.c

215

} else if (i_size_read(&inode->vfs_inode) <= datal) {

fs/btrfs/reflink.c

237

if (i_size_read(&inode->vfs_inode) > datal) {

fs/btrfs/reflink.c

600

if (last_dest_end >= i_size_read(inode))

fs/btrfs/send.c

6744

i_size = i_size_read(sctx->cur_inode);

fs/btrfs/tree-log.c

2882

from = ALIGN(i_size_read(&inode->vfs_inode),

fs/btrfs/tree-log.c

4791

const u64 i_size = i_size_read(&inode->vfs_inode);

fs/btrfs/tree-log.c

5238

const u64 i_size = i_size_read(&inode->vfs_inode);

fs/btrfs/tree-log.c

5395

em->start >= i_size_read(&inode->vfs_inode))

fs/btrfs/tree-log.c

5619

const u64 i_size = i_size_read(&inode->vfs_inode);

fs/btrfs/tree-log.c

6371

const u64 i_size = i_size_read(&inode->vfs_inode);

fs/buffer.c

1861

last_block = div_u64(i_size_read(inode) - 1, blocksize);

fs/buffer.c

2064

(offset >= i_size_read(inode)))

fs/buffer.c

2069

(offset >= i_size_read(inode)))

fs/buffer.c

2086

offset >= i_size_read(inode)) {

fs/buffer.c

2394

loff_t limit = i_size_read(inode);

fs/buffer.c

2623

size = i_size_read(inode);

fs/buffer.c

2729

loff_t i_size = i_size_read(inode);

fs/cachefiles/interface.c

132

oi_size = i_size_read(file_inode(file));

fs/cachefiles/interface.c

242

i_size = i_size_read(inode);

fs/cachefiles/io.c

219

i_size_read(file_inode(file)));

fs/cachefiles/io.c

299

i_size_read(file_inode(file)));

fs/cachefiles/io.c

98

i_size_read(file_inode(file)));

fs/ceph/addr.c

1169

folio_pos(folio) >= i_size_read(inode)) &&

fs/ceph/addr.c

1904

if (pos+copied > i_size_read(inode))

fs/ceph/addr.c

2012

if (err < 0 || off >= i_size_read(inode)) {

fs/ceph/addr.c

2048

loff_t size = i_size_read(inode);

fs/ceph/addr.c

2152

if (i_size_read(inode) == 0)

fs/ceph/addr.c

2250

len = i_size_read(inode);

fs/ceph/addr.c

226

subreq->len, i_size_read(req->r_inode));

fs/ceph/addr.c

566

fscache_write_to_cache(cookie, inode->i_mapping, off, len, i_size_read(inode),

fs/ceph/addr.c

643

ctl->i_size = i_size_read(inode);

fs/ceph/addr.c

668

ctl->i_size = i_size_read(inode);

fs/ceph/addr.c

685

u64 end = i_size_read(inode);

fs/ceph/cache.c

38

i_size_read(inode));

fs/ceph/cache.c

60

loff_t i_size = i_size_read(inode);

fs/ceph/cache.c

72

loff_t i_size = i_size_read(inode);

fs/ceph/cache.c

82

&ci->i_version, i_size_read(inode),

fs/ceph/caps.c

1430

arg->size = i_size_read(inode);

fs/ceph/caps.c

1986

loff_t size = i_size_read(&ci->netfs.inode);

fs/ceph/caps.c

3139

i_size_read(inode) > 0) {

fs/ceph/caps.c

3524

max_size, i_size_read(inode));

fs/ceph/dir.c

141

if (ptr_pos >= i_size_read(dir))

fs/ceph/dir.c

164

if (ceph_dir_is_complete_ordered(dir) && ptr_pos < i_size_read(dir))

fs/ceph/dir.c

205

u64 count = div_u64(i_size_read(dir), sizeof(struct dentry *));

fs/ceph/file.c

1053

u64 i_size = i_size_read(inode);

fs/ceph/file.c

1147

i_size = i_size_read(inode);

fs/ceph/file.c

1302

if (endoff > i_size_read(inode)) {

fs/ceph/file.c

1371

loff_t i_size = i_size_read(inode);

fs/ceph/file.c

1574

(len == count || pos + count <= i_size_read(inode))) {

fs/ceph/file.c

1624

size = i_size_read(inode);

fs/ceph/file.c

2078

if (pos > i_size_read(inode)) {

fs/ceph/file.c

2206

i_size = i_size_read(inode);

fs/ceph/file.c

2343

loff_t limit = max(i_size_read(inode), fsc->max_file_size);

fs/ceph/file.c

2404

i_size_read(inode));

fs/ceph/file.c

2705

size = i_size_read(inode);

fs/ceph/file.c

2815

size = i_size_read(src_inode);

fs/ceph/file.c

2827

size = i_size_read(dst_inode);

fs/ceph/file.c

3112

size = i_size_read(dst_inode);

fs/ceph/inode.c

1232

if (symlen != i_size_read(inode))

fs/ceph/inode.c

1236

i_size_read(inode));

fs/ceph/inode.c

1250

if (symlen != i_size_read(inode)) {

fs/ceph/inode.c

1254

i_size_read(inode));

fs/ceph/inode.c

2165

doutc(cl, "set_size %p %llu -> %llu\n", inode, i_size_read(inode), size);

fs/ceph/inode.c

2354

return fscrypt_get_symlink(inode, ci->i_symlink, i_size_read(inode),

fs/ceph/inode.c

2412

loff_t i_size = i_size_read(inode);

fs/ceph/inode.c

2537

loff_t isize = i_size_read(inode);

fs/ceph/inode.c

2903

attr->ia_size > max(i_size_read(inode), fsc->max_file_size))

fs/ceph/inode.c

810

loff_t isize = i_size_read(inode);

fs/ceph/mds_client.c

4703

rec.v1.size = cpu_to_le64(i_size_read(inode));

fs/ceph/quota.c

445

loff_t size = i_size_read(inode);

fs/ceph/snap.c

670

capsnap->size = i_size_read(inode);

fs/dax.c

1465

loff_t size = i_size_read(inode);

fs/dax.c

1594

end = min(end, i_size_read(iomi->inode));

fs/dax.c

1883

if (iter.pos >= i_size_read(iter.inode)) {

fs/dax.c

1994

max_pgoff = DIV_ROUND_UP(i_size_read(iter.inode), PAGE_SIZE);

fs/direct-io.c

1145

dio->i_size = i_size_read(inode);

fs/direct-io.c

1175

else if (iov_iter_rw(iter) == WRITE && end > i_size_read(inode))

fs/direct-io.c

643

i_size = i_size_read(dio->inode);

fs/direct-io.c

991

i_size_aligned = ALIGN(i_size_read(dio->inode),

fs/ecryptfs/crypto.c

1152

file_size = i_size_read(ecryptfs_inode_to_lower(inode));

fs/ecryptfs/file.c

174

!i_size_read(ecryptfs_inode_to_lower(inode))) {

fs/ecryptfs/file.c

257

(unsigned long long)i_size_read(inode));

fs/ecryptfs/inode.c

439

file_size_save = i_size_read(d_inode(old_dentry));

fs/ecryptfs/inode.c

731

loff_t i_size = i_size_read(inode);

fs/ecryptfs/inode.c

818

i_size_read(inode));

fs/ecryptfs/mmap.c

219

if ((i_size_read(inode) / PAGE_SIZE) != folio->index)

fs/ecryptfs/mmap.c

221

end_byte_in_page = i_size_read(inode) % PAGE_SIZE;

fs/ecryptfs/mmap.c

304

>= i_size_read(mapping->host)) {

fs/ecryptfs/mmap.c

324

if (prev_page_end_size > i_size_read(mapping->host)) {

fs/ecryptfs/mmap.c

338

if ((i_size_read(mapping->host) == prev_page_end_size)

fs/ecryptfs/mmap.c

366

put_unaligned_be64(i_size_read(ecryptfs_inode), file_size_virt);

fs/ecryptfs/mmap.c

406

put_unaligned_be64(i_size_read(ecryptfs_inode), xattr_virt);

fs/ecryptfs/mmap.c

485

if (pos + copied > i_size_read(ecryptfs_inode)) {

fs/ecryptfs/mmap.c

489

(unsigned long long)i_size_read(ecryptfs_inode));

fs/ecryptfs/read_write.c

97

loff_t ecryptfs_file_size = i_size_read(ecryptfs_inode);

fs/efivarfs/file.c

127

var->removed = (--var->open_count == 0 && i_size_read(inode) == 0);

fs/erofs/zdata.c

1862

while ((cur >= end) && (cur < i_size_read(inode))) {

fs/exfat/dir.c

241

if (ei->flags == ALLOC_NO_FAT_CHAIN && cpos >= i_size_read(inode))

fs/exfat/dir.c

87

EXFAT_B_TO_CLU(i_size_read(inode), sbi), ei->flags);

fs/exfat/dir.c

956

int total_entries = EXFAT_B_TO_DEN(i_size_read(&ei->vfs_inode));

fs/exfat/file.c

162

num_clusters_new = EXFAT_B_TO_CLU_ROUND_UP(i_size_read(inode), sbi);

fs/exfat/file.c

167

if (i_size_read(inode) > 0) {

fs/exfat/file.c

197

if (i_size_read(inode) < ei->valid_size)

fs/exfat/file.c

198

ei->valid_size = i_size_read(inode);

fs/exfat/file.c

264

inode->i_blocks = round_up(i_size_read(inode), sbi->cluster_size) >> 9;

fs/exfat/file.c

29

truncate_pagecache(inode, i_size_read(inode));

fs/exfat/file.c

297

attr->ia_size > i_size_read(inode)) {

fs/exfat/file.c

645

if (pos > i_size_read(inode))

fs/exfat/file.c

646

truncate_pagecache(inode, i_size_read(inode));

fs/exfat/file.c

720

new_valid_size = min(new_valid_size, i_size_read(inode));

fs/exfat/inode.c

263

i_size = i_size_read(inode);

fs/exfat/inode.c

405

if (ei->valid_size < i_size_read(inode) &&

fs/exfat/inode.c

426

if (to > i_size_read(inode)) {

fs/exfat/inode.c

427

truncate_pagecache(inode, i_size_read(inode));

fs/exfat/inode.c

650

inode->i_blocks = round_up(i_size_read(inode), sbi->cluster_size) >> 9;

fs/exfat/inode.c

73

on_disk_size = i_size_read(inode);

fs/exfat/namei.c

1173

EXFAT_B_TO_CLU_ROUND_UP(i_size_read(new_inode),

fs/exfat/namei.c

1218

EXFAT_B_TO_CLU_ROUND_UP(i_size_read(new_inode),

fs/exfat/namei.c

1251

loff_t size = i_size_read(new_dir);

fs/exfat/namei.c

1273

if (IS_DIRSYNC(new_dir) && size != i_size_read(new_dir))

fs/exfat/namei.c

276

if (EXFAT_B_TO_DEN(i_size_read(inode)) >= MAX_EXFAT_DENTRIES) {

fs/exfat/namei.c

324

EXFAT_B_TO_CLU(i_size_read(inode), sbi), ei->flags);

fs/exfat/namei.c

553

loff_t size = i_size_read(dir);

fs/exfat/namei.c

566

if (IS_DIRSYNC(dir) && size != i_size_read(dir))

fs/exfat/namei.c

613

EXFAT_B_TO_CLU(i_size_read(dir), sbi), ei->flags);

fs/exfat/namei.c

698

i_size_read(dir), ei->dir.dir, ei->entry);

fs/exfat/namei.c

855

loff_t size = i_size_read(dir);

fs/exfat/namei.c

868

if (IS_DIRSYNC(dir) && size != i_size_read(dir))

fs/exfat/namei.c

966

EXFAT_B_TO_CLU_ROUND_UP(i_size_read(inode), sbi), ei->flags);

fs/exfat/super.c

387

inode->i_blocks = round_up(i_size_read(inode), sbi->cluster_size) >> 9;

fs/ext2/file.c

202

if (pos > i_size_read(inode)) {

fs/ext2/file.c

237

if (iocb->ki_pos + iov_iter_count(from) > i_size_read(inode) ||

fs/ext2/file.c

70

if (ret > 0 && iocb->ki_pos > i_size_read(inode)) {

fs/ext2/inode.c

1459

if (i_size_read(inode) < 0) {

fs/ext2/inode.c

824

(first_block << blkbits) < i_size_read(inode))

fs/ext2/inode.c

832

if ((flags & IOMAP_WRITE) && offset + length > i_size_read(inode))

fs/ext2/inode.c

901

i_size = i_size_read(inode);

fs/ext2/super.c

1529

loff_t i_size = i_size_read(inode);

fs/ext4/crypto.c

147

if (WARN_ON_ONCE(IS_DAX(inode) && i_size_read(inode)))

fs/ext4/extents.c

4585

loff_t epos, old_size = i_size_read(inode);

fs/ext4/fast_commit.c

1873

ext4_ext_replay_shrink_inode(inode, i_size_read(inode) >>

fs/ext4/fast_commit.c

1937

i_size_read(inode) >> sb->s_blocksize_bits);

fs/ext4/file.c

211

if (offset + len > i_size_read(inode) ||

fs/ext4/file.c

225

if (pos + len > i_size_read(inode))

fs/ext4/file.c

400

pos + size <= i_size_read(inode))

fs/ext4/file.c

519

if (offset + count > i_size_read(inode))

fs/ext4/file.c

938

maxbytes, i_size_read(inode));

fs/ext4/inline.c

1835

i_size_read(inode));

fs/ext4/inline.c

524

len = min_t(size_t, ext4_get_inline_size(inode), i_size_read(inode));

fs/ext4/inode.c

2085

size = i_size_read(mpd->inode);

fs/ext4/inode.c

2179

ext4_lblk_t blocks = (i_size_read(inode) + i_blocksize(inode) - 1)

fs/ext4/inode.c

2539

i_size = i_size_read(inode);

fs/ext4/inode.c

2583

loff_t size = i_size_read(inode);

fs/ext4/inode.c

3468

offset + length > i_size_read(inode))

fs/ext4/inode.c

3715

else if (EXT4_LBLK_TO_B(inode, map->m_lblk) >= i_size_read(inode))

fs/ext4/inode.c

3787

if (offset + length <= i_size_read(inode)) {

fs/ext4/inode.c

4227

loff_t size = i_size_read(inode);

fs/ext4/inode.c

5286

size = i_size_read(inode);

fs/ext4/inode.c

6610

size = i_size_read(inode);

fs/ext4/inode.c

6690

size = i_size_read(inode);

fs/ext4/ioctl.c

345

isize = i_size_read(inode1);

fs/ext4/ioctl.c

346

i_size_write(inode1, i_size_read(inode2));

fs/ext4/mballoc.c

4553

if (size < i_size_read(ac->ac_inode))

fs/ext4/mballoc.c

4554

size = i_size_read(ac->ac_inode);

fs/ext4/mballoc.c

5852

isize = (i_size_read(ac->ac_inode) + ac->ac_sb->s_blocksize - 1)

fs/ext4/migrate.c

477

i_size_write(tmp_inode, i_size_read(inode));

fs/ext4/move_extent.c

542

orig_eof = EXT4_B_TO_LBLK(orig_inode, i_size_read(orig_inode));

fs/ext4/move_extent.c

543

donor_eof = EXT4_B_TO_LBLK(donor_inode, i_size_read(donor_inode));

fs/ext4/readpage.c

208

return i_size_read(inode);

fs/ext4/super.c

7335

loff_t i_size = i_size_read(inode);

fs/ext4/xattr.c

1555

if (i_size_read(ea_inode) == value_len &&

fs/ext4/xattr.c

2202

i_size_read(ea_inode));

fs/ext4/xattr.c

2285

i_size_read(ea_inode));

fs/ext4/xattr.c

543

if (i_size_read(ea_inode) != size) {

fs/ext4/xattr.c

546

i_size_read(ea_inode), size);

fs/f2fs/compress.c

874

loff_t i_size = i_size_read(cc->inode);

fs/f2fs/data.c

1456

if (new_i_size && i_size_read(inode) <

fs/f2fs/data.c

1887

if (pos + len > i_size_read(inode))

fs/f2fs/data.c

2150

return i_size_read(inode);

fs/f2fs/data.c

3063

loff_t i_size = i_size_read(inode);

fs/f2fs/data.c

3640

loff_t i_size = i_size_read(inode);

fs/f2fs/data.c

3684

} else if ((pos & PAGE_MASK) >= i_size_read(inode)) {

fs/f2fs/data.c

3816

if ((pos & PAGE_MASK) >= i_size_read(inode))

fs/f2fs/data.c

3946

if (!(pos & (PAGE_SIZE - 1)) && (pos + len) >= i_size_read(inode) &&

fs/f2fs/data.c

4013

if (pos + copied > i_size_read(inode) &&

fs/f2fs/data.c

4028

if (pos + copied > i_size_read(inode) &&

fs/f2fs/data.c

4255

last_lblock = F2FS_BYTES_TO_BLK(i_size_read(inode));

fs/f2fs/data.c

4579

offset + length > i_size_read(inode))

fs/f2fs/dir.c

41

return ((unsigned long long) (i_size_read(inode) + PAGE_SIZE - 1))

fs/f2fs/extent_cache.c

894

loff_t f_size = i_size_read(inode);

fs/f2fs/f2fs.h

3419

if (i_size_read(inode) == i_size)

fs/f2fs/f2fs.h

3652

i_size_read(inode) & ~PAGE_MASK)

fs/f2fs/f2fs.h

3659

ret = F2FS_I(inode)->last_disk_size == i_size_read(inode);

fs/f2fs/file.c

1107

attr->ia_size <= i_size_read(inode) &&

fs/f2fs/file.c

1140

loff_t old_size = i_size_read(inode);

fs/f2fs/file.c

1179

fi->last_disk_size = i_size_read(inode);

fs/f2fs/file.c

134

folio_pos(folio) > i_size_read(inode) ||

fs/f2fs/file.c

1559

pgoff_t nrpages = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

fs/f2fs/file.c

1588

if (offset + len >= i_size_read(inode))

fs/f2fs/file.c

1613

new_size = i_size_read(inode) - len;

fs/f2fs/file.c

1680

loff_t new_size = i_size_read(inode);

fs/f2fs/file.c

171

i_size_read(inode)) {

fs/f2fs/file.c

174

offset = i_size_read(inode) & ~PAGE_MASK;

fs/f2fs/file.c

1776

if (new_size > i_size_read(inode)) {

fs/f2fs/file.c

1793

new_size = i_size_read(inode) + len;

fs/f2fs/file.c

1798

if (offset >= i_size_read(inode))

fs/f2fs/file.c

1812

ret = f2fs_truncate_blocks(inode, i_size_read(inode), true);

fs/f2fs/file.c

1825

idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

fs/f2fs/file.c

1977

if (new_size > i_size_read(inode)) {

fs/f2fs/file.c

2348

isize = i_size_read(inode);

fs/f2fs/file.c

2908

DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE));

fs/f2fs/file.c

3634

end = F2FS_BLK_ALIGN(i_size_read(inode));

fs/f2fs/file.c

3901

last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

fs/f2fs/file.c

4079

last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

fs/f2fs/file.c

43

loff_t old_size = i_size_read(inode);

fs/f2fs/file.c

4513

last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

fs/f2fs/file.c

4593

last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

fs/f2fs/file.c

468

isize = i_size_read(inode);

fs/f2fs/file.c

4977

if (dio && i_size_read(inode) &&

fs/f2fs/file.c

4978

(F2FS_BYTES_TO_BLK(pos) < F2FS_BLK_ALIGN(i_size_read(inode))))

fs/f2fs/file.c

5270

if (preallocated && i_size_read(inode) < target_size) {

fs/f2fs/file.c

548

maxbytes, i_size_read(inode));

fs/f2fs/file.c

601

truncate_setsize(inode, i_size_read(inode));

fs/f2fs/file.c

932

err = f2fs_truncate_blocks(inode, i_size_read(inode), true);

fs/f2fs/inline.c

23

if (i_size_read(inode) > MAX_INLINE_DATA(inode))

fs/f2fs/inline.c

402

if (i_size_read(inode) < MAX_INLINE_DATA(inode))

fs/f2fs/inline.c

478

if (i_size_read(dir) < PAGE_SIZE)

fs/f2fs/inline.c

817

ilen = min_t(size_t, MAX_INLINE_DATA(inode), i_size_read(inode));

fs/f2fs/inode.c

694

ri->i_size = cpu_to_le64(i_size_read(inode));

fs/f2fs/recovery.c

714

(i_size_read(inode) <= ((loff_t)index << PAGE_SHIFT)))

fs/f2fs/segment.c

317

pgoff_t len = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

fs/f2fs/super.c

3123

loff_t i_size = i_size_read(inode);

fs/fat/cache.c

335

*last_block = (i_size_read(inode) + (blocksize - 1)) >> blocksize_bits;

fs/fat/file.c

298

if ((offset + len) <= i_size_read(inode))

fs/fuse/dax.c

400

loff_t i_size = i_size_read(inode);

fs/fuse/dax.c

617

if (pos >= i_size_read(inode))

fs/fuse/dax.c

700

((iocb->ki_pos) >= i_size_read(inode) ||

fs/fuse/dax.c

701

(iocb->ki_pos + iov_iter_count(from) > i_size_read(inode))));

fs/fuse/dev.c

1795

file_size = i_size_read(inode);

fs/fuse/dev.c

1877

file_size = i_size_read(inode);

fs/fuse/file.c

1098

(iocb->ki_pos + iov_iter_count(to) > i_size_read(inode))) {

fs/fuse/file.c

1391

return iocb->ki_pos + iov_iter_count(iter) > i_size_read(inode);

fs/fuse/file.c

1972

loff_t crop = i_size_read(inode);

fs/fuse/file.c

2803

attr.ia_size = i_size_read(inode);

fs/fuse/file.c

2832

i_size = i_size_read(inode);

fs/fuse/file.c

2965

offset + length > i_size_read(inode)) {

fs/fuse/inode.c

346

attr->size = i_size_read(inode);

fs/gfs2/aops.c

387

size_t dsize = i_size_read(&ip->i_inode);

fs/gfs2/aops.c

75

loff_t i_size = i_size_read(inode);

fs/gfs2/bmap.c

102

if (i_size_read(&ip->i_inode)) {

fs/gfs2/bmap.c

131

if (i_size_read(&ip->i_inode)) {

fs/gfs2/bmap.c

2011

if (!i_size_read(&ip->i_inode)) {

fs/gfs2/bmap.c

2178

error = punch_hole(ip, i_size_read(&ip->i_inode), 0);

fs/gfs2/bmap.c

2271

lblock_stop = i_size_read(jd->jd_inode) >> shift;

fs/gfs2/bmap.c

2298

(unsigned long long)(i_size_read(jd->jd_inode) - size),

fs/gfs2/bmap.c

2336

end_of_file = (i_size_read(&ip->i_inode) + sdp->sd_sb.sb_bsize - 1) >> shift;

fs/gfs2/bmap.c

61

u64 dsize = i_size_read(inode);

fs/gfs2/bmap.c

846

loff_t size = i_size_read(inode);

fs/gfs2/dir.c

350

if (hsize != i_size_read(&ip->i_inode)) {

fs/gfs2/dir.c

824

if (hsize * sizeof(u64) != i_size_read(inode)) {

fs/gfs2/file.c

441

size = i_size_read(inode);

fs/gfs2/file.c

909

if (iocb->ki_pos + iov_iter_count(from) > i_size_read(&ip->i_inode))

fs/gfs2/glops.c

558

(unsigned long long)i_size_read(inode),

fs/gfs2/inode.c

1926

size = (unsigned int)i_size_read(&ip->i_inode);

fs/gfs2/inode.h

78

u64 size = i_size_read(inode);

fs/gfs2/quota.c

1392

u64 size = i_size_read(sdp->sd_qc_inode);

fs/gfs2/rgrp.c

852

if (pos + sizeof(struct gfs2_rindex) > i_size_read(inode))

fs/gfs2/rgrp.c

903

if (pos >= i_size_read(&ip->i_inode))

fs/gfs2/super.c

111

u64 size = i_size_read(jd->jd_inode);

fs/gfs2/super.c

407

str->di_size = cpu_to_be64(i_size_read(inode));

fs/hfs/inode.c

140

loff_t isize = i_size_read(inode);

fs/hfs/inode.c

676

attr->ia_size != i_size_read(inode)) {

fs/hfsplus/inode.c

138

loff_t isize = i_size_read(inode);

fs/hfsplus/inode.c

241

if (!(file->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)

fs/hfsplus/inode.c

277

attr->ia_size != i_size_read(inode)) {

fs/hfsplus/xattr.c

175

if (i_size_read(attr_file) != 0) {

fs/hfsplus/xattr.c

81

tmp = i_size_read(attr_file);

fs/hostfs/hostfs_kern.c

404

loff_t i_size = i_size_read(inode);

fs/hostfs/hostfs_kern.c

868

attr->ia_size != i_size_read(inode))

fs/hpfs/file.c

238

len = min_t(u64, len, i_size_read(inode));

fs/hpfs/inode.c

283

attr->ia_size != i_size_read(inode)) {

fs/hugetlbfs/inode.c

257

isize = i_size_read(inode);

fs/ioctl.c

283

sr.l_start += i_size_read(inode);

fs/ioctl.c

312

sr.l_start += i_size_read(inode);

fs/ioctl.c

553

return put_user(i_size_read(inode) - filp->f_pos,

fs/iomap/buffered-io.c

1396

loff_t scan_end_byte = min(i_size_read(inode), end_byte);

fs/iomap/buffered-io.c

1508

loff_t size = i_size_read(inode);

fs/iomap/buffered-io.c

1809

u64 isize = i_size_read(inode);

fs/iomap/buffered-io.c

292

loff_t isize = i_size_read(inode);

fs/iomap/buffered-io.c

358

pos >= i_size_read(iter->inode);

fs/iomap/buffered-io.c

374

size_t size = i_size_read(iter->inode) - iomap->offset;

fs/iomap/buffered-io.c

778

loff_t i_size = i_size_read(inode);

fs/iomap/direct-io.c

558

((dio->flags & IOMAP_DIO_WRITE) && pos >= i_size_read(inode))) {

fs/iomap/direct-io.c

700

dio->i_size = i_size_read(inode);

fs/iomap/seek.c

32

loff_t size = i_size_read(inode);

fs/iomap/seek.c

78

loff_t size = i_size_read(inode);

fs/iomap/swapfile.c

148

.len = ALIGN_DOWN(i_size_read(inode), PAGE_SIZE),

fs/iomap/trace.h

66

__entry->size = i_size_read(inode);

fs/jfs/file.c

115

iattr->ia_size != i_size_read(inode)) {

fs/jfs/inode.c

346

loff_t isize = i_size_read(inode);

fs/jfs/super.c

705

loff_t i_size = i_size_read(inode);

fs/kernel_read_file.c

55

i_size = i_size_read(file_inode(file));

fs/locks.c

521

fl->fl_start = i_size_read(file_inode(filp));

fs/minix/file.c

36

attr->ia_size != i_size_read(inode)) {

fs/mpage.c

183

last_block_in_file = (i_size_read(inode) + blocksize - 1) >> blkbits;

fs/mpage.c

473

loff_t i_size = i_size_read(inode);

fs/netfs/buffered_read.c

560

loff_t i_size = i_size_read(inode);

fs/netfs/buffered_write.c

476

_enter("%llx,%zx,%llx", iocb->ki_pos, iov_iter_count(from), i_size_read(inode));

fs/netfs/buffered_write.c

63

if (end <= i_size_read(inode))

fs/netfs/buffered_write.c

73

i_size = i_size_read(inode);

fs/netfs/direct_write.c

337

_enter("%llx,%zx,%llx", pos, iov_iter_count(from), i_size_read(inode));

fs/netfs/direct_write.c

382

fscache_invalidate(netfs_i_cookie(ictx), NULL, i_size_read(inode),

fs/netfs/misc.c

196

loff_t i_size = i_size_read(inode);

fs/netfs/misc.c

220

unsigned long long i_size = i_size_read(&ctx->inode);

fs/netfs/misc.c

301

end = umin(folio_next_pos(folio), i_size_read(&ctx->inode));

fs/netfs/objects.c

46

rreq->i_size = i_size_read(inode);

fs/netfs/read_pgpriv2.c

32

i_size = i_size_read(creq->inode);

fs/netfs/write_issue.c

343

i_size = i_size_read(wreq->inode);

fs/nfs/blocklayout/blocklayout.c

839

(req_offset(req) + req->wb_bytes == i_size_read(pgio->pg_inode))) {

fs/nfs/blocklayout/blocklayout.c

894

end = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

fs/nfs/blocklayout/blocklayout.c

902

return i_size_read(inode) - (idx << PAGE_SHIFT);

fs/nfs/callback_proc.c

65

res->size = i_size_read(inode);

fs/nfs/direct.c

138

loff_t oldsize = i_size_read(inode);

fs/nfs/file.c

396

nfs_truncate_last_folio(mapping, i_size_read(mapping->host), pos);

fs/nfs/file.c

723

if (iocb->ki_flags & IOCB_APPEND || iocb->ki_pos > i_size_read(inode)) {

fs/nfs/fscache.c

182

i_size_read(inode));

fs/nfs/fscache.c

228

fscache_invalidate(cookie, &auxdata, i_size_read(inode),

fs/nfs/fscache.c

238

loff_t i_size = i_size_read(inode);

fs/nfs/fscache.h

135

fscache_invalidate(cookie, &auxdata, i_size_read(inode), flags);

fs/nfs/inode.c

1650

&& i_size_read(inode) == nfs_size_to_loff_t(fattr->pre_size)

fs/nfs/inode.c

1706

cur_size = i_size_read(inode);

fs/nfs/inode.c

2199

fattr->pre_size = i_size_read(inode);

fs/nfs/inode.c

2400

cur_isize = i_size_read(inode);

fs/nfs/inode.c

729

oldsize = i_size_read(inode);

fs/nfs/internal.h

872

loff_t i_size = i_size_read(folio->mapping->host);

fs/nfs/localio.c

635

if (hdr->args.offset + hdr->res.count >= i_size_read(file_inode(filp)))

fs/nfs/nfs42proc.c

1273

loff_t oldsize_dst = i_size_read(dst_inode);

fs/nfs/nfs42proc.c

150

oldsize = i_size_read(inode);

fs/nfs/nfs42proc.c

207

oldsize = i_size_read(inode);

fs/nfs/nfs42proc.c

397

if (newsize > i_size_read(inode))

fs/nfs/nfs42proc.c

472

oldsize_dst = i_size_read(dst_inode);

fs/nfs/nfs4file.c

272

if (!IS_ALIGNED(count, bs) && i_size_read(src_inode) != (src_off + count))

fs/nfs/nfs4proc.c

4529

sattr->ia_size < i_size_read(inode))

fs/nfs/nfstrace.h

128

__entry->size = i_size_read(inode);

fs/nfs/nfstrace.h

218

__entry->size = i_size_read(inode);

fs/nfs/nfstrace.h

270

__entry->cur_size = i_size_read(inode);

fs/nfs/pnfs.c

1203

loff_t i_size = i_size_read(ino);

fs/nfs/pnfs.c

2009

loff_t fsize = i_size_read(ino);

fs/nfs/pnfs.c

2439

(i_size_read(ino) == 0 || ino->i_mapping->nrpages != 0))

fs/nfs/pnfs.c

2891

rd_size = i_size_read(pgio->pg_inode) - req_offset(req);

fs/nfs/write.c

1327

status, (long long)i_size_read(inode));

fs/nfs/write.c

1447

if (nfs_size_to_loff_t(fattr->size) < i_size_read(hdr->inode)) {

fs/nfs/write.c

196

i_size = i_size_read(inode);

fs/nfsd/nfs4proc.c

2413

else if (seek->seek_pos >= i_size_read(file_inode(nf->nf_file)))

fs/nfsd/nfs4proc.c

2745

if (new_size > i_size_read(inode)) {

fs/nfsd/nfs4xdr.c

5815

read->rd_eof = read->rd_offset >= i_size_read(file_inode(file));

fs/nfsd/vfs.c

1042

if (offset+len >= i_size_read(file_inode(file)))

fs/nilfs2/file.c

61

folio_pos(folio) >= i_size_read(inode) ||

fs/nilfs2/inode.c

1121

isize = i_size_read(inode);

fs/nilfs2/inode.c

926

iattr->ia_size != i_size_read(inode)) {

fs/ntfs3/dir.c

407

loff_t i_size = i_size_read(dir);

fs/ntfs3/dir.c

579

size_t max_indx = i_size_read(&ni->vfs_inode) >> ni->dir.index_bits;

fs/ntfs3/file.c

1540

i_size_read(inode));

fs/ntfs3/file.c

254

u64 to = min_t(u64, i_size_read(inode),

fs/ntfs3/file.c

311

u64 to = min_t(u64, i_size_read(inode),

fs/ntfs3/file.c

750

oldsize = i_size_read(inode);

fs/ntfs3/file.c

983

loff_t i_size = i_size_read(inode);

fs/ntfs3/frecord.c

1898

if (vbo >= i_size_read(&ni->vfs_inode)) {

fs/ntfs3/frecord.c

1972

loff_t i_size = i_size_read(inode);

fs/ntfs3/frecord.c

2288

loff_t i_size = i_size_read(&ni->vfs_inode);

fs/ocfs2/alloc.c

6982

range_end = min_t(u64, range_end, i_size_read(inode));

fs/ocfs2/alloc.c

7096

has_data = i_size_read(inode) ? 1 : 0;

fs/ocfs2/alloc.c

7253

i_size_read(inode));

fs/ocfs2/alloc.c

7417

if (start >= i_size_read(inode))

fs/ocfs2/alloc.c

7420

if (end > i_size_read(inode))

fs/ocfs2/alloc.c

7421

end = i_size_read(inode);

fs/ocfs2/aops.c

1028

last_byte = max(user_pos + user_len, i_size_read(inode));

fs/ocfs2/aops.c

1550

if (oi->ip_clusters != 0 || i_size_read(inode) != 0)

fs/ocfs2/aops.c

1596

if (newsize <= i_size_read(inode))

fs/ocfs2/aops.c

1606

ocfs2_clusters_for_bytes(inode->i_sb, i_size_read(inode));

fs/ocfs2/aops.c

1617

if (pos > i_size_read(inode))

fs/ocfs2/aops.c

1699

(long long)i_size_read(inode),

fs/ocfs2/aops.c

191

mlog(ML_ERROR, "Size %llu, clusters %u\n", (unsigned long long)i_size_read(inode), OCFS2_I(inode)->ip_clusters);

fs/ocfs2/aops.c

1959

new_isize = max_t(loff_t, i_size_read(inode), pos + copied);

fs/ocfs2/aops.c

197

past_eof = ocfs2_blocks_for_bytes(inode->i_sb, i_size_read(inode));

fs/ocfs2/aops.c

2017

if (pos > i_size_read(inode)) {

fs/ocfs2/aops.c

2022

di->i_size = cpu_to_le64((u64)i_size_read(inode));

fs/ocfs2/aops.c

2127

sector_t endblk = (i_size_read(inode) - 1) >> i_blkbits;

fs/ocfs2/aops.c

2157

if (pos + total_len <= i_size_read(inode)) {

fs/ocfs2/aops.c

2178

ocfs2_clusters_for_bytes(inode->i_sb, i_size_read(inode)) &&

fs/ocfs2/aops.c

223

size = i_size_read(inode);

fs/ocfs2/aops.c

2287

end <= i_size_read(inode) &&

fs/ocfs2/aops.c

2303

end = end > i_size_read(inode) ? end : 0;

fs/ocfs2/aops.c

2359

if (end > i_size_read(inode)) {

fs/ocfs2/aops.c

2431

if (iocb->ki_pos + iter->count > i_size_read(inode) &&

fs/ocfs2/aops.c

302

if (start >= i_size_read(inode)) {

fs/ocfs2/aops.c

362

if (readahead_pos(rac) >= i_size_read(inode))

fs/ocfs2/aops.c

560

if (i_size_read(inode) > offset)

fs/ocfs2/aops.c

936

new = new | ((i_size_read(inode) <= folio_pos(folio)) &&

fs/ocfs2/cluster/heartbeat.c

1358

i_size_read(file->f_mapping->host));

fs/ocfs2/cluster/netdebug.c

475

i_size_read(file->f_mapping->host));

fs/ocfs2/dir.c

1102

if (unlikely(i_size_read(dir) <= 0)) {

fs/ocfs2/dir.c

1113

if (unlikely(i_size_read(dir) > dir->i_sb->s_blocksize)) {

fs/ocfs2/dir.c

1413

i_size_read(dir));

fs/ocfs2/dir.c

1672

size = i_size_read(dir);

fs/ocfs2/dir.c

1801

while (ctx->pos < i_size_read(inode)) {

fs/ocfs2/dir.c

1807

for (i = 0; i < i_size_read(inode) && i < offset; ) {

fs/ocfs2/dir.c

1827

i_size_read(inode), ctx->pos)) {

fs/ocfs2/dir.c

1829

ctx->pos = i_size_read(inode);

fs/ocfs2/dir.c

1867

while (ctx->pos < i_size_read(inode)) {

fs/ocfs2/dir.c

1917

while (ctx->pos < i_size_read(inode)

fs/ocfs2/dir.c

2738

limit = de_buf + i_size_read(dir);

fs/ocfs2/dir.c

2960

memcpy(dirdata_bh->b_data, di->id2.i_data.id_data, i_size_read(dir));

fs/ocfs2/dir.c

2961

memset(dirdata_bh->b_data + i_size_read(dir), 0,

fs/ocfs2/dir.c

2962

sb->s_blocksize - i_size_read(dir));

fs/ocfs2/dir.c

2963

i = ocfs2_expand_last_dirent(dirdata_bh->b_data, i_size_read(dir), dir);

fs/ocfs2/dir.c

3147

extend = (i_size_read(dir) == ocfs2_clusters_to_bytes(sb, OCFS2_I(dir)->ip_clusters));

fs/ocfs2/dir.c

3169

v_blkno = ocfs2_blocks_for_bytes(sb, i_size_read(dir));

fs/ocfs2/dir.c

3260

dir_i_size = i_size_read(dir);

fs/ocfs2/dir.c

3267

dir_i_size = i_size_read(dir);

fs/ocfs2/dir.c

3406

free_space = ocfs2_dir_trailer_blk_off(sb) - i_size_read(dir);

fs/ocfs2/dir.c

3408

free_space = dir->i_sb->s_blocksize - i_size_read(dir);

fs/ocfs2/dir.c

3412

limit = de_buf + i_size_read(dir);

fs/ocfs2/dir.c

3419

i_size_read(dir), offset)) {

fs/ocfs2/dir.c

3450

i_size_read(dir));

fs/ocfs2/dir.c

3492

if (i_size_read(dir) <= offset) {

fs/ocfs2/dir.c

428

data->id_data, i_size_read(dir), res_dir);

fs/ocfs2/dir.c

700

nblocks = i_size_read(dir) >> sb->s_blocksize_bits;

fs/ocfs2/dir.c

767

nblocks = i_size_read(dir) >> sb->s_blocksize_bits;

fs/ocfs2/dlm/dlmdebug.c

291

i_size_read(file->f_mapping->host));

fs/ocfs2/dlmglue.c

2181

lvb->lvb_isize = cpu_to_be64(i_size_read(inode));

fs/ocfs2/extent_map.c

901

if (*offset >= i_size_read(inode)) {

fs/ocfs2/extent_map.c

908

*offset = i_size_read(inode);

fs/ocfs2/extent_map.c

914

cend = ocfs2_clusters_for_bytes(inode->i_sb, i_size_read(inode));

fs/ocfs2/extent_map.c

953

if ((extoff + extlen) > i_size_read(inode))

fs/ocfs2/extent_map.c

954

extlen = i_size_read(inode) - extoff;

fs/ocfs2/extent_map.c

988

i_size_read(inode)) {

fs/ocfs2/file.c

1062

if (i_size_read(inode) == new_i_size)

fs/ocfs2/file.c

1064

BUG_ON(new_i_size < i_size_read(inode));

fs/ocfs2/file.c

1212

if (i_size_read(inode) >= attr->ia_size) {

fs/ocfs2/file.c

1591

loff_t isize = i_size_read(inode);

fs/ocfs2/file.c

1987

sr->l_start += i_size_read(inode);

fs/ocfs2/file.c

2042

orig_isize = i_size_read(inode);

fs/ocfs2/file.c

2386

i_size_read(inode) ? 1 : 0);

fs/ocfs2/file.c

2671

offset += i_size_read(inode);

fs/ocfs2/file.c

455

mlog_bug_on_msg(le64_to_cpu(fe->i_size) != i_size_read(inode),

fs/ocfs2/file.c

459

i_size_read(inode),

fs/ocfs2/file.c

490

i_size_read(inode), 1);

fs/ocfs2/file.c

609

(unsigned long long)i_size_read(inode),

fs/ocfs2/file.c

680

(unsigned long long)i_size_read(inode));

fs/ocfs2/file.c

827

di->i_size = cpu_to_le64((u64)i_size_read(inode));

fs/ocfs2/file.c

974

zero_start = ocfs2_align_bytes_to_blocks(sb, i_size_read(inode));

fs/ocfs2/file.c

977

(unsigned long long)i_size_read(inode));

fs/ocfs2/inode.c

1372

fe->i_size = cpu_to_le64(i_size_read(inode));

fs/ocfs2/ioctl.c

268

oij.ij_journal_size = i_size_read(osb->journal->j_inode);

fs/ocfs2/journal.c

1253

num_blocks = ocfs2_blocks_for_bytes(inode->i_sb, i_size_read(inode));

fs/ocfs2/journal.c

2333

i_size_read(inode));

fs/ocfs2/journal.c

949

if (i_size_read(inode) < OCFS2_MIN_JOURNAL_SIZE) {

fs/ocfs2/journal.c

951

i_size_read(inode));

fs/ocfs2/journal.c

956

trace_ocfs2_journal_init(i_size_read(inode),

fs/ocfs2/mmap.c

58

loff_t size = i_size_read(inode);

fs/ocfs2/move_extents.c

1029

if (range.me_start > i_size_read(inode)) {

fs/ocfs2/move_extents.c

1034

if (range.me_start + range.me_len > i_size_read(inode))

fs/ocfs2/move_extents.c

1035

range.me_len = i_size_read(inode) - range.me_start;

fs/ocfs2/move_extents.c

1047

if (range.me_threshold > i_size_read(inode))

fs/ocfs2/move_extents.c

1048

range.me_threshold = i_size_read(inode);

fs/ocfs2/move_extents.c

780

if ((i_size_read(inode) == 0) || (range->me_len == 0))

fs/ocfs2/namei.c

1723

bytes_left = i_size_read(inode) + 1;

fs/ocfs2/namei.c

1729

i_size_read(inode), blocks);

fs/ocfs2/namei.c

2659

status = ocfs2_truncate_file(inode, di_bh, i_size_read(inode));

fs/ocfs2/quota_global.c

172

loff_t i_size = i_size_read(gqinode);

fs/ocfs2/quota_global.c

240

if (i_size_read(gqinode) < off + len) {

fs/ocfs2/quota_global.c

854

i_size_read(gqinode) + (need_alloc << sb->s_blocksize_bits),

fs/ocfs2/quota_global.c

855

i_size_read(gqinode));

fs/ocfs2/quota_local.c

1120

i_size_read(lqinode) + sb->s_blocksize,

fs/ocfs2/quota_local.c

1121

i_size_read(lqinode));

fs/ocfs2/quota_local.c

1127

i_size_read(lqinode) + sb->s_blocksize);

fs/ocfs2/quota_local.c

140

if (i_size_read(inode) >> inode->i_sb->s_blocksize_bits <= v_block)

fs/ocfs2/quota_local.c

145

(unsigned long long)i_size_read(inode));

fs/ocfs2/quota_local.c

977

i_size_read(lqinode) + 2 * sb->s_blocksize,

fs/ocfs2/quota_local.c

978

i_size_read(lqinode));

fs/ocfs2/quota_local.c

984

i_size_read(lqinode) + 2 * sb->s_blocksize);

fs/ocfs2/refcounttree.c

2920

if (end > i_size_read(inode))

fs/ocfs2/refcounttree.c

2921

end = i_size_read(inode);

fs/ocfs2/refcounttree.c

3796

size = i_size_read(inode);

fs/ocfs2/refcounttree.c

3977

size = i_size_read(s_inode);

fs/ocfs2/refcounttree.c

4024

loff_t size = i_size_read(s_inode);

fs/ocfs2/refcounttree.c

4456

if (newlen <= i_size_read(dest))

fs/ocfs2/refcounttree.c

4469

if (newlen > i_size_read(dest))

fs/ocfs2/refcounttree.c

4623

if (pos_in == pos_out && pos_in == 0 && len == i_size_read(s_inode) &&

fs/ocfs2/refcounttree.c

4624

i_size_read(t_inode) <= len &&

fs/ocfs2/slot_map.c

224

if (bytes_needed > i_size_read(inode)) {

fs/ocfs2/slot_map.c

227

i_size_read(inode), bytes_needed);

fs/ocfs2/super.c

371

i_size_read(file->f_mapping->host));

fs/omfs/file.c

352

attr->ia_size != i_size_read(inode)) {

fs/open.c

1545

if (!(filp->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)

fs/orangefs/file.c

366

if (iocb->ki_pos > i_size_read(file_inode(iocb->ki_filp))) {

fs/orangefs/file.c

529

(unsigned long)i_size_read(inode));

fs/orangefs/inode.c

32

len = i_size_read(inode);

fs/orangefs/inode.c

575

if (*offset > i_size_read(inode))

fs/orangefs/inode.c

703

orig_size = i_size_read(inode);

fs/orangefs/inode.c

733

if (orig_size != i_size_read(inode))

fs/orangefs/inode.c

89

len = i_size_read(inode);

fs/overlayfs/util.c

1541

i_size_write(inode, i_size_read(realinode));

fs/overlayfs/util.c

778

if (!d_is_reg(dentry) || i_size_read(d_inode(dentry)) != 0)

fs/proc/kcore.c

651

if (i_size_read(inode) != proc_root_kcore->size) {

fs/quota/quota_v1.c

137

isize = i_size_read(inode);

fs/quota/quota_v2.c

165

i_size_read(sb_dqopt(sb)->files[type])) {

fs/quota/quota_v2.c

168

i_size_read(sb_dqopt(sb)->files[type]));

fs/ramfs/file-nommu.c

213

isize = i_size_read(inode);

fs/read_write.c

1529

size_in = i_size_read(inode_in);

fs/read_write.c

1750

iocb->ki_pos = i_size_read(inode);

fs/read_write.c

208

loff_t eof = i_size_read(inode);

fs/read_write.c

252

i_size_read(inode));

fs/read_write.c

342

offset += i_size_read(inode);

fs/remap_range.c

145

if (pos_out + *len < i_size_read(inode_out))

fs/remap_range.c

302

loff_t isize = i_size_read(inode_in);

fs/remap_range.c

51

size_in = i_size_read(inode_in);

fs/remap_range.c

52

size_out = i_size_read(inode_out);

fs/remap_range.c

526

if (off + len > i_size_read(src))

fs/romfs/mmap-nommu.c

34

isize = i_size_read(inode);

fs/romfs/super.c

113

size = i_size_read(inode);

fs/smb/client/cifsfs.c

1413

i_size_read(target_inode), 0);

fs/smb/client/cifsfs.c

1525

i_size_read(target_inode), 0);

fs/smb/client/cifsfs.c

1531

if (rc > 0 && destoff + rc > i_size_read(target_inode)) {

fs/smb/client/cifsfs.c

1534

i_size_read(target_inode), true);

fs/smb/client/cifsfs.c

1536

i_size_read(target_inode));

fs/smb/client/file.c

3144

if (i_size_read(&cifsInode->netfs.inode) < end_of_file)

fs/smb/client/fscache.c

144

i_size_read(&cifsi->netfs.inode));

fs/smb/client/fscache.c

153

loff_t i_size = i_size_read(inode);

fs/smb/client/fscache.h

79

i_size_read(inode), flags);

fs/smb/client/inode.c

133

fscache_invalidate(cifs_inode_cookie(inode), &cd, i_size_read(inode), 0);

fs/smb/client/inode.c

3240

attrs->ia_size != i_size_read(inode)) {

fs/smb/client/inode.c

3440

attrs->ia_size != i_size_read(inode)) {

fs/smb/client/smb2ops.c

3400

i_size = i_size_read(inode);

fs/smb/client/smb2ops.c

3430

if (keep_size == false && (unsigned long long)i_size_read(inode) < new_size) {

fs/smb/client/smb2ops.c

3502

i_size = i_size_read(inode);

fs/smb/client/smb2ops.c

3669

if ((keep_size == false) && i_size_read(inode) < off + len) {

fs/smb/client/smb2ops.c

3702

if (off >= i_size_read(inode)) {

fs/smb/client/smb2ops.c

3710

if (off + len > i_size_read(inode)) {

fs/smb/client/smb2ops.c

3711

len = i_size_read(inode) - off;

fs/smb/client/smb2ops.c

3715

if ((keep_size == true) || (i_size_read(inode) >= off + len)) {

fs/smb/client/smb2ops.c

3744

if ((off > 8192) || (off + len + 8192 < i_size_read(inode))) {

fs/smb/client/smb2ops.c

3778

old_eof = i_size_read(inode);

fs/smb/client/smb2ops.c

3830

old_eof = i_size_read(inode);

fs/smb/client/smb2ops.c

3852

netfs_resize_file(&cifsi->netfs, i_size_read(inode), true);

fs/smb/client/smb2ops.c

3853

fscache_resize_cookie(cifs_inode_cookie(inode), i_size_read(inode));

fs/smb/client/smb2ops.c

3888

if (offset < 0 || offset >= i_size_read(inode))

fs/smb/client/smb2ops.c

3908

offset = i_size_read(inode);

fs/smb/client/smb2ops.c

3913

in_data.length = cpu_to_le64(i_size_read(inode));

fs/smb/server/smb2pdu.c

6351

size = i_size_read(inode);

fs/smb/server/vfs.c

1755

src_file_size = i_size_read(file_inode(src_fp->filp));

fs/squashfs/dir.c

151

while (length < i_size_read(inode)) {

fs/squashfs/file.c

233

int skip = calculate_skip(i_size_read(inode) >> msblk->block_log);

fs/squashfs/file.c

467

int file_end = i_size_read(inode) >> msblk->block_log;

fs/squashfs/file.c

469

(i_size_read(inode) & (msblk->block_size - 1)) :

fs/squashfs/file.c

476

if (folio->index >= ((i_size_read(inode) + PAGE_SIZE - 1) >>

fs/squashfs/file.c

586

loff_t file_end = i_size_read(inode) >> msblk->block_log;

fs/squashfs/file.c

602

(i_size_read(inode) & (msblk->block_size - 1)) :

fs/squashfs/file.c

611

if (readahead_pos(ractl) >= i_size_read(inode))

fs/squashfs/file.c

676

u64 file_end = (i_size_read(inode) + msblk->block_size - 1) >> msblk->block_log;

fs/squashfs/file.c

681

if ((unsigned long long)offset >= i_size_read(inode))

fs/squashfs/file.c

691

return i_size_read(inode);

fs/squashfs/file.c

744

offset = i_size_read(inode);

fs/squashfs/file_direct.c

28

loff_t file_end = (i_size_read(inode) - 1) >> PAGE_SHIFT;

fs/squashfs/namei.c

152

while (length < i_size_read(dir)) {

fs/squashfs/symlink.c

41

int length = min_t(int, i_size_read(inode) - index, PAGE_SIZE);

fs/stack.c

22

i_size = i_size_read(src);

fs/stat.c

95

stat->size = i_size_read(inode);

fs/ubifs/debug.c

1105

inode->i_mode, i_size_read(inode));

fs/ubifs/debug.c

1165

if (i_size_read(dir) != size) {

fs/ubifs/debug.c

1167

dir->i_ino, (unsigned long long)i_size_read(dir),

fs/ubifs/debug.c

235

(unsigned long long)i_size_read(inode));

fs/ubifs/file.c

106

loff_t i_size = i_size_read(inode);

fs/ubifs/file.c

1499

i_size_read(inode));

fs/ubifs/file.c

1541

folio_pos(folio) >= i_size_read(inode))) {

fs/ubifs/file.c

597

loff_t i_size = i_size_read(inode);

fs/ubifs/file.c

757

isize = i_size_read(inode);

fs/ubifs/file.c

987

loff_t i_size = i_size_read(inode), synced_i_size;

fs/udf/file.c

236

attr->ia_size != i_size_read(inode)) {

fs/udf/file.c

53

size = i_size_read(inode);

fs/udf/inode.c

199

0, i_size_read(inode));

fs/udf/inode.c

216

loff_t isize = i_size_read(inode);

fs/ufs/inode.c

1174

(unsigned long long)i_size_read(inode));

fs/vboxsf/file.c

271

loff_t size = i_size_read(inode);

fs/xfs/scrub/bmap.c

811

return i_size_read(VFS_I(ip)) != 0;

fs/xfs/scrub/tempfile.c

900

temp = i_size_read(VFS_I(sc->ip));

fs/xfs/scrub/tempfile.c

901

i_size_write(VFS_I(sc->ip), i_size_read(VFS_I(sc->tempip)));

fs/xfs/scrub/tempfile.c

950

i_size_write(VFS_I(sc->ip), i_size_read(VFS_I(sc->tempip)));

fs/xfs/scrub/trace.h

1020

__entry->size = i_size_read(inode);

fs/xfs/scrub/trace.h

996

__entry->size = i_size_read(inode);

fs/xfs/scrub/xfile.c

191

if (pos + count > i_size_read(inode))

fs/xfs/scrub/xfile.c

267

if ((flags & XFILE_ALLOC) && pos + len > i_size_read(inode))

fs/xfs/xfs_bmap_util.c

1274

end_fsb = XFS_B_TO_FSB(ip->i_mount, i_size_read(VFS_I(ip)));

fs/xfs/xfs_exchrange.c

301

temp = i_size_read(VFS_I(ip2));

fs/xfs/xfs_exchrange.c

302

i_size_write(VFS_I(ip2), i_size_read(VFS_I(ip1)));

fs/xfs/xfs_exchrange.c

342

loff_t size1 = i_size_read(inode1);

fs/xfs/xfs_exchrange.c

344

loff_t size2 = i_size_read(inode2);

fs/xfs/xfs_exchrange.c

532

size1 = i_size_read(VFS_I(ip1));

fs/xfs/xfs_exchrange.c

533

size2 = i_size_read(VFS_I(ip2));

fs/xfs/xfs_file.c

1193

if ((mode & FALLOC_FL_KEEP_SIZE) || offset + len <= i_size_read(inode))

fs/xfs/xfs_file.c

1223

loff_t new_size = i_size_read(inode) - len;

fs/xfs/xfs_file.c

1233

if (offset + len >= i_size_read(inode))

fs/xfs/xfs_file.c

1249

loff_t isize = i_size_read(inode);

fs/xfs/xfs_file.c

1610

if (pos_in == 0 && len == i_size_read(inode_in) &&

fs/xfs/xfs_file.c

1612

pos_out == 0 && len >= i_size_read(inode_out) &&

fs/xfs/xfs_file.c

405

isize = i_size_read(VFS_I(ip));

fs/xfs/xfs_file.c

509

if (iocb->ki_pos > i_size_read(inode)) {

fs/xfs/xfs_file.c

639

if (offset + size <= i_size_read(inode))

fs/xfs/xfs_file.c

643

if (offset + size > i_size_read(inode)) {

fs/xfs/xfs_file.c

857

size_t isize = i_size_read(VFS_I(ip));

fs/xfs/xfs_file.c

972

if (ret > 0 && iocb->ki_pos > i_size_read(inode)) {

fs/xfs/xfs_inode.h

195

return i_size_read(VFS_I(ip));

fs/xfs/xfs_inode.h

206

xfs_fsize_t i_size = i_size_read(VFS_I(ip));

fs/xfs/xfs_iomap.c

689

if (update_isize && i_size > i_size_read(inode))

fs/xfs/xfs_iomap.c

876

if (offset + length > i_size_read(inode))

fs/xfs/xfs_pnfs.c

157

limit = max(limit, round_up(i_size_read(inode),

fs/xfs/xfs_pnfs.c

273

size = i_size_read(inode);

fs/xfs/xfs_reflink.c

1242

if (newlen <= i_size_read(VFS_I(dest)) && cowextsize == 0)

fs/xfs/xfs_reflink.c

1252

if (newlen > i_size_read(VFS_I(dest))) {

fs/xfs/xfs_reflink.c

1504

if (newlen > i_size_read(VFS_I(ip))) {

fs/xfs/xfs_reflink.c

1613

loff_t isize = i_size_read(VFS_I(ip));

fs/xfs/xfs_trace.h

5148

__entry->size = i_size_read(inode);

fs/xfs/xfs_zone_alloc.c

654

if (i_size_read(VFS_I(ip)) >= zone_capacity)

fs/zonefs/file.c

135

if (WARN_ON_ONCE(offset >= i_size_read(wpc->inode)))

fs/zonefs/file.c

229

old_isize = i_size_read(inode);

fs/zonefs/file.c

348

loff_t isize = i_size_read(file_inode(file));

fs/zonefs/file.c

383

if (i_size_read(inode) < iocb->ki_pos + size) {

fs/zonefs/file.c

43

isize = i_size_read(inode);

fs/zonefs/file.c

657

isize = i_size_read(inode);

fs/zonefs/file.c

709

isize = i_size_read(inode);

fs/zonefs/file.c

762

if (i_size_read(inode) < z->z_capacity) {

fs/zonefs/file.c

94

isize = i_size_read(inode);

fs/zonefs/super.c

158

loff_t old_isize = i_size_read(inode);

fs/zonefs/super.c

274

isize = i_size_read(inode);

include/linux/netfs.h

491

ctx->remote_i_size = i_size_read(&ctx->inode);

include/linux/pagemap.h

1549

loff_t size = i_size_read(inode);

include/trace/events/afs.h

977

__entry->i_size = i_size_read(&vnode->netfs.inode);

include/trace/events/f2fs.h

1059

__entry->size = i_size_read(inode);

include/trace/events/f2fs.h

225

__entry->size = i_size_read(inode);

include/trace/events/f2fs.h

2397

__entry->i_size = i_size_read(inode);

include/trace/events/f2fs.h

374

__entry->size = i_size_read(dir);

include/trace/events/f2fs.h

454

__entry->size = i_size_read(inode);

include/trace/events/f2fs.h

625

__entry->size = i_size_read(inode);

include/trace/events/fsverity.h

27

__entry->data_size = i_size_read(inode);

include/trace/events/fsverity.h

55

__entry->data_size = i_size_read(inode);

init/do_mounts_rd.c

177

return i_size_read(inode) >> 10;

ipc/shm.c

1616

size = i_size_read(file_inode(base));

ipc/shm.c

1785

size = i_size_read(file_inode(vma->vm_file));

kernel/events/uprobes.c

1080

if (offs >= i_size_read(uprobe->inode))

kernel/events/uprobes.c

1406

if (offset > i_size_read(inode))

mm/filemap.c

2802

if (unlikely(iocb->ki_pos >= i_size_read(inode)))

mm/filemap.c

2817

isize = i_size_read(inode);

mm/filemap.c

2993

if (iocb->ki_pos >= i_size_read(inode))

mm/filemap.c

3080

if (*ppos >= i_size_read(in->f_mapping->host))

mm/filemap.c

3096

isize = i_size_read(in->f_mapping->host);

mm/filemap.c

3524

max_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

mm/filemap.c

3628

max_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

mm/filemap.c

3729

max_idx = DIV_ROUND_UP(i_size_read(mapping->host), PAGE_SIZE);

mm/filemap.c

3891

file_end = DIV_ROUND_UP(i_size_read(mapping->host), PAGE_SIZE) - 1;

mm/filemap.c

4284

if (pos > i_size_read(inode) && !S_ISBLK(inode->i_mode)) {

mm/gup.c

3457

if (end >= i_size_read(file_inode(memfd)))

mm/huge_memory.c

4033

end = DIV_ROUND_UP(i_size_read(mapping->host), PAGE_SIZE);

mm/hugetlb.c

5755

size = i_size_read(mapping->host) >> huge_page_shift(h);

mm/hugetlb.c

6333

if (idx >= (i_size_read(mapping->host) >> huge_page_shift(h)))

mm/memfd_luo.c

275

ser->size = i_size_read(inode);

mm/memfd_luo.c

98

size = i_size_read(inode);

mm/memory.c

5592

file_end = DIV_ROUND_UP(i_size_read(mapping->host), PAGE_SIZE);

mm/page_io.c

103

last_block = i_size_read(inode) >> blkbits;

mm/readahead.c

320

loff_t isize = i_size_read(mapping->host);

mm/readahead.c

474

pgoff_t limit = (i_size_read(mapping->host) - 1) >> PAGE_SHIFT;

mm/secretmem.c

61

if (((loff_t)vmf->pgoff << PAGE_SHIFT) >= i_size_read(inode))

mm/shmem.c

1617

DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE));

mm/shmem.c

2485

((loff_t)index << PAGE_SHIFT) >= i_size_read(inode))

mm/shmem.c

2579

DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE) <

mm/shmem.c

2624

((loff_t)index << PAGE_SHIFT) >= i_size_read(inode)) {

mm/shmem.c

3269

max_off = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

mm/shmem.c

3380

loff_t end_offset, i_size = i_size_read(inode);

mm/shmem.c

3413

i_size = i_size_read(inode);

mm/shmem.c

3575

if (*ppos >= i_size_read(inode))

mm/shmem.c

3607

isize = i_size_read(inode);

mm/shmem.c

3672

MAX_LFS_FILESIZE, i_size_read(inode));

mm/shmem.c

5989

error = shmem_get_folio_gfp(inode, index, i_size_read(inode),

mm/shmem.c

615

i_size = max(write_end, i_size_read(inode));

mm/shmem.c

772

i_size = i_size_read(inode);

mm/swapfile.c

3212

swapfilepages = i_size_read(inode) >> PAGE_SHIFT;

mm/userfaultfd.c

158

max_off = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

security/integrity/ima/ima_crypto.c

351

i_size = i_size_read(file_inode(file));

security/integrity/ima/ima_crypto.c

468

i_size = i_size_read(file_inode(file));

security/integrity/ima/ima_crypto.c

560

i_size = i_size_read(file_inode(f));

security/selinux/selinuxfs.c

391

if ((size_t)i_size_read(inode) != plm->len) {

virt/kvm/guest_memfd.c

259

if (offset + len > i_size_read(inode))

virt/kvm/guest_memfd.c

397

if (((loff_t)vmf->pgoff << PAGE_SHIFT) >= i_size_read(inode))

virt/kvm/guest_memfd.c

668

offset + size > i_size_read(inode))