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

1756

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

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

1277

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

1335

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

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

1412

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

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

1413

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

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

1414

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

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

1415

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

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

1964

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

drivers/gpu/drm/xe/xe_gt_debugfs.c

365

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

484

d_inode(root)->i_private = hba;

drivers/ufs/core/ufs-debugfs.c

505

d_inode(txeq_dir)->i_private = hba;

drivers/usb/gadget/function/f_fs.c

2384

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

136

if (!ret && dentry->d_inode)

fs/9p/fid.c

137

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

fs/9p/vfs_dentry.c

149

inode = d_inode(dentry);

fs/9p/vfs_inode.c

1002

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

fs/9p/vfs_inode.c

1003

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

fs/9p/vfs_inode.c

1022

struct inode *inode = d_inode(dentry);

fs/9p/vfs_inode.c

1290

v9fs_refresh_inode(oldfid, d_inode(old_dentry));

fs/9p/vfs_inode.c

529

inode = d_inode(dentry);

fs/9p/vfs_inode.c

804

inode = d_inode(dentry);

fs/9p/vfs_inode.c

879

old_inode = d_inode(old_dentry);

fs/9p/vfs_inode.c

880

new_inode = d_inode(new_dentry);

fs/9p/vfs_inode.c

974

struct inode *inode = d_inode(dentry);

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

795

v9fs_refresh_inode_dotl(fid, d_inode(old_dentry));

fs/9p/vfs_inode_dotl.c

798

ihold(d_inode(old_dentry));

fs/9p/vfs_inode_dotl.c

799

d_instantiate(dentry, d_inode(old_dentry));

fs/adfs/inode.c

304

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

218

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

462

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

fs/affs/namei.c

466

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

fs/affs/namei.c

529

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

fs/afs/dir.c

1007

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

fs/afs/dir.c

1070

vnode = AFS_FS_I(d_inode(dentry));

fs/afs/dir.c

1118

inode = d_inode(dentry);

fs/afs/dir.c

1189

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

fs/afs/dir.c

1190

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

fs/afs/dir.c

1351

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

fs/afs/dir.c

1431

vnode = AFS_FS_I(d_inode(dentry));

fs/afs/dir.c

1556

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

fs/afs/dir.c

1587

write_inode_now(d_inode(dentry), 0);

fs/afs/dir.c

1716

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

fs/afs/dir.c

1895

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

fs/afs/dir.c

1938

new_inode = d_inode(new_dentry);

fs/afs/dir.c

2085

vnode = AFS_FS_I(d_inode(old_dentry));

fs/afs/dir.c

2089

new_vnode = AFS_FS_I(d_inode(new_dentry));

fs/afs/dir.c

2169

AFS_FS_I(d_inode(new_dentry)),

fs/afs/dir.c

974

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

602

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

fs/afs/inode.c

769

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

749

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

fs/afs/symlink.c

217

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

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

637

d_inode(dentry)->i_size = 0;

fs/autofs/root.c

638

clear_nlink(d_inode(dentry));

fs/autofs/root.c

718

d_inode(dentry)->i_size = 0;

fs/autofs/root.c

719

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

157

struct inode *inode = d_inode(old);

fs/bfs/dir.c

179

struct inode *inode = d_inode(dentry);

fs/bfs/dir.c

223

old_inode = d_inode(old_dentry);

fs/bfs/dir.c

236

new_inode = d_inode(new_dentry);

fs/binfmt_misc.c

748

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

fs/binfmt_misc.c

892

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

317

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

1551

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

fs/btrfs/inode.c

4359

struct inode *inode = d_inode(dentry);

fs/btrfs/inode.c

4375

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

fs/btrfs/inode.c

4378

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

fs/btrfs/inode.c

4401

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

fs/btrfs/inode.c

4589

struct inode *inode = d_inode(dentry);

fs/btrfs/inode.c

4730

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

fs/btrfs/inode.c

5298

struct inode *inode = d_inode(dentry);

fs/btrfs/inode.c

5945

struct inode *inode = d_inode(dentry);

fs/btrfs/inode.c

5948

inode = d_inode(dentry->d_parent);

fs/btrfs/inode.c

6854

struct inode *inode = d_inode(old_dentry);

fs/btrfs/inode.c

8040

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

fs/btrfs/inode.c

8090

struct inode *new_inode = new_dentry->d_inode;

fs/btrfs/inode.c

8091

struct inode *old_inode = old_dentry->d_inode;

fs/btrfs/inode.c

8266

BTRFS_I(old_dentry->d_inode),

fs/btrfs/inode.c

8288

BTRFS_I(new_dentry->d_inode),

fs/btrfs/inode.c

8379

struct inode *new_inode = d_inode(new_dentry);

fs/btrfs/inode.c

8380

struct inode *old_inode = d_inode(old_dentry);

fs/btrfs/inode.c

8557

BTRFS_I(d_inode(old_dentry)),

fs/btrfs/inode.c

8582

BTRFS_I(d_inode(new_dentry)),

fs/btrfs/inode.c

8591

BTRFS_I(d_inode(new_dentry)));

fs/btrfs/ioctl.c

2224

struct inode *dir = d_inode(parent);

fs/btrfs/ioctl.c

2302

dir = d_inode(parent);

fs/btrfs/ioctl.c

2368

inode = d_inode(dentry);

fs/btrfs/ioctl.c

275

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

fs/btrfs/ioctl.c

284

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

fs/btrfs/ioctl.c

828

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

fs/btrfs/ioctl.c

865

struct inode *dir = d_inode(parent);

fs/btrfs/super.c

1153

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

fs/btrfs/super.c

1155

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

fs/btrfs/super.c

1205

struct inode *root_inode = d_inode(root);

fs/btrfs/super.c

1845

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

fs/btrfs/super.c

1846

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

fs/btrfs/tree-log.c

7482

inode = BTRFS_I(d_inode(parent));

fs/btrfs/tree-log.c

7749

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

fs/btrfs/tree-log.c

8070

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

140

trace_cachefiles_vfs_error(NULL, d_inode(dir), ret,

fs/cachefiles/namei.c

159

inode_lock(d_inode(subdir));

fs/cachefiles/namei.c

162

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

fs/cachefiles/namei.c

164

subdir, d_inode(subdir)->i_ino);

fs/cachefiles/namei.c

168

inode_unlock(d_inode(subdir));

fs/cachefiles/namei.c

197

inode_unlock(d_inode(subdir));

fs/cachefiles/namei.c

222

cachefiles_do_unmark_inode_in_use(NULL, d_inode(dir));

fs/cachefiles/namei.c

241

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

fs/cachefiles/namei.c

317

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

fs/cachefiles/namei.c

365

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

fs/cachefiles/namei.c

370

trace_cachefiles_vfs_error(object, d_inode(dir), ret,

fs/cachefiles/namei.c

377

cachefiles_do_unmark_inode_in_use(object, d_inode(rep));

fs/cachefiles/namei.c

432

trace_cachefiles_vfs_error(object, d_inode(fan), ret,

fs/cachefiles/namei.c

522

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

fs/cachefiles/namei.c

524

dentry, d_inode(dentry)->i_ino);

fs/cachefiles/namei.c

579

cachefiles_do_unmark_inode_in_use(object, d_inode(dentry));

fs/cachefiles/namei.c

658

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

fs/cachefiles/namei.c

683

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

fs/cachefiles/namei.c

693

d_inode(fan), dentry, NULL);

fs/cachefiles/namei.c

695

trace_cachefiles_vfs_error(object, d_inode(fan), ret,

fs/cachefiles/namei.c

729

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

fs/cachefiles/namei.c

771

inode = d_inode(victim);

fs/cachefiles/namei.c

829

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

121

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

fs/ceph/dir.c

1187

ceph_init_inode_acls(d_inode(dentry), &as_ctx);

fs/ceph/dir.c

1232

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

fs/ceph/dir.c

1244

ihold(d_inode(old_dentry));

fs/ceph/dir.c

1245

d_instantiate(dentry, d_inode(old_dentry));

fs/ceph/dir.c

134

struct inode *dir = d_inode(parent);

fs/ceph/dir.c

1348

struct inode *inode = d_inode(dentry);

fs/ceph/dir.c

1417

req->r_old_inode = d_inode(dentry);

fs/ceph/dir.c

1533

ceph_drop_caps_for_unlink(d_inode(new_dentry));

fs/ceph/dir.c

191

struct inode *dir = d_inode(parent);

fs/ceph/dir.c

1913

dir = d_inode(dentry->d_parent);

fs/ceph/dir.c

1952

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

fs/ceph/dir.c

2037

d_inode(dentry) == req->r_target_inode)

fs/ceph/dir.c

2073

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

fs/ceph/dir.c

2127

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

731

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

fs/ceph/dir.c

772

dentry, ceph_vinop(d_inode(dentry)));

fs/ceph/dir.c

978

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

621

struct inode *dinode = d_inode(dentry);

fs/ceph/file.c

986

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

fs/ceph/file.c

989

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

fs/ceph/file.c

995

struct inode *newino = d_inode(dentry);

fs/ceph/inode.c

1501

dir = d_inode(dentry->d_parent);

fs/ceph/inode.c

1511

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

fs/ceph/inode.c

1535

BUG_ON(d_inode(dn));

fs/ceph/inode.c

1571

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

fs/ceph/inode.c

1577

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

fs/ceph/inode.c

1694

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

fs/ceph/inode.c

1695

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

fs/ceph/inode.c

1697

dn, d_inode(dn));

fs/ceph/inode.c

1757

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

fs/ceph/inode.c

1841

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

fs/ceph/inode.c

1843

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

fs/ceph/inode.c

2004

struct inode *inode = d_inode(parent);

fs/ceph/inode.c

2048

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

fs/ceph/inode.c

2108

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

fs/ceph/inode.c

2109

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

fs/ceph/inode.c

2112

dn, d_inode(dn));

fs/ceph/inode.c

2130

in = d_inode(dn);

fs/ceph/inode.c

2177

update_dentry_lease(d_inode(parent), dn,

fs/ceph/inode.c

2182

ret = fill_readdir_cache(d_inode(parent), dn,

fs/ceph/inode.c

2926

struct inode *inode = d_inode(dentry);

fs/ceph/inode.c

3150

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

fs/ceph/mds_client.c

1385

inode = d_inode(req->r_dentry);

fs/ceph/mds_client.c

1396

inode = d_inode(req->r_dentry);

fs/ceph/mds_client.c

2875

inode = d_inode(cur);

fs/ceph/mds_client.c

2885

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

fs/ceph/mds_client.c

2907

ret = ceph_fscrypt_prepare_readdir(d_inode(parent));

fs/ceph/mds_client.c

2915

if (fscrypt_has_encryption_key(d_inode(parent))) {

fs/ceph/mds_client.c

2916

len = ceph_encode_encrypted_dname(d_inode(parent),

fs/ceph/mds_client.c

2945

inode = d_inode(cur);

fs/ceph/mds_client.c

2971

if (d_inode(dentry))

fs/ceph/mds_client.c

2972

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

fs/ceph/mds_client.c

3361

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

fs/ceph/mds_client.c

3383

d_inode(req->r_old_dentry),

fs/ceph/mds_client.c

3741

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

fs/ceph/mds_client.c

3752

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

fs/ceph/mds_client.c

491

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

fs/ceph/mds_client.c

6096

dir = d_inode(dentry->d_parent);

fs/ceph/quota.c

26

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

fs/ceph/quota.c

513

if (!ceph_has_realms_with_quotas(d_inode(fsc->sb->s_root)))

fs/ceph/quota.c

517

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

fs/ceph/super.c

1359

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

fs/ceph/super.c

1631

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

fs/ceph/super.c

61

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

453

cii = ITOC(d_inode(de));

fs/coda/dir.c

482

struct inode *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

1164

inode_lock(d_inode(root));

fs/configfs/dir.c

1176

inode_unlock(d_inode(root));

fs/configfs/dir.c

1259

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

fs/configfs/dir.c

1283

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

fs/configfs/dir.c

1527

inode_lock(d_inode(wait));

fs/configfs/dir.c

1528

inode_unlock(d_inode(wait));

fs/configfs/dir.c

1599

inode_lock(d_inode(dentry));

fs/configfs/dir.c

1609

inode_unlock(d_inode(dentry));

fs/configfs/dir.c

1619

inode_lock(d_inode(dentry));

fs/configfs/dir.c

1623

inode_unlock(d_inode(dentry));

fs/configfs/dir.c

1669

inode = d_inode(dentry);

fs/configfs/dir.c

1769

inode_lock_nested(d_inode(parent), I_MUTEX_PARENT);

fs/configfs/dir.c

1777

inode_unlock(d_inode(parent));

fs/configfs/dir.c

1781

inode_unlock(d_inode(parent));

fs/configfs/dir.c

1808

inode_lock_nested(d_inode(parent), I_MUTEX_PARENT);

fs/configfs/dir.c

1814

d_inode(dentry)->i_flags |= S_DEAD;

fs/configfs/dir.c

1817

fsnotify_rmdir(d_inode(parent), dentry);

fs/configfs/dir.c

1818

inode_unlock(d_inode(parent));

fs/configfs/dir.c

1899

inode_lock_nested(d_inode(root), I_MUTEX_PARENT);

fs/configfs/dir.c

1911

BUG_ON(d_inode(dentry));

fs/configfs/dir.c

1921

inode_unlock(d_inode(root));

fs/configfs/dir.c

1951

inode_lock_nested(d_inode(root),

fs/configfs/dir.c

1953

inode_lock_nested(d_inode(dentry), I_MUTEX_CHILD);

fs/configfs/dir.c

1962

d_inode(dentry)->i_flags |= S_DEAD;

fs/configfs/dir.c

1964

inode_unlock(d_inode(dentry));

fs/configfs/dir.c

1967

fsnotify_rmdir(d_inode(root), dentry);

fs/configfs/dir.c

1969

inode_unlock(d_inode(root));

fs/configfs/dir.c

299

struct inode *p_inode = d_inode(p);

fs/configfs/dir.c

375

struct inode *p_inode = d_inode(parent);

fs/configfs/dir.c

417

if (unlikely(simple_rmdir(d_inode(parent), d)))

fs/configfs/dir.c

607

struct inode *inode = child->d_inode;

fs/configfs/dir.c

680

inode_lock(d_inode(child));

fs/configfs/dir.c

683

d_inode(child)->i_flags |= S_DEAD;

fs/configfs/dir.c

686

inode_unlock(d_inode(child));

fs/configfs/dir.c

725

BUG_ON(d_inode(child));

fs/configfs/dir.c

872

inode_lock(d_inode(dentry));

fs/configfs/dir.c

874

d_inode(dentry)->i_flags |= S_DEAD;

fs/configfs/dir.c

876

inode_unlock(d_inode(dentry));

fs/configfs/dir.c

912

inode_lock_nested(d_inode(dentry), I_MUTEX_CHILD);

fs/configfs/dir.c

917

d_inode(dentry)->i_flags |= S_DEAD;

fs/configfs/dir.c

921

inode_unlock(d_inode(dentry));

fs/configfs/file.c

453

inode_lock_nested(d_inode(dir), I_MUTEX_NORMAL);

fs/configfs/file.c

456

inode_unlock(d_inode(dir));

fs/configfs/file.c

475

inode_lock_nested(dir->d_inode, I_MUTEX_NORMAL);

fs/configfs/file.c

478

inode_unlock(dir->d_inode);

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

1784

dentry->d_inode ?

fs/dcache.c

1785

dentry->d_inode->i_ino : (u64)0,

fs/dcache.c

1867

if (!dentry->d_inode)

fs/dcache.c

1943

dentry->d_inode = NULL;

fs/dcache.c

2684

struct inode *inode = dentry->d_inode;

fs/dcache.c

2777

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

fs/dcache.c

2802

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

fs/dcache.c

2923

dir = dentry->d_parent->d_inode;

fs/dcache.c

3057

WARN_ON(!dentry->d_inode);

fs/dcache.c

3082

dir = target->d_parent->d_inode;

fs/dcache.c

3161

WARN_ON(!dentry1->d_inode);

fs/dcache.c

3162

WARN_ON(!dentry2->d_inode);

fs/dcache.c

3214

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

fs/dcache.c

3216

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

fs/dcache.c

3430

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

459

__releases(dentry->d_inode->i_lock)

fs/dcache.c

461

struct inode *inode = dentry->d_inode;

fs/dcache.c

727

struct inode *inode = dentry->d_inode;

fs/dcache.c

747

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

fs/dcache.c

750

inode = dentry->d_inode;

fs/dcache.c

825

if (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

1176

ecryptfs_i_size_init(page_virt, d_inode(ecryptfs_dentry));

fs/ecryptfs/crypto.c

1275

struct inode *ecryptfs_inode = d_inode(ecryptfs_dentry);

fs/ecryptfs/crypto.c

991

struct inode *lower_inode = d_inode(lower_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

1045

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

fs/ecryptfs/inode.c

1049

inode_lock(d_inode(lower_dentry));

fs/ecryptfs/inode.c

1050

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

fs/ecryptfs/inode.c

1051

inode_unlock(d_inode(lower_dentry));

fs/ecryptfs/inode.c

1088

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

fs/ecryptfs/inode.c

1106

struct inode *lower_inode = d_inode(lower_dentry);

fs/ecryptfs/inode.c

1111

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

437

file_size_save = i_size_read(d_inode(old_dentry));

fs/ecryptfs/inode.c

442

lower_dir = lower_new_dentry->d_parent->d_inode;

fs/ecryptfs/inode.c

452

set_nlink(d_inode(old_dentry),

fs/ecryptfs/inode.c

453

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

fs/ecryptfs/inode.c

454

i_size_write(d_inode(new_dentry), file_size_save);

fs/ecryptfs/inode.c

462

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

fs/ecryptfs/inode.c

479

lower_dir = lower_dentry->d_parent->d_inode;

fs/ecryptfs/inode.c

518

lower_dir = lower_dir_dentry->d_inode;

fs/ecryptfs/inode.c

550

lower_dir = lower_dentry->d_parent->d_inode;

fs/ecryptfs/inode.c

554

clear_nlink(d_inode(dentry));

fs/ecryptfs/inode.c

575

lower_dir = lower_dentry->d_parent->d_inode;

fs/ecryptfs/inode.c

614

target_inode = d_inode(new_dentry);

fs/ecryptfs/inode.c

629

fsstack_copy_attr_all(new_dir, d_inode(lower_new_dir_dentry));

fs/ecryptfs/inode.c

631

fsstack_copy_attr_all(old_dir, d_inode(lower_old_dir_dentry));

fs/ecryptfs/inode.c

671

fsstack_copy_attr_atime(d_inode(dentry),

fs/ecryptfs/inode.c

672

d_inode(ecryptfs_dentry_to_lower(dentry)));

fs/ecryptfs/inode.c

736

struct inode *inode = d_inode(dentry);

fs/ecryptfs/inode.c

823

inode_lock(d_inode(lower_dentry));

fs/ecryptfs/inode.c

825

inode_unlock(d_inode(lower_dentry));

fs/ecryptfs/inode.c

875

struct inode *inode = d_inode(dentry);

fs/ecryptfs/inode.c

881

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

fs/ecryptfs/inode.c

932

inode_lock(d_inode(lower_dentry));

fs/ecryptfs/inode.c

935

inode_unlock(d_inode(lower_dentry));

fs/ecryptfs/inode.c

952

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

fs/ecryptfs/inode.c

979

fsstack_copy_attr_all(d_inode(dentry),

fs/ecryptfs/inode.c

980

ecryptfs_inode_to_lower(d_inode(dentry)));

fs/ecryptfs/inode.c

982

d_inode(dentry), stat);

fs/ecryptfs/inode.c

998

lower_inode = d_inode(lower_dentry);

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

542

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

253

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

fs/efivarfs/super.c

473

inode = d_inode(child);

fs/efs/namei.c

115

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

fs/erofs/inode.c

318

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

fs/erofs/ishare.c

88

svi = EROFS_I(d_inode(vi->sharedentry));

fs/erofs/super.c

585

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

fs/erofs/xattr.c

382

struct inode *inode = d_inode(dentry);

fs/exec.c

119

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

fs/exfat/dir.c

1225

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

fs/exfat/dir.c

1328

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

fs/exfat/file.c

353

struct inode *inode = dentry->d_inode;

fs/exfat/namei.c

1154

struct inode *new_inode = new_dentry->d_inode;

fs/exfat/namei.c

1271

old_inode = old_dentry->d_inode;

fs/exfat/namei.c

1272

new_inode = new_dentry->d_inode;

fs/exfat/namei.c

765

struct inode *inode = dentry->d_inode;

fs/exfat/namei.c

906

struct inode *inode = dentry->d_inode;

fs/exportfs/expfs.c

133

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

fs/exportfs/expfs.c

138

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

fs/exportfs/expfs.c

277

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

fs/exportfs/expfs.c

419

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

fs/exportfs/expfs.c

427

parent = p->d_inode;

fs/exportfs/expfs.c

53

inode = result->d_inode;

fs/exportfs/expfs.c

554

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

275

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

fs/ext2/inode.c

1584

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

fs/ext2/inode.c

1610

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

205

struct inode *inode = d_inode(old_dentry);

fs/ext2/namei.c

273

struct inode *inode = d_inode(dentry);

fs/ext2/namei.c

305

struct inode * inode = d_inode(dentry);

fs/ext2/namei.c

324

struct inode * old_inode = d_inode(old_dentry);

fs/ext2/namei.c

325

struct inode * new_inode = d_inode(new_dentry);

fs/ext2/namei.c

85

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

fs/ext2/super.c

1591

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

462

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

fs/ext4/fast_commit.c

532

struct inode *inode = d_inode(dentry);

fs/ext4/fast_commit.c

575

struct inode *inode = d_inode(dentry);

fs/ext4/fsync.c

62

inode = dentry->d_inode;

fs/ext4/ialloc.c

458

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

fs/ext4/inode.c

5937

struct inode *inode = d_inode(dentry);

fs/ext4/inode.c

6197

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

fs/ext4/inode.c

6271

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

fs/ext4/ioctl.c

1014

struct inode *inode = d_inode(dentry);

fs/ext4/ioctl.c

997

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

2463

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

fs/ext4/namei.c

2787

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

fs/ext4/namei.c

3153

retval = dquot_initialize(d_inode(dentry));

fs/ext4/namei.c

3164

inode = d_inode(dentry);

fs/ext4/namei.c

3315

retval = dquot_initialize(d_inode(dentry));

fs/ext4/namei.c

3319

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

fs/ext4/namei.c

3495

struct inode *inode = d_inode(old_dentry);

fs/ext4/namei.c

3507

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

fs/ext4/namei.c

3805

.inode = d_inode(old_dentry),

fs/ext4/namei.c

3810

.inode = d_inode(new_dentry),

fs/ext4/namei.c

3826

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

fs/ext4/namei.c

4058

.inode = d_inode(old_dentry),

fs/ext4/namei.c

4063

.inode = d_inode(new_dentry),

fs/ext4/namei.c

4070

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

fs/ext4/namei.c

4073

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

fs/ext4/super.c

2353

journal_inode = d_inode(path.dentry);

fs/ext4/super.c

6987

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

fs/ext4/super.c

6989

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

fs/ext4/super.c

7146

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

fs/ext4/super.c

7165

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

fs/ext4/super.c

7168

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

fs/ext4/super.c

7191

lockdep_set_quota_inode(path->dentry->d_inode,

fs/ext4/xattr.c

1490

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

295

struct inode *inode = d_inode(dentry);

fs/f2fs/f2fs.h

3912

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

fs/f2fs/file.c

1076

struct inode *inode = d_inode(dentry);

fs/f2fs/file.c

2337

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

fs/f2fs/file.c

3457

struct inode *inode = d_inode(dentry);

fs/f2fs/file.c

3481

struct inode *inode = d_inode(dentry);

fs/f2fs/file.c

985

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

fs/f2fs/namei.c

1136

struct inode *old_inode = d_inode(old_dentry);

fs/f2fs/namei.c

1137

struct inode *new_inode = d_inode(new_dentry);

fs/f2fs/namei.c

418

struct inode *inode = d_inode(old_dentry);

fs/f2fs/namei.c

468

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

fs/f2fs/namei.c

563

struct inode *inode = d_inode(dentry);

fs/f2fs/namei.c

779

struct inode *inode = d_inode(dentry);

fs/f2fs/namei.c

937

struct inode *old_inode = d_inode(old_dentry);

fs/f2fs/namei.c

938

struct inode *new_inode = d_inode(new_dentry);

fs/f2fs/super.c

2274

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

fs/f2fs/super.c

2276

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

fs/f2fs/super.c

3482

inode = d_inode(path->dentry);

fs/f2fs/xattr.c

567

struct inode *inode = d_inode(dentry);

fs/fat/file.c

428

if (d_inode(dentry)->i_flags & S_IMMUTABLE) {

fs/fat/file.c

439

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

fs/fat/file.c

522

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

365

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

fs/file_table.c

366

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

fs/file_table.c

381

i_readcount_inc(path->dentry->d_inode);

fs/fuse/acl.c

68

struct inode *inode = d_inode(dentry);

fs/fuse/acl.c

96

struct inode *inode = d_inode(dentry);

fs/fuse/control.c

227

inc_nlink(d_inode(parent));

fs/fuse/control.c

282

d_inode(dentry)->i_private = NULL;

fs/fuse/dir.c

1173

struct inode *inode = d_inode(entry);

fs/fuse/dir.c

1266

fuse_update_ctime(d_inode(oldent));

fs/fuse/dir.c

1269

fuse_update_ctime(d_inode(newent));

fs/fuse/dir.c

1331

struct inode *inode = d_inode(entry);

fs/fuse/dir.c

1616

inode_lock(d_inode(entry));

fs/fuse/dir.c

1617

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

fs/fuse/dir.c

1631

d_inode(entry)->i_flags |= S_DEAD;

fs/fuse/dir.c

1634

clear_nlink(d_inode(entry));

fs/fuse/dir.c

1637

inode_unlock(d_inode(entry));

fs/fuse/dir.c

2131

struct inode *inode = d_inode(dentry);

fs/fuse/dir.c

2310

struct inode *inode = d_inode(entry);

fs/fuse/dir.c

2374

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

fs/fuse/dir.c

514

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

fs/fuse/inode.c

1160

struct inode *child_inode = d_inode(child);

fs/fuse/inode.c

505

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

fs/fuse/inode.c

662

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

fs/fuse/inode.c

750

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

fs/fuse/ioctl.c

508

struct inode *inode = d_inode(dentry);

fs/fuse/ioctl.c

546

struct inode *inode = d_inode(dentry);

fs/fuse/readdir.c

163

struct inode *dir = d_inode(parent);

fs/fuse/readdir.c

208

inode = d_inode(dentry);

fs/fuse/xattr.c

109

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

1046

struct inode *inode = d_inode(old_dentry);

fs/gfs2/inode.c

1212

struct inode *inode = d_inode(dentry);

fs/gfs2/inode.c

1248

struct inode *inode = d_inode(dentry);

fs/gfs2/inode.c

1432

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

fs/gfs2/inode.c

1492

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

fs/gfs2/inode.c

1506

nip = GFS2_I(d_inode(ndentry));

fs/gfs2/inode.c

1651

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

fs/gfs2/inode.c

1744

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

fs/gfs2/inode.c

1745

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

fs/gfs2/inode.c

1820

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

fs/gfs2/inode.c

1826

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

fs/gfs2/inode.c

2102

struct inode *inode = d_inode(dentry);

fs/gfs2/inode.c

2164

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

fs/gfs2/inode.c

337

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

fs/gfs2/inode.c

822

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

252

struct inode *inode = d_inode(dentry);

fs/hfs/dir.c

300

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

fs/hfs/dir.c

304

struct inode *inode = d_inode(old_dentry);

fs/hfs/inode.c

630

struct inode *inode = d_inode(dentry);

fs/hfs/sysdep.c

25

inode = d_inode(dentry);

fs/hfsplus/dir.c

298

struct inode *inode = d_inode(src_dentry);

fs/hfsplus/dir.c

299

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

fs/hfsplus/dir.c

373

struct inode *inode = d_inode(dentry);

fs/hfsplus/dir.c

442

struct inode *inode = d_inode(dentry);

fs/hfsplus/dir.c

600

struct inode *inode = d_inode(old_dentry);

fs/hfsplus/dir.c

85

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

fs/hfsplus/inode.c

303

struct inode *inode = d_inode(dentry);

fs/hfsplus/inode.c

334

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

fs/hfsplus/inode.c

773

struct inode *inode = d_inode(dentry);

fs/hfsplus/inode.c

795

struct inode *inode = d_inode(dentry);

fs/hfsplus/ioctl.c

30

struct inode *inode = d_inode(dentry);

fs/hfsplus/xattr.c

738

struct inode *inode = d_inode(dentry);

fs/hfsplus/xattr.c

806

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

1097

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

fs/hugetlbfs/inode.c

834

struct inode *inode = d_inode(dentry);

fs/inode.c

2310

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

fs/inode.c

2347

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

808

inode = d_inode(path->dentry);

fs/jfs/xattr.c

874

struct inode *inode = d_inode(dentry);

fs/kernfs/inode.c

113

struct inode *inode = d_inode(dentry);

fs/kernfs/inode.c

148

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

fs/kernfs/inode.c

188

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

fs/kernfs/kernfs-internal.h

144

return d_inode(dentry)->i_private;

fs/libfs.c

163

inode_lock_shared(dentry->d_inode);

fs/libfs.c

177

inode_unlock_shared(dentry->d_inode);

fs/libfs.c

1817

dir = READ_ONCE(parent->d_inode);

fs/libfs.c

1852

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

fs/libfs.c

206

d_inode(next)->i_ino,

fs/libfs.c

207

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

fs/libfs.c

2263

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

fs/libfs.c

2270

struct inode *inode = d_inode(dentry);

fs/libfs.c

36

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

fs/libfs.c

477

struct inode *inode = d_inode(parent);

fs/libfs.c

496

struct inode *inode = d_inode(dentry);

fs/libfs.c

558

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

fs/libfs.c

604

struct inode *inode = this->d_inode;

fs/libfs.c

617

inode = this->d_inode;

fs/libfs.c

624

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

fs/libfs.c

755

struct inode *inode = d_inode(old_dentry);

fs/libfs.c

789

struct inode *inode = d_inode(dentry);

fs/libfs.c

799

drop_nlink(d_inode(dentry));

fs/libfs.c

838

struct inode *newino = d_inode(new_dentry);

fs/libfs.c

844

inode_set_ctime_current(d_inode(old_dentry));

fs/libfs.c

888

drop_nlink(d_inode(new_dentry));

fs/libfs.c

919

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

36

struct inode *inode = d_inode(dentry);

fs/minix/inode.c

713

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

1150

nd->inode = d->d_inode;

fs/namei.c

1158

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

fs/namei.c

1187

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

fs/namei.c

1362

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

fs/namei.c

1555

dentry->d_inode)

fs/namei.c

1770

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

fs/namei.c

1802

dir = base->d_inode;

fs/namei.c

1898

struct inode *inode = dir->d_inode;

fs/namei.c

1933

struct inode *inode = dir->d_inode;

fs/namei.c

1945

struct inode *inode = dir->d_inode;

fs/namei.c

2107

inode = path.dentry->d_inode;

fs/namei.c

2141

struct inode *inode = dentry->d_inode;

fs/namei.c

2170

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

fs/namei.c

2209

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

fs/namei.c

2702

struct inode *inode = root->d_inode;

fs/namei.c

2735

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

fs/namei.c

2740

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

fs/namei.c

2763

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

fs/namei.c

2767

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

fs/namei.c

2910

struct inode *dir = d_inode(parent);

fs/namei.c

2955

inode_unlock(de->d_parent->d_inode);

fs/namei.c

3121

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

fs/namei.c

3172

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

fs/namei.c

3199

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

fs/namei.c

3563

inode_lock_nested(parent->d_inode, I_MUTEX_PARENT);

fs/namei.c

3564

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

fs/namei.c

3567

inode_unlock(parent->d_inode);

fs/namei.c

3571

inode_unlock(parent->d_inode);

fs/namei.c

3596

inode_lock_nested(parent->d_inode, I_MUTEX_PARENT);

fs/namei.c

3597

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

fs/namei.c

3600

inode_unlock(parent->d_inode);

fs/namei.c

3604

inode_unlock(parent->d_inode);

fs/namei.c

3688

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

fs/namei.c

3735

if (child->d_inode)

fs/namei.c

3755

inode_lock_nested(p2->d_inode, I_MUTEX_PARENT);

fs/namei.c

3756

inode_lock_nested(p1->d_inode, I_MUTEX_PARENT2);

fs/namei.c

3765

inode_lock_nested(p1->d_inode, I_MUTEX_PARENT);

fs/namei.c

3766

inode_lock_nested(p2->d_inode, I_MUTEX_PARENT2);

fs/namei.c

3770

inode_lock_nested(p1->d_inode, I_MUTEX_PARENT);

fs/namei.c

3771

inode_lock_nested(p2->d_inode, I_MUTEX_PARENT2);

fs/namei.c

3785

inode_lock_nested(p1->d_inode, I_MUTEX_PARENT);

fs/namei.c

3802

inode_lock_nested(p2->d_inode, I_MUTEX_PARENT);

fs/namei.c

3814

inode_unlock(p2->d_inode);

fs/namei.c

3829

inode_lock_nested(p2->d_inode, I_MUTEX_PARENT);

fs/namei.c

3836

inode_unlock(p1->d_inode);

fs/namei.c

3838

inode_unlock(p2->d_inode);

fs/namei.c

4185

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

fs/namei.c

4213

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

fs/namei.c

4240

struct inode *inode = dentry->d_inode;

fs/namei.c

4298

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

fs/namei.c

4331

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

fs/namei.c

4336

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

fs/namei.c

4357

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

fs/namei.c

4410

struct inode *dir_inode = dir->d_inode;

fs/namei.c

4439

if (dentry->d_inode) {

fs/namei.c

4462

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

fs/namei.c

4495

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

fs/namei.c

4513

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

fs/namei.c

4551

if (!dentry->d_inode) {

fs/namei.c

4605

inode_lock(dir->d_inode);

fs/namei.c

4607

inode_lock_shared(dir->d_inode);

fs/namei.c

4611

fsnotify_create(dir->d_inode, dentry);

fs/namei.c

4616

inode_unlock(dir->d_inode);

fs/namei.c

4618

inode_unlock_shared(dir->d_inode);

fs/namei.c

4734

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

fs/namei.c

5034

struct inode *dir_inode = d_inode(dir);

fs/namei.c

5069

fsnotify_create(dir->d_inode, dentry);

fs/namei.c

5178

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

fs/namei.c

5190

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

fs/namei.c

5194

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

fs/namei.c

5307

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

fs/namei.c

5309

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

fs/namei.c

5366

inode_lock(dentry->d_inode);

fs/namei.c

5370

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

fs/namei.c

5386

dentry->d_inode->i_flags |= S_DEAD;

fs/namei.c

5391

inode_unlock(dentry->d_inode);

fs/namei.c

5438

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

fs/namei.c

5492

struct inode *target = dentry->d_inode;

fs/namei.c

5580

inode = dentry->d_inode;

fs/namei.c

5585

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

fs/namei.c

5685

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

fs/namei.c

5745

struct inode *inode = old_dentry->d_inode;

fs/namei.c

5859

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

fs/namei.c

5944

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

fs/namei.c

5945

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

fs/namei.c

5951

struct inode *source = old_dentry->d_inode;

fs/namei.c

5952

struct inode *target = new_dentry->d_inode;

fs/namei.c

6263

struct inode *inode = d_inode(dentry);

fs/namei.c

6309

struct inode *inode = d_inode(dentry);

fs/namei.c

6400

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

fs/namei.c

953

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

fs/namespace.c

2098

ns = d_inode(dentry)->i_private;

fs/namespace.c

2146

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

fs/namespace.c

2768

inode_lock(dentry->d_inode);

fs/namespace.c

2787

inode_unlock(dentry->d_inode);

fs/namespace.c

2808

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

fs/namespace.c

3857

inode_lock(dentry->d_inode);

fs/namespace.c

3867

inode_unlock(dentry->d_inode);

fs/namespace.c

6398

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

fs/nfs/dir.c

1225

struct inode *inode = d_inode(dentry);

fs/nfs/dir.c

1436

struct inode *inode = d_inode(dentry);

fs/nfs/dir.c

1786

inode = d_inode(dentry);

fs/nfs/dir.c

1886

struct inode *inode = d_inode(dentry);

fs/nfs/dir.c

1921

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

fs/nfs/dir.c

2119

BUG_ON(d_inode(dentry));

fs/nfs/dir.c

2225

inode = d_inode(dentry);

fs/nfs/dir.c

2232

inode = d_inode(res);

fs/nfs/dir.c

2269

inode = d_inode(dentry);

fs/nfs/dir.c

2344

struct inode *dir = d_inode(parent);

fs/nfs/dir.c

2502

nfs_d_prune_case_insensitive_aliases(d_inode(dentry));

fs/nfs/dir.c

2516

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

fs/nfs/dir.c

2521

clear_nlink(d_inode(dentry));

fs/nfs/dir.c

2526

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

fs/nfs/dir.c

2545

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

fs/nfs/dir.c

2546

struct inode *inode = d_inode(dentry);

fs/nfs/dir.c

2588

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

fs/nfs/dir.c

2591

write_inode_now(d_inode(dentry), 0);

fs/nfs/dir.c

2678

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

fs/nfs/dir.c

2692

struct inode *inode = d_inode(old_dentry);

fs/nfs/dir.c

2761

struct inode *old_inode = d_inode(old_dentry);

fs/nfs/dir.c

2762

struct inode *new_inode = d_inode(new_dentry);

fs/nfs/dir.c

648

inode = d_inode(dentry);

fs/nfs/dir.c

770

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

fs/nfs/dir.c

772

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

fs/nfs/dir.c

773

trace_nfs_readdir_lookup_revalidate(d_inode(parent),

fs/nfs/dir.c

778

d_inode(parent), dentry, 0);

fs/nfs/dir.c

801

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

99

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

fs/nfs/inode.c

1074

struct inode *inode = d_inode(dentry);

fs/nfs/inode.c

1110

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

fs/nfs/inode.c

1142

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

fs/nfs/inode.c

1171

inode = d_inode(ctx->dentry);

fs/nfs/inode.c

1229

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

fs/nfs/inode.c

1267

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

fs/nfs/inode.c

1318

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

fs/nfs/inode.c

689

struct inode *inode = d_inode(dentry);

fs/nfs/inode.c

907

nfs_readdir_record_entry_cache_miss(d_inode(parent));

fs/nfs/inode.c

916

nfs_readdir_record_entry_cache_hit(d_inode(parent));

fs/nfs/inode.c

954

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

327

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

130

struct inode *inode = d_inode(dentry);

fs/nfs/nfs3proc.c

418

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

fs/nfs/nfs3proc.c

424

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

fs/nfs/nfs3proc.c

621

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

fs/nfs/nfs3proc.c

677

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

fs/nfs/nfs3proc.c

774

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

10611

error2 = security_inode_listsecurity(d_inode(dentry), &list, &left2);

fs/nfs/nfs4proc.c

10618

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, d_inode(dentry)->i_ino);

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, d_inode(dentry->d_parent)->i_ino);

fs/nfs/nfs4proc.c

4532

struct inode *inode = d_inode(dentry);

fs/nfs/nfs4proc.c

4930

struct inode *inode = d_inode(dentry);

fs/nfs/nfs4proc.c

4978

nfs_request_directory_delegation(d_inode(dentry->d_parent));

fs/nfs/nfs4proc.c

5019

struct inode *old_inode = d_inode(old_dentry);

fs/nfs/nfs4proc.c

5020

struct inode *new_inode = d_inode(new_dentry);

fs/nfs/nfs4proc.c

5054

nfs_d_prune_case_insensitive_aliases(d_inode(data->old_dentry));

fs/nfs/nfs4proc.c

5319

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

fs/nfs/nfs4proc.c

5368

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

fs/nfs/nfs4proc.c

5369

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

fs/nfs/nfs4proc.c

7354

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 = d_inode(ctx->dentry->d_parent)->i_ino;

fs/nfs/nfstrace.h

434

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

fs/nfs/nfstrace.h

482

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

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

2439

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

fs/nfs/pnfs.c

2474

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

fs/nfs/pnfs.c

2495

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

fs/nfs/pnfs.c

2501

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

fs/nfs/proc.c

130

struct inode *inode = d_inode(dentry);

fs/nfs/proc.c

512

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

fs/nfs/super.c

1065

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

292

nfs_mark_for_revalidate(d_inode(data->old_dentry));

fs/nfs/unlink.c

449

struct inode *inode = d_inode(dentry);

fs/nfs/unlink.c

463

fileid = d_inode(dentry)->i_ino;

fs/nfs/unlink.c

484

} 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

1711

inode = d_inode(ctx->dentry);

fs/nfs/write.c

1822

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

fs/nfs/write.c

887

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

fs/nfsd/export.c

1108

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

fs/nfsd/export.c

1743

inode = d_inode(path.dentry);

fs/nfsd/filecache.c

1155

inode = d_inode(fhp->fh_dentry);

fs/nfsd/nfs2acl.c

110

inode = d_inode(fh->fh_dentry);

fs/nfsd/nfs2acl.c

254

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

179

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

1287

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

2702

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

fs/nfsd/nfs4proc.c

271

inode = d_inode(parent);

fs/nfsd/nfs4proc.c

2744

inode = d_inode(current_fh->fh_dentry);

fs/nfsd/nfs4proc.c

356

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

fs/nfsd/nfs4proc.c

357

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

fs/nfsd/nfs4proc.c

358

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

fs/nfsd/nfs4proc.c

365

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

fs/nfsd/nfs4proc.c

366

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

fs/nfsd/nfs4proc.c

367

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

357

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

fs/nfsd/nfs4state.c

4932

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

fs/nfsd/nfs4state.c

5406

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

fs/nfsd/nfs4state.c

5436

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

fs/nfsd/nfs4state.c

5979

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

fs/nfsd/nfs4state.c

8042

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

fs/nfsd/nfs4state.c

8392

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

fs/nfsd/nfs4state.c

8675

inode = fhp->fh_dentry->d_inode;

fs/nfsd/nfs4state.c

9431

struct inode *inode = d_inode(dentry);

fs/nfsd/nfs4state.c

9492

struct inode *inode = d_inode(dentry);

fs/nfsd/nfs4xdr.c

3201

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

fs/nfsd/nfs4xdr.c

3334

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

fs/nfsd/nfs4xdr.c

3544

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

fs/nfsd/nfs4xdr.c

3633

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

fs/nfsd/nfs4xdr.c

3657

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

fs/nfsd/nfs4xdr.c

3673

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

fs/nfsd/nfs4xdr.c

3735

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

fs/nfsd/nfs4xdr.c

4063

err = security_inode_getsecctx(d_inode(dentry),

fs/nfsd/nfs4xdr.c

4079

struct inode *inode = d_inode(dentry);

fs/nfsd/nfs4xdr.c

4102

struct inode *inode = d_inode(dentry);

fs/nfsd/nfsctl.c

1138

struct inode *dir = parent->d_inode;

fs/nfsd/nfsctl.c

1173

struct inode *dir = parent->d_inode;

fs/nfsd/nfsctl.c

1205

struct inode *inode = d_inode(dentry);

fs/nfsd/nfsctl.c

1233

struct inode *dir = d_inode(root);

fs/nfsd/nfsfh.c

45

d_inode(parent), MAY_EXEC);

fs/nfsd/nfsfh.c

670

struct inode * inode = d_inode(dentry);

fs/nfsd/nfsfh.c

675

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

fs/nfsd/nfsfh.c

68

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

fs/nfsd/nfsfh.c

710

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

fs/nfsd/nfsfh.c

768

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

1165

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

fs/nfsd/vfs.c

1800

dirp = d_inode(dentry);

fs/nfsd/vfs.c

2003

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

fs/nfsd/vfs.c

2062

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

fs/nfsd/vfs.c

2068

dirp = d_inode(ddir);

fs/nfsd/vfs.c

2113

struct inode *inode = d_inode(dentry);

fs/nfsd/vfs.c

2123

struct inode *inode = d_inode(dentry);

fs/nfsd/vfs.c

2204

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

fs/nfsd/vfs.c

2206

if (d_inode(rd.new_dentry))

fs/nfsd/vfs.c

2207

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

fs/nfsd/vfs.c

2220

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

fs/nfsd/vfs.c

228

if (!d_inode(dentry))

fs/nfsd/vfs.c

2302

dirp = d_inode(dentry);

fs/nfsd/vfs.c

2314

rinode = d_inode(rdentry);

fs/nfsd/vfs.c

2319

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

fs/nfsd/vfs.c

2648

inode = d_inode(dentry);

fs/nfsd/vfs.c

2720

inode = d_inode(dentry);

fs/nfsd/vfs.c

2784

inode_lock(fhp->fh_dentry->d_inode);

fs/nfsd/vfs.c

2793

inode_unlock(fhp->fh_dentry->d_inode);

fs/nfsd/vfs.c

2813

inode_lock(fhp->fh_dentry->d_inode);

fs/nfsd/vfs.c

2822

inode_unlock(fhp->fh_dentry->d_inode);

fs/nfsd/vfs.c

2835

struct inode *inode = d_inode(dentry);

fs/nfsd/vfs.c

379

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

fs/nfsd/vfs.c

425

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

fs/nfsd/vfs.c

551

inode = d_inode(dentry);

fs/nfsd/vfs.c

664

struct inode *inode = d_inode(dentry);

fs/nfsd/vfs.c

909

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

1178

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

642

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

fs/notify/fanotify/fanotify_user.c

2056

inode = path.dentry->d_inode;

fs/notify/fsnotify.c

190

struct inode *inode = d_inode(dentry);

fs/notify/fsnotify.c

212

p_inode = parent->d_inode;

fs/notify/fsnotify.c

299

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

fs/notify/fsnotify.c

521

inode2 = moved->d_parent->d_inode;

fs/notify/fsnotify.c

646

p_mask = fsnotify_object_watched(d_inode(dentry), mnt_mask,

fs/notify/fsnotify.c

650

p_mask |= fsnotify_inode_watches_children(d_inode(parent));

fs/notify/fsnotify.c

90

if (!child->d_inode)

fs/notify/inotify/inotify_user.c

778

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/ntfs/ea.c

452

struct inode *inode = d_inode(dentry);

fs/ntfs/ea.c

799

struct inode *inode = d_inode(dentry);

fs/ntfs/ea.c

925

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

fs/ntfs/file.c

302

struct inode *vi = d_inode(dentry);

fs/ntfs/namei.c

1014

struct inode *vi = dentry->d_inode;

fs/ntfs/namei.c

1099

struct inode *vi = dentry->d_inode;

fs/ntfs/namei.c

1303

old_inode = old_dentry->d_inode;

fs/ntfs/namei.c

1304

new_inode = new_dentry->d_inode;

fs/ntfs/namei.c

1509

struct inode *vi = old_dentry->d_inode;

fs/ntfs/namei.c

1595

struct inode *vi = d_inode(child_dent);

fs/ntfs3/file.c

135

struct inode *inode = d_inode(dentry);

fs/ntfs3/file.c

267

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

fs/ntfs3/file.c

709

struct inode *inode = d_inode(dentry);

fs/ntfs3/file.c

97

struct inode *inode = d_inode(dentry);

fs/ntfs3/inode.c

1727

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

fs/ntfs3/inode.c

1743

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

1125

struct inode *inode = d_inode(dentry);

fs/ocfs2/file.c

1323

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

fs/ocfs2/file.c

2268

struct inode *inode = d_inode(dentry);

fs/ocfs2/inode.c

1345

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

4152

struct inode *inode = d_inode(old_dentry);

fs/ocfs2/refcounttree.c

4242

struct inode *inode = d_inode(old_dentry);

fs/ocfs2/refcounttree.c

4351

struct inode *inode = d_inode(old_dentry);

fs/ocfs2/refcounttree.c

4440

d_inode(new_path.dentry),

fs/ocfs2/xattr.c

1067

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

fs/ocfs2/xattr.c

1075

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

fs/ocfs2/xattr.c

1084

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

fs/ocfs2/xattr.c

1092

b_ret = ocfs2_xattr_block_list(d_inode(dentry), di,

fs/ocfs2/xattr.c

1098

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

167

struct inode *inode = dentry->d_inode;

fs/open.c

620

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

743

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

fs/open.c

79

inode = path->dentry->d_inode;

fs/open.c

889

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

819

struct inode *inode = d_inode(dentry);

fs/orangefs/inode.c

841

sync_inode_metadata(d_inode(dentry), 1);

fs/orangefs/inode.c

855

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

fs/orangefs/inode.c

925

ret = orangefs_inode_getxattr(d_inode(dentry),

fs/orangefs/inode.c

959

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

414

struct inode *inode = dentry->d_inode;

fs/overlayfs/copy_up.c

1001

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

fs/overlayfs/copy_up.c

1008

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

fs/overlayfs/copy_up.c

1050

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

fs/overlayfs/copy_up.c

1122

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

fs/overlayfs/copy_up.c

1123

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

fs/overlayfs/copy_up.c

1124

ovl_set_upperdata(d_inode(c->dentry));

fs/overlayfs/copy_up.c

1266

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

907

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

fs/overlayfs/copy_up.c

909

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

fs/overlayfs/copy_up.c

910

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

fs/overlayfs/copy_up.c

913

ovl_set_upperdata(d_inode(c->dentry));

fs/overlayfs/copy_up.c

914

ovl_inode_update(d_inode(c->dentry), newdentry);

fs/overlayfs/dir.c

1093

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

fs/overlayfs/dir.c

112

ofs->whiteout->d_inode->i_nlink,

fs/overlayfs/dir.c

1188

} else if (d_inode(new)) {

fs/overlayfs/dir.c

1267

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

fs/overlayfs/dir.c

1285

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

fs/overlayfs/dir.c

1320

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

fs/overlayfs/dir.c

1322

clear_nlink(d_inode(new));

fs/overlayfs/dir.c

1330

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

fs/overlayfs/dir.c

1333

ovl_copyattr(d_inode(old));

fs/overlayfs/dir.c

1334

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

fs/overlayfs/dir.c

1335

ovl_copyattr(d_inode(new));

fs/overlayfs/dir.c

1458

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

fs/overlayfs/dir.c

165

struct inode *dir = parent->d_inode;

fs/overlayfs/dir.c

172

if (newdentry->d_inode)

fs/overlayfs/dir.c

215

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

fs/overlayfs/dir.c

240

} else if (d->d_inode != newdentry->d_inode) {

fs/overlayfs/dir.c

330

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

fs/overlayfs/dir.c

447

inode_lock(opaquedir->d_inode);

fs/overlayfs/dir.c

449

inode_unlock(opaquedir->d_inode);

fs/overlayfs/dir.c

501

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

fs/overlayfs/dir.c

535

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

fs/overlayfs/dir.c

54

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

fs/overlayfs/dir.c

540

inode_lock(newdentry->d_inode);

fs/overlayfs/dir.c

542

inode_unlock(newdentry->d_inode);

fs/overlayfs/dir.c

720

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

fs/overlayfs/dir.c

725

if (inode != d_inode(dentry))

fs/overlayfs/dir.c

792

inode = d_inode(old);

fs/overlayfs/dir.c

809

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

fs/overlayfs/dir.c

82

struct inode *wdir = workdir->d_inode;

fs/overlayfs/dir.c

863

struct inode *dir = upperdir->d_inode;

fs/overlayfs/dir.c

912

!ovl_test_flag(OVL_WHITEOUTS, d_inode(dentry));

fs/overlayfs/dir.c

917

struct inode *inode = d_inode(dentry);

fs/overlayfs/dir.c

966

clear_nlink(dentry->d_inode);

fs/overlayfs/dir.c

979

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

395

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

488

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

fs/overlayfs/overlayfs.h

819

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

1131

if (dentry->d_inode)

fs/overlayfs/readdir.c

1219

if (dentry->d_inode)

fs/overlayfs/readdir.c

1242

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

1311

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

fs/overlayfs/super.c

1324

ino = d_inode(upperdentry)->i_ino;

fs/overlayfs/super.c

1328

ovl_set_flag(OVL_IMPURE, d_inode(root));

fs/overlayfs/super.c

1346

ovl_set_flag(OVL_WHITEOUTS, d_inode(root));

fs/overlayfs/super.c

1348

ovl_set_upperdata(d_inode(root));

fs/overlayfs/super.c

1349

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

fs/overlayfs/super.c

1350

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

630

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

1229

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

fs/overlayfs/util.c

1297

if (!ovl_has_upperdata(d_inode(dentry)))

fs/overlayfs/util.c

1354

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

fs/overlayfs/util.c

1383

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

fs/overlayfs/util.c

1408

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

fs/overlayfs/util.c

1431

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

fs/overlayfs/util.c

1441

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

1058

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

fs/pidfs.c

822

struct inode *inode = d_inode(dentry);

fs/pipe.c

975

d_inode(dentry)->i_ino);

fs/posix_acl.c

1027

struct inode *inode = d_inode(dentry);

fs/posix_acl.c

1101

struct inode *inode = d_inode(dentry);

fs/posix_acl.c

1176

struct inode *inode = d_inode(dentry);

fs/posix_acl.c

1222

struct inode *inode = d_inode(dentry);

fs/posix_acl.c

1301

error = vfs_posix_acl_to_xattr(idmap, d_inode(dentry),

fs/posix_acl.c

614

struct inode *inode = d_inode(dentry);

fs/posix_acl.c

945

struct inode *inode = d_inode(dentry);

fs/proc/base.c

1842

struct inode *inode = d_inode(dentry);

fs/proc/base.c

2000

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

fs/proc/base.c

2076

return proc_inode_is_dead(d_inode(dentry));

fs/proc/base.c

2129

inode = d_inode(child);

fs/proc/base.c

2192

inode = d_inode(dentry);

fs/proc/base.c

3943

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

fs/proc/base.c

709

struct inode *inode = d_inode(dentry);

fs/proc/fd.c

153

inode = d_inode(dentry);

fs/proc/fd.c

178

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

fs/proc/fd.c

349

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

fs/proc/generic.c

123

struct inode *inode = d_inode(dentry);

fs/proc/generic.c

142

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

fs/proc/generic.c

227

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

fs/proc/generic.c

234

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

fs/proc/namespaces.c

80

struct inode *inode = d_inode(dentry);

fs/proc/proc_net.c

315

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

fs/proc/proc_sysctl.c

714

inode = d_inode(child);

fs/proc/proc_sysctl.c

823

struct inode *inode = d_inode(dentry);

fs/proc/proc_sysctl.c

841

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

fs/proc/proc_sysctl.c

890

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

fs/proc/proc_sysctl.c

895

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

fs/proc/root.c

409

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

fs/pstore/inode.c

186

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

fs/pstore/inode.c

305

inode_lock_nested(d_inode(root), I_MUTEX_PARENT);

fs/pstore/inode.c

329

inode_unlock(d_inode(root));

fs/pstore/inode.c

347

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

fs/pstore/inode.c

410

inode_unlock(d_inode(root));

fs/qnx6/inode.c

184

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

fs/quota/dquot.c

2571

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

fs/quota/dquot.c

2594

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

259

inode = d_inode(cfile->dentry);

fs/smb/client/cifsfs.c

1195

struct inode *inode = d_inode(dentry);

fs/smb/client/cifsfs.c

959

struct inode *dir = d_inode(dentry);

fs/smb/client/dir.c

829

full_path, d_inode(direntry));

fs/smb/client/dir.c

881

struct inode *inode = d_inode(direntry);

fs/smb/client/file.c

1219

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

fs/smb/client/file.c

1273

inode = d_inode(cfile->dentry);

fs/smb/client/file.c

1434

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

fs/smb/client/file.c

1673

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

fs/smb/client/file.c

1699

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

fs/smb/client/file.c

1728

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

fs/smb/client/file.c

1745

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

fs/smb/client/file.c

1942

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

fs/smb/client/file.c

2033

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

fs/smb/client/file.c

2236

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

fs/smb/client/file.c

2345

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

fs/smb/client/file.c

2503

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

fs/smb/client/file.c

2801

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

fs/smb/client/file.c

2833

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

fs/smb/client/file.c

3308

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

fs/smb/client/file.c

674

struct inode *inode = d_inode(dentry);

fs/smb/client/file.c

773

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

fs/smb/client/file.c

870

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

fs/smb/client/file.c

907

d_inode(cifs_file->dentry));

fs/smb/client/file.c

995

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

fs/smb/client/file.c

996

struct inode *inode = d_inode(dentry);

fs/smb/client/inode.c

1817

struct inode *inode = d_inode(dentry);

fs/smb/client/inode.c

1960

struct inode *inode = d_inode(dentry);

fs/smb/client/inode.c

2407

cifsInode = CIFS_I(d_inode(direntry));

fs/smb/client/inode.c

2411

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

fs/smb/client/inode.c

2412

i_size_write(d_inode(direntry), 0);

fs/smb/client/inode.c

2413

clear_nlink(d_inode(direntry));

fs/smb/client/inode.c

2414

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

fs/smb/client/inode.c

2429

inode_set_ctime_current(d_inode(direntry));

fs/smb/client/inode.c

2581

if (d_inode(target_dentry) != NULL) {

fs/smb/client/inode.c

2582

netfs_wait_for_outstanding_io(d_inode(target_dentry));

fs/smb/client/inode.c

2650

struct inode *inode = d_inode(target_dentry);

fs/smb/client/inode.c

2720

struct inode *inode = d_inode(dentry);

fs/smb/client/inode.c

2857

struct inode *inode = d_inode(dentry);

fs/smb/client/inode.c

2917

struct inode *inode = d_inode(dentry);

fs/smb/client/inode.c

2932

struct inode *inode = d_inode(dentry);

fs/smb/client/inode.c

3069

struct inode *inode = d_inode(dentry);

fs/smb/client/inode.c

3144

struct inode *inode = d_inode(direntry);

fs/smb/client/inode.c

3321

struct inode *inode = d_inode(direntry);

fs/smb/client/link.c

495

cifsInode = CIFS_I(d_inode(old_file));

fs/smb/client/link.c

498

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

fs/smb/client/link.c

499

inc_nlink(d_inode(old_file));

fs/smb/client/link.c

500

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

fs/smb/client/misc.c

448

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

fs/smb/client/misc.c

478

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

fs/smb/client/misc.c

549

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

fs/smb/client/misc.c

551

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

fs/smb/client/misc.c

625

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

fs/smb/client/misc.c

627

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

fs/smb/client/readdir.c

112

inode = d_inode(dentry);

fs/smb/client/smb1misc.c

154

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

fs/smb/client/smb1ops.c

905

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

fs/smb/client/smb2file.c

293

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

fs/smb/client/smb2file.c

434

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

fs/smb/client/smb2inode.c

1135

inode = d_inode(dentry);

fs/smb/client/smb2inode.c

1241

struct inode *inode = source_dentry ? d_inode(source_dentry) : NULL;

fs/smb/client/smb2inode.c

1281

struct inode *inode = source_dentry ? d_inode(source_dentry) : NULL;

fs/smb/client/smb2inode.c

1305

struct inode *inode = dentry ? d_inode(dentry) : NULL;

fs/smb/client/smb2inode.c

1506

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

fs/smb/client/smb2inode.c

1551

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

fs/smb/client/smb2inode.c

1560

cifs_get_writable_path(tcon, full_path, d_inode(dentry),

fs/smb/client/smb2inode.c

1566

cifs_get_writable_path(tcon, full_path, d_inode(dentry),

fs/smb/client/smb2inode.c

275

inode = d_inode(dentry);

fs/smb/client/smb2inode.c

55

ci = CIFS_I(d_inode(dentry));

fs/smb/client/smb2misc.c

581

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

fs/smb/client/smb2misc.c

757

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

fs/smb/client/smb2ops.c

1481

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

fs/smb/client/smb2ops.c

1519

inode = d_inode(cfile->dentry);

fs/smb/client/smb2ops.c

2176

inode = d_inode(cfile->dentry);

fs/smb/client/smb2ops.c

2220

inode = d_inode(trgtfile->dentry);

fs/smb/client/smb2ops.c

3622

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

fs/smb/client/smb2ops.c

3733

inode = d_inode(cfile->dentry);

fs/smb/client/smb2ops.c

4051

inode = d_inode(cfile->dentry);

fs/smb/client/smb2ops.c

4132

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

fs/smb/server/smb2pdu.c

3559

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

fs/smb/server/smb2pdu.c

3577

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

fs/smb/server/smb2pdu.c

3588

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

fs/smb/server/smb2pdu.c

3625

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

fs/smb/server/smb2pdu.c

3673

d_inode(path.dentry),

fs/smb/server/smb2pdu.c

3681

d_inode(path.dentry->d_parent),

fs/smb/server/smb2pdu.c

3742

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

fs/smb/server/smb2pdu.c

3746

d_inode(path.dentry->d_parent));

fs/smb/server/smb2pdu.c

6753

struct inode *inode = d_inode(dentry);

fs/smb/server/smbacl.c

1190

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

fs/smb/server/smbacl.c

1547

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

fs/smb/server/smbacl.c

1617

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

fs/smb/server/vfs.c

1041

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

fs/smb/server/vfs.c

1042

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

fs/smb/server/vfs.c

1044

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

fs/smb/server/vfs.c

121

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

fs/smb/server/vfs.c

127

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

fs/smb/server/vfs.c

130

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

fs/smb/server/vfs.c

133

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

fs/smb/server/vfs.c

1442

struct inode *inode = d_inode(dentry);

fs/smb/server/vfs.c

1505

struct inode *inode = d_inode(dentry);

fs/smb/server/vfs.c

164

ksmbd_vfs_inherit_owner(work, d_inode(path.dentry),

fs/smb/server/vfs.c

165

d_inode(dentry));

fs/smb/server/vfs.c

1838

struct inode *inode = d_inode(dentry);

fs/smb/server/vfs.c

203

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

fs/smb/server/vfs.c

209

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

fs/smb/server/vfs.c

587

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

fs/smb/server/vfs.c

593

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

fs/smb/server/vfs.c

594

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

fs/smb/server/vfs.c

598

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

fs/smb/server/vfs.c

649

d_inode(newpath.dentry),

fs/smb/server/vfs_cache.c

176

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

fs/smb/server/vfs_cache.c

300

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

fs/smb/server/vfs_cache.c

947

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

190

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

fs/tracefs/event_inode.c

208

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

fs/tracefs/event_inode.c

767

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

fs/tracefs/event_inode.c

768

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

fs/tracefs/event_inode.c

803

inc_nlink(dentry->d_parent->d_inode);

fs/tracefs/event_inode.c

804

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

fs/tracefs/inode.c

142

inode_unlock(d_inode(dentry));

fs/tracefs/inode.c

147

inode_lock(d_inode(dentry));

fs/tracefs/inode.c

168

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

fs/tracefs/inode.c

172

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

fs/tracefs/inode.c

214

struct inode *inode = d_inode(dentry);

fs/tracefs/inode.c

313

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

fs/tracefs/inode.c

573

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

fs/tracefs/inode.c

577

ti = get_tracefs(d_inode(parent));

fs/tracefs/inode.c

583

return d_inode(parent);

fs/tracefs/inode.c

642

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

fs/tracefs/inode.c

643

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

fs/tracefs/inode.c

645

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

fs/tracefs/inode.c

668

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

fs/tracefs/inode.c

669

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

fs/tracefs/inode.c

677

inc_nlink(d_inode(dentry->d_parent));

fs/tracefs/inode.c

678

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

225

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

1201

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

408

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

fs/vboxsf/utils.c

205

inode = d_inode(dentry);

fs/vboxsf/utils.c

241

struct inode *inode = d_inode(dentry);

fs/vboxsf/utils.c

257

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

fs/vboxsf/utils.c

264

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

fs/xattr.c

249

struct inode *inode = dentry->d_inode;

fs/xattr.c

302

struct inode *inode = dentry->d_inode;

fs/xattr.c

330

struct inode *inode = dentry->d_inode;

fs/xattr.c

403

struct inode *inode = dentry->d_inode;

fs/xattr.c

454

struct inode *inode = dentry->d_inode;

fs/xattr.c

508

struct inode *inode = d_inode(dentry);

fs/xattr.c

533

struct inode *inode = d_inode(dentry);

fs/xattr.c

564

struct inode *inode = dentry->d_inode;

fs/xattr.c

595

struct inode *inode = dentry->d_inode;

fs/xfs/scrub/findparent.c

455

pip = igrab(d_inode(parent));

fs/xfs/scrub/orphanage.c

186

orphanage_inode = igrab(d_inode(orphanage_dentry));

fs/xfs/scrub/trace.h

3324

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

fs/xfs/scrub/trace.h

3325

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

fs/xfs/scrub/trace.h

3328

__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

541

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

fs/xfs/xfs_ioctl.c

755

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 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_iops.c

911

struct inode *inode = d_inode(dentry);

fs/xfs/xfs_super.c

926

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

682

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

fs/zonefs/super.c

744

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

fs/zonefs/super.c

833

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

include/linux/dcache.h

103

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

include/linux/dcache.h

527

return dentry->d_inode == NULL;

include/linux/dcache.h

545

return dentry->d_inode != NULL;

include/linux/dcache.h

564

return dentry->d_inode;

include/linux/dcache.h

576

return READ_ONCE(dentry->d_inode);

include/linux/dcache.h

591

struct inode *inode = upper->d_inode;

include/linux/dcache.h

624

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

include/linux/fs.h

1363

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

include/linux/fs.h

2523

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

include/linux/fs.h

2702

d_inode(path->dentry), mask);

include/linux/fs.h

3578

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

include/linux/fs.h

3592

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

include/linux/fscrypt.h

1096

if (IS_ENCRYPTED(d_inode(dentry)))

include/linux/fscrypt.h

977

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

376

struct inode *inode = d_inode(dentry);

include/linux/fsnotify.h

394

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

include/linux/fsnotify.h

421

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

include/linux/fsnotify.h

79

struct inode *inode = d_inode(dentry);

include/linux/fsnotify_backend.h

350

return d_inode(data);

include/linux/fsnotify_backend.h

352

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

include/linux/fsnotify_backend.h

354

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

include/linux/fsnotify_backend.h

358

return d_inode(((const struct fsnotify_rename_data *)data)->moved);

include/linux/fsnotify_backend.h

721

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

include/trace/events/btrfs.h

844

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

include/trace/events/ceph.h

73

inode = d_inode(req->r_dentry);

include/trace/events/ext4.h

1001

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

include/trace/events/ext4.h

1003

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

include/trace/events/ext4.h

1521

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

include/trace/events/ext4.h

1523

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

include/trace/events/ext4.h

1545

__entry->ino = d_inode(dentry)->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

90

dir = d_inode(path.dentry);

kernel/audit_fsnotify.c

91

child = d_inode(dentry);

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

1217

inode = d_inode(sb->s_root);

kernel/bpf/inode.c

367

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

kernel/bpf/inode.c

504

dir = d_inode(path.dentry);

kernel/bpf/inode.c

780

struct inode *inode = d_inode(root);

kernel/bpf/inode.c

929

struct inode *inode = d_inode(dentry);

kernel/bpf/offload.c

492

ns_inode = ns_path.dentry->d_inode;

kernel/bpf/offload.c

679

ns_inode = ns_path.dentry->d_inode;

kernel/bpf/verifier.c

5674

struct inode *d_inode;

kernel/events/core.c

12140

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

kernel/events/core.c

9484

ns_inode = ns_path.dentry->d_inode;

kernel/events/core.c

9872

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

7629

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

kernel/trace/trace_osnoise.c

2787

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

kernel/trace/trace_snapshot.c

360

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

mm/secretmem.c

167

struct inode *inode = d_inode(dentry);

mm/shmem.c

1297

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

mm/shmem.c

1329

struct inode *inode = d_inode(dentry);

mm/shmem.c

3888

struct inode *inode = d_inode(old_dentry);

mm/shmem.c

3918

struct inode *inode = d_inode(dentry);

mm/shmem.c

3944

drop_nlink(d_inode(dentry));

mm/shmem.c

3975

struct inode *inode = d_inode(old_dentry);

mm/shmem.c

4010

drop_nlink(d_inode(new_dentry));

mm/shmem.c

4130

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

mm/shmem.c

4140

struct inode *inode = d_inode(dentry);

mm/shmem.c

4312

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

mm/shmem.c

4314

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

net/socket.c

396

d_inode(dentry)->i_ino);

net/socket.c

624

struct sockfs_inode *si = SOCKFS_I(d_inode(dentry));

net/socket.c

627

len = simple_xattr_list(d_inode(dentry), &si->xattrs, buffer, size);

net/socket.c

654

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

1384

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

net/unix/af_unix.c

1410

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

155

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

security/apparmor/apparmorfs.c

1578

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

security/apparmor/apparmorfs.c

1634

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

security/apparmor/apparmorfs.c

1947

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

security/apparmor/apparmorfs.c

2002

inode_unlock(dentry->d_inode);

security/apparmor/apparmorfs.c

2019

inode_lock(dentry->d_inode);

security/apparmor/apparmorfs.c

2680

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

security/apparmor/apparmorfs.c

2728

d_inode(dentry)->i_ino);

security/apparmor/apparmorfs.c

355

dir = d_inode(parent);

security/apparmor/apparmorfs.c

424

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

234

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

security/integrity/evm/evm_main.c

1017

evm_reset_status(dentry->d_inode);

security/integrity/evm/evm_main.c

563

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

security/integrity/evm/evm_main.c

864

evm_reset_status(dentry->d_inode);

security/integrity/evm/evm_main.c

909

evm_reset_status(dentry->d_inode);

security/integrity/evm/evm_secfs.c

234

inode = evm_xattrs->d_inode;

security/integrity/ima/ima_appraise.c

752

integrity_audit_msg(AUDIT_INTEGRITY_DATA, d_inode(dentry), path,

security/integrity/ima/ima_appraise.c

93

if (IS_RDONLY(d_inode(dentry)))

security/integrity/ima/ima_appraise.c

95

if (IS_IMMUTABLE(d_inode(dentry)))

security/integrity/ima/ima_main.c

360

metadata_inode = d_inode(d_real(file_dentry(file),

security/integrity/ima/ima_main.c

717

ima_reset_action_flags(path->dentry->d_inode);

security/integrity/ima/ima_main.c

885

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

1769

inode = d_inode(path->dentry);

security/selinux/hooks.c

2929

d_inode(dentry->d_parent), name,

security/selinux/hooks.c

2952

d_inode(dentry->d_parent), name,

security/selinux/hooks.c

3712

selinux_inode_getlsmprop(d_inode(src), &prop);

security/selinux/hooks.c

3982

inode = d_inode(backing_file_user_path(file)->dentry);

security/selinux/selinuxfs.c

1780

inc_nlink(d_inode(dir));

security/selinux/selinuxfs.c

1816

inc_nlink(sb->s_root->d_inode);

security/selinux/selinuxfs.c

476

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

security/selinux/selinuxfs.c

483

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

security/smack/smack_lsm.c

4983

isp = smack_inode(d_inode(dentry));

security/smack/smack_lsm.c

5019

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;