arch/powerpc/platforms/cell/spufs/inode.c

149

struct spu_context *ctx = SPUFS_I(d_inode(dir))->i_ctx;

arch/powerpc/platforms/cell/spufs/inode.c

176

struct inode *inode = dir->d_inode;

arch/powerpc/platforms/cell/spufs/inode.c

197

parent = d_inode(dir->d_parent);

arch/powerpc/platforms/cell/spufs/inode.c

426

spufs_set_affinity(flags, SPUFS_I(d_inode(dentry))->i_ctx,

arch/powerpc/platforms/cell/spufs/inode.c

530

struct inode *dir = d_inode(path->dentry);

arch/powerpc/platforms/cell/spufs/inode.c

581

struct inode *inode = root->d_inode;

arch/powerpc/platforms/cell/spufs/inode.c

98

struct inode *inode = d_inode(dentry);

arch/s390/hypfs/inode.c

340

inc_nlink(d_inode(parent));

arch/s390/hypfs/inode.c

53

struct inode *inode = d_inode(sb_info->update_file);

drivers/android/binder/rust_binderfs.c

190

fsnotify_create(root->d_inode, dentry);

drivers/android/binder/rust_binderfs.c

484

fsnotify_create(parent->d_inode, dentry);

drivers/android/binder/rust_binderfs.c

522

inc_nlink(parent->d_inode);

drivers/android/binder/rust_binderfs.c

525

fsnotify_mkdir(parent->d_inode, dentry);

drivers/android/binderfs.c

193

fsnotify_create(root->d_inode, dentry);

drivers/android/binderfs.c

477

parent_inode = d_inode(parent);

drivers/android/binderfs.c

505

parent_inode = d_inode(parent);

drivers/base/devtmpfs.c

182

dentry = vfs_mkdir(&nop_mnt_idmap, d_inode(path.dentry), dentry, mode, NULL);

drivers/base/devtmpfs.c

185

d_inode(dentry)->i_private = &thread;

drivers/base/devtmpfs.c

232

err = vfs_mknod(&nop_mnt_idmap, d_inode(path.dentry), dentry, mode,

drivers/base/devtmpfs.c

241

inode_lock(d_inode(dentry));

drivers/base/devtmpfs.c

243

inode_unlock(d_inode(dentry));

drivers/base/devtmpfs.c

246

d_inode(dentry)->i_private = &thread;

drivers/base/devtmpfs.c

261

if (d_inode(dentry)->i_private == &thread)

drivers/base/devtmpfs.c

262

err = vfs_rmdir(&nop_mnt_idmap, d_inode(parent.dentry),

drivers/base/devtmpfs.c

329

inode = d_inode(dentry);

drivers/base/devtmpfs.c

341

inode_lock(d_inode(dentry));

drivers/base/devtmpfs.c

343

inode_unlock(d_inode(dentry));

drivers/base/devtmpfs.c

344

err = vfs_unlink(&nop_mnt_idmap, d_inode(parent.dentry),

drivers/block/drbd/drbd_debugfs.c

429

inode_lock(d_inode(parent));

drivers/block/drbd/drbd_debugfs.c

434

inode_unlock(d_inode(parent));

drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c

1634

i_size_write(ent->d_inode, adev->rmmio_size);

drivers/gpu/drm/amd/amdgpu/amdgpu_ras_eeprom.c

1269

d_inode(de)->i_size = amdgpu_ras_debugfs_table_size(control);

drivers/gpu/drm/drm_debugfs.c

286

drmm_kfree(minor->dev, d_inode(dent)->i_private);

drivers/gpu/drm/nouveau/nouveau_debugfs.c

291

d_inode(dentry)->i_size = drm->vbios.length;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1334

i_size_write(d_inode(dent), blob->size);

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1411

i_size_write(d_inode(gsp->debugfs.init), gsp->blob_init.size);

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1412

i_size_write(d_inode(gsp->debugfs.intr), gsp->blob_intr.size);

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1413

i_size_write(d_inode(gsp->debugfs.rm), gsp->blob_rm.size);

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1414

i_size_write(d_inode(gsp->debugfs.pmu), gsp->blob_pmu.size);

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1963

i_size_write(d_inode(dent), t->size);

drivers/gpu/drm/xe/xe_gt_debugfs.c

337

root->d_inode->i_private = gt;

drivers/gpu/drm/xe/xe_gt_debugfs.c

39

return node->dent->d_parent->d_inode->i_private;

drivers/gpu/drm/xe/xe_gt_sriov_pf_debugfs.c

49

return d->d_inode->i_private;

drivers/gpu/drm/xe/xe_gt_sriov_pf_debugfs.c

875

dent->d_inode->i_private = gt;

drivers/gpu/drm/xe/xe_gt_sriov_pf_debugfs.c

912

xe_gt_assert(gt, dent->d_inode->i_private == gt);

drivers/gpu/drm/xe/xe_gt_sriov_vf_debugfs.c

59

xe_assert(xe, root->d_inode->i_private == gt);

drivers/gpu/drm/xe/xe_gt_sriov_vf_debugfs.c

69

vfdentry->d_inode->i_private = gt;

drivers/gpu/drm/xe/xe_guc_debugfs.c

69

struct xe_gt *gt = grandparent->d_inode->i_private;

drivers/gpu/drm/xe/xe_sriov_pf_debugfs.c

141

struct xe_device *xe = parent->d_inode->i_private;

drivers/gpu/drm/xe/xe_sriov_pf_debugfs.c

32

return d->d_inode->i_private;

drivers/gpu/drm/xe/xe_sriov_pf_debugfs.c

357

dent->d_inode->i_private = xe;

drivers/gpu/drm/xe/xe_sriov_pf_debugfs.c

370

pfdent->d_inode->i_private = xe;

drivers/gpu/drm/xe/xe_sriov_pf_debugfs.c

387

vfdent->d_inode->i_private = (void *)(uintptr_t)VFID(n);

drivers/gpu/drm/xe/xe_tile_debugfs.c

140

tile->debugfs->d_inode->i_private = tile;

drivers/gpu/drm/xe/xe_tile_debugfs.c

16

return node->dent->d_parent->d_inode->i_private;

drivers/gpu/drm/xe/xe_tile_sriov_pf_debugfs.c

245

dent->d_inode->i_private = tile;

drivers/gpu/drm/xe/xe_tile_sriov_pf_debugfs.c

39

return d->d_inode->i_private;

drivers/hv/mshv_debugfs.c

385

pstats = dentry->d_inode->i_private;

drivers/hv/mshv_debugfs.c

446

pstats = vp_stats_ptr->d_inode->i_private;

drivers/ufs/core/ufs-debugfs.c

21

return d_inode(file->f_path.dentry->d_parent)->i_private;

drivers/ufs/core/ufs-debugfs.c

225

d_inode(root)->i_private = hba;

drivers/usb/gadget/function/f_fs.c

2361

smp_store_release(&dentry->d_inode->i_private, NULL);

drivers/virt/coco/efi_secret/efi_secret.c

120

struct inode *inode = d_inode(dentry);

drivers/virt/coco/efi_secret/efi_secret.c

233

d_inode(dir)->i_op = &efi_secret_dir_inode_operations;

fs/9p/acl.c

152

return v9fs_get_cached_acl(d_inode(dentry), type);

fs/9p/acl.c

163

struct inode *inode = d_inode(dentry);

fs/9p/fid.c

135

if (!ret && dentry->d_inode)

fs/9p/fid.c

136

ret = v9fs_fid_find_inode(dentry->d_inode, false, uid, any);

fs/9p/vfs_dentry.c

73

inode = d_inode(dentry);

fs/9p/vfs_inode.c

1016

struct inode *inode = d_inode(dentry);

fs/9p/vfs_inode.c

1282

v9fs_refresh_inode(oldfid, d_inode(old_dentry));

fs/9p/vfs_inode.c

518

inode = d_inode(dentry);

fs/9p/vfs_inode.c

798

inode = d_inode(dentry);

fs/9p/vfs_inode.c

873

old_inode = d_inode(old_dentry);

fs/9p/vfs_inode.c

874

new_inode = d_inode(new_dentry);

fs/9p/vfs_inode.c

968

struct inode *inode = d_inode(dentry);

fs/9p/vfs_inode.c

996

v9fs_stat2inode(st, d_inode(dentry), dentry->d_sb, 0);

fs/9p/vfs_inode.c

997

generic_fillattr(&nop_mnt_idmap, request_mask, d_inode(dentry), stat);

fs/9p/vfs_inode_dotl.c

426

struct inode *inode = d_inode(dentry);

fs/9p/vfs_inode_dotl.c

456

v9fs_stat2inode_dotl(st, d_inode(dentry), 0);

fs/9p/vfs_inode_dotl.c

457

generic_fillattr(&nop_mnt_idmap, request_mask, d_inode(dentry), stat);

fs/9p/vfs_inode_dotl.c

517

struct inode *inode = d_inode(dentry);

fs/9p/vfs_inode_dotl.c

769

v9fs_refresh_inode_dotl(fid, d_inode(old_dentry));

fs/9p/vfs_inode_dotl.c

772

ihold(d_inode(old_dentry));

fs/9p/vfs_inode_dotl.c

773

d_instantiate(dentry, d_inode(old_dentry));

fs/adfs/inode.c

305

struct inode *inode = d_inode(dentry);

fs/affs/amigaffs.c

144

struct inode *dir, *inode = d_inode(dentry);

fs/affs/amigaffs.c

274

dir = d_inode(dentry->d_parent);

fs/affs/amigaffs.c

278

inode = d_inode(dentry);

fs/affs/inode.c

219

struct inode *inode = d_inode(dentry);

fs/affs/namei.c

239

d_inode(dentry)->i_ino, dentry);

fs/affs/namei.c

310

d_inode(dentry)->i_ino, dentry);

fs/affs/namei.c

396

struct inode *inode = d_inode(old_dentry);

fs/affs/namei.c

426

bh = affs_bread(sb, d_inode(old_dentry)->i_ino);

fs/affs/namei.c

461

bh_old = affs_bread(sb, d_inode(old_dentry)->i_ino);

fs/affs/namei.c

465

bh_new = affs_bread(sb, d_inode(new_dentry)->i_ino);

fs/affs/namei.c

528

bh = affs_bread(child->d_sb, d_inode(child)->i_ino);

fs/afs/dir.c

1010

_debug("splice %p", dentry->d_inode);

fs/afs/dir.c

1073

vnode = AFS_FS_I(d_inode(dentry));

fs/afs/dir.c

1121

inode = d_inode(dentry);

fs/afs/dir.c

1192

(test_bit(AFS_VNODE_DELETED, &AFS_FS_I(d_inode(dentry))->flags) ||

fs/afs/dir.c

1193

test_bit(AFS_VNODE_PSEUDODIR, &AFS_FS_I(d_inode(dentry))->flags)))

fs/afs/dir.c

1354

struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry));

fs/afs/dir.c

1434

vnode = AFS_FS_I(d_inode(dentry));

fs/afs/dir.c

1559

struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry));

fs/afs/dir.c

1590

write_inode_now(d_inode(dentry), 0);

fs/afs/dir.c

1719

struct afs_vnode *vnode = AFS_FS_I(d_inode(from));

fs/afs/dir.c

1881

struct afs_vnode *vnode = AFS_FS_I(d_inode(op->dentry));

fs/afs/dir.c

1924

new_inode = d_inode(new_dentry);

fs/afs/dir.c

2071

vnode = AFS_FS_I(d_inode(old_dentry));

fs/afs/dir.c

2075

new_vnode = AFS_FS_I(d_inode(new_dentry));

fs/afs/dir.c

2155

AFS_FS_I(d_inode(new_dentry)),

fs/afs/dir.c

977

ASSERTCMP(d_inode(dentry), ==, NULL);

fs/afs/dir_silly.c

246

struct afs_vnode *dvnode = AFS_FS_I(d_inode(dentry->d_parent));

fs/afs/dir_silly.c

27

struct afs_vnode *vnode = AFS_FS_I(d_inode(op->dentry));

fs/afs/dir_silly.c

86

op->more_files[0].vnode = AFS_FS_I(d_inode(old));

fs/afs/dir_silly.c

88

op->more_files[1].vnode = AFS_FS_I(d_inode(new));

fs/afs/inode.c

100

content = afs_get_link(dentry, d_inode(dentry), &done);

fs/afs/inode.c

681

struct inode *inode = d_inode(path->dentry);

fs/afs/inode.c

845

struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry));

fs/afs/mntpt.c

125

loff_t size = i_size_read(d_inode(mntpt));

fs/afs/mntpt.c

133

content = afs_get_link(mntpt, d_inode(mntpt), &cleanup);

fs/afs/mntpt.c

165

BUG_ON(!d_inode(mntpt));

fs/afs/mntpt.c

75

struct afs_vnode *vnode = AFS_FS_I(d_inode(mntpt));

fs/afs/super.c

748

struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry));

fs/anon_inodes.c

53

struct inode *inode = d_inode(path->dentry);

fs/attr.c

164

struct inode *inode = d_inode(dentry);

fs/attr.c

430

struct inode *inode = dentry->d_inode;

fs/autofs/autofs_i.h

266

return d_inode(sbi->sb->s_root)->i_ino;

fs/autofs/inode.c

439

inode->i_uid = d_inode(sb->s_root)->i_uid;

fs/autofs/inode.c

440

inode->i_gid = d_inode(sb->s_root)->i_gid;

fs/autofs/inode.c

66

struct inode *root_inode = d_inode(root->d_sb->s_root);

fs/autofs/root.c

639

d_inode(dentry)->i_size = 0;

fs/autofs/root.c

640

clear_nlink(d_inode(dentry));

fs/autofs/root.c

720

d_inode(dentry)->i_size = 0;

fs/autofs/root.c

721

clear_nlink(d_inode(dentry));

fs/autofs/symlink.c

21

return d_inode(dentry)->i_private;

fs/befs/linuxvfs.c

668

struct befs_inode_info *befs_ino = BEFS_I(d_inode(child));

fs/bfs/dir.c

150

struct inode *inode = d_inode(old);

fs/bfs/dir.c

172

struct inode *inode = d_inode(dentry);

fs/bfs/dir.c

216

old_inode = d_inode(old_dentry);

fs/bfs/dir.c

229

new_inode = d_inode(new_dentry);

fs/binfmt_misc.c

737

inode = d_inode(inode->i_sb->s_root);

fs/binfmt_misc.c

881

inode = d_inode(file_inode(file)->i_sb->s_root);

fs/bpf_fs_kfuncs.c

131

struct inode *inode = d_inode(dentry);

fs/bpf_fs_kfuncs.c

204

struct inode *inode = d_inode(dentry);

fs/bpf_fs_kfuncs.c

249

struct inode *inode = d_inode(dentry);

fs/bpf_fs_kfuncs.c

289

struct inode *inode = d_inode(dentry);

fs/bpf_fs_kfuncs.c

314

struct inode *inode = d_inode(dentry);

fs/btrfs/acl.c

107

struct inode *inode = d_inode(dentry);

fs/btrfs/export.c

154

struct btrfs_inode *dir = BTRFS_I(d_inode(child));

fs/btrfs/export.c

233

struct btrfs_inode *inode = BTRFS_I(d_inode(child));

fs/btrfs/export.c

234

struct btrfs_inode *dir = BTRFS_I(d_inode(parent));

fs/btrfs/file.c

1560

struct btrfs_inode *inode = BTRFS_I(d_inode(dentry));

fs/btrfs/inode.c

4538

struct inode *inode = d_inode(dentry);

fs/btrfs/inode.c

4554

btrfs_record_unlink_dir(trans, BTRFS_I(dir), BTRFS_I(d_inode(dentry)),

fs/btrfs/inode.c

4557

ret = btrfs_unlink_inode(trans, BTRFS_I(dir), BTRFS_I(d_inode(dentry)),

fs/btrfs/inode.c

4580

struct btrfs_inode *inode = BTRFS_I(d_inode(dentry));

fs/btrfs/inode.c

4768

struct inode *inode = d_inode(dentry);

fs/btrfs/inode.c

4909

struct btrfs_inode *inode = BTRFS_I(d_inode(dentry));

fs/btrfs/inode.c

5482

struct inode *inode = d_inode(dentry);

fs/btrfs/inode.c

6129

struct inode *inode = d_inode(dentry);

fs/btrfs/inode.c

6132

inode = d_inode(dentry->d_parent);

fs/btrfs/inode.c

7038

struct inode *inode = d_inode(old_dentry);

fs/btrfs/inode.c

8237

struct inode *inode = d_inode(path->dentry);

fs/btrfs/inode.c

8286

struct inode *new_inode = new_dentry->d_inode;

fs/btrfs/inode.c

8287

struct inode *old_inode = old_dentry->d_inode;

fs/btrfs/inode.c

8462

BTRFS_I(old_dentry->d_inode),

fs/btrfs/inode.c

8484

BTRFS_I(new_dentry->d_inode),

fs/btrfs/inode.c

8575

struct inode *new_inode = d_inode(new_dentry);

fs/btrfs/inode.c

8576

struct inode *old_inode = d_inode(old_dentry);

fs/btrfs/inode.c

8753

BTRFS_I(d_inode(old_dentry)),

fs/btrfs/inode.c

8778

BTRFS_I(d_inode(new_dentry)),

fs/btrfs/inode.c

8787

BTRFS_I(d_inode(new_dentry)));

fs/btrfs/ioctl.c

2165

struct inode *dir = d_inode(parent);

fs/btrfs/ioctl.c

2247

dir = d_inode(parent);

fs/btrfs/ioctl.c

2313

inode = d_inode(dentry);

fs/btrfs/ioctl.c

250

const struct btrfs_inode *inode = BTRFS_I(d_inode(dentry));

fs/btrfs/ioctl.c

259

struct btrfs_inode *inode = BTRFS_I(d_inode(dentry));

fs/btrfs/ioctl.c

797

inode = btrfs_lookup_dentry(d_inode(dentry->d_parent), dentry);

fs/btrfs/ioctl.c

835

struct inode *dir = d_inode(parent);

fs/btrfs/super.c

1151

seq_printf(seq, ",subvolid=%llu", btrfs_root_id(BTRFS_I(d_inode(dentry))->root));

fs/btrfs/super.c

1153

btrfs_root_id(BTRFS_I(d_inode(dentry))->root));

fs/btrfs/super.c

1203

struct inode *root_inode = d_inode(root);

fs/btrfs/super.c

1827

buf->f_fsid.val[0] ^= btrfs_root_id(BTRFS_I(d_inode(dentry))->root) >> 32;

fs/btrfs/super.c

1828

buf->f_fsid.val[1] ^= btrfs_root_id(BTRFS_I(d_inode(dentry))->root);

fs/btrfs/tree-log.c

7431

inode = BTRFS_I(d_inode(parent));

fs/btrfs/tree-log.c

7673

ret = btrfs_log_inode_parent(trans, BTRFS_I(d_inode(dentry)), parent,

fs/btrfs/tree-log.c

7988

struct btrfs_inode *inode = BTRFS_I(d_inode(old_dentry));

fs/btrfs/xattr.c

266

struct inode *inode = d_inode(dentry);

fs/cachefiles/cache.c

212

trace_cachefiles_vfs_error(NULL, d_inode(path.dentry), ret,

fs/cachefiles/namei.c

132

subdir = vfs_mkdir(&nop_mnt_idmap, d_inode(dir), subdir, 0700, NULL);

fs/cachefiles/namei.c

138

trace_cachefiles_vfs_error(NULL, d_inode(dir), ret,

fs/cachefiles/namei.c

157

inode_lock(d_inode(subdir));

fs/cachefiles/namei.c

160

if (!__cachefiles_mark_inode_in_use(NULL, d_inode(subdir))) {

fs/cachefiles/namei.c

162

subdir, d_inode(subdir)->i_ino);

fs/cachefiles/namei.c

166

inode_unlock(d_inode(subdir));

fs/cachefiles/namei.c

195

inode_unlock(d_inode(subdir));

fs/cachefiles/namei.c

210

inode_unlock(d_inode(dir));

fs/cachefiles/namei.c

221

cachefiles_do_unmark_inode_in_use(NULL, d_inode(dir));

fs/cachefiles/namei.c

240

trace_cachefiles_unlink(object, d_inode(dentry)->i_ino, why);

fs/cachefiles/namei.c

311

if (rep->d_parent != dir || IS_DEADDIR(d_inode(rep))) {

fs/cachefiles/namei.c

340

trace_cachefiles_vfs_error(object, d_inode(cache->graveyard),

fs/cachefiles/namei.c

392

trace_cachefiles_rename(object, d_inode(rep)->i_ino, why);

fs/cachefiles/namei.c

397

trace_cachefiles_vfs_error(object, d_inode(dir), ret,

fs/cachefiles/namei.c

404

__cachefiles_unmark_inode_in_use(object, d_inode(rep));

fs/cachefiles/namei.c

460

trace_cachefiles_vfs_error(object, d_inode(fan), ret,

fs/cachefiles/namei.c

551

if (!cachefiles_mark_inode_in_use(object, d_inode(dentry))) {

fs/cachefiles/namei.c

553

dentry, d_inode(dentry)->i_ino);

fs/cachefiles/namei.c

608

cachefiles_do_unmark_inode_in_use(object, d_inode(dentry));

fs/cachefiles/namei.c

687

trace_cachefiles_vfs_error(object, d_inode(fan), PTR_ERR(dentry),

fs/cachefiles/namei.c

712

trace_cachefiles_vfs_error(object, d_inode(fan), PTR_ERR(dentry),

fs/cachefiles/namei.c

722

d_inode(fan), dentry, NULL);

fs/cachefiles/namei.c

724

trace_cachefiles_vfs_error(object, d_inode(fan), ret,

fs/cachefiles/namei.c

758

if (d_inode(victim)->i_flags & S_KERNEL_FILE)

fs/cachefiles/namei.c

800

inode = d_inode(victim);

fs/cachefiles/namei.c

853

inode_unlock(d_inode(dir));

fs/cachefiles/xattr.c

176

trace_cachefiles_vfs_error(object, d_inode(dentry), ret,

fs/cachefiles/xattr.c

240

trace_cachefiles_vfs_error(NULL, d_inode(dentry), ret,

fs/cachefiles/xattr.c

242

trace_cachefiles_vol_coherency(volume, d_inode(dentry)->i_ino,

fs/cachefiles/xattr.c

248

trace_cachefiles_vol_coherency(volume, d_inode(dentry)->i_ino,

fs/cachefiles/xattr.c

283

trace_cachefiles_vfs_error(NULL, d_inode(dentry), xlen,

fs/cachefiles/xattr.c

300

trace_cachefiles_vol_coherency(volume, d_inode(dentry)->i_ino, why);

fs/ceph/acl.c

98

struct inode *inode = d_inode(dentry);

fs/ceph/debugfs.c

88

ceph_ino(d_inode(req->r_dentry->d_parent)),

fs/ceph/dir.c

1180

ceph_init_inode_acls(d_inode(dentry), &as_ctx);

fs/ceph/dir.c

1225

req->r_ino2 = ceph_vino(d_inode(old_dentry));

fs/ceph/dir.c

1237

ihold(d_inode(old_dentry));

fs/ceph/dir.c

1238

d_instantiate(dentry, d_inode(old_dentry));

fs/ceph/dir.c

134

struct inode *dir = d_inode(parent);

fs/ceph/dir.c

1341

struct inode *inode = d_inode(dentry);

fs/ceph/dir.c

1410

req->r_old_inode = d_inode(dentry);

fs/ceph/dir.c

1526

ceph_drop_caps_for_unlink(d_inode(new_dentry));

fs/ceph/dir.c

1906

dir = d_inode(dentry->d_parent);

fs/ceph/dir.c

191

struct inode *dir = d_inode(parent);

fs/ceph/dir.c

1945

if (dir == d_inode(dentry->d_parent) &&

fs/ceph/dir.c

2030

d_inode(dentry) == req->r_target_inode)

fs/ceph/dir.c

2066

if (ceph_snap(d_inode(dentry)) != CEPH_NOSNAP)

fs/ceph/dir.c

2120

dir_ci = ceph_inode(d_inode(dentry->d_parent));

fs/ceph/dir.c

269

dentry, dentry, d_inode(dentry));

fs/ceph/dir.c

272

dentry->d_name.len, ceph_present_inode(d_inode(dentry)),

fs/ceph/dir.c

273

d_inode(dentry)->i_mode >> 12)) {

fs/ceph/dir.c

349

ino = ceph_present_inode(dentry->d_parent->d_inode);

fs/ceph/dir.c

726

struct inode *parent = d_inode(dentry->d_parent); /* we hold i_rwsem */

fs/ceph/dir.c

767

dentry, ceph_vinop(d_inode(dentry)));

fs/ceph/dir.c

971

ceph_init_inode_acls(d_inode(dentry), &as_ctx);

fs/ceph/export.c

155

if (ceph_security_xattr_wanted(d_inode(sb->s_root)))

fs/ceph/export.c

255

if (ceph_security_xattr_wanted(d_inode(sb->s_root)))

fs/ceph/export.c

338

req->r_inode = d_inode(child);

fs/ceph/export.c

339

ihold(d_inode(child));

fs/ceph/export.c

348

if (ceph_security_xattr_wanted(d_inode(sb->s_root)))

fs/ceph/export.c

371

struct inode *inode = d_inode(child);

fs/ceph/export.c

448

struct inode *inode = d_inode(child);

fs/ceph/export.c

449

struct inode *dir = d_inode(parent);

fs/ceph/export.c

553

struct inode *dir = d_inode(parent);

fs/ceph/export.c

554

struct inode *inode = d_inode(child);

fs/ceph/export.c

570

req->r_ino2 = ceph_vino(d_inode(parent));

fs/ceph/file.c

601

struct inode *dinode = d_inode(dentry);

fs/ceph/file.c

965

!fscrypt_has_permitted_context(dir, d_inode(dentry))) {

fs/ceph/file.c

968

ceph_vinop(dir), ceph_vinop(d_inode(dentry)));

fs/ceph/file.c

974

struct inode *newino = d_inode(dentry);

fs/ceph/inode.c

1462

dir = d_inode(dentry->d_parent);

fs/ceph/inode.c

1472

if (!ceph_ino_compare(d_inode(dentry), ptvino))

fs/ceph/inode.c

1496

BUG_ON(d_inode(dn));

fs/ceph/inode.c

1532

d_inode(realdn), ceph_vinop(d_inode(realdn)));

fs/ceph/inode.c

1538

d_inode(dn), ceph_vinop(d_inode(dn)));

fs/ceph/inode.c

1653

(ceph_ino(d_inode(dn)) != tvino.ino ||

fs/ceph/inode.c

1654

ceph_snap(d_inode(dn)) != tvino.snap)) {

fs/ceph/inode.c

1656

dn, d_inode(dn));

fs/ceph/inode.c

1715

BUG_ON(d_inode(dn->d_parent) != dir);

fs/ceph/inode.c

1799

} else if (d_really_is_positive(dn) && d_inode(dn) != in) {

fs/ceph/inode.c

1801

dn, d_inode(dn), ceph_vinop(d_inode(dn)),

fs/ceph/inode.c

1962

struct inode *inode = d_inode(parent);

fs/ceph/inode.c

2006

ceph_fill_dirfrag(d_inode(parent), rinfo->dir_dir);

fs/ceph/inode.c

2066

(ceph_ino(d_inode(dn)) != tvino.ino ||

fs/ceph/inode.c

2067

ceph_snap(d_inode(dn)) != tvino.snap)) {

fs/ceph/inode.c

2070

dn, d_inode(dn));

fs/ceph/inode.c

2088

in = d_inode(dn);

fs/ceph/inode.c

2135

update_dentry_lease(d_inode(parent), dn,

fs/ceph/inode.c

2140

ret = fill_readdir_cache(d_inode(parent), dn,

fs/ceph/inode.c

2884

struct inode *inode = d_inode(dentry);

fs/ceph/inode.c

3108

struct inode *inode = d_inode(path->dentry);

fs/ceph/mds_client.c

1338

inode = d_inode(req->r_dentry);

fs/ceph/mds_client.c

1349

inode = d_inode(req->r_dentry);

fs/ceph/mds_client.c

2735

inode = d_inode(cur);

fs/ceph/mds_client.c

2745

} else if (!for_wire || !IS_ENCRYPTED(d_inode(cur->d_parent))) {

fs/ceph/mds_client.c

2767

ret = ceph_fscrypt_prepare_readdir(d_inode(parent));

fs/ceph/mds_client.c

2775

if (fscrypt_has_encryption_key(d_inode(parent))) {

fs/ceph/mds_client.c

2776

len = ceph_encode_encrypted_dname(d_inode(parent),

fs/ceph/mds_client.c

2805

inode = d_inode(cur);

fs/ceph/mds_client.c

2831

if (d_inode(dentry))

fs/ceph/mds_client.c

2832

path_info->vino.snap = ceph_snap(d_inode(dentry));

fs/ceph/mds_client.c

3221

req->r_inode ? req->r_inode : d_inode(req->r_dentry),

fs/ceph/mds_client.c

3243

d_inode(req->r_old_dentry),

fs/ceph/mds_client.c

3601

if (!d_inode(req->r_dentry)) {

fs/ceph/mds_client.c

3612

ci = ceph_inode(d_inode(req->r_dentry));

fs/ceph/mds_client.c

446

struct inode *inode = d_inode(req->r_dentry);

fs/ceph/mds_client.c

5373

dir = d_inode(dentry->d_parent);

fs/ceph/quota.c

26

struct inode *root = d_inode(sb->s_root);

fs/ceph/quota.c

500

get_quota_realm(mdsc, d_inode(fsc->sb->s_root), QUOTA_GET_MAX_BYTES,

fs/ceph/super.c

1351

d_inode(res), ceph_vinop(d_inode(res)));

fs/ceph/super.c

1623

err = __ceph_do_getattr(d_inode(sb->s_root), NULL,

fs/ceph/super.c

60

struct ceph_fs_client *fsc = ceph_inode_to_fs_client(d_inode(dentry));

fs/ceph/xattr.c

1065

struct inode *inode = d_inode(dentry);

fs/coda/dir.c

208

struct inode *inode = d_inode(source_de);

fs/coda/dir.c

274

drop_nlink(d_inode(de));

fs/coda/dir.c

288

clear_nlink(d_inode(de));

fs/coda/dir.c

320

coda_flag_inode(d_inode(new_dentry), C_VATTR);

fs/coda/dir.c

449

inode = d_inode(de);

fs/coda/dir.c

455

cii = ITOC(d_inode(de));

fs/coda/dir.c

491

inode = d_inode(dentry);

fs/coda/inode.c

300

int err = coda_revalidate_inode(d_inode(path->dentry));

fs/coda/inode.c

303

d_inode(path->dentry), stat);

fs/coda/inode.c

310

struct inode *inode = d_inode(de);

fs/coda/pioctl.c

73

target_inode = d_inode(path.dentry);

fs/coda/upcall.c

904

coda_flag_inode(d_inode(sb->s_root), C_FLUSH);

fs/configfs/dir.c

1163

inode_lock(d_inode(root));

fs/configfs/dir.c

1175

inode_unlock(d_inode(root));

fs/configfs/dir.c

1258

inode_lock(d_inode(root->cg_item.ci_dentry));

fs/configfs/dir.c

1282

inode_unlock(d_inode(root->cg_item.ci_dentry));

fs/configfs/dir.c

1530

inode_lock(d_inode(wait));

fs/configfs/dir.c

1531

inode_unlock(d_inode(wait));

fs/configfs/dir.c

1602

inode_lock(d_inode(dentry));

fs/configfs/dir.c

1612

inode_unlock(d_inode(dentry));

fs/configfs/dir.c

1622

inode_lock(d_inode(dentry));

fs/configfs/dir.c

1626

inode_unlock(d_inode(dentry));

fs/configfs/dir.c

1672

inode = d_inode(dentry);

fs/configfs/dir.c

1772

inode_lock_nested(d_inode(parent), I_MUTEX_PARENT);

fs/configfs/dir.c

1780

inode_unlock(d_inode(parent));

fs/configfs/dir.c

1784

inode_unlock(d_inode(parent));

fs/configfs/dir.c

1811

inode_lock_nested(d_inode(parent), I_MUTEX_PARENT);

fs/configfs/dir.c

1817

d_inode(dentry)->i_flags |= S_DEAD;

fs/configfs/dir.c

1820

fsnotify_rmdir(d_inode(parent), dentry);

fs/configfs/dir.c

1821

inode_unlock(d_inode(parent));

fs/configfs/dir.c

1902

inode_lock_nested(d_inode(root), I_MUTEX_PARENT);

fs/configfs/dir.c

1915

BUG_ON(d_inode(dentry));

fs/configfs/dir.c

1925

inode_unlock(d_inode(root));

fs/configfs/dir.c

1955

inode_lock_nested(d_inode(root),

fs/configfs/dir.c

1957

inode_lock_nested(d_inode(dentry), I_MUTEX_CHILD);

fs/configfs/dir.c

1966

d_inode(dentry)->i_flags |= S_DEAD;

fs/configfs/dir.c

1968

inode_unlock(d_inode(dentry));

fs/configfs/dir.c

1971

fsnotify_rmdir(d_inode(root), dentry);

fs/configfs/dir.c

1973

inode_unlock(d_inode(root));

fs/configfs/dir.c

320

inc_nlink(d_inode(p));

fs/configfs/dir.c

405

__simple_rmdir(d_inode(parent),d);

fs/configfs/dir.c

668

inode_lock(d_inode(child));

fs/configfs/dir.c

671

d_inode(child)->i_flags |= S_DEAD;

fs/configfs/dir.c

674

inode_unlock(d_inode(child));

fs/configfs/dir.c

717

BUG_ON(d_inode(child));

fs/configfs/dir.c

861

inode_lock(d_inode(dentry));

fs/configfs/dir.c

863

d_inode(dentry)->i_flags |= S_DEAD;

fs/configfs/dir.c

865

inode_unlock(d_inode(dentry));

fs/configfs/dir.c

902

inode_lock_nested(d_inode(dentry), I_MUTEX_CHILD);

fs/configfs/dir.c

907

d_inode(dentry)->i_flags |= S_DEAD;

fs/configfs/dir.c

911

inode_unlock(d_inode(dentry));

fs/configfs/file.c

454

inode_lock_nested(d_inode(dir), I_MUTEX_NORMAL);

fs/configfs/file.c

457

inode_unlock(d_inode(dir));

fs/configfs/file.c

476

inode_lock_nested(dir->d_inode, I_MUTEX_NORMAL);

fs/configfs/file.c

479

inode_unlock(dir->d_inode);

fs/configfs/inode.c

173

p_inode = d_inode(dentry->d_parent);

fs/configfs/inode.c

214

__simple_unlink(d_inode(parent), dentry);

fs/configfs/inode.c

38

struct inode * inode = d_inode(dentry);

fs/configfs/symlink.c

190

if (dentry->d_inode || d_unhashed(dentry))

fs/crypto/hooks.c

106

d_inode(old_dentry)))

fs/crypto/hooks.c

112

d_inode(new_dentry)))

fs/crypto/hooks.c

170

return fscrypt_require_key(d_inode(dentry));

fs/crypto/hooks.c

454

struct inode *inode = d_inode(dentry);

fs/crypto/hooks.c

63

if (!fscrypt_has_permitted_context(d_inode(dentry_parent), inode)) {

fs/crypto/hooks.c

66

d_inode(dentry_parent)->i_ino);

fs/dcache.c

1643

dentry->d_inode ?

fs/dcache.c

1644

dentry->d_inode->i_ino : 0UL,

fs/dcache.c

1705

if (!dentry->d_inode)

fs/dcache.c

1781

dentry->d_inode = NULL;

fs/dcache.c

2519

struct inode *inode = dentry->d_inode;

fs/dcache.c

2621

seq = smp_load_acquire(&parent->d_inode->i_dir_seq);

fs/dcache.c

2649

if (unlikely(READ_ONCE(parent->d_inode->i_dir_seq) != seq)) {

fs/dcache.c

2755

dir = dentry->d_parent->d_inode;

fs/dcache.c

2888

WARN_ON(!dentry->d_inode);

fs/dcache.c

2913

dir = target->d_parent->d_inode;

fs/dcache.c

2991

WARN_ON(!dentry1->d_inode);

fs/dcache.c

2992

WARN_ON(!dentry2->d_inode);

fs/dcache.c

3044

if (!inode_trylock_shared(alias->d_parent->d_inode))

fs/dcache.c

3046

m2 = &alias->d_parent->d_inode->i_rwsem;

fs/dcache.c

3231

ret = dentry->d_parent->d_inode->i_ino;

fs/dcache.c

407

dentry->d_inode = inode;

fs/dcache.c

420

dentry->d_inode = NULL;

fs/dcache.c

452

__releases(dentry->d_inode->i_lock)

fs/dcache.c

454

struct inode *inode = dentry->d_inode;

fs/dcache.c

669

if (dentry->d_inode)

fs/dcache.c

710

struct inode *inode = dentry->d_inode;

fs/dcache.c

722

if (likely(inode == dentry->d_inode))

fs/dcache.c

725

inode = dentry->d_inode;

fs/debugfs/file.c

79

struct inode *inode = dentry->d_inode;

fs/debugfs/inode.c

151

struct inode *inode = d_inode(sb->s_root);

fs/debugfs/inode.c

258

struct inode *inode = path->dentry->d_inode;

fs/debugfs/inode.c

451

fsnotify_create(d_inode(dentry->d_parent), dentry);

fs/debugfs/inode.c

542

d_inode(de)->i_size = file_size;

fs/debugfs/inode.c

592

inc_nlink(d_inode(dentry->d_parent));

fs/debugfs/inode.c

593

fsnotify_mkdir(d_inode(dentry->d_parent), dentry);

fs/debugfs/inode.c

634

inc_nlink(d_inode(dentry->d_parent));

fs/debugfs/inode.c

635

fsnotify_mkdir(d_inode(dentry->d_parent), dentry);

fs/debugfs/inode.c

857

dir = d_inode(rd.old_parent);

fs/devpts/inode.c

529

fsnotify_create(d_inode(root), dentry);

fs/devpts/inode.c

558

drop_nlink(dentry->d_inode);

fs/devpts/inode.c

560

fsnotify_unlink(d_inode(dentry->d_parent), dentry);

fs/ecryptfs/crypto.c

1005

struct inode *lower_inode = d_inode(lower_dentry);

fs/ecryptfs/crypto.c

1190

ecryptfs_i_size_init(page_virt, d_inode(ecryptfs_dentry));

fs/ecryptfs/crypto.c

1289

struct inode *ecryptfs_inode = d_inode(ecryptfs_dentry);

fs/ecryptfs/dentry.c

53

struct inode *inode = d_inode(dentry);

fs/ecryptfs/file.c

146

struct inode *inode = d_inode(dentry);

fs/ecryptfs/inode.c

1008

fsstack_copy_attr_all(d_inode(dentry),

fs/ecryptfs/inode.c

1009

ecryptfs_inode_to_lower(d_inode(dentry)));

fs/ecryptfs/inode.c

1011

d_inode(dentry), stat);

fs/ecryptfs/inode.c

1027

lower_inode = d_inode(lower_dentry);

fs/ecryptfs/inode.c

1074

if (!d_inode(lower_dentry)->i_op->listxattr) {

fs/ecryptfs/inode.c

1078

inode_lock(d_inode(lower_dentry));

fs/ecryptfs/inode.c

1079

rc = d_inode(lower_dentry)->i_op->listxattr(lower_dentry, list, size);

fs/ecryptfs/inode.c

1080

inode_unlock(d_inode(lower_dentry));

fs/ecryptfs/inode.c

1117

fsstack_copy_attr_all(d_inode(dentry), d_inode(lower_dentry));

fs/ecryptfs/inode.c

1135

struct inode *lower_inode = d_inode(lower_dentry);

fs/ecryptfs/inode.c

1140

fsstack_copy_attr_all(d_inode(dentry), lower_inode);

fs/ecryptfs/inode.c

136

struct inode *inode = ecryptfs_get_inode(d_inode(lower_dentry), sb);

fs/ecryptfs/inode.c

156

lower_dir = lower_dentry->d_parent->d_inode;

fs/ecryptfs/inode.c

196

lower_dir = lower_dentry->d_parent->d_inode;

fs/ecryptfs/inode.c

204

inode = __ecryptfs_get_inode(d_inode(lower_dentry),

fs/ecryptfs/inode.c

339

fsstack_copy_attr_atime(d_inode(dentry->d_parent),

fs/ecryptfs/inode.c

340

d_inode(lower_parent));

fs/ecryptfs/inode.c

351

lower_inode = READ_ONCE(lower_dentry->d_inode);

fs/ecryptfs/inode.c

439

file_size_save = i_size_read(d_inode(old_dentry));

fs/ecryptfs/inode.c

444

lower_dir = lower_new_dentry->d_parent->d_inode;

fs/ecryptfs/inode.c

454

set_nlink(d_inode(old_dentry),

fs/ecryptfs/inode.c

455

ecryptfs_inode_to_lower(d_inode(old_dentry))->i_nlink);

fs/ecryptfs/inode.c

456

i_size_write(d_inode(new_dentry), file_size_save);

fs/ecryptfs/inode.c

464

return ecryptfs_do_unlink(dir, dentry, d_inode(dentry));

fs/ecryptfs/inode.c

481

lower_dir = lower_dentry->d_parent->d_inode;

fs/ecryptfs/inode.c

520

lower_dir = lower_dir_dentry->d_inode;

fs/ecryptfs/inode.c

552

lower_dir = lower_dentry->d_parent->d_inode;

fs/ecryptfs/inode.c

556

clear_nlink(d_inode(dentry));

fs/ecryptfs/inode.c

577

lower_dir = lower_dentry->d_parent->d_inode;

fs/ecryptfs/inode.c

616

target_inode = d_inode(new_dentry);

fs/ecryptfs/inode.c

631

fsstack_copy_attr_all(new_dir, d_inode(lower_new_dir_dentry));

fs/ecryptfs/inode.c

633

fsstack_copy_attr_all(old_dir, d_inode(lower_old_dir_dentry));

fs/ecryptfs/inode.c

673

fsstack_copy_attr_atime(d_inode(dentry),

fs/ecryptfs/inode.c

674

d_inode(ecryptfs_dentry_to_lower(dentry)));

fs/ecryptfs/inode.c

729

struct inode *inode = d_inode(dentry);

fs/ecryptfs/inode.c

742

crypt_stat = &ecryptfs_inode_to_private(d_inode(dentry))->crypt_stat;

fs/ecryptfs/inode.c

849

rc = ecryptfs_inode_newsize_ok(d_inode(dentry), new_length);

fs/ecryptfs/inode.c

857

inode_lock(d_inode(lower_dentry));

fs/ecryptfs/inode.c

860

inode_unlock(d_inode(lower_dentry));

fs/ecryptfs/inode.c

896

crypt_stat = &ecryptfs_inode_to_private(d_inode(dentry))->crypt_stat;

fs/ecryptfs/inode.c

899

inode = d_inode(dentry);

fs/ecryptfs/inode.c

963

inode_lock(d_inode(lower_dentry));

fs/ecryptfs/inode.c

965

inode_unlock(d_inode(lower_dentry));

fs/ecryptfs/inode.c

981

generic_fillattr(&nop_mnt_idmap, request_mask, d_inode(dentry), stat);

fs/ecryptfs/kthread.c

134

flags |= IS_RDONLY(d_inode(lower_dentry)) ? O_RDONLY : O_RDWR;

fs/ecryptfs/main.c

504

!uid_eq(d_inode(path.dentry)->i_uid, current_uid())) {

fs/ecryptfs/main.c

508

i_uid_read(d_inode(path.dentry)),

fs/ecryptfs/main.c

541

inode = ecryptfs_get_inode(d_inode(path.dentry), s);

fs/ecryptfs/mmap.c

387

struct inode *lower_inode = d_inode(lower_dentry);

fs/efivarfs/inode.c

123

struct efivar_entry *var = d_inode(dentry)->i_private;

fs/efivarfs/inode.c

143

i_flags = d_inode(dentry)->i_flags;

fs/efivarfs/inode.c

167

inode_set_flags(d_inode(dentry), i_flags, S_IMMUTABLE);

fs/efivarfs/inode.c

176

struct inode *inode = d_inode(dentry);

fs/efivarfs/super.c

256

inode = efivarfs_get_inode(sb, d_inode(root), S_IFREG | 0644, 0,

fs/efivarfs/super.c

476

inode = d_inode(child);

fs/efs/namei.c

115

ino = efs_find_entry(d_inode(child), "..", 2);

fs/erofs/inode.c

317

struct inode *const inode = d_inode(path->dentry);

fs/erofs/super.c

602

err = erofs_namei(d_inode(child), &dotdot_name, &nid, &d_type);

fs/erofs/xattr.c

376

struct inode *inode = d_inode(dentry);

fs/exec.c

118

VFS_WARN_ON_ONCE(IS_ANON_FILE(d_inode(path->dentry)) &&

fs/exfat/dir.c

1263

struct exfat_inode_info *ei = EXFAT_I(sb->s_root->d_inode);

fs/exfat/dir.c

1366

struct inode *root_inode = sb->s_root->d_inode;

fs/exfat/file.c

289

struct inode *inode = dentry->d_inode;

fs/exfat/namei.c

1145

struct inode *new_inode = new_dentry->d_inode;

fs/exfat/namei.c

1262

old_inode = old_dentry->d_inode;

fs/exfat/namei.c

1263

new_inode = new_dentry->d_inode;

fs/exfat/namei.c

799

struct inode *inode = dentry->d_inode;

fs/exfat/namei.c

946

struct inode *inode = dentry->d_inode;

fs/exportfs/expfs.c

134

dentry->d_inode->i_ino, PTR_ERR(parent));

fs/exportfs/expfs.c

139

dentry->d_inode->i_ino, parent->d_inode->i_ino);

fs/exportfs/expfs.c

278

struct inode *dir = path->dentry->d_inode;

fs/exportfs/expfs.c

420

struct inode *inode = dentry->d_inode, *parent = NULL;

fs/exportfs/expfs.c

428

parent = p->d_inode;

fs/exportfs/expfs.c

53

inode = result->d_inode;

fs/exportfs/expfs.c

555

if (unlikely(nresult->d_inode != result->d_inode)) {

fs/ext2/acl.c

227

struct inode *inode = d_inode(dentry);

fs/ext2/dir.c

479

struct inode *dir = d_inode(dentry->d_parent);

fs/ext2/ialloc.c

274

if ((parent == d_inode(sb->s_root)) ||

fs/ext2/inode.c

1624

struct inode *inode = d_inode(path->dentry);

fs/ext2/inode.c

1650

struct inode *inode = d_inode(dentry);

fs/ext2/ioctl.c

23

struct ext2_inode_info *ei = EXT2_I(d_inode(dentry));

fs/ext2/ioctl.c

33

struct inode *inode = d_inode(dentry);

fs/ext2/namei.c

207

struct inode *inode = d_inode(old_dentry);

fs/ext2/namei.c

275

struct inode *inode = d_inode(dentry);

fs/ext2/namei.c

304

struct inode * inode = d_inode(dentry);

fs/ext2/namei.c

323

struct inode * old_inode = d_inode(old_dentry);

fs/ext2/namei.c

324

struct inode * new_inode = d_inode(new_dentry);

fs/ext2/namei.c

87

res = ext2_inode_by_name(d_inode(child), &dotdot_name, &ino);

fs/ext2/super.c

1623

inode = d_inode(path->dentry);

fs/ext2/xattr.c

290

struct inode *inode = d_inode(dentry);

fs/ext4/acl.c

234

struct inode *inode = d_inode(dentry);

fs/ext4/fast_commit.c

404

struct inode *dir = dentry->d_parent->d_inode;

fs/ext4/fast_commit.c

474

struct inode *inode = d_inode(dentry);

fs/ext4/fast_commit.c

501

struct inode *inode = d_inode(dentry);

fs/ext4/fast_commit.c

528

struct inode *inode = d_inode(dentry);

fs/ext4/fsync.c

62

inode = dentry->d_inode;

fs/ext4/ialloc.c

456

((parent == d_inode(sb->s_root)) ||

fs/ext4/inode.c

5797

struct inode *inode = d_inode(dentry);

fs/ext4/inode.c

6053

struct inode *inode = d_inode(path->dentry);

fs/ext4/inode.c

6127

struct inode *inode = d_inode(path->dentry);

fs/ext4/ioctl.c

1008

struct inode *inode = d_inode(dentry);

fs/ext4/ioctl.c

991

struct inode *inode = d_inode(dentry);

fs/ext4/migrate.c

462

tmp_inode = ext4_new_inode(handle, d_inode(inode->i_sb->s_root),

fs/ext4/namei.c

1822

bh = ext4_find_entry(d_inode(child), &dotdot_name, &de, NULL);

fs/ext4/namei.c

1831

EXT4_ERROR_INODE(d_inode(child),

fs/ext4/namei.c

2359

struct inode *dir = d_inode(dentry->d_parent);

fs/ext4/namei.c

2780

struct inode *dir = d_inode(dentry->d_parent);

fs/ext4/namei.c

3146

retval = dquot_initialize(d_inode(dentry));

fs/ext4/namei.c

3157

inode = d_inode(dentry);

fs/ext4/namei.c

3308

retval = dquot_initialize(d_inode(dentry));

fs/ext4/namei.c

3312

retval = __ext4_unlink(dir, &dentry->d_name, d_inode(dentry), dentry);

fs/ext4/namei.c

3489

struct inode *inode = d_inode(old_dentry);

fs/ext4/namei.c

3501

EXT4_I(old_dentry->d_inode)->i_projid)))

fs/ext4/namei.c

3795

.inode = d_inode(old_dentry),

fs/ext4/namei.c

3800

.inode = d_inode(new_dentry),

fs/ext4/namei.c

3816

EXT4_I(old_dentry->d_inode)->i_projid)))

fs/ext4/namei.c

4048

.inode = d_inode(old_dentry),

fs/ext4/namei.c

4053

.inode = d_inode(new_dentry),

fs/ext4/namei.c

4060

EXT4_I(old_dentry->d_inode)->i_projid)) ||

fs/ext4/namei.c

4063

EXT4_I(new_dentry->d_inode)->i_projid)))

fs/ext4/super.c

2342

journal_inode = d_inode(path.dentry);

fs/ext4/super.c

6972

if (ext4_test_inode_flag(dentry->d_inode, EXT4_INODE_PROJINHERIT) &&

fs/ext4/super.c

6974

ext4_statfs_project(sb, EXT4_I(dentry->d_inode)->i_projid, buf);

fs/ext4/super.c

7131

if (IS_NOQUOTA(d_inode(path->dentry)))

fs/ext4/super.c

7150

lockdep_set_quota_inode(path->dentry->d_inode, I_DATA_SEM_QUOTA);

fs/ext4/super.c

7153

struct inode *inode = d_inode(path->dentry);

fs/ext4/super.c

7176

lockdep_set_quota_inode(path->dentry->d_inode,

fs/ext4/xattr.c

1488

ea_inode = ext4_new_inode(handle, inode->i_sb->s_root->d_inode,

fs/ext4/xattr.c

750

struct inode *inode = d_inode(dentry);

fs/ext4/xattr.c

780

struct inode *inode = d_inode(dentry);

fs/ext4/xattr.c

817

down_read(&EXT4_I(d_inode(dentry))->xattr_sem);

fs/ext4/xattr.c

830

up_read(&EXT4_I(d_inode(dentry))->xattr_sem);

fs/f2fs/acl.c

281

struct inode *inode = d_inode(dentry);

fs/f2fs/f2fs.h

3890

return f2fs_do_add_link(d_inode(dentry->d_parent), &dentry->d_name,

fs/f2fs/file.c

1068

struct inode *inode = d_inode(dentry);

fs/f2fs/file.c

2320

struct inode *dir = d_inode(dentry->d_parent);

fs/f2fs/file.c

3438

struct inode *inode = d_inode(dentry);

fs/f2fs/file.c

3462

struct inode *inode = d_inode(dentry);

fs/f2fs/file.c

977

struct inode *inode = d_inode(path->dentry);

fs/f2fs/namei.c

1120

struct inode *old_inode = d_inode(old_dentry);

fs/f2fs/namei.c

1121

struct inode *new_inode = d_inode(new_dentry);

fs/f2fs/namei.c

403

struct inode *inode = d_inode(old_dentry);

fs/f2fs/namei.c

453

unsigned long ino = f2fs_inode_by_name(d_inode(child), &dotdot_name, &folio);

fs/f2fs/namei.c

548

struct inode *inode = d_inode(dentry);

fs/f2fs/namei.c

764

struct inode *inode = d_inode(dentry);

fs/f2fs/namei.c

922

struct inode *old_inode = d_inode(old_dentry);

fs/f2fs/namei.c

923

struct inode *new_inode = d_inode(new_dentry);

fs/f2fs/super.c

2262

if (is_inode_flag_set(d_inode(dentry), FI_PROJ_INHERIT) &&

fs/f2fs/super.c

2264

f2fs_statfs_project(sb, F2FS_I(d_inode(dentry))->i_projid, buf);

fs/f2fs/super.c

3448

inode = d_inode(path->dentry);

fs/f2fs/xattr.c

565

struct inode *inode = d_inode(dentry);

fs/fat/file.c

402

struct inode *inode = d_inode(path->dentry);

fs/fat/file.c

485

struct inode *inode = d_inode(dentry);

fs/fat/namei_msdos.c

313

struct inode *inode = d_inode(dentry);

fs/fat/namei_msdos.c

408

struct inode *inode = d_inode(dentry);

fs/fat/namei_msdos.c

445

old_inode = d_inode(old_dentry);

fs/fat/namei_msdos.c

446

new_inode = d_inode(new_dentry);

fs/fat/namei_vfat.c

1073

old_inode = d_inode(old_dentry);

fs/fat/namei_vfat.c

1074

new_inode = d_inode(new_dentry);

fs/fat/namei_vfat.c

790

struct inode *inode = d_inode(dentry);

fs/fat/namei_vfat.c

826

struct inode *inode = d_inode(dentry);

fs/fat/namei_vfat.c

947

old_inode = d_inode(old_dentry);

fs/fat/namei_vfat.c

948

new_inode = d_inode(new_dentry);

fs/fat/nfs.c

276

if (!fat_get_dotdot_entry(d_inode(child_dir), &bh, &de)) {

fs/fhandle.c

219

if (!privileged_wrt_inode_uidgid(user_ns, idmap, d_inode(dentry)))

fs/fhandle.c

242

d_inode(parent))) {

fs/file_attr.c

271

struct inode *inode = d_inode(dentry);

fs/file_attr.c

88

struct inode *inode = d_inode(dentry);

fs/file_table.c

324

file->f_inode = path->dentry->d_inode;

fs/file_table.c

325

file->f_mapping = path->dentry->d_inode->i_mapping;

fs/file_table.c

340

i_readcount_inc(path->dentry->d_inode);

fs/fuse/acl.c

70

struct inode *inode = d_inode(dentry);

fs/fuse/acl.c

98

struct inode *inode = d_inode(dentry);

fs/fuse/control.c

235

inc_nlink(d_inode(parent));

fs/fuse/control.c

290

d_inode(dentry)->i_private = NULL;

fs/fuse/dir.c

1171

struct inode *inode = d_inode(entry);

fs/fuse/dir.c

1264

fuse_update_ctime(d_inode(oldent));

fs/fuse/dir.c

1267

fuse_update_ctime(d_inode(newent));

fs/fuse/dir.c

1329

struct inode *inode = d_inode(entry);

fs/fuse/dir.c

1620

inode_lock(d_inode(entry));

fs/fuse/dir.c

1621

if (get_node_id(d_inode(entry)) != child_nodeid) {

fs/fuse/dir.c

1635

d_inode(entry)->i_flags |= S_DEAD;

fs/fuse/dir.c

1638

clear_nlink(d_inode(entry));

fs/fuse/dir.c

1641

inode_unlock(d_inode(entry));

fs/fuse/dir.c

2135

struct inode *inode = d_inode(dentry);

fs/fuse/dir.c

2314

struct inode *inode = d_inode(entry);

fs/fuse/dir.c

2378

struct inode *inode = d_inode(path->dentry);

fs/fuse/dir.c

511

struct fuse_inode *mp_fi = get_fuse_inode(d_inode(path->dentry));

fs/fuse/inode.c

1183

struct inode *child_inode = d_inode(child);

fs/fuse/inode.c

518

if (inode != d_inode(sb->s_root)) {

fs/fuse/inode.c

673

args.nodeid = get_node_id(d_inode(dentry));

fs/fuse/inode.c

763

args.nodeid = get_node_id(sb->s_root->d_inode);

fs/fuse/ioctl.c

507

struct inode *inode = d_inode(dentry);

fs/fuse/ioctl.c

545

struct inode *inode = d_inode(dentry);

fs/fuse/readdir.c

160

struct inode *dir = d_inode(parent);

fs/fuse/readdir.c

206

inode = d_inode(dentry);

fs/fuse/xattr.c

111

struct inode *inode = d_inode(entry);

fs/gfs2/acl.c

108

struct inode *inode = d_inode(dentry);

fs/gfs2/dentry.c

49

inode = d_inode(dentry);

fs/gfs2/dentry.c

88

ginode = GFS2_I(d_inode(dentry));

fs/gfs2/export.c

128

return d_obtain_alias(gfs2_lookupi(d_inode(child), &gfs2_qdotdot, 1));

fs/gfs2/export.c

49

if (!parent || inode == d_inode(sb->s_root))

fs/gfs2/export.c

88

struct inode *dir = d_inode(parent);

fs/gfs2/export.c

89

struct inode *inode = d_inode(child);

fs/gfs2/file.c

160

struct inode *inode = d_inode(dentry);

fs/gfs2/file.c

281

struct inode *inode = d_inode(dentry);

fs/gfs2/inode.c

1044

struct inode *inode = d_inode(old_dentry);

fs/gfs2/inode.c

1210

struct inode *inode = d_inode(dentry);

fs/gfs2/inode.c

1246

struct inode *inode = d_inode(dentry);

fs/gfs2/inode.c

1430

if (dir == d_inode(sb->s_root)) {

fs/gfs2/inode.c

1490

struct gfs2_inode *ip = GFS2_I(d_inode(odentry));

fs/gfs2/inode.c

1504

nip = GFS2_I(d_inode(ndentry));

fs/gfs2/inode.c

1649

error = gfs2_permission(&nop_mnt_idmap, d_inode(odentry),

fs/gfs2/inode.c

1742

struct gfs2_inode *oip = GFS2_I(odentry->d_inode);

fs/gfs2/inode.c

1743

struct gfs2_inode *nip = GFS2_I(ndentry->d_inode);

fs/gfs2/inode.c

1818

error = gfs2_permission(&nop_mnt_idmap, odentry->d_inode,

fs/gfs2/inode.c

1824

error = gfs2_permission(&nop_mnt_idmap, ndentry->d_inode,

fs/gfs2/inode.c

2100

struct inode *inode = d_inode(dentry);

fs/gfs2/inode.c

2162

struct inode *inode = d_inode(path->dentry);

fs/gfs2/inode.c

337

dir == d_inode(sb->s_root))) {

fs/gfs2/inode.c

815

if ((GFS2_I(d_inode(sdp->sd_root_dir)) == dip) ||

fs/gfs2/ops_fstype.c

608

struct inode *master = d_inode(sdp->sd_master_dir);

fs/gfs2/ops_fstype.c

696

struct inode *master = d_inode(sdp->sd_master_dir);

fs/gfs2/ops_fstype.c

839

struct inode *master = d_inode(sdp->sd_master_dir);

fs/gfs2/ops_fstype.c

895

struct inode *master = d_inode(sdp->sd_master_dir);

fs/gfs2/xattr.c

418

struct gfs2_inode *ip = GFS2_I(d_inode(dentry));

fs/hfs/dir.c

258

struct inode *inode = d_inode(dentry);

fs/hfs/dir.c

306

res = hfs_cat_move(d_inode(old_dentry)->i_ino,

fs/hfs/dir.c

311

(btree_key *)&HFS_I(d_inode(old_dentry))->cat_key,

fs/hfs/inode.c

645

struct inode *inode = d_inode(dentry);

fs/hfs/sysdep.c

25

inode = d_inode(dentry);

fs/hfsplus/dir.c

304

struct inode *inode = d_inode(src_dentry);

fs/hfsplus/dir.c

305

struct inode *src_dir = d_inode(src_dentry->d_parent);

fs/hfsplus/dir.c

379

struct inode *inode = d_inode(dentry);

fs/hfsplus/dir.c

448

struct inode *inode = d_inode(dentry);

fs/hfsplus/dir.c

85

HFSPLUS_I(d_inode(sb->s_root))->

fs/hfsplus/inode.c

269

struct inode *inode = d_inode(dentry);

fs/hfsplus/inode.c

300

struct inode *inode = d_inode(path->dentry);

fs/hfsplus/inode.c

729

struct inode *inode = d_inode(dentry);

fs/hfsplus/inode.c

748

struct inode *inode = d_inode(dentry);

fs/hfsplus/ioctl.c

30

struct inode *inode = d_inode(dentry);

fs/hfsplus/xattr.c

645

struct inode *inode = d_inode(dentry);

fs/hfsplus/xattr.c

713

struct inode *inode = d_inode(dentry);

fs/hostfs/hostfs_kern.c

807

struct inode *inode = d_inode(dentry);

fs/hpfs/inode.c

263

struct inode *inode = d_inode(dentry);

fs/hpfs/namei.c

378

struct inode *inode = d_inode(dentry);

fs/hpfs/namei.c

429

struct inode *inode = d_inode(dentry);

fs/hpfs/namei.c

511

struct inode *i = d_inode(old_dentry);

fs/hpfs/namei.c

512

struct inode *new_inode = d_inode(new_dentry);

fs/hugetlbfs/inode.c

1128

struct hstate *h = hstate_inode(d_inode(dentry));

fs/hugetlbfs/inode.c

866

struct inode *inode = d_inode(dentry);

fs/inode.c

2251

struct inode *inode = d_inode(path->dentry);

fs/inode.c

2288

struct inode *inode = d_inode(dentry);

fs/isofs/export.c

48

struct inode *child_inode = d_inode(child);

fs/jffs2/acl.c

235

struct inode *inode = d_inode(dentry);

fs/jffs2/dir.c

234

struct jffs2_inode_info *dead_f = JFFS2_INODE_INFO(d_inode(dentry));

fs/jffs2/dir.c

241

set_nlink(d_inode(dentry), dead_f->inocache->pino_nlink);

fs/jffs2/dir.c

253

struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry));

fs/jffs2/dir.c

267

type = (d_inode(old_dentry)->i_mode & S_IFMT) >> 12;

fs/jffs2/dir.c

275

set_nlink(d_inode(old_dentry), ++f->inocache->pino_nlink);

fs/jffs2/dir.c

277

d_instantiate(dentry, d_inode(old_dentry));

fs/jffs2/dir.c

280

ihold(d_inode(old_dentry));

fs/jffs2/dir.c

600

struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(dentry));

fs/jffs2/dir.c

619

clear_nlink(d_inode(dentry));

fs/jffs2/dir.c

794

victim_f = JFFS2_INODE_INFO(d_inode(new_dentry));

fs/jffs2/dir.c

817

type = (d_inode(old_dentry)->i_mode & S_IFMT) >> 12;

fs/jffs2/dir.c

822

d_inode(old_dentry)->i_ino, type,

fs/jffs2/dir.c

831

clear_nlink(d_inode(new_dentry));

fs/jffs2/dir.c

833

drop_nlink(d_inode(new_dentry));

fs/jffs2/dir.c

859

struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry));

fs/jffs2/dir.c

861

inc_nlink(d_inode(old_dentry));

fs/jffs2/fs.c

196

struct inode *inode = d_inode(dentry);

fs/jffs2/super.c

143

f = JFFS2_INODE_INFO(d_inode(child));

fs/jffs2/xattr.c

967

struct inode *inode = d_inode(dentry);

fs/jfs/acl.c

98

struct inode *inode = d_inode(dentry);

fs/jfs/file.c

95

struct inode *inode = d_inode(dentry);

fs/jfs/ioctl.c

62

struct jfs_inode_info *jfs_inode = JFS_IP(d_inode(dentry));

fs/jfs/ioctl.c

76

struct inode *inode = d_inode(dentry);

fs/jfs/namei.c

1102

old_ip = d_inode(old_dentry);

fs/jfs/namei.c

1103

new_ip = d_inode(new_dentry);

fs/jfs/namei.c

1518

le32_to_cpu(JFS_IP(d_inode(dentry))->i_dtroot.header.idotdot);

fs/jfs/namei.c

338

struct inode *ip = d_inode(dentry);

fs/jfs/namei.c

468

struct inode *ip = d_inode(dentry);

fs/jfs/namei.c

792

struct inode *ip = d_inode(old_dentry);

fs/jfs/super.c

807

inode = d_inode(path->dentry);

fs/jfs/xattr.c

874

struct inode *inode = d_inode(dentry);

fs/kernfs/inode.c

114

struct inode *inode = d_inode(dentry);

fs/kernfs/inode.c

149

return simple_xattr_list(d_inode(dentry), &attrs->xattrs, buf, size);

fs/kernfs/inode.c

189

struct inode *inode = d_inode(path->dentry);

fs/kernfs/kernfs-internal.h

143

return d_inode(dentry)->i_private;

fs/libfs.c

165

inode_lock_shared(dentry->d_inode);

fs/libfs.c

179

inode_unlock_shared(dentry->d_inode);

fs/libfs.c

1826

dir = READ_ONCE(parent->d_inode);

fs/libfs.c

1861

const struct inode *dir = READ_ONCE(dentry->d_inode);

fs/libfs.c

208

d_inode(next)->i_ino,

fs/libfs.c

209

fs_umode_to_dtype(d_inode(next)->i_mode)))

fs/libfs.c

2272

VFS_WARN_ON_ONCE(d_inode(path->dentry)->i_private != data);

fs/libfs.c

2279

struct inode *inode = d_inode(dentry);

fs/libfs.c

2321

inode_unlock(child->d_parent->d_inode);

fs/libfs.c

37

struct inode *inode = d_inode(path->dentry);

fs/libfs.c

479

struct inode *inode = d_inode(parent);

fs/libfs.c

498

struct inode *inode = d_inode(dentry);

fs/libfs.c

560

lockdep_assert_held(&d_inode(dir)->i_rwsem);

fs/libfs.c

606

struct inode *inode = this->d_inode;

fs/libfs.c

619

inode = this->d_inode;

fs/libfs.c

626

fsnotify_delete(inode, d_inode(victim), victim);

fs/libfs.c

756

struct inode *inode = d_inode(old_dentry);

fs/libfs.c

790

struct inode *inode = d_inode(dentry);

fs/libfs.c

800

drop_nlink(d_inode(dentry));

fs/libfs.c

839

struct inode *newino = d_inode(new_dentry);

fs/libfs.c

845

inode_set_ctime_current(d_inode(old_dentry));

fs/libfs.c

889

drop_nlink(d_inode(new_dentry));

fs/libfs.c

920

struct inode *inode = d_inode(dentry);

fs/minix/dir.c

158

struct inode * dir = d_inode(dentry->d_parent);

fs/minix/dir.c

201

struct inode *dir = d_inode(dentry->d_parent);

fs/minix/file.c

28

struct inode *inode = d_inode(dentry);

fs/minix/inode.c

708

struct inode *inode = d_inode(path->dentry);

fs/minix/namei.c

143

struct inode * inode = d_inode(dentry);

fs/minix/namei.c

168

struct inode * inode = d_inode(dentry);

fs/minix/namei.c

195

struct inode * old_inode = d_inode(old_dentry);

fs/minix/namei.c

196

struct inode * new_inode = d_inode(new_dentry);

fs/minix/namei.c

99

struct inode *inode = d_inode(old_dentry);

fs/namei.c

1145

nd->inode = d->d_inode;

fs/namei.c

1153

nd->inode = nd->path.dentry->d_inode;

fs/namei.c

1182

nd->inode = nd->path.dentry->d_inode;

fs/namei.c

1357

struct inode *inode = link->dentry->d_inode;

fs/namei.c

1550

dentry->d_inode)

fs/namei.c

1765

int error = d_revalidate(dir->d_inode, name, dentry, flags);

fs/namei.c

1797

dir = base->d_inode;

fs/namei.c

1894

struct inode *inode = dir->d_inode;

fs/namei.c

1930

struct inode *inode = dir->d_inode;

fs/namei.c

1942

struct inode *inode = dir->d_inode;

fs/namei.c

2104

inode = path.dentry->d_inode;

fs/namei.c

2138

struct inode *inode = dentry->d_inode;

fs/namei.c

2167

nd->inode = path.dentry->d_inode;

fs/namei.c

2206

nd->inode = path.dentry->d_inode;

fs/namei.c

2699

struct inode *inode = root->d_inode;

fs/namei.c

2732

nd->inode = nd->path.dentry->d_inode;

fs/namei.c

2737

nd->inode = nd->path.dentry->d_inode;

fs/namei.c

2760

nd->inode = nd->path.dentry->d_inode;

fs/namei.c

2764

nd->inode = nd->path.dentry->d_inode;

fs/namei.c

2921

struct inode *dir = d_inode(parent);

fs/namei.c

2953

inode_unlock(de->d_parent->d_inode);

fs/namei.c

3124

return inode_permission(idmap, base->d_inode, MAY_EXEC);

fs/namei.c

3169

WARN_ON_ONCE(!inode_is_locked(base->d_inode));

fs/namei.c

3196

WARN_ON_ONCE(!inode_is_locked(base->d_inode));

fs/namei.c

3539

inode_lock_nested(parent->d_inode, I_MUTEX_PARENT);

fs/namei.c

3540

if (unlikely(IS_DEADDIR(parent->d_inode) ||

fs/namei.c

3543

inode_unlock(parent->d_inode);

fs/namei.c

3547

inode_unlock(parent->d_inode);

fs/namei.c

3572

inode_lock_nested(parent->d_inode, I_MUTEX_PARENT);

fs/namei.c

3573

if (unlikely(IS_DEADDIR(parent->d_inode) ||

fs/namei.c

3576

inode_unlock(parent->d_inode);

fs/namei.c

3580

inode_unlock(parent->d_inode);

fs/namei.c

3665

BUG_ON(victim->d_parent->d_inode != dir);

fs/namei.c

3712

if (child->d_inode)

fs/namei.c

3732

inode_lock_nested(p2->d_inode, I_MUTEX_PARENT);

fs/namei.c

3733

inode_lock_nested(p1->d_inode, I_MUTEX_PARENT2);

fs/namei.c

3742

inode_lock_nested(p1->d_inode, I_MUTEX_PARENT);

fs/namei.c

3743

inode_lock_nested(p2->d_inode, I_MUTEX_PARENT2);

fs/namei.c

3747

inode_lock_nested(p1->d_inode, I_MUTEX_PARENT);

fs/namei.c

3748

inode_lock_nested(p2->d_inode, I_MUTEX_PARENT2);

fs/namei.c

3762

inode_lock_nested(p1->d_inode, I_MUTEX_PARENT);

fs/namei.c

3780

inode_lock_nested(p2->d_inode, I_MUTEX_PARENT);

fs/namei.c

3792

inode_unlock(p2->d_inode);

fs/namei.c

3807

inode_lock_nested(p2->d_inode, I_MUTEX_PARENT);

fs/namei.c

3815

inode_unlock(p1->d_inode);

fs/namei.c

3817

inode_unlock(p2->d_inode);

fs/namei.c

4165

struct inode *dir = d_inode(dentry->d_parent);

fs/namei.c

4193

struct inode *dir = dentry->d_parent->d_inode;

fs/namei.c

4220

struct inode *inode = dentry->d_inode;

fs/namei.c

4278

struct inode *inode = path->dentry->d_inode;

fs/namei.c

4311

error = inode_permission(idmap, dir->dentry->d_inode,

fs/namei.c

4316

return security_inode_create(dir->dentry->d_inode, dentry, mode);

fs/namei.c

4337

struct inode *dir = path->dentry->d_inode;

fs/namei.c

4390

struct inode *dir_inode = dir->d_inode;

fs/namei.c

4420

if (dentry->d_inode) {

fs/namei.c

4443

mode = vfs_prepare_mode(idmap, dir->d_inode, mode, mode, mode);

fs/namei.c

4476

if (!dentry->d_inode && (open_flag & O_CREAT)) {

fs/namei.c

4494

if (unlikely(create_error) && !dentry->d_inode) {

fs/namei.c

4532

if (!dentry->d_inode) {

fs/namei.c

4586

inode_lock(dir->d_inode);

fs/namei.c

4588

inode_lock_shared(dir->d_inode);

fs/namei.c

4592

fsnotify_create(dir->d_inode, dentry);

fs/namei.c

4597

inode_unlock(dir->d_inode);

fs/namei.c

4599

inode_unlock_shared(dir->d_inode);

fs/namei.c

4711

struct inode *dir = d_inode(parentpath->dentry);

fs/namei.c

5006

struct inode *dir_inode = d_inode(dir);

fs/namei.c

5032

fsnotify_create(dir->d_inode, dentry);

fs/namei.c

5141

mode_strip_umask(path.dentry->d_inode, mode), dev);

fs/namei.c

5153

error = vfs_mknod(idmap, path.dentry->d_inode,

fs/namei.c

5157

error = vfs_mknod(idmap, path.dentry->d_inode,

fs/namei.c

5270

mode_strip_umask(path.dentry->d_inode, mode));

fs/namei.c

5272

dentry = vfs_mkdir(mnt_idmap(path.mnt), path.dentry->d_inode,

fs/namei.c

5329

inode_lock(dentry->d_inode);

fs/namei.c

5333

(dentry->d_inode->i_flags & S_KERNEL_FILE))

fs/namei.c

5349

dentry->d_inode->i_flags |= S_DEAD;

fs/namei.c

5354

inode_unlock(dentry->d_inode);

fs/namei.c

5399

error = vfs_rmdir(mnt_idmap(path.mnt), path.dentry->d_inode,

fs/namei.c

5453

struct inode *target = dentry->d_inode;

fs/namei.c

5541

inode = dentry->d_inode;

fs/namei.c

5546

error = vfs_unlink(mnt_idmap(path.mnt), path.dentry->d_inode,

fs/namei.c

5646

error = vfs_symlink(mnt_idmap(path.mnt), path.dentry->d_inode,

fs/namei.c

5706

struct inode *inode = old_dentry->d_inode;

fs/namei.c

5820

error = vfs_link(old_path.dentry, idmap, new_path.dentry->d_inode,

fs/namei.c

5905

struct inode *old_dir = d_inode(rd->old_parent);

fs/namei.c

5906

struct inode *new_dir = d_inode(rd->new_parent);

fs/namei.c

5912

struct inode *source = old_dentry->d_inode;

fs/namei.c

5913

struct inode *target = new_dentry->d_inode;

fs/namei.c

6221

struct inode *inode = d_inode(dentry);

fs/namei.c

6267

struct inode *inode = d_inode(dentry);

fs/namei.c

6358

link = page_get_link(dentry, d_inode(dentry), &done);

fs/namei.c

948

BUG_ON(nd->inode != parent->d_inode);

fs/namespace.c

2093

ns = d_inode(dentry)->i_private;

fs/namespace.c

2141

return to_mnt_ns(get_proc_ns(dentry->d_inode));

fs/namespace.c

2750

inode_lock(dentry->d_inode);

fs/namespace.c

2769

inode_unlock(dentry->d_inode);

fs/namespace.c

2790

inode_unlock(m->mp->m_dentry->d_inode);

fs/namespace.c

3855

inode_lock(dentry->d_inode);

fs/namespace.c

3865

inode_unlock(dentry->d_inode);

fs/namespace.c

6351

struct inode *inode = child->mnt_mountpoint->d_inode;

fs/nfs/dir.c

1227

struct inode *inode = d_inode(dentry);

fs/nfs/dir.c

1438

struct inode *inode = d_inode(dentry);

fs/nfs/dir.c

1788

inode = d_inode(dentry);

fs/nfs/dir.c

1888

struct inode *inode = d_inode(dentry);

fs/nfs/dir.c

1923

if (d_really_is_positive(dentry) && NFS_STALE(d_inode(dentry)))

fs/nfs/dir.c

2122

BUG_ON(d_inode(dentry));

fs/nfs/dir.c

2224

inode = d_inode(dentry);

fs/nfs/dir.c

2231

inode = d_inode(res);

fs/nfs/dir.c

2268

inode = d_inode(dentry);

fs/nfs/dir.c

2343

struct inode *dir = d_inode(parent);

fs/nfs/dir.c

2501

nfs_d_prune_case_insensitive_aliases(d_inode(dentry));

fs/nfs/dir.c

2515

down_write(&NFS_I(d_inode(dentry))->rmdir_sem);

fs/nfs/dir.c

2520

clear_nlink(d_inode(dentry));

fs/nfs/dir.c

2525

up_write(&NFS_I(d_inode(dentry))->rmdir_sem);

fs/nfs/dir.c

2544

struct inode *dir = d_inode(dentry->d_parent);

fs/nfs/dir.c

2545

struct inode *inode = d_inode(dentry);

fs/nfs/dir.c

2587

&NFS_I(d_inode(dentry))->flags)) {

fs/nfs/dir.c

2590

write_inode_now(d_inode(dentry), 0);

fs/nfs/dir.c

2677

if (filemap_add_folio(d_inode(dentry)->i_mapping, folio, 0,

fs/nfs/dir.c

2691

struct inode *inode = d_inode(old_dentry);

fs/nfs/dir.c

2760

struct inode *old_inode = d_inode(old_dentry);

fs/nfs/dir.c

2761

struct inode *new_inode = d_inode(new_dentry);

fs/nfs/dir.c

649

inode = d_inode(dentry);

fs/nfs/dir.c

772

status = nfs_refresh_inode(d_inode(dentry), entry->fattr);

fs/nfs/dir.c

774

nfs_setsecurity(d_inode(dentry), entry->fattr);

fs/nfs/dir.c

775

trace_nfs_readdir_lookup_revalidate(d_inode(parent),

fs/nfs/dir.c

780

d_inode(parent), dentry, 0);

fs/nfs/dir.c

803

trace_nfs_readdir_lookup(d_inode(parent), dentry, 0);

fs/nfs/export.c

127

struct inode *inode = d_inode(dentry), *pinode;

fs/nfs/getroot.c

130

if (d_inode(fc->root)->i_fop != &nfs_dir_operations) {

fs/nfs/getroot.c

55

spin_lock(&d_inode(sb->s_root)->i_lock);

fs/nfs/getroot.c

59

spin_unlock(&d_inode(sb->s_root)->i_lock);

fs/nfs/inode.c

1128

struct inode *inode = d_inode(ctx->dentry);

fs/nfs/inode.c

1160

struct inode *inode = d_inode(ctx->dentry);

fs/nfs/inode.c

1189

inode = d_inode(ctx->dentry);

fs/nfs/inode.c

1247

struct inode *inode = d_inode(ctx->dentry);

fs/nfs/inode.c

1285

struct inode *inode = d_inode(ctx->dentry);

fs/nfs/inode.c

1336

struct inode *inode = d_inode(ctx->dentry);

fs/nfs/inode.c

713

struct inode *inode = d_inode(dentry);

fs/nfs/inode.c

938

nfs_readdir_record_entry_cache_miss(d_inode(parent));

fs/nfs/inode.c

947

nfs_readdir_record_entry_cache_hit(d_inode(parent));

fs/nfs/inode.c

985

struct inode *inode = d_inode(path->dentry);

fs/nfs/internal.h

42

if (!d_is_positive(dentry) || !NFS_FH(d_inode(dentry))->size)

fs/nfs/namespace.c

229

if (NFS_FH(d_inode(path->dentry))->size != 0)

fs/nfs/namespace.c

232

generic_fillattr(&nop_mnt_idmap, request_mask, d_inode(path->dentry),

fs/nfs/namespace.c

241

if (NFS_FH(d_inode(dentry))->size != 0)

fs/nfs/namespace.c

325

err = server->nfs_client->rpc_ops->lookup(d_inode(parent), dentry, &dentry->d_name,

fs/nfs/nfs3acl.c

261

struct inode *inode = d_inode(dentry);

fs/nfs/nfs3acl.c

329

struct inode *inode = d_inode(dentry);

fs/nfs/nfs3proc.c

129

struct inode *inode = d_inode(dentry);

fs/nfs/nfs3proc.c

417

nfs_post_op_update_inode(d_inode(dentry), data->res.fattr);

fs/nfs/nfs3proc.c

423

status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl);

fs/nfs/nfs3proc.c

620

status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl);

fs/nfs/nfs3proc.c

676

struct inode *dir = d_inode(nr_arg->dentry);

fs/nfs/nfs3proc.c

773

status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl);

fs/nfs/nfs4client.c

1202

return nfs_probe_server(server, NFS_FH(d_inode(server->super->s_root)));

fs/nfs/nfs4file.c

58

dir = d_inode(parent);

fs/nfs/nfs4file.c

87

if (inode != d_inode(dentry))

fs/nfs/nfs4namespace.c

431

err = nfs4_proc_fs_locations(client, d_inode(parent), &dentry->d_name, fs_locations, page);

fs/nfs/nfs4namespace.c

456

struct inode *dir = d_inode(parent);

fs/nfs/nfs4proc.c

10546

error2 = security_inode_listsecurity(d_inode(dentry), list, left);

fs/nfs/nfs4proc.c

10554

error3 = nfs4_listxattr_nfs4_user(d_inode(dentry), list, left);

fs/nfs/nfs4proc.c

1367

struct inode *dir = d_inode(parent);

fs/nfs/nfs4proc.c

1439

p->o_arg.fh = NFS_FH(d_inode(dentry));

fs/nfs/nfs4proc.c

2042

inode = d_inode(data->dentry);

fs/nfs/nfs4proc.c

2433

struct nfs_server *server = NFS_SERVER(d_inode(data->dir));

fs/nfs/nfs4proc.c

2597

struct inode *dir = d_inode(data->dir);

fs/nfs/nfs4proc.c

2651

struct inode *dir = d_inode(data->dir);

fs/nfs/nfs4proc.c

2713

struct inode *dir = d_inode(data->dir);

fs/nfs/nfs4proc.c

2754

fh = NFS_FH(d_inode(data->dentry));

fs/nfs/nfs4proc.c

3064

struct inode *dir = d_inode(opendata->dir);

fs/nfs/nfs4proc.c

3119

if (d_inode(dentry) == state->inode)

fs/nfs/nfs4proc.c

3166

nfs4_return_incompatible_delegation(d_inode(dentry), fmode);

fs/nfs/nfs4proc.c

3184

opendata->state = nfs4_get_open_state(d_inode(dentry), sp);

fs/nfs/nfs4proc.c

380

p = xdr_encode_hyper(p, NFS_FILEID(d_inode(dentry)));

fs/nfs/nfs4proc.c

3851

nfs4_inode_set_return_delegation_on_close(d_inode(dentry));

fs/nfs/nfs4proc.c

394

p = xdr_encode_hyper(p, NFS_FILEID(d_inode(dentry->d_parent)));

fs/nfs/nfs4proc.c

4522

struct inode *inode = d_inode(dentry);

fs/nfs/nfs4proc.c

4920

struct inode *inode = d_inode(dentry);

fs/nfs/nfs4proc.c

4968

nfs_request_directory_delegation(d_inode(dentry->d_parent));

fs/nfs/nfs4proc.c

5009

struct inode *old_inode = d_inode(old_dentry);

fs/nfs/nfs4proc.c

5010

struct inode *new_inode = d_inode(new_dentry);

fs/nfs/nfs4proc.c

5044

nfs_d_prune_case_insensitive_aliases(d_inode(data->old_dentry));

fs/nfs/nfs4proc.c

5309

struct inode *dir = d_inode(nr_arg->dentry);

fs/nfs/nfs4proc.c

5358

trace_nfs4_readdir(d_inode(arg->dentry), err);

fs/nfs/nfs4proc.c

5359

err = nfs4_handle_exception(NFS_SERVER(d_inode(arg->dentry)),

fs/nfs/nfs4proc.c

7345

renew_lease(NFS_SERVER(d_inode(data->ctx->dentry)),

fs/nfs/nfs4state.c

2066

inode = d_inode(server->super->s_root);

fs/nfs/nfs4state.c

2191

inode = d_inode(server->super->s_root);

fs/nfs/nfs4trace.h

1857

const struct inode *inode = d_inode(ctx->dentry);

fs/nfs/nfs4trace.h

606

__entry->dir = NFS_FILEID(d_inode(ctx->dentry->d_parent));

fs/nfs/nfstrace.h

434

__entry->fileid = d_is_negative(dentry) ? 0 : NFS_FILEID(d_inode(dentry));

fs/nfs/nfstrace.h

482

__entry->fileid = d_is_negative(dentry) ? 0 : NFS_FILEID(d_inode(dentry));

fs/nfs/nfstrace.h

943

struct inode *dir = d_inode(data->dentry->d_parent);

fs/nfs/pagelist.c

1086

flctx = locks_inode_context(d_inode(nfs_req_openctx(req)->dentry));

fs/nfs/pagelist.c

173

struct inode *inode = d_inode(l_ctx->open_context->dentry);

fs/nfs/pagelist.c

567

rpc_wake_up(&NFS_SERVER(d_inode(ctx->dentry))->uoc_rpcwaitq);

fs/nfs/pnfs.c

1120

server = NFS_SERVER(parent_dir->d_inode);

fs/nfs/pnfs.c

2427

struct inode *ino = data->dentry->d_inode;

fs/nfs/pnfs.c

2462

struct inode *ino = data->dentry->d_inode;

fs/nfs/pnfs.c

2483

struct nfs_server *server = NFS_SERVER(data->dir->d_inode);

fs/nfs/pnfs.c

2489

if (!nfs_server_capable(data->dir->d_inode, NFS_CAP_LGOPEN))

fs/nfs/proc.c

129

struct inode *inode = d_inode(dentry);

fs/nfs/proc.c

511

struct inode *dir = d_inode(nr_arg->dentry);

fs/nfs/super.c

1061

return nfs_probe_server(nfss, NFS_FH(d_inode(fc->root)));

fs/nfs/super.c

251

struct nfs_fh *fh = NFS_FH(d_inode(dentry));

fs/nfs/super.c

264

nfs_zap_caches(d_inode(pd_dentry));

fs/nfs/unlink.c

104

struct inode *dir = d_inode(data->dentry->d_parent);

fs/nfs/unlink.c

123

struct inode *dir = d_inode(dentry->d_parent);

fs/nfs/unlink.c

142

!nfs_compare_fh(NFS_FH(inode), NFS_FH(d_inode(alias))) &&

fs/nfs/unlink.c

293

nfs_mark_for_revalidate(d_inode(data->old_dentry));

fs/nfs/unlink.c

450

struct inode *inode = d_inode(dentry);

fs/nfs/unlink.c

464

fileid = NFS_FILEID(d_inode(dentry));

fs/nfs/unlink.c

485

} while (d_inode(sdentry) != NULL); /* need negative lookup */

fs/nfs/unlink.c

49

struct inode *dir = d_inode(data->dentry->d_parent);

fs/nfs/unlink.c

69

up_read_non_owner(&NFS_I(d_inode(dentry->d_parent))->rmdir_sem);

fs/nfs/unlink.c

79

struct inode *dir = d_inode(data->dentry->d_parent);

fs/nfs/write.c

1703

inode = d_inode(ctx->dentry);

fs/nfs/write.c

1814

(unsigned long long)NFS_FILEID(d_inode(nfs_req_openctx(req)->dentry)),

fs/nfs/write.c

886

struct inode *inode = d_inode(ctx->dentry);

fs/nfsd/export.c

1052

inode = d_inode(path.dentry);

fs/nfsd/export.c

419

struct inode *inode = d_inode(path->dentry);

fs/nfsd/filecache.c

1109

inode = d_inode(fhp->fh_dentry);

fs/nfsd/nfs2acl.c

110

inode = d_inode(fh->fh_dentry);

fs/nfsd/nfs2acl.c

257

inode = d_inode(dentry);

fs/nfsd/nfs2acl.c

45

inode = d_inode(fh->fh_dentry);

fs/nfsd/nfs3acl.c

100

inode = d_inode(fh->fh_dentry);

fs/nfsd/nfs3acl.c

182

inode = d_inode(dentry);

fs/nfsd/nfs3acl.c

41

inode = d_inode(fh->fh_dentry);

fs/nfsd/nfs3proc.c

278

inode = d_inode(parent);

fs/nfsd/nfs3proc.c

328

if (inode_get_mtime_sec(d_inode(child)) == v_mtime &&

fs/nfsd/nfs3proc.c

329

inode_get_atime_sec(d_inode(child)) == v_atime &&

fs/nfsd/nfs3proc.c

330

d_inode(child)->i_size == 0) {

fs/nfsd/nfs3xdr.c

1011

if (dchild->d_inode->i_ino != ino)

fs/nfsd/nfs3xdr.c

444

lease_get_mtime(d_inode(dentry), &stat.mtime);

fs/nfsd/nfs3xdr.c

746

lease_get_mtime(d_inode(resp->fh.fh_dentry), &resp->stat.mtime);

fs/nfsd/nfs4acl.c

132

struct inode *inode = d_inode(dentry);

fs/nfsd/nfs4proc.c

1284

inode = cstate->current_fh.fh_dentry->d_inode;

fs/nfsd/nfs4proc.c

173

umode_t mode = d_inode(fh->fh_dentry)->i_mode;

fs/nfsd/nfs4proc.c

2691

nfserr = ops->proc_layoutget(rqstp, d_inode(current_fh->fh_dentry),

fs/nfsd/nfs4proc.c

271

inode = d_inode(parent);

fs/nfsd/nfs4proc.c

2733

inode = d_inode(current_fh->fh_dentry);

fs/nfsd/nfs4proc.c

352

if (inode_get_mtime_sec(d_inode(child)) == v_mtime &&

fs/nfsd/nfs4proc.c

353

inode_get_atime_sec(d_inode(child)) == v_atime &&

fs/nfsd/nfs4proc.c

354

d_inode(child)->i_size == 0) {

fs/nfsd/nfs4proc.c

361

if (inode_get_mtime_sec(d_inode(child)) == v_mtime &&

fs/nfsd/nfs4proc.c

362

inode_get_atime_sec(d_inode(child)) == v_atime &&

fs/nfsd/nfs4proc.c

363

d_inode(child)->i_size == 0) {

fs/nfsd/nfs4proc.c

92

if ((bmval[0] & FATTR4_WORD0_ACL) && !IS_POSIXACL(d_inode(dentry)))

fs/nfsd/nfs4proc.c

96

!IS_POSIXACL(d_inode(dentry)))

fs/nfsd/nfs4recover.c

163

dentry = vfs_mkdir(&nop_mnt_idmap, d_inode(dir), dentry, 0700, NULL);

fs/nfsd/nfs4recover.c

269

status = vfs_rmdir(&nop_mnt_idmap, d_inode(dir), dentry, NULL);

fs/nfsd/nfs4recover.c

355

inode_lock_nested(d_inode(parent), I_MUTEX_PARENT);

fs/nfsd/nfs4recover.c

358

status = vfs_rmdir(&nop_mnt_idmap, d_inode(parent), child, NULL);

fs/nfsd/nfs4recover.c

364

inode_unlock(d_inode(parent));

fs/nfsd/nfs4state.c

4815

fp->fi_inode = d_inode(fh->fh_dentry);

fs/nfsd/nfs4state.c

5281

struct inode *inode = d_inode(fhp->fh_dentry);

fs/nfsd/nfs4state.c

5311

struct inode *inode = d_inode(fhp->fh_dentry);

fs/nfsd/nfs4state.c

5852

status = nfserrno(nfsd_open_break_lease(cur_fh->fh_dentry->d_inode,

fs/nfsd/nfs4state.c

7911

wake_up_var(d_inode(cstate->current_fh.fh_dentry));

fs/nfsd/nfs4state.c

8258

struct inode *inode = d_inode(cstate->current_fh.fh_dentry);

fs/nfsd/nfs4state.c

8541

inode = fhp->fh_dentry->d_inode;

fs/nfsd/nfs4state.c

9296

struct inode *inode = d_inode(dentry);

fs/nfsd/nfs4state.c

9357

struct inode *inode = d_inode(dentry);

fs/nfsd/nfs4xdr.c

3197

if (!IS_POSIXACL(d_inode(args->dentry)))

fs/nfsd/nfs4xdr.c

3330

if (IS_POSIXACL(d_inode(args->dentry)))

fs/nfsd/nfs4xdr.c

3513

const struct inode *inode = d_inode(args->dentry);

fs/nfsd/nfs4xdr.c

3602

if (!IS_POSIXACL(d_inode(args->dentry)))

fs/nfsd/nfs4xdr.c

3626

struct inode *inode = d_inode(args->dentry);

fs/nfsd/nfs4xdr.c

3642

int err = xattr_supports_user_prefix(d_inode(args->dentry));

fs/nfsd/nfs4xdr.c

3704

if (IS_POSIXACL(d_inode(args->dentry)))

fs/nfsd/nfs4xdr.c

3988

err = security_inode_getsecctx(d_inode(dentry),

fs/nfsd/nfs4xdr.c

4004

struct inode *inode = d_inode(dentry);

fs/nfsd/nfs4xdr.c

4027

struct inode *inode = d_inode(dentry);

fs/nfsd/nfsctl.c

1137

struct inode *dir = parent->d_inode;

fs/nfsd/nfsctl.c

1172

struct inode *dir = parent->d_inode;

fs/nfsd/nfsctl.c

1204

struct inode *inode = d_inode(dentry);

fs/nfsd/nfsctl.c

1232

struct inode *dir = d_inode(root);

fs/nfsd/nfsfh.c

44

d_inode(parent), MAY_EXEC);

fs/nfsd/nfsfh.c

601

struct inode * inode = d_inode(dentry);

fs/nfsd/nfsfh.c

606

(long) d_inode(exp->ex_path.dentry)->i_ino,

fs/nfsd/nfsfh.c

641

d_inode(exp->ex_path.dentry)->i_ino,

fs/nfsd/nfsfh.c

67

umode_t mode = d_inode(dentry)->i_mode & S_IFMT;

fs/nfsd/nfsfh.c

699

struct inode *inode = d_inode(p.dentry);

fs/nfsd/nfsproc.c

334

inode = d_inode(newfhp->fh_dentry);

fs/nfsd/nfsxdr.c

264

lease_get_mtime(d_inode(dentry), &time);

fs/nfsd/trace.h

290

__entry->inode = d_inode(fhp->fh_dentry);

fs/nfsd/trace.h

331

__entry->inode = d_inode(fhp->fh_dentry);

fs/nfsd/vfs.c

1164

struct inode *inode = d_inode(fhp->fh_dentry);

fs/nfsd/vfs.c

1791

dirp = d_inode(dentry);

fs/nfsd/vfs.c

1994

host_err = vfs_symlink(&nop_mnt_idmap, d_inode(dentry), dnew, path, NULL);

fs/nfsd/vfs.c

2053

type = d_inode(tfhp->fh_dentry)->i_mode & S_IFMT;

fs/nfsd/vfs.c

2059

dirp = d_inode(ddir);

fs/nfsd/vfs.c

2104

struct inode *inode = d_inode(dentry);

fs/nfsd/vfs.c

2114

struct inode *inode = d_inode(dentry);

fs/nfsd/vfs.c

2195

type = d_inode(rd.old_dentry)->i_mode & S_IFMT;

fs/nfsd/vfs.c

2197

if (d_inode(rd.new_dentry))

fs/nfsd/vfs.c

2198

type = d_inode(rd.new_dentry)->i_mode & S_IFMT;

fs/nfsd/vfs.c

2211

if (!nfsd_wait_for_delegreturn(rqstp, d_inode(rd.old_dentry)))

fs/nfsd/vfs.c

227

if (!d_inode(dentry))

fs/nfsd/vfs.c

2293

dirp = d_inode(dentry);

fs/nfsd/vfs.c

2305

rinode = d_inode(rdentry);

fs/nfsd/vfs.c

2310

type = d_inode(rdentry)->i_mode & S_IFMT;

fs/nfsd/vfs.c

2639

inode = d_inode(dentry);

fs/nfsd/vfs.c

2711

inode = d_inode(dentry);

fs/nfsd/vfs.c

2775

inode_lock(fhp->fh_dentry->d_inode);

fs/nfsd/vfs.c

2784

inode_unlock(fhp->fh_dentry->d_inode);

fs/nfsd/vfs.c

2804

inode_lock(fhp->fh_dentry->d_inode);

fs/nfsd/vfs.c

2813

inode_unlock(fhp->fh_dentry->d_inode);

fs/nfsd/vfs.c

2826

struct inode *inode = d_inode(dentry);

fs/nfsd/vfs.c

378

struct inode *inode = d_inode(fhp->fh_dentry);

fs/nfsd/vfs.c

424

struct inode *inode = d_inode(fhp->fh_dentry);

fs/nfsd/vfs.c

550

inode = d_inode(dentry);

fs/nfsd/vfs.c

663

struct inode *inode = d_inode(dentry);

fs/nfsd/vfs.c

908

inode = d_inode(path.dentry);

fs/nilfs2/dir.c

430

struct inode *dir = d_inode(dentry->d_parent);

fs/nilfs2/inode.c

913

struct inode *inode = d_inode(dentry);

fs/nilfs2/ioctl.c

123

struct inode *inode = d_inode(dentry);

fs/nilfs2/ioctl.c

141

struct inode *inode = d_inode(dentry);

fs/nilfs2/namei.c

196

struct inode *inode = d_inode(old_dentry);

fs/nilfs2/namei.c

288

inode = d_inode(dentry);

fs/nilfs2/namei.c

324

nilfs_mark_inode_dirty(d_inode(dentry));

fs/nilfs2/namei.c

334

struct inode *inode = d_inode(dentry);

fs/nilfs2/namei.c

366

struct inode *old_inode = d_inode(old_dentry);

fs/nilfs2/namei.c

367

struct inode *new_inode = d_inode(new_dentry);

fs/nilfs2/namei.c

470

res = nilfs_inode_by_name(d_inode(child), &dotdot_name, &ino);

fs/nilfs2/namei.c

474

root = NILFS_I(d_inode(child))->i_root;

fs/nilfs2/super.c

1180

root = NILFS_I(d_inode(sb->s_root))->i_root;

fs/nilfs2/super.c

617

struct nilfs_root *root = NILFS_I(d_inode(dentry))->i_root;

fs/nilfs2/super.c

685

struct nilfs_root *root = NILFS_I(d_inode(dentry))->i_root;

fs/notify/fanotify/fanotify.c

644

struct inode *dir2 = moved ? d_inode(moved->d_parent) : NULL;

fs/notify/fanotify/fanotify_user.c

2079

inode = path.dentry->d_inode;

fs/notify/fsnotify.c

187

struct inode *inode = d_inode(dentry);

fs/notify/fsnotify.c

209

p_inode = parent->d_inode;

fs/notify/fsnotify.c

296

if (dir != moved->d_parent->d_inode)

fs/notify/fsnotify.c

516

inode2 = moved->d_parent->d_inode;

fs/notify/fsnotify.c

641

p_mask = fsnotify_object_watched(d_inode(dentry), mnt_mask,

fs/notify/fsnotify.c

645

p_mask |= fsnotify_inode_watches_children(d_inode(parent));

fs/notify/fsnotify.c

87

if (!child->d_inode)

fs/notify/inotify/inotify_user.c

777

inode = path.dentry->d_inode;

fs/nsfs.c

406

struct inode *inode = d_inode(dentry);

fs/nsfs.c

45

struct inode *inode = d_inode(dentry);

fs/ntfs3/file.c

189

struct inode *inode = d_inode(path->dentry);

fs/ntfs3/file.c

724

struct inode *inode = d_inode(dentry);

fs/ntfs3/inode.c

1794

err = ni_add_name(ntfs_i(d_inode(dentry->d_parent)), ni, de);

fs/ntfs3/inode.c

1810

struct inode *inode = d_inode(dentry);

fs/ntfs3/namei.c

130

struct inode *inode = d_inode(ode);

fs/ntfs3/namei.c

255

struct inode *inode = d_inode(dentry);

fs/ntfs3/namei.c

257

struct inode *new_inode = d_inode(new_dentry);

fs/ntfs3/namei.c

357

struct inode *inode = d_inode(child);

fs/ntfs3/xattr.c

546

struct inode *inode = d_inode(dentry);

fs/ntfs3/xattr.c

681

return ntfs_set_acl_ex(idmap, d_inode(dentry), acl, type, false);

fs/ntfs3/xattr.c

725

struct inode *inode = d_inode(dentry);

fs/ntfs3/xattr.c

742

struct inode *inode = d_inode(dentry);

fs/ocfs2/acl.c

270

struct inode *inode = d_inode(dentry);

fs/ocfs2/dcache.c

126

parent = d_inode(dentry->d_parent);

fs/ocfs2/dcache.c

29

OCFS2_I(d_inode(dentry->d_parent))->ip_dir_lock_gen;

fs/ocfs2/dcache.c

30

BUG_ON(d_inode(dentry));

fs/ocfs2/dcache.c

434

struct inode *inode = d_inode(dentry);

fs/ocfs2/dcache.c

45

inode = d_inode(dentry);

fs/ocfs2/dir.h

59

return __ocfs2_add_entry(handle, d_inode(dentry->d_parent),

fs/ocfs2/dlmfs/dlmfs.c

195

struct inode *inode = d_inode(dentry);

fs/ocfs2/dlmfs/dlmfs.c

491

struct inode *inode = d_inode(dentry);

fs/ocfs2/export.c

135

struct inode *dir = d_inode(child);

fs/ocfs2/file.c

1120

struct inode *inode = d_inode(dentry);

fs/ocfs2/file.c

1318

struct inode *inode = d_inode(path->dentry);

fs/ocfs2/file.c

2263

struct inode *inode = d_inode(dentry);

fs/ocfs2/inode.c

1311

struct inode *inode = d_inode(dentry);

fs/ocfs2/ioctl.c

67

struct inode *inode = d_inode(dentry);

fs/ocfs2/ioctl.c

88

struct inode *inode = d_inode(dentry);

fs/ocfs2/namei.c

1214

struct inode *old_inode = d_inode(old_dentry);

fs/ocfs2/namei.c

1215

struct inode *new_inode = d_inode(new_dentry);

fs/ocfs2/namei.c

1474

BUG_ON(d_inode(new_dentry->d_parent) != new_dir);

fs/ocfs2/namei.c

689

struct inode *inode = d_inode(old_dentry);

fs/ocfs2/namei.c

690

struct inode *old_dir = d_inode(old_dentry->d_parent);

fs/ocfs2/namei.c

884

struct inode *inode = d_inode(dentry);

fs/ocfs2/namei.c

907

BUG_ON(d_inode(dentry->d_parent) != dir);

fs/ocfs2/refcounttree.c

4148

struct inode *inode = d_inode(old_dentry);

fs/ocfs2/refcounttree.c

4238

struct inode *inode = d_inode(old_dentry);

fs/ocfs2/refcounttree.c

4347

struct inode *inode = d_inode(old_dentry);

fs/ocfs2/refcounttree.c

4436

d_inode(new_path.dentry),

fs/ocfs2/xattr.c

1057

struct ocfs2_inode_info *oi = OCFS2_I(d_inode(dentry));

fs/ocfs2/xattr.c

1065

ret = ocfs2_inode_lock(d_inode(dentry), &di_bh, 0);

fs/ocfs2/xattr.c

1074

i_ret = ocfs2_xattr_ibody_list(d_inode(dentry), di, buffer, size);

fs/ocfs2/xattr.c

1082

b_ret = ocfs2_xattr_block_list(d_inode(dentry), di,

fs/ocfs2/xattr.c

1088

ocfs2_inode_unlock(d_inode(dentry), 0);

fs/omfs/dir.c

113

struct inode *dir = d_inode(dentry->d_parent);

fs/omfs/dir.c

158

struct inode *dir = d_inode(dentry->d_parent);

fs/omfs/dir.c

240

struct inode *inode = d_inode(dentry);

fs/omfs/dir.c

377

struct inode *new_inode = d_inode(new_dentry);

fs/omfs/dir.c

378

struct inode *old_inode = d_inode(old_dentry);

fs/omfs/file.c

344

struct inode *inode = d_inode(dentry);

fs/open.c

175

inode = dentry->d_inode;

fs/open.c

622

struct inode *inode = path->dentry->d_inode;

fs/open.c

63

ret = inode_lock_killable(dentry->d_inode);

fs/open.c

69

inode_unlock(dentry->d_inode);

fs/open.c

745

struct inode *inode = path->dentry->d_inode;

fs/open.c

79

inode = path->dentry->d_inode;

fs/open.c

891

struct inode *inode = f->f_path.dentry->d_inode;

fs/orangefs/acl.c

121

struct inode *inode = d_inode(dentry);

fs/orangefs/dcache.c

108

if (dentry->d_inode && is_root_handle(dentry->d_inode))

fs/orangefs/dcache.c

119

if (!dentry->d_inode) {

fs/orangefs/dcache.c

128

ret = orangefs_inode_check_changed(dentry->d_inode);

fs/orangefs/dcache.c

20

struct inode *inode = dentry->d_inode;

fs/orangefs/inode.c

801

struct inode *inode = d_inode(dentry);

fs/orangefs/inode.c

823

sync_inode_metadata(d_inode(dentry), 1);

fs/orangefs/inode.c

837

struct inode *inode = path->dentry->d_inode;

fs/orangefs/inode.c

907

ret = orangefs_inode_getxattr(d_inode(dentry),

fs/orangefs/inode.c

941

return orangefs_inode_setxattr(d_inode(dentry),

fs/orangefs/namei.c

172

struct inode *inode = dentry->d_inode;

fs/orangefs/namei.c

403

get_interruptible_flag(old_dentry->d_inode));

fs/orangefs/namei.c

409

if (new_dentry->d_inode)

fs/orangefs/namei.c

410

inode_set_ctime_current(d_inode(new_dentry));

fs/orangefs/xattr.c

410

struct inode *inode = dentry->d_inode;

fs/overlayfs/copy_up.c

1000

struct inode *udir = d_inode(c->destdir);

fs/overlayfs/copy_up.c

1042

!fsverity_active(d_inode(lowerdata.dentry))) {

fs/overlayfs/copy_up.c

1114

ovl_clear_flag(OVL_HAS_DIGEST, d_inode(c->dentry));

fs/overlayfs/copy_up.c

1115

ovl_clear_flag(OVL_VERIFIED_DIGEST, d_inode(c->dentry));

fs/overlayfs/copy_up.c

1116

ovl_set_upperdata(d_inode(c->dentry));

fs/overlayfs/copy_up.c

1258

if (special_file(d_inode(dentry)->i_mode))

fs/overlayfs/copy_up.c

483

return ovl_encode_real_fh(ofs, d_inode(origin), false);

fs/overlayfs/copy_up.c

508

fh = ovl_encode_real_fh(ofs, d_inode(upper), true);

fs/overlayfs/copy_up.c

543

if (WARN_ON(ovl_test_flag(OVL_INDEX, d_inode(dentry))))

fs/overlayfs/copy_up.c

601

struct inode *udir = d_inode(upperdir);

fs/overlayfs/copy_up.c

662

struct inode *inode = d_inode(c->dentry);

fs/overlayfs/copy_up.c

713

inode_lock(temp->d_inode);

fs/overlayfs/copy_up.c

718

inode_unlock(temp->d_inode);

fs/overlayfs/copy_up.c

828

inode = d_inode(c->dentry);

fs/overlayfs/copy_up.c

83

if (!old->d_inode->i_op->listxattr || !new->d_inode->i_op->listxattr)

fs/overlayfs/copy_up.c

855

struct inode *udir = d_inode(c->destdir);

fs/overlayfs/copy_up.c

899

ovl_set_flag(OVL_HAS_DIGEST, d_inode(c->dentry));

fs/overlayfs/copy_up.c

901

ovl_clear_flag(OVL_HAS_DIGEST, d_inode(c->dentry));

fs/overlayfs/copy_up.c

902

ovl_clear_flag(OVL_VERIFIED_DIGEST, d_inode(c->dentry));

fs/overlayfs/copy_up.c

905

ovl_set_upperdata(d_inode(c->dentry));

fs/overlayfs/copy_up.c

906

ovl_inode_update(d_inode(c->dentry), dget(temp));

fs/overlayfs/copy_up.c

993

ovl_set_flag(OVL_INDEX, d_inode(c->dentry));

fs/overlayfs/dir.c

1078

return (d_inode(lowerdentry)->i_nlink > 1);

fs/overlayfs/dir.c

112

ofs->whiteout->d_inode->i_nlink,

fs/overlayfs/dir.c

1173

} else if (d_inode(new)) {

fs/overlayfs/dir.c

1252

if (d_inode(new) && ovl_dentry_upper(new)) {

fs/overlayfs/dir.c

1270

if (rd.old_dentry->d_inode == rd.new_dentry->d_inode)

fs/overlayfs/dir.c

1305

if (ovlrd->overwrite && d_inode(new)) {

fs/overlayfs/dir.c

1307

clear_nlink(d_inode(new));

fs/overlayfs/dir.c

1315

(d_inode(new) && ovl_type_origin(new)));

fs/overlayfs/dir.c

1318

ovl_copyattr(d_inode(old));

fs/overlayfs/dir.c

1319

if (d_inode(new) && ovl_dentry_upper(new))

fs/overlayfs/dir.c

1320

ovl_copyattr(d_inode(new));

fs/overlayfs/dir.c

1443

if (WARN_ON(inode != d_inode(dentry)))

fs/overlayfs/dir.c

164

struct inode *dir = parent->d_inode;

fs/overlayfs/dir.c

171

if (newdentry->d_inode)

fs/overlayfs/dir.c

214

if (WARN_ON(!newdentry->d_inode)) {

fs/overlayfs/dir.c

316

WARN_ON(ovl_inode_real(inode) != d_inode(newdentry));

fs/overlayfs/dir.c

432

inode_lock(opaquedir->d_inode);

fs/overlayfs/dir.c

434

inode_unlock(opaquedir->d_inode);

fs/overlayfs/dir.c

486

err = posix_acl_create(dentry->d_parent->d_inode,

fs/overlayfs/dir.c

520

newdentry->d_inode->i_mode != cattr->mode) {

fs/overlayfs/dir.c

525

inode_lock(newdentry->d_inode);

fs/overlayfs/dir.c

527

inode_unlock(newdentry->d_inode);

fs/overlayfs/dir.c

54

ovl_cleanup_locked(ofs, workdir->d_inode, wdentry);

fs/overlayfs/dir.c

705

inode_init_owner(&nop_mnt_idmap, inode, dentry->d_parent->d_inode, mode);

fs/overlayfs/dir.c

710

if (inode != d_inode(dentry))

fs/overlayfs/dir.c

777

inode = d_inode(old);

fs/overlayfs/dir.c

794

return d_inode(ovl_dentry_upper(dentry)) == d_inode(upper);

fs/overlayfs/dir.c

83

struct inode *wdir = workdir->d_inode;

fs/overlayfs/dir.c

848

struct inode *dir = upperdir->d_inode;

fs/overlayfs/dir.c

897

!ovl_test_flag(OVL_WHITEOUTS, d_inode(dentry));

fs/overlayfs/dir.c

902

struct inode *inode = d_inode(dentry);

fs/overlayfs/dir.c

951

clear_nlink(dentry->d_inode);

fs/overlayfs/dir.c

964

ovl_copyattr(d_inode(dentry));

fs/overlayfs/export.c

135

ovl_test_flag(OVL_INDEX, d_inode(parent)))

fs/overlayfs/export.c

202

if (inode == d_inode(inode->i_sb->s_root))

fs/overlayfs/export.c

362

struct inode *dir = d_inode(connected);

fs/overlayfs/export.c

395

} else if (!this || !this->d_inode) {

fs/overlayfs/export.c

85

!ovl_test_flag(OVL_INDEX, d_inode(dentry)))

fs/overlayfs/file.c

119

return file_inode(realfile) == d_inode(realpath->dentry);

fs/overlayfs/file.c

31

struct inode *realinode = d_inode(realpath->dentry);

fs/overlayfs/inode.c

1011

nlink = d_inode(buf[0] == 'L' ? lowerdentry : upperdentry)->i_nlink;

fs/overlayfs/inode.c

1072

if (lowerdentry && ovl_inode_lower(inode) != d_inode(lowerdentry))

fs/overlayfs/inode.c

1079

if (upperdentry && ovl_inode_upper(inode) != d_inode(upperdentry))

fs/overlayfs/inode.c

1088

struct inode *inode, *key = d_inode(real);

fs/overlayfs/inode.c

1105

struct inode *key = d_inode(dir);

fs/overlayfs/inode.c

1127

struct inode *key = d_inode(dir);

fs/overlayfs/inode.c

1173

!d_is_dir(lower) && d_inode(lower)->i_nlink > 1)

fs/overlayfs/inode.c

1199

struct inode *realinode = upperdentry ? d_inode(upperdentry) : NULL;

fs/overlayfs/inode.c

1214

realinode = d_inode(lowerdentry);

fs/overlayfs/inode.c

1222

struct inode *key = d_inode(bylower ? lowerdentry :

fs/overlayfs/inode.c

131

if (S_ISDIR(dentry->d_inode->i_mode)) {

fs/overlayfs/inode.c

142

stat->ino = dentry->d_inode->i_ino;

fs/overlayfs/inode.c

170

struct inode *inode = d_inode(dentry);

fs/overlayfs/inode.c

223

if (ovl_test_flag(OVL_INDEX, d_inode(dentry)) ||

fs/overlayfs/inode.c

284

if (!is_dir && ovl_test_flag(OVL_INDEX, d_inode(dentry)))

fs/overlayfs/inode.c

285

stat->nlink = dentry->d_inode->i_nlink;

fs/overlayfs/inode.c

394

struct inode *realinode = d_inode(path->dentry);

fs/overlayfs/inode.c

48

winode = d_inode(upperdentry);

fs/overlayfs/inode.c

527

struct inode *inode = d_inode(dentry);

fs/overlayfs/inode.c

531

if (!IS_POSIXACL(d_inode(workdir)))

fs/overlayfs/inode.c

573

inode_get_atime(d_inode(upperpath.dentry)));

fs/overlayfs/inode.c

640

struct inode *inode = d_inode(dentry);

fs/overlayfs/inode.c

716

struct inode *inode = d_inode(dentry);

fs/overlayfs/inode.c

79

inode_lock(upperdentry->d_inode);

fs/overlayfs/inode.c

83

ovl_copyattr(dentry->d_inode);

fs/overlayfs/inode.c

84

inode_unlock(upperdentry->d_inode);

fs/overlayfs/inode.c

960

struct inode *inode = d_inode(dentry);

fs/overlayfs/inode.c

961

struct inode *realinode = d_inode(realdentry);

fs/overlayfs/inode.c

994

if (!lowerdentry || !upperdentry || d_inode(lowerdentry)->i_nlink == 1)

fs/overlayfs/namei.c

1002

struct inode *inode = d_inode(dentry);

fs/overlayfs/namei.c

1435

if (!dentry->d_inode)

fs/overlayfs/namei.c

480

inode_wrong_type(d_inode(upperdentry), d_inode(origin)->i_mode))

fs/overlayfs/namei.c

498

upperdentry, d_inode(upperdentry)->i_mode & S_IFMT,

fs/overlayfs/namei.c

499

d_inode(origin)->i_mode & S_IFMT);

fs/overlayfs/namei.c

577

fh = ovl_encode_real_fh(ofs, d_inode(real), is_upper);

fs/overlayfs/namei.c

593

inode = d_inode(real);

fs/overlayfs/namei.c

645

if (!d_inode(index))

fs/overlayfs/namei.c

710

if (!d_is_dir(index) && d_inode(index)->i_nlink == 1) {

fs/overlayfs/namei.c

726

index, d_inode(index)->i_mode & S_IFMT, err);

fs/overlayfs/namei.c

731

index, d_inode(index)->i_mode & S_IFMT,

fs/overlayfs/namei.c

732

d_inode(index)->i_nlink);

fs/overlayfs/namei.c

773

fh = ovl_encode_real_fh(ofs, d_inode(origin), false);

fs/overlayfs/namei.c

836

d_inode(origin)->i_ino, name.len, name.name,

fs/overlayfs/namei.c

841

inode = d_inode(index);

fs/overlayfs/namei.c

853

inode_wrong_type(inode, d_inode(origin)->i_mode)) {

fs/overlayfs/namei.c

862

index, d_inode(index)->i_mode & S_IFMT,

fs/overlayfs/namei.c

863

d_inode(origin)->i_mode & S_IFMT);

fs/overlayfs/namei.c

881

} else if (upper && d_inode(upper) != inode) {

fs/overlayfs/namei.c

957

struct inode *inode = d_inode(dentry);

fs/overlayfs/overlayfs.h

495

return sb_has_encoding(dentry->d_sb) && IS_CASEFOLDED(d_inode(dentry));

fs/overlayfs/overlayfs.h

828

return do_ovl_get_acl(idmap, d_inode(dentry), type, false, false);

fs/overlayfs/ovl_entry.h

187

return OVL_I_E(d_inode(dentry));

fs/overlayfs/readdir.c

1132

if (dentry->d_inode)

fs/overlayfs/readdir.c

1220

if (dentry->d_inode)

fs/overlayfs/readdir.c

1243

err = ovl_do_rmdir(ofs, parent->d_inode, dentry);

fs/overlayfs/readdir.c

170

ovl_test_flag(OVL_IMPURE, d_inode(rdd->dentry)))

fs/overlayfs/readdir.c

486

struct inode *inode = d_inode(dentry);

fs/overlayfs/readdir.c

494

ovl_set_dir_cache(d_inode(dentry), NULL);

fs/overlayfs/readdir.c

578

if (IS_ERR_OR_NULL(this) || !this->d_inode) {

fs/overlayfs/readdir.c

697

struct inode *inode = d_inode(dentry);

fs/overlayfs/super.c

105

dir = d_inode(parent);

fs/overlayfs/super.c

1315

unsigned long ino = d_inode(lowerpath->dentry)->i_ino;

fs/overlayfs/super.c

1328

ino = d_inode(upperdentry)->i_ino;

fs/overlayfs/super.c

1332

ovl_set_flag(OVL_IMPURE, d_inode(root));

fs/overlayfs/super.c

1350

ovl_set_flag(OVL_WHITEOUTS, d_inode(root));

fs/overlayfs/super.c

1352

ovl_set_upperdata(d_inode(root));

fs/overlayfs/super.c

1353

ovl_inode_init(d_inode(root), &oip, ino, fsid);

fs/overlayfs/super.c

1354

WARN_ON(!!IS_CASEFOLDED(d_inode(root)) != ofs->casefold);

fs/overlayfs/super.c

314

struct inode *dir = ofs->workbasedir->d_inode;

fs/overlayfs/super.c

329

if (work->d_inode) {

fs/overlayfs/super.c

378

inode_lock(work->d_inode);

fs/overlayfs/super.c

380

inode_unlock(work->d_inode);

fs/overlayfs/super.c

51

ovl_has_upperdata(d_inode(dentry))))

fs/overlayfs/super.c

635

if (!child->d_inode)

fs/overlayfs/util.c

1016

struct inode *inode = d_inode(dentry);

fs/overlayfs/util.c

1032

struct inode *inode = d_inode(dentry);

fs/overlayfs/util.c

1043

struct inode *inode = d_inode(dentry);

fs/overlayfs/util.c

1068

if (!d_is_dir(lower) && d_inode(lower)->i_nlink > 1)

fs/overlayfs/util.c

1096

inode = d_inode(upperdentry);

fs/overlayfs/util.c

1109

set_nlink(d_inode(dentry), inode->i_nlink - 1);

fs/overlayfs/util.c

1147

struct inode *inode = d_inode(dentry);

fs/overlayfs/util.c

1207

struct inode *inode = d_inode(dentry);

fs/overlayfs/util.c

1254

if (!S_ISREG(d_inode(path->dentry)->i_mode))

fs/overlayfs/util.c

1322

if (!ovl_has_upperdata(d_inode(dentry)))

fs/overlayfs/util.c

1379

struct inode *inode = d_inode(datapath->dentry);

fs/overlayfs/util.c

1408

!S_ISREG(d_inode(metapath->dentry)->i_mode))

fs/overlayfs/util.c

1433

digest_size = fsverity_get_digest(d_inode(datapath->dentry), actual_digest,

fs/overlayfs/util.c

1456

if (!ofs->config.verity_mode || !S_ISREG(d_inode(src->dentry)->i_mode))

fs/overlayfs/util.c

1466

digest_size = fsverity_get_digest(d_inode(src->dentry),

fs/overlayfs/util.c

232

if (ovl_test_flag(OVL_CONST_INO, d_inode(dentry)))

fs/overlayfs/util.c

235

!ovl_has_upperdata(d_inode(dentry)))

fs/overlayfs/util.c

314

struct inode *inode = d_inode(dentry);

fs/overlayfs/util.c

396

return upperdentry ? d_inode(upperdentry) : NULL;

fs/overlayfs/util.c

403

return lowerpath ? d_inode(lowerpath->dentry) : NULL;

fs/overlayfs/util.c

419

return lowerdata ? d_inode(lowerdata) : NULL;

fs/overlayfs/util.c

472

return !dentry->d_inode && ovl_dentry_is_opaque(dentry);

fs/overlayfs/util.c

568

return !ovl_test_flag(OVL_UPPERDATA, d_inode(dentry));

fs/overlayfs/util.c

576

return !ovl_has_upperdata(d_inode(dentry));

fs/overlayfs/util.c

581

return OVL_I(d_inode(dentry))->redirect;

fs/overlayfs/util.c

586

struct ovl_inode *oi = OVL_I(d_inode(dentry));

fs/overlayfs/util.c

594

struct inode *upperinode = d_inode(upperdentry);

fs/overlayfs/util.c

611

struct inode *inode = d_inode(dentry);

fs/overlayfs/util.c

629

ovl_copyattr(d_inode(dentry));

fs/overlayfs/util.c

642

struct inode *inode = dentry->d_inode;

fs/overlayfs/util.c

659

struct inode *inode = d_inode(path->dentry);

fs/overlayfs/util.c

732

struct inode *inode = d_inode(dentry);

fs/overlayfs/util.c

756

ovl_inode_unlock(d_inode(dentry));

fs/overlayfs/util.c

778

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

fs/overlayfs/util.c

914

if (ovl_test_flag(OVL_IMPURE, d_inode(dentry)))

fs/overlayfs/util.c

923

ovl_set_flag(OVL_IMPURE, d_inode(dentry));

fs/pidfs.c

762

struct inode *inode = d_inode(dentry);

fs/pidfs.c

984

struct pid *pid = d_inode(dentry)->i_private;

fs/pipe.c

877

d_inode(dentry)->i_ino);

fs/posix_acl.c

1020

struct inode *inode = d_inode(dentry);

fs/posix_acl.c

1094

struct inode *inode = d_inode(dentry);

fs/posix_acl.c

1169

struct inode *inode = d_inode(dentry);

fs/posix_acl.c

1215

struct inode *inode = d_inode(dentry);

fs/posix_acl.c

1294

error = vfs_posix_acl_to_xattr(idmap, d_inode(dentry),

fs/posix_acl.c

607

struct inode *inode = d_inode(dentry);

fs/posix_acl.c

938

struct inode *inode = d_inode(dentry);

fs/proc/base.c

1785

task = get_proc_task(d_inode(dentry));

fs/proc/base.c

1849

struct inode *inode = d_inode(dentry);

fs/proc/base.c

2021

struct inode *inode = d_inode(path->dentry);

fs/proc/base.c

2097

return proc_inode_is_dead(d_inode(dentry));

fs/proc/base.c

2151

inode = d_inode(child);

fs/proc/base.c

2214

inode = d_inode(dentry);

fs/proc/base.c

223

struct task_struct *task = get_proc_task(d_inode(dentry));

fs/proc/base.c

2262

task = get_proc_task(d_inode(dentry));

fs/proc/base.c

240

struct task_struct *task = get_proc_task(d_inode(dentry));

fs/proc/base.c

3962

struct inode *inode = d_inode(path->dentry);

fs/proc/base.c

728

struct inode *inode = d_inode(dentry);

fs/proc/fd.c

153

inode = d_inode(dentry);

fs/proc/fd.c

179

task = get_proc_task(d_inode(dentry));

fs/proc/fd.c

181

unsigned int fd = proc_fd(d_inode(dentry));

fs/proc/fd.c

354

struct inode *inode = d_inode(path->dentry);

fs/proc/generic.c

121

struct inode *inode = d_inode(dentry);

fs/proc/generic.c

140

struct inode *inode = d_inode(path->dentry);

fs/proc/generic.c

225

if (atomic_read(&PDE(d_inode(dentry))->in_use) < 0)

fs/proc/generic.c

232

return atomic_read(&PDE(d_inode(dentry))->in_use) < 0;

fs/proc/namespaces.c

73

struct inode *inode = d_inode(dentry);

fs/proc/proc_net.c

307

struct inode *inode = d_inode(path->dentry);

fs/proc/proc_sysctl.c

715

inode = d_inode(child);

fs/proc/proc_sysctl.c

824

struct inode *inode = d_inode(dentry);

fs/proc/proc_sysctl.c

842

struct inode *inode = d_inode(path->dentry);

fs/proc/proc_sysctl.c

891

return !PROC_I(d_inode(dentry))->sysctl->unregistering;

fs/proc/proc_sysctl.c

896

return !!PROC_I(d_inode(dentry))->sysctl->unregistering;

fs/proc/root.c

397

generic_fillattr(&nop_mnt_idmap, request_mask, d_inode(path->dentry),

fs/proc/self.c

38

struct inode *root_inode = d_inode(s->s_root);

fs/proc/thread_self.c

38

struct inode *root_inode = d_inode(s->s_root);

fs/pstore/inode.c

184

struct pstore_private *p = d_inode(dentry)->i_private;

fs/pstore/inode.c

303

inode_lock_nested(d_inode(root), I_MUTEX_PARENT);

fs/pstore/inode.c

327

inode_unlock(d_inode(root));

fs/pstore/inode.c

345

if (WARN_ON(!inode_is_locked(d_inode(root))))

fs/pstore/inode.c

408

inode_unlock(d_inode(root));

fs/qnx6/inode.c

184

struct inode *root = d_inode(s->s_root);

fs/quota/dquot.c

2549

error = dquot_load_quota_inode(d_inode(path->dentry), type,

fs/quota/dquot.c

2572

error = dquot_load_quota_inode(d_inode(dentry), type, format_id,

fs/ramfs/file-nommu.c

164

struct inode *inode = d_inode(dentry);

fs/smb/client/cached_dir.c

86

struct inode *dir = d_inode(dentry);

fs/smb/client/cifs_debug.c

260

inode = d_inode(cfile->dentry);

fs/smb/client/cifsfs.c

975

struct inode *dir = d_inode(dentry);

fs/smb/client/dir.c

748

full_path, d_inode(direntry));

fs/smb/client/dir.c

800

struct inode *inode = d_inode(direntry);

fs/smb/client/file.c

1193

struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));

fs/smb/client/file.c

1247

inode = d_inode(cfile->dentry);

fs/smb/client/file.c

1409

spin_lock(&CIFS_I(d_inode(cfile->dentry))->deferred_lock);

fs/smb/client/file.c

1412

spin_unlock(&CIFS_I(d_inode(cfile->dentry))->deferred_lock);

fs/smb/client/file.c

1636

struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));

fs/smb/client/file.c

1662

struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));

fs/smb/client/file.c

1691

struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));

fs/smb/client/file.c

1708

struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));

fs/smb/client/file.c

1899

struct inode *inode = d_inode(cfile->dentry);

fs/smb/client/file.c

1990

struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));

fs/smb/client/file.c

2193

struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));

fs/smb/client/file.c

2302

struct inode *inode = d_inode(cfile->dentry);

fs/smb/client/file.c

2460

set_bit(CIFS_INO_CLOSE_ON_LOCK, &CIFS_I(d_inode(cfile->dentry))->flags);

fs/smb/client/file.c

2708

cinode = CIFS_I(d_inode(cfile->dentry));

fs/smb/client/file.c

2740

cinode = CIFS_I(d_inode(cfile->dentry));

fs/smb/client/file.c

3156

struct inode *inode = d_inode(cfile->dentry);

fs/smb/client/file.c

662

struct inode *inode = d_inode(dentry);

fs/smb/client/file.c

758

struct inode *inode = d_inode(cifs_file->dentry);

fs/smb/client/file.c

855

struct inode *inode = d_inode(cifs_file->dentry);

fs/smb/client/file.c

892

d_inode(cifs_file->dentry));

fs/smb/client/file.c

972

struct cifsInodeInfo *cinode = CIFS_I(d_inode(dentry));

fs/smb/client/file.c

973

struct inode *inode = d_inode(dentry);

fs/smb/client/inode.c

1795

struct inode *inode = d_inode(dentry);

fs/smb/client/inode.c

1938

struct inode *inode = d_inode(dentry);

fs/smb/client/inode.c

2383

cifsInode = CIFS_I(d_inode(direntry));

fs/smb/client/inode.c

2387

spin_lock(&d_inode(direntry)->i_lock);

fs/smb/client/inode.c

2388

i_size_write(d_inode(direntry), 0);

fs/smb/client/inode.c

2389

clear_nlink(d_inode(direntry));

fs/smb/client/inode.c

2390

spin_unlock(&d_inode(direntry)->i_lock);

fs/smb/client/inode.c

2403

inode_set_ctime_current(d_inode(direntry));

fs/smb/client/inode.c

2554

if (d_inode(target_dentry) != NULL) {

fs/smb/client/inode.c

2555

netfs_wait_for_outstanding_io(d_inode(target_dentry));

fs/smb/client/inode.c

2623

struct inode *inode = d_inode(target_dentry);

fs/smb/client/inode.c

2687

struct inode *inode = d_inode(dentry);

fs/smb/client/inode.c

2823

struct inode *inode = d_inode(dentry);

fs/smb/client/inode.c

2883

struct inode *inode = d_inode(dentry);

fs/smb/client/inode.c

2898

struct inode *inode = d_inode(dentry);

fs/smb/client/inode.c

3027

struct inode *inode = d_inode(dentry);

fs/smb/client/inode.c

3102

struct inode *inode = d_inode(direntry);

fs/smb/client/inode.c

3268

struct inode *inode = d_inode(direntry);

fs/smb/client/link.c

504

cifsInode = CIFS_I(d_inode(old_file));

fs/smb/client/link.c

506

spin_lock(&d_inode(old_file)->i_lock);

fs/smb/client/link.c

507

inc_nlink(d_inode(old_file));

fs/smb/client/link.c

508

spin_unlock(&d_inode(old_file)->i_lock);

fs/smb/client/misc.c

444

list_for_each_entry(dclose, &CIFS_I(d_inode(cfile->dentry))->deferred_closes, dlist) {

fs/smb/client/misc.c

474

list_add_tail(&dclose->dlist, &CIFS_I(d_inode(cfile->dentry))->deferred_closes);

fs/smb/client/misc.c

540

spin_lock(&CIFS_I(d_inode(cfile->dentry))->deferred_lock);

fs/smb/client/misc.c

542

spin_unlock(&CIFS_I(d_inode(cfile->dentry))->deferred_lock);

fs/smb/client/misc.c

611

spin_lock(&CIFS_I(d_inode(cfile->dentry))->deferred_lock);

fs/smb/client/misc.c

613

spin_unlock(&CIFS_I(d_inode(cfile->dentry))->deferred_lock);

fs/smb/client/readdir.c

113

inode = d_inode(dentry);

fs/smb/client/smb1misc.c

154

pCifsInode = CIFS_I(d_inode(netfile->dentry));

fs/smb/client/smb1ops.c

902

struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));

fs/smb/client/smb2file.c

268

struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));

fs/smb/client/smb2file.c

409

struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));

fs/smb/client/smb2inode.c

1229

inode = d_inode(dentry);

fs/smb/client/smb2inode.c

1569

struct cifs_sb_info *cifs_sb = CIFS_SB(d_inode(dentry)->i_sb);

fs/smb/client/smb2inode.c

1570

struct cifsInodeInfo *cinode = CIFS_I(d_inode(dentry));

fs/smb/client/smb2inode.c

1629

if (d_inode(dentry)->i_nlink <= 1)

fs/smb/client/smb2inode.c

250

inode = d_inode(dentry);

fs/smb/client/smb2inode.c

55

ci = CIFS_I(d_inode(dentry));

fs/smb/client/smb2misc.c

544

cinode = CIFS_I(d_inode(cfile->dentry));

fs/smb/client/smb2misc.c

720

cinode = CIFS_I(d_inode(cfile->dentry));

fs/smb/client/smb2ops.c

1470

struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));

fs/smb/client/smb2ops.c

1508

inode = d_inode(cfile->dentry);

fs/smb/client/smb2ops.c

2158

inode = d_inode(cfile->dentry);

fs/smb/client/smb2ops.c

2198

inode = d_inode(trgtfile->dentry);

fs/smb/client/smb2ops.c

3652

inode = d_inode(cfile->dentry);

fs/smb/client/smb2ops.c

3885

inode = d_inode(cfile->dentry);

fs/smb/client/smb2ops.c

3966

rc = fiemap_prep(d_inode(cfile->dentry), fei, start, &len, 0);

fs/smb/server/smb2pdu.c

3197

if (file_present && S_ISDIR(d_inode(path.dentry)->i_mode) &&

fs/smb/server/smb2pdu.c

3215

S_ISDIR(d_inode(path.dentry)->i_mode) &&

fs/smb/server/smb2pdu.c

3226

!S_ISDIR(d_inode(path.dentry)->i_mode)) {

fs/smb/server/smb2pdu.c

3263

file_present ? d_inode(path.dentry)->i_mode : 0);

fs/smb/server/smb2pdu.c

3311

d_inode(path.dentry),

fs/smb/server/smb2pdu.c

3319

d_inode(path.dentry->d_parent),

fs/smb/server/smb2pdu.c

3380

struct inode *inode = d_inode(path.dentry);

fs/smb/server/smb2pdu.c

3384

d_inode(path.dentry->d_parent));

fs/smb/server/smb2pdu.c

6292

struct inode *inode = d_inode(dentry);

fs/smb/server/smbacl.c

1082

bool is_dir = S_ISDIR(d_inode(path->dentry)->i_mode);

fs/smb/server/smbacl.c

1391

posix_acls = get_inode_acl(d_inode(path->dentry), ACL_TYPE_ACCESS);

fs/smb/server/smbacl.c

1461

struct inode *inode = d_inode(path->dentry);

fs/smb/server/vfs.c

1026

if (S_ISDIR(d_inode(dentry)->i_mode))

fs/smb/server/vfs.c

1027

err = vfs_rmdir(idmap, d_inode(dir), dentry, NULL);

fs/smb/server/vfs.c

1029

err = vfs_unlink(idmap, d_inode(dir), dentry, NULL);

fs/smb/server/vfs.c

127

if (!inode_permission(idmap, d_inode(dentry), MAY_OPEN | MAY_WRITE))

fs/smb/server/vfs.c

133

if (!inode_permission(idmap, d_inode(dentry), MAY_OPEN | MAY_READ))

fs/smb/server/vfs.c

136

if (!inode_permission(idmap, d_inode(dentry), MAY_OPEN | MAY_EXEC))

fs/smb/server/vfs.c

139

if (!inode_permission(idmap, d_inode(dentry->d_parent), MAY_EXEC | MAY_WRITE))

fs/smb/server/vfs.c

1411

struct inode *inode = d_inode(dentry);

fs/smb/server/vfs.c

1474

struct inode *inode = d_inode(dentry);

fs/smb/server/vfs.c

170

ksmbd_vfs_inherit_owner(work, d_inode(path.dentry),

fs/smb/server/vfs.c

171

d_inode(dentry));

fs/smb/server/vfs.c

1807

struct inode *inode = d_inode(dentry);

fs/smb/server/vfs.c

1860

struct inode *inode = d_inode(dentry);

fs/smb/server/vfs.c

209

dentry = vfs_mkdir(idmap, d_inode(path.dentry), dentry, mode, NULL);

fs/smb/server/vfs.c

215

ksmbd_vfs_inherit_owner(work, d_inode(path.dentry), d_inode(dentry));

fs/smb/server/vfs.c

586

if (!d_inode(path->dentry)->i_nlink) {

fs/smb/server/vfs.c

592

if (S_ISDIR(d_inode(path->dentry)->i_mode)) {

fs/smb/server/vfs.c

593

err = vfs_rmdir(idmap, d_inode(parent), path->dentry, NULL);

fs/smb/server/vfs.c

597

err = vfs_unlink(idmap, d_inode(parent), path->dentry, NULL);

fs/smb/server/vfs.c

648

d_inode(newpath.dentry),

fs/smb/server/vfs_cache.c

172

inode_hash(d_inode(de)->i_sb, (unsigned long)de);

fs/smb/server/vfs_cache.c

269

inode_hash(d_inode(ci->m_de)->i_sb, (unsigned long)ci->m_de);

fs/smb/server/vfs_cache.c

665

struct inode *inode = d_inode(dentry);

fs/squashfs/export.c

105

struct inode *inode = d_inode(child);

fs/squashfs/xattr.c

29

struct inode *inode = d_inode(d);

fs/tracefs/event_inode.c

192

if (!(dentry->d_inode->i_mode & S_IFDIR)) {

fs/tracefs/event_inode.c

212

if (dentry->d_inode->i_mode & S_IFDIR) {

fs/tracefs/event_inode.c

792

uid = d_inode(dentry->d_parent)->i_uid;

fs/tracefs/event_inode.c

793

gid = d_inode(dentry->d_parent)->i_gid;

fs/tracefs/event_inode.c

828

inc_nlink(dentry->d_parent->d_inode);

fs/tracefs/event_inode.c

829

fsnotify_mkdir(dentry->d_parent->d_inode, dentry);

fs/tracefs/inode.c

164

inode_unlock(d_inode(dentry));

fs/tracefs/inode.c

169

inode_lock(d_inode(dentry));

fs/tracefs/inode.c

191

if (root_inode != d_inode(root_inode->i_sb->s_root)) {

fs/tracefs/inode.c

195

root_inode = d_inode(root_inode->i_sb->s_root);

fs/tracefs/inode.c

237

struct inode *inode = d_inode(dentry);

fs/tracefs/inode.c

336

struct inode *inode = d_inode(sb->s_root);

fs/tracefs/inode.c

592

return d_inode(inode->i_sb->s_root);

fs/tracefs/inode.c

596

ti = get_tracefs(d_inode(parent));

fs/tracefs/inode.c

602

return d_inode(parent);

fs/tracefs/inode.c

661

inode->i_uid = d_inode(dentry->d_parent)->i_uid;

fs/tracefs/inode.c

662

inode->i_gid = d_inode(dentry->d_parent)->i_gid;

fs/tracefs/inode.c

664

fsnotify_create(d_inode(dentry->d_parent), dentry);

fs/tracefs/inode.c

686

inode->i_uid = d_inode(dentry->d_parent)->i_uid;

fs/tracefs/inode.c

687

inode->i_gid = d_inode(dentry->d_parent)->i_gid;

fs/tracefs/inode.c

695

inc_nlink(d_inode(dentry->d_parent));

fs/tracefs/inode.c

696

fsnotify_mkdir(d_inode(dentry->d_parent), dentry);

fs/ubifs/dir.c

1326

struct inode *old_inode = d_inode(old_dentry);

fs/ubifs/dir.c

1327

struct inode *new_inode = d_inode(new_dentry);

fs/ubifs/dir.c

1588

struct inode *fst_inode = d_inode(old_dentry);

fs/ubifs/dir.c

1589

struct inode *snd_inode = d_inode(new_dentry);

fs/ubifs/dir.c

1674

struct inode *inode = d_inode(path->dentry);

fs/ubifs/dir.c

754

struct inode *inode = d_inode(old_dentry);

fs/ubifs/dir.c

825

struct inode *inode = d_inode(dentry);

fs/ubifs/dir.c

932

struct inode *inode = d_inode(dentry);

fs/ubifs/dir.c

948

err = ubifs_check_dir_empty(d_inode(dentry));

fs/ubifs/file.c

1258

struct inode *inode = d_inode(dentry);

fs/ubifs/file.c

1620

if (IS_ENCRYPTED(d_inode(path->dentry)))

fs/ubifs/ioctl.c

135

struct inode *inode = d_inode(dentry);

fs/ubifs/ioctl.c

150

struct inode *inode = d_inode(dentry);

fs/ubifs/xattr.c

386

struct inode *host = d_inode(dentry);

fs/udf/file.c

218

struct inode *inode = d_inode(dentry);

fs/udf/namei.c

349

struct inode *dir = d_inode(dentry->d_parent);

fs/udf/namei.c

499

struct inode *inode = d_inode(dentry);

fs/udf/namei.c

539

struct inode *inode = d_inode(dentry);

fs/udf/namei.c

734

struct inode *inode = d_inode(old_dentry);

fs/udf/namei.c

769

struct inode *old_inode = d_inode(old_dentry);

fs/udf/namei.c

770

struct inode *new_inode = d_inode(new_dentry);

fs/udf/namei.c

921

err = udf_fiiter_find_entry(d_inode(child), &dotdot_name, &iter);

fs/ufs/dir.c

300

struct inode *dir = d_inode(dentry->d_parent);

fs/ufs/inode.c

1202

struct inode *inode = d_inode(dentry);

fs/ufs/namei.c

153

struct inode *inode = d_inode(old_dentry);

fs/ufs/namei.c

210

struct inode * inode = d_inode(dentry);

fs/ufs/namei.c

230

struct inode * inode = d_inode(dentry);

fs/ufs/namei.c

248

struct inode *old_inode = d_inode(old_dentry);

fs/ufs/namei.c

249

struct inode *new_inode = d_inode(new_dentry);

fs/ufs/super.c

133

ino = ufs_inode_by_name(d_inode(child), &dotdot_name);

fs/utimes.c

25

struct inode *inode = path->dentry->d_inode;

fs/vboxsf/dir.c

335

sf_handle = vboxsf_create_sf_handle(d_inode(dentry), handle, SHFL_CF_ACCESS_READWRITE);

fs/vboxsf/dir.c

344

vboxsf_release_sf_handle(d_inode(dentry), sf_handle);

fs/vboxsf/dir.c

357

struct inode *inode = d_inode(dentry);

fs/vboxsf/dir.c

412

if (d_inode(old_dentry)->i_mode & S_IFDIR)

fs/vboxsf/super.c

401

struct inode *iroot = fc->root->d_sb->s_root->d_inode;

fs/vboxsf/utils.c

204

inode = d_inode(dentry);

fs/vboxsf/utils.c

240

struct inode *inode = d_inode(dentry);

fs/vboxsf/utils.c

256

generic_fillattr(&nop_mnt_idmap, request_mask, d_inode(dentry), kstat);

fs/vboxsf/utils.c

263

struct vboxsf_inode *sf_i = VBOXSF_I(d_inode(dentry));

fs/xattr.c

226

struct inode *inode = dentry->d_inode;

fs/xattr.c

279

struct inode *inode = dentry->d_inode;

fs/xattr.c

307

struct inode *inode = dentry->d_inode;

fs/xattr.c

380

struct inode *inode = dentry->d_inode;

fs/xattr.c

431

struct inode *inode = dentry->d_inode;

fs/xattr.c

485

struct inode *inode = d_inode(dentry);

fs/xattr.c

507

struct inode *inode = d_inode(dentry);

fs/xattr.c

538

struct inode *inode = dentry->d_inode;

fs/xattr.c

569

struct inode *inode = dentry->d_inode;

fs/xfs/scrub/findparent.c

456

pip = igrab(d_inode(parent));

fs/xfs/scrub/orphanage.c

186

orphanage_inode = igrab(d_inode(orphanage_dentry));

fs/xfs/scrub/trace.h

3359

if (dentry->d_parent && d_inode(dentry->d_parent))

fs/xfs/scrub/trace.h

3360

__entry->parent_ino = d_inode(dentry->d_parent)->i_ino;

fs/xfs/scrub/trace.h

3363

__entry->ino = d_inode(dentry) ? d_inode(dentry)->i_ino : 0;

fs/xfs/xfs_acl.c

252

struct inode *inode = d_inode(dentry);

fs/xfs/xfs_export.c

226

error = xfs_lookup(XFS_I(d_inode(child)), &xfs_name_dotdot, &cip, NULL);

fs/xfs/xfs_filestream.c

184

dir = igrab(d_inode(parent));

fs/xfs/xfs_handle.c

104

inode = d_inode(path.dentry);

fs/xfs/xfs_handle.c

248

inode = d_inode(dentry);

fs/xfs/xfs_handle.c

486

error = xfs_ioc_attr_list(XFS_I(d_inode(dentry)), al_hreq.buffer,

fs/xfs/xfs_handle.c

642

d_inode(dentry), ops[i].am_opcode,

fs/xfs/xfs_ioctl.c

515

struct xfs_inode *ip = XFS_I(d_inode(dentry));

fs/xfs/xfs_ioctl.c

729

struct xfs_inode *ip = XFS_I(d_inode(dentry));

fs/xfs/xfs_ioctl32.c

359

error = xfs_ioc_attr_list(XFS_I(d_inode(dentry)),

fs/xfs/xfs_ioctl32.c

405

d_inode(dentry), ops[i].am_opcode,

fs/xfs/xfs_iops.c

1138

struct xfs_inode *ip = XFS_I(d_inode(dentry));

fs/xfs/xfs_iops.c

1155

struct inode *inode = d_inode(dentry);

fs/xfs/xfs_iops.c

383

struct inode *inode = d_inode(old_dentry);

fs/xfs/xfs_iops.c

413

error = xfs_remove(XFS_I(dir), &name, XFS_I(d_inode(dentry)));

fs/xfs/xfs_iops.c

477

struct inode *new_inode = d_inode(ndentry);

fs/xfs/xfs_iops.c

488

omode = d_inode(ndentry)->i_mode;

fs/xfs/xfs_iops.c

495

d_inode(odentry)->i_mode);

fs/xfs/xfs_iops.c

500

XFS_I(d_inode(odentry)), XFS_I(ndir), &nname,

fs/xfs/xfs_iops.c

525

error = xfs_readlink(XFS_I(d_inode(dentry)), link);

fs/xfs/xfs_iops.c

689

struct inode *inode = d_inode(path->dentry);

fs/xfs/xfs_iops.c

762

struct xfs_mount *mp = XFS_I(d_inode(dentry))->i_mount;

fs/xfs/xfs_super.c

923

struct xfs_inode *ip = XFS_I(d_inode(dentry));

fs/xfs/xfs_xattr.c

323

struct inode *inode = d_inode(dentry);

fs/zonefs/super.c

539

struct inode *inode = d_inode(dentry);

fs/zonefs/super.c

678

struct inode *root = d_inode(sb->s_root);

fs/zonefs/super.c

740

if (dir == d_inode(dir->i_sb->s_root))

fs/zonefs/super.c

829

if (inode == d_inode(inode->i_sb->s_root))

include/linux/dcache.h

102

struct inode *d_inode; /* Where the name belongs to - NULL is

include/linux/dcache.h

497

return dentry->d_inode == NULL;

include/linux/dcache.h

515

return dentry->d_inode != NULL;

include/linux/dcache.h

534

return dentry->d_inode;

include/linux/dcache.h

546

return READ_ONCE(dentry->d_inode);

include/linux/dcache.h

561

struct inode *inode = upper->d_inode;

include/linux/dcache.h

594

return d_inode(d_real((struct dentry *) dentry, D_REAL_DATA));

include/linux/fs.h

1367

WARN_ON_ONCE(d_inode(dentry) != file_inode(file));

include/linux/fs.h

2498

return d_inode(backing_file_user_path(f)->dentry);

include/linux/fs.h

2679

d_inode(path->dentry), mask);

include/linux/fs.h

3557

return inode == inode->i_sb->s_root->d_inode;

include/linux/fs.h

3571

file->f_path.dentry->d_inode->i_ino, DT_DIR);

include/linux/fscrypt.h

1113

if (IS_ENCRYPTED(d_inode(dentry)))

include/linux/fscrypt.h

994

return __fscrypt_prepare_link(d_inode(old_dentry), dir, dentry);

include/linux/fsnotify.h

191

struct inode *inode = d_inode(path->dentry);

include/linux/fsnotify.h

254

struct inode *source = moved->d_inode;

include/linux/fsnotify.h

372

struct inode *inode = d_inode(dentry);

include/linux/fsnotify.h

390

fsnotify_delete(dir, d_inode(dentry), dentry);

include/linux/fsnotify.h

417

fsnotify_delete(dir, d_inode(dentry), dentry);

include/linux/fsnotify.h

79

struct inode *inode = d_inode(dentry);

include/linux/fsnotify_backend.h

344

return d_inode(data);

include/linux/fsnotify_backend.h

346

return d_inode(((const struct path *)data)->dentry);

include/linux/fsnotify_backend.h

348

return d_inode(file_range_path(data)->dentry);

include/linux/fsnotify_backend.h

701

if (fsnotify_inode_watches_children(dentry->d_parent->d_inode))

include/trace/events/btrfs.h

775

struct inode *parent_inode = d_inode(parent);

include/trace/events/ceph.h

73

inode = d_inode(req->r_dentry);

include/trace/events/ext4.h

1501

__entry->ino = d_inode(dentry)->i_ino;

include/trace/events/ext4.h

1503

__entry->size = d_inode(dentry)->i_size;

include/trace/events/ext4.h

1525

__entry->ino = d_inode(dentry)->i_ino;

include/trace/events/ext4.h

981

__entry->ino = d_inode(dentry)->i_ino;

include/trace/events/ext4.h

983

__entry->parent = d_inode(dentry->d_parent)->i_ino;

include/trace/events/f2fs.h

990

__entry->ino = old_dentry->d_inode->i_ino;

ipc/mqueue.c

568

struct inode *dir = dentry->d_parent->d_inode;

ipc/mqueue.c

885

return inode_permission(&nop_mnt_idmap, d_inode(dentry), acc);

ipc/mqueue.c

962

inode = d_inode(dentry);

ipc/mqueue.c

964

err = vfs_unlink(&nop_mnt_idmap, d_inode(mnt->mnt_root),

kernel/audit_fsnotify.c

101

audit_update_mark(audit_mark, dentry->d_inode);

kernel/audit_fsnotify.c

104

ret = fsnotify_add_inode_mark(&audit_mark->mark, path.dentry->d_inode, 0);

kernel/audit_tree.c

707

struct inode *inode = p->dentry->d_inode;

kernel/audit_tree.c

748

int err = tag_chunk(p->dentry->d_inode, tree);

kernel/bpf/inode.c

1014

inode = sb->s_root->d_inode;

kernel/bpf/inode.c

332

struct inode *dir = dentry->d_parent->d_inode;

kernel/bpf/inode.c

444

dir = d_inode(path.dentry);

kernel/bpf/inode.c

720

struct inode *inode = d_inode(root);

kernel/bpf/offload.c

493

ns_inode = ns_path.dentry->d_inode;

kernel/bpf/offload.c

681

ns_inode = ns_path.dentry->d_inode;

kernel/bpf/verifier.c

7320

struct inode *d_inode;

kernel/events/core.c

12062

!S_ISREG(d_inode(filter->path.dentry)

kernel/events/core.c

9415

ns_inode = ns_path.dentry->d_inode;

kernel/events/core.c

9803

if (d_inode(filter->path.dentry) != file_user_inode(file))

kernel/relay.c

349

d_inode(buf->dentry)->i_size = buf->early_bytes;

kernel/relay.c

570

d_inode(buf->dentry)->i_size +=

kernel/trace/trace.c

1498

fsnotify_inode(tr->d_max_latency->d_inode, FS_MODIFY);

kernel/trace/trace.c

8616

d_inode(ret)->i_cdev = (void *)(cpu + 1);

kernel/trace/trace_osnoise.c

2726

d_inode(timerlat_fd)->i_cdev = (void *)(cpu);

mm/secretmem.c

167

struct inode *inode = d_inode(dentry);

mm/shmem.c

1287

struct inode *inode = path->dentry->d_inode;

mm/shmem.c

1319

struct inode *inode = d_inode(dentry);

mm/shmem.c

3966

struct inode *inode = d_inode(old_dentry);

mm/shmem.c

3996

struct inode *inode = d_inode(dentry);

mm/shmem.c

4022

drop_nlink(d_inode(dentry));

mm/shmem.c

4053

struct inode *inode = d_inode(old_dentry);

mm/shmem.c

4088

drop_nlink(d_inode(new_dentry));

mm/shmem.c

4208

struct shmem_inode_info *info = SHMEM_I(d_inode(dentry));

mm/shmem.c

4218

struct inode *inode = d_inode(dentry);

mm/shmem.c

4393

struct shmem_inode_info *info = SHMEM_I(d_inode(dentry));

mm/shmem.c

4394

return simple_xattr_list(d_inode(dentry), &info->xattrs, buffer, size);

net/socket.c

377

d_inode(dentry)->i_ino);

net/socket.c

578

len = security_inode_listsecurity(d_inode(dentry), buffer, size);

net/socket.c

606

struct socket *sock = SOCKET_I(d_inode(dentry));

net/sunrpc/rpc_pipe.c

157

wake_up(&RPC_I(d_inode(dentry))->waitq);

net/sunrpc/rpc_pipe.c

173

struct inode *inode = dentry->d_inode;

net/sunrpc/rpc_pipe.c

531

struct inode *dir = parent->d_inode;

net/sunrpc/rpc_pipe.c

557

struct inode *dir = parent->d_inode;

net/sunrpc/rpc_pipe.c

638

struct inode *dir = d_inode(parent);

net/sunrpc/rpc_pipe.c

99

rpc_purge_list(dentry ? &RPC_I(d_inode(dentry))->waitq : NULL,

net/unix/af_unix.c

1381

err = vfs_mknod(idmap, d_inode(parent.dentry), dentry, mode, 0, NULL);

net/unix/af_unix.c

1407

vfs_unlink(idmap, d_inode(parent.dentry), dentry, NULL);

security/apparmor/af_unix.c

48

struct inode *inode = path->dentry->d_inode;

security/apparmor/apparmorfs.c

154

seq_printf(seq, "%s:[%lu]", AAFS_NAME, d_inode(dentry)->i_ino);

security/apparmor/apparmorfs.c

1587

d_inode(dent)->i_size = rawdata->size;

security/apparmor/apparmorfs.c

1643

struct inode *inode = d_inode(new->dents[i]);

security/apparmor/apparmorfs.c

1904

AA_BUG(d_inode(ns_subns_dir(parent)) != dir);

security/apparmor/apparmorfs.c

1959

inode_unlock(dentry->d_inode);

security/apparmor/apparmorfs.c

1976

inode_lock(dentry->d_inode);

security/apparmor/apparmorfs.c

2631

inode_lock(d_inode(parent));

security/apparmor/apparmorfs.c

2637

inode = new_inode(parent->d_inode->i_sb);

security/apparmor/apparmorfs.c

2657

inode_unlock(d_inode(parent));

security/apparmor/apparmorfs.c

2691

d_inode(dentry)->i_ino);

security/apparmor/apparmorfs.c

352

dir = d_inode(parent);

security/apparmor/apparmorfs.c

432

dir = d_inode(dentry->d_parent);

security/apparmor/mount.c

287

(S_ISDIR(path->dentry->d_inode->i_mode) ? PATH_IS_DIR : 0);

security/apparmor/policy_unpack.c

93

inode = d_inode(data->dents[AAFS_LOADDATA_DIR]);

security/apparmor/policy_unpack.c

96

inode = d_inode(data->dents[AAFS_LOADDATA_REVISION]);

security/inode.c

138

dir = d_inode(parent);

security/integrity/evm/evm_crypto.c

228

struct inode *inode = d_inode(d_real(dentry, D_REAL_METADATA));

security/integrity/evm/evm_main.c

540

dentry->d_inode, dentry->d_name.name,

security/integrity/evm/evm_main.c

813

evm_reset_status(dentry->d_inode);

security/integrity/evm/evm_main.c

858

evm_reset_status(dentry->d_inode);

security/integrity/evm/evm_main.c

966

evm_reset_status(dentry->d_inode);

security/integrity/evm/evm_secfs.c

228

inode = evm_xattrs->d_inode;

security/integrity/ima/ima_appraise.c

766

integrity_audit_msg(AUDIT_INTEGRITY_DATA, d_inode(dentry), path,

security/integrity/ima/ima_main.c

342

metadata_inode = d_inode(d_real(file_dentry(file),

security/integrity/ima/ima_main.c

830

struct inode *inode = dentry->d_inode;

security/ipe/policy_fs.c

134

root = d_inode(f->f_path.dentry->d_parent);

security/ipe/policy_fs.c

174

root = d_inode(f->f_path.dentry->d_parent);

security/ipe/policy_fs.c

226

root = d_inode(f->f_path.dentry->d_parent);

security/ipe/policy_fs.c

264

root = d_inode(f->f_path.dentry->d_parent);

security/ipe/policy_fs.c

317

root = d_inode(f->f_path.dentry->d_parent);

security/ipe/policy_fs.c

366

root = d_inode(f->f_path.dentry->d_parent);

security/ipe/policy_fs.c

468

root = d_inode(policyfs);

security/ipe/policy_fs.c

54

root = d_inode(f->f_path.dentry->d_parent);

security/ipe/policy_fs.c

97

root = d_inode(f->f_path.dentry->d_parent);

security/lsm_audit.c

227

inode = a->u.op->path.dentry->d_inode;

security/selinux/hooks.c

2905

d_inode(dentry->d_parent), name,

security/selinux/hooks.c

2928

d_inode(dentry->d_parent), name,

security/selinux/hooks.c

3696

selinux_inode_getlsmprop(d_inode(src), &prop);

security/selinux/selinuxfs.c

1916

inc_nlink(d_inode(dir));

security/selinux/selinuxfs.c

1950

inode_lock(sb->s_root->d_inode);

security/selinux/selinuxfs.c

1952

inc_nlink(sb->s_root->d_inode);

security/selinux/selinuxfs.c

1953

inode_unlock(sb->s_root->d_inode);

security/selinux/selinuxfs.c

519

tmp_ino = fsi->bool_dir->d_inode->i_ino - 1; /* sel_make_dir will increment and set */

security/selinux/selinuxfs.c

526

tmp_ino = fsi->class_dir->d_inode->i_ino - 1; /* sel_make_dir will increment and set */

security/smack/smack_lsm.c

4990

isp = smack_inode(d_inode(dentry));

security/smack/smack_lsm.c

5026

isp = smack_inode(d_inode(dentry->d_parent));

security/smack/smack_lsm.c

631

isp = smack_inode(reference->s_root->d_inode);

tools/testing/selftests/bpf/progs/local_storage.c

113

bpf_inode_storage_get(&inode_storage_map, new_dentry->d_inode, 0,

tools/testing/selftests/bpf/progs/local_storage.c

116

storage = bpf_inode_storage_get(&inode_storage_map, old_dentry->d_inode,

tools/testing/selftests/bpf/progs/local_storage.c

124

err = bpf_inode_storage_delete(&inode_storage_map, old_dentry->d_inode);

tools/testing/selftests/bpf/progs/local_storage.c

83

is_self_unlink = storage->exec_inode == victim->d_inode;

tools/testing/selftests/bpf/progs/profiler.inc.h

512

u64 dir_ino = BPF_CORE_READ(filp_dentry, d_inode, i_ino);

tools/testing/selftests/bpf/progs/profiler.inc.h

536

u64 ino = BPF_CORE_READ(file_dentry, d_inode, i_ino);

tools/testing/selftests/bpf/progs/verifier_vfs_accept.c

92

struct inode *inode = new_dentry->d_inode;

tools/testing/selftests/bpf/progs/verifier_vfs_reject.c

168

struct inode *inode = new_dentry->d_inode;