d_inode          2119 arch/ia64/kernel/perfmon.c 			     d_inode(dentry)->i_ino);
d_inode            96 arch/powerpc/platforms/cell/spufs/inode.c 	struct inode *inode = d_inode(dentry);
d_inode           148 arch/powerpc/platforms/cell/spufs/inode.c 	inode_lock(d_inode(dir));
d_inode           155 arch/powerpc/platforms/cell/spufs/inode.c 			simple_unlink(d_inode(dir), dentry);
d_inode           165 arch/powerpc/platforms/cell/spufs/inode.c 	inode_unlock(d_inode(dir));
d_inode           177 arch/powerpc/platforms/cell/spufs/inode.c 	spu_forget(SPUFS_I(d_inode(dir))->i_ctx);
d_inode           207 arch/powerpc/platforms/cell/spufs/inode.c 	parent = d_inode(dir->d_parent);
d_inode           208 arch/powerpc/platforms/cell/spufs/inode.c 	ctx = SPUFS_I(d_inode(dir))->i_ctx;
d_inode           445 arch/powerpc/platforms/cell/spufs/inode.c 		spufs_set_affinity(flags, SPUFS_I(d_inode(dentry))->i_ctx,
d_inode           491 arch/powerpc/platforms/cell/spufs/inode.c 	inc_nlink(d_inode(dentry));
d_inode           548 arch/powerpc/platforms/cell/spufs/inode.c 	struct inode *dir = d_inode(path->dentry);
d_inode           604 arch/powerpc/platforms/cell/spufs/inode.c 	struct inode *inode = root->d_inode;
d_inode            53 arch/s390/hypfs/inode.c 	struct inode *inode = d_inode(sb_info->update_file);
d_inode            72 arch/s390/hypfs/inode.c 	inode_lock(d_inode(parent));
d_inode            75 arch/s390/hypfs/inode.c 			simple_rmdir(d_inode(parent), dentry);
d_inode            77 arch/s390/hypfs/inode.c 			simple_unlink(d_inode(parent), dentry);
d_inode            81 arch/s390/hypfs/inode.c 	inode_unlock(d_inode(parent));
d_inode           348 arch/s390/hypfs/inode.c 	inode_lock(d_inode(parent));
d_inode           369 arch/s390/hypfs/inode.c 		inc_nlink(d_inode(parent));
d_inode           376 arch/s390/hypfs/inode.c 	inode_unlock(d_inode(parent));
d_inode           716 block/blk-mq-debugfs.c 	void *data = d_inode(m->file->f_path.dentry->d_parent)->i_private;
d_inode           726 block/blk-mq-debugfs.c 	void *data = d_inode(file->f_path.dentry->d_parent)->i_private;
d_inode           741 block/blk-mq-debugfs.c 	void *data = d_inode(file->f_path.dentry->d_parent)->i_private;
d_inode           814 block/blk-mq-debugfs.c 	d_inode(parent)->i_private = data;
d_inode           174 drivers/android/binderfs.c 	inode_lock(d_inode(root));
d_inode           179 drivers/android/binderfs.c 		inode_unlock(d_inode(root));
d_inode           187 drivers/android/binderfs.c 		inode_unlock(d_inode(root));
d_inode           194 drivers/android/binderfs.c 	fsnotify_create(root->d_inode, dentry);
d_inode           195 drivers/android/binderfs.c 	inode_unlock(d_inode(root));
d_inode           513 drivers/android/binderfs.c 	parent_inode = d_inode(dentry->d_parent);
d_inode           532 drivers/android/binderfs.c 	parent_inode = d_inode(parent);
d_inode           564 drivers/android/binderfs.c 	parent_inode = d_inode(parent);
d_inode           174 drivers/base/devtmpfs.c 	err = vfs_mkdir(d_inode(path.dentry), dentry, mode);
d_inode           177 drivers/base/devtmpfs.c 		d_inode(dentry)->i_private = &thread;
d_inode           224 drivers/base/devtmpfs.c 	err = vfs_mknod(d_inode(path.dentry), dentry, mode, dev->devt);
d_inode           232 drivers/base/devtmpfs.c 		inode_lock(d_inode(dentry));
d_inode           234 drivers/base/devtmpfs.c 		inode_unlock(d_inode(dentry));
d_inode           237 drivers/base/devtmpfs.c 		d_inode(dentry)->i_private = &thread;
d_inode           253 drivers/base/devtmpfs.c 		if (d_inode(dentry)->i_private == &thread)
d_inode           254 drivers/base/devtmpfs.c 			err = vfs_rmdir(d_inode(parent.dentry), dentry);
d_inode           261 drivers/base/devtmpfs.c 	inode_unlock(d_inode(parent.dentry));
d_inode           328 drivers/base/devtmpfs.c 		if (!err && dev_mynode(dev, d_inode(dentry), &stat)) {
d_inode           339 drivers/base/devtmpfs.c 			inode_lock(d_inode(dentry));
d_inode           341 drivers/base/devtmpfs.c 			inode_unlock(d_inode(dentry));
d_inode           342 drivers/base/devtmpfs.c 			err = vfs_unlink(d_inode(parent.dentry), dentry, NULL);
d_inode           350 drivers/base/devtmpfs.c 	inode_unlock(d_inode(parent.dentry));
d_inode           429 drivers/block/drbd/drbd_debugfs.c 	inode_lock(d_inode(parent));
d_inode           434 drivers/block/drbd/drbd_debugfs.c 	inode_unlock(d_inode(parent));
d_inode           179 drivers/char/tpm/eventlog/common.c 			inode = d_inode(chip->bios_dir[i]);
d_inode           836 drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c 			i_size_write(ent->d_inode, adev->rmmio_size);
d_inode           504 drivers/gpu/drm/amd/amdgpu/amdgpu_ring.c 	i_size_write(ent->d_inode, ring->ring_size + 12);
d_inode          2448 drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c 			i_size_write(ent->d_inode, adev->gmc.mc_vram_size);
d_inode          2450 drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c 			i_size_write(ent->d_inode, adev->gmc.gart_size);
d_inode           249 drivers/gpu/drm/nouveau/nouveau_debugfs.c 	d_inode(dentry)->i_size = drm->vbios.length;
d_inode            93 drivers/infiniband/hw/qib/qib_fs.c 	inode_lock(d_inode(parent));
d_inode            96 drivers/infiniband/hw/qib/qib_fs.c 		error = qibfs_mknod(d_inode(parent), *dentry,
d_inode           100 drivers/infiniband/hw/qib/qib_fs.c 	inode_unlock(d_inode(parent));
d_inode           446 drivers/infiniband/hw/qib/qib_fs.c 		simple_unlink(d_inode(parent), tmp);
d_inode           469 drivers/infiniband/hw/qib/qib_fs.c 	inode_lock(d_inode(root));
d_inode           479 drivers/infiniband/hw/qib/qib_fs.c 	inode_lock(d_inode(dir));
d_inode           494 drivers/infiniband/hw/qib/qib_fs.c 	inode_unlock(d_inode(dir));
d_inode           495 drivers/infiniband/hw/qib/qib_fs.c 	ret = simple_rmdir(d_inode(root), dir);
d_inode           500 drivers/infiniband/hw/qib/qib_fs.c 	inode_unlock(d_inode(root));
d_inode          1125 drivers/misc/ibmvmc.c 	file->f_path.dentry->d_inode->i_mtime = current_time(file_inode(file));
d_inode          1126 drivers/misc/ibmvmc.c 	mark_inode_dirty(file->f_path.dentry->d_inode);
d_inode           145 drivers/oprofile/oprofilefs.c 	inode_lock(d_inode(root));
d_inode           148 drivers/oprofile/oprofilefs.c 		inode_unlock(d_inode(root));
d_inode           154 drivers/oprofile/oprofilefs.c 		inode_unlock(d_inode(root));
d_inode           160 drivers/oprofile/oprofilefs.c 	inode_unlock(d_inode(root));
d_inode           222 drivers/oprofile/oprofilefs.c 	inode_lock(d_inode(parent));
d_inode           225 drivers/oprofile/oprofilefs.c 		inode_unlock(d_inode(parent));
d_inode           231 drivers/oprofile/oprofilefs.c 		inode_unlock(d_inode(parent));
d_inode           237 drivers/oprofile/oprofilefs.c 	inode_unlock(d_inode(parent));
d_inode           182 drivers/staging/exfat/exfat_super.c 	if (dentry->d_inode)
d_inode           192 drivers/staging/exfat/exfat_super.c 	if (dentry->d_inode)
d_inode          1228 drivers/staging/exfat/exfat_super.c 	struct inode *new_inode = new_dentry->d_inode;
d_inode          2304 drivers/staging/exfat/exfat_super.c struct inode *inode = filp->f_path.dentry->d_inode;
d_inode          2397 drivers/staging/exfat/exfat_super.c 	dentry->d_time = GET_IVERSION(dentry->d_parent->d_inode);
d_inode          2482 drivers/staging/exfat/exfat_super.c 	dentry->d_time = GET_IVERSION(dentry->d_parent->d_inode);
d_inode          2485 drivers/staging/exfat/exfat_super.c 		dentry->d_time = GET_IVERSION(dentry->d_parent->d_inode);
d_inode          2523 drivers/staging/exfat/exfat_super.c 	struct inode *inode = dentry->d_inode;
d_inode          2623 drivers/staging/exfat/exfat_super.c 	dentry->d_time = GET_IVERSION(dentry->d_parent->d_inode);
d_inode          2677 drivers/staging/exfat/exfat_super.c 	dentry->d_time = GET_IVERSION(dentry->d_parent->d_inode);
d_inode          2688 drivers/staging/exfat/exfat_super.c 	struct inode *inode = dentry->d_inode;
d_inode          2747 drivers/staging/exfat/exfat_super.c 	old_inode = old_dentry->d_inode;
d_inode          2748 drivers/staging/exfat/exfat_super.c 	new_inode = new_dentry->d_inode;
d_inode          2932 drivers/staging/exfat/exfat_super.c 	struct inode *inode = dentry->d_inode;
d_inode          2998 drivers/staging/exfat/exfat_super.c 	struct inode *inode = path->dentry->d_inode;
d_inode          1546 drivers/usb/gadget/legacy/inode.c 		parent = d_inode(dentry->d_parent);
d_inode            71 fs/9p/vfs_dentry.c 	inode = d_inode(dentry);
d_inode           597 fs/9p/vfs_inode.c 	inode = d_inode(dentry);
d_inode           877 fs/9p/vfs_inode.c 	v9inode = V9FS_I(d_inode(dentry));
d_inode           904 fs/9p/vfs_inode.c 		v9fs_cache_inode_set_cookie(d_inode(dentry), file);
d_inode           969 fs/9p/vfs_inode.c 	old_inode = d_inode(old_dentry);
d_inode           970 fs/9p/vfs_inode.c 	new_inode = d_inode(new_dentry);
d_inode          1063 fs/9p/vfs_inode.c 		generic_fillattr(d_inode(dentry), stat);
d_inode          1074 fs/9p/vfs_inode.c 	v9fs_stat2inode(st, d_inode(dentry), dentry->d_sb, 0);
d_inode          1075 fs/9p/vfs_inode.c 	generic_fillattr(d_inode(dentry), stat);
d_inode          1130 fs/9p/vfs_inode.c 		filemap_write_and_wait(d_inode(dentry)->i_mapping);
d_inode          1137 fs/9p/vfs_inode.c 	    iattr->ia_size != i_size_read(d_inode(dentry)))
d_inode          1138 fs/9p/vfs_inode.c 		truncate_setsize(d_inode(dentry), iattr->ia_size);
d_inode          1140 fs/9p/vfs_inode.c 	v9fs_invalidate_inode_attr(d_inode(dentry));
d_inode          1142 fs/9p/vfs_inode.c 	setattr_copy(d_inode(dentry), iattr);
d_inode          1143 fs/9p/vfs_inode.c 	mark_inode_dirty(d_inode(dentry));
d_inode          1354 fs/9p/vfs_inode.c 		v9fs_refresh_inode(oldfid, d_inode(old_dentry));
d_inode           469 fs/9p/vfs_inode_dotl.c 		generic_fillattr(d_inode(dentry), stat);
d_inode           484 fs/9p/vfs_inode_dotl.c 	v9fs_stat2inode_dotl(st, d_inode(dentry), 0);
d_inode           485 fs/9p/vfs_inode_dotl.c 	generic_fillattr(d_inode(dentry), stat);
d_inode           545 fs/9p/vfs_inode_dotl.c 	struct inode *inode = d_inode(dentry);
d_inode           785 fs/9p/vfs_inode_dotl.c 		v9fs_refresh_inode_dotl(fid, d_inode(old_dentry));
d_inode           787 fs/9p/vfs_inode_dotl.c 	ihold(d_inode(old_dentry));
d_inode           788 fs/9p/vfs_inode_dotl.c 	d_instantiate(dentry, d_inode(old_dentry));
d_inode           163 fs/9p/vfs_super.c 		d_inode(root)->i_ino = v9fs_qid2ino(&st->qid);
d_inode           164 fs/9p/vfs_super.c 		v9fs_stat2inode_dotl(st, d_inode(root), 0);
d_inode           174 fs/9p/vfs_super.c 		d_inode(root)->i_ino = v9fs_qid2ino(&st->qid);
d_inode           175 fs/9p/vfs_super.c 		v9fs_stat2inode(st, d_inode(root), sb, 0);
d_inode           296 fs/adfs/inode.c 	struct inode *inode = d_inode(dentry);
d_inode           144 fs/affs/amigaffs.c 	struct inode *dir, *inode = d_inode(dentry);
d_inode           274 fs/affs/amigaffs.c 	dir = d_inode(dentry->d_parent);
d_inode           278 fs/affs/amigaffs.c 	inode = d_inode(dentry);
d_inode           221 fs/affs/inode.c 	struct inode *inode = d_inode(dentry);
d_inode           239 fs/affs/namei.c 		 d_inode(dentry)->i_ino, dentry);
d_inode           308 fs/affs/namei.c 		 d_inode(dentry)->i_ino, dentry);
d_inode           393 fs/affs/namei.c 	struct inode *inode = d_inode(old_dentry);
d_inode           423 fs/affs/namei.c 	bh = affs_bread(sb, d_inode(old_dentry)->i_ino);
d_inode           458 fs/affs/namei.c 	bh_old = affs_bread(sb, d_inode(old_dentry)->i_ino);
d_inode           462 fs/affs/namei.c 	bh_new = affs_bread(sb, d_inode(new_dentry)->i_ino);
d_inode           523 fs/affs/namei.c 	bh = affs_bread(child->d_sb, d_inode(child)->i_ino);
d_inode           920 fs/afs/dir.c   	ASSERTCMP(d_inode(dentry), ==, NULL);
d_inode          1043 fs/afs/dir.c   		vnode = AFS_FS_I(d_inode(dentry));
d_inode          1056 fs/afs/dir.c   		inode = d_inode(dentry);
d_inode          1067 fs/afs/dir.c   	dir = AFS_FS_I(d_inode(parent));
d_inode          1101 fs/afs/dir.c   		inode = d_inode(dentry);
d_inode          1185 fs/afs/dir.c   	    (test_bit(AFS_VNODE_DELETED,   &AFS_FS_I(d_inode(dentry))->flags) ||
d_inode          1186 fs/afs/dir.c   	     test_bit(AFS_VNODE_PSEUDODIR, &AFS_FS_I(d_inode(dentry))->flags)))
d_inode          1350 fs/afs/dir.c   		struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry));
d_inode          1386 fs/afs/dir.c   		vnode = AFS_FS_I(d_inode(dentry));
d_inode          1447 fs/afs/dir.c   		struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry));
d_inode          1484 fs/afs/dir.c   	struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry));
d_inode          1515 fs/afs/dir.c   		write_inode_now(d_inode(dentry), 0);
d_inode          1667 fs/afs/dir.c   	struct afs_vnode *vnode = AFS_FS_I(d_inode(from));
d_inode          1853 fs/afs/dir.c   	vnode = AFS_FS_I(d_inode(old_dentry));
d_inode          1897 fs/afs/dir.c   					      AFS_FS_I(d_inode(new_dentry)),
d_inode          1976 fs/afs/dir.c   		new_inode = d_inode(new_dentry);
d_inode           208 fs/afs/dir_silly.c 	struct afs_vnode *dvnode = AFS_FS_I(d_inode(dentry->d_parent));
d_inode           137 fs/afs/dynroot.c 	ASSERTCMP(d_inode(dentry), ==, NULL);
d_inode           199 fs/afs/dynroot.c 	inode_lock(root->d_inode);
d_inode           210 fs/afs/dynroot.c 	inode_unlock(root->d_inode);
d_inode           227 fs/afs/dynroot.c 	inode_lock(root->d_inode);
d_inode           245 fs/afs/dynroot.c 	inode_unlock(root->d_inode);
d_inode           292 fs/afs/dynroot.c 	inode_lock(root->d_inode);
d_inode           302 fs/afs/dynroot.c 	inode_unlock(root->d_inode);
d_inode           726 fs/afs/inode.c 	struct inode *inode = d_inode(path->dentry);
d_inode           819 fs/afs/inode.c 	struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry));
d_inode            76 fs/afs/mntpt.c 	struct afs_vnode *vnode = AFS_FS_I(d_inode(mntpt));
d_inode           123 fs/afs/mntpt.c 		loff_t size = i_size_read(d_inode(mntpt));
d_inode           132 fs/afs/mntpt.c 		page = read_mapping_page(d_inode(mntpt)->i_mapping, 0, NULL);
d_inode           137 fs/afs/mntpt.c 			ret = afs_bad(AFS_FS_I(d_inode(mntpt)), afs_file_error_mntpt);
d_inode           164 fs/afs/mntpt.c 	BUG_ON(!d_inode(mntpt));
d_inode           202 fs/afs/super.c 	if (test_bit(AFS_VNODE_AUTOCELL, &AFS_FS_I(d_inode(root))->flags))
d_inode           726 fs/afs/super.c 	struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry));
d_inode            63 fs/attr.c      	struct inode *inode = d_inode(dentry);
d_inode           225 fs/attr.c      	struct inode *inode = dentry->d_inode;
d_inode           235 fs/autofs/autofs_i.h 	return d_inode(sbi->sb->s_root)->i_ino;
d_inode            64 fs/autofs/inode.c 	struct inode *root_inode = d_inode(root->d_sb->s_root);
d_inode           369 fs/autofs/inode.c 		inode->i_uid = d_inode(sb->s_root)->i_uid;
d_inode           370 fs/autofs/inode.c 		inode->i_gid = d_inode(sb->s_root)->i_gid;
d_inode           620 fs/autofs/root.c 	d_inode(dentry)->i_size = 0;
d_inode           621 fs/autofs/root.c 	clear_nlink(d_inode(dentry));
d_inode           719 fs/autofs/root.c 	d_inode(dentry)->i_size = 0;
d_inode           720 fs/autofs/root.c 	clear_nlink(d_inode(dentry));
d_inode            21 fs/autofs/symlink.c 	return d_inode(dentry)->i_private;
d_inode           669 fs/befs/linuxvfs.c 	struct befs_inode_info *befs_ino = BEFS_I(d_inode(child));
d_inode           150 fs/bfs/dir.c   	struct inode *inode = d_inode(old);
d_inode           172 fs/bfs/dir.c   	struct inode *inode = d_inode(dentry);
d_inode           216 fs/bfs/dir.c   	old_inode = d_inode(old_dentry);
d_inode           229 fs/bfs/dir.c   	new_inode = d_inode(new_dentry);
d_inode           623 fs/binfmt_misc.c 	drop_nlink(d_inode(dentry));
d_inode           669 fs/binfmt_misc.c 		inode_lock(d_inode(root));
d_inode           674 fs/binfmt_misc.c 		inode_unlock(d_inode(root));
d_inode           705 fs/binfmt_misc.c 	inode_lock(d_inode(root));
d_inode           756 fs/binfmt_misc.c 	inode_unlock(d_inode(root));
d_inode           798 fs/binfmt_misc.c 		inode_lock(d_inode(root));
d_inode           803 fs/binfmt_misc.c 		inode_unlock(d_inode(root));
d_inode           157 fs/btrfs/export.c 	struct inode *dir = d_inode(child);
d_inode           226 fs/btrfs/export.c 	struct inode *inode = d_inode(child);
d_inode           227 fs/btrfs/export.c 	struct inode *dir = d_inode(parent);
d_inode          2065 fs/btrfs/file.c 	struct inode *inode = d_inode(dentry);
d_inode          4260 fs/btrfs/inode.c 	struct inode *inode = d_inode(dentry);
d_inode          4267 fs/btrfs/inode.c 	btrfs_record_unlink_dir(trans, BTRFS_I(dir), BTRFS_I(d_inode(dentry)),
d_inode          4271 fs/btrfs/inode.c 			BTRFS_I(d_inode(dentry)), dentry->d_name.name,
d_inode          4292 fs/btrfs/inode.c 	struct btrfs_inode *inode = BTRFS_I(d_inode(dentry));
d_inode          4509 fs/btrfs/inode.c 	struct inode *inode = d_inode(dentry);
d_inode          4640 fs/btrfs/inode.c 	struct inode *inode = d_inode(dentry);
d_inode          4668 fs/btrfs/inode.c 			BTRFS_I(d_inode(dentry)), dentry->d_name.name,
d_inode          5383 fs/btrfs/inode.c 	struct inode *inode = d_inode(dentry);
d_inode          6013 fs/btrfs/inode.c 	struct inode *inode = d_inode(dentry);
d_inode          6016 fs/btrfs/inode.c 		inode = d_inode(dentry->d_parent);
d_inode          6821 fs/btrfs/inode.c 	struct inode *inode = d_inode(old_dentry);
d_inode          9571 fs/btrfs/inode.c 	struct inode *inode = d_inode(path->dentry);
d_inode          9612 fs/btrfs/inode.c 	struct inode *new_inode = new_dentry->d_inode;
d_inode          9613 fs/btrfs/inode.c 	struct inode *old_inode = old_dentry->d_inode;
d_inode          9728 fs/btrfs/inode.c 					   BTRFS_I(old_dentry->d_inode),
d_inode          9744 fs/btrfs/inode.c 					   BTRFS_I(new_dentry->d_inode),
d_inode          9936 fs/btrfs/inode.c 	struct inode *new_inode = d_inode(new_dentry);
d_inode          9937 fs/btrfs/inode.c 	struct inode *old_inode = d_inode(old_dentry);
d_inode          10049 fs/btrfs/inode.c 					BTRFS_I(d_inode(old_dentry)),
d_inode          10069 fs/btrfs/inode.c 						 BTRFS_I(d_inode(new_dentry)),
d_inode          10075 fs/btrfs/inode.c 					BTRFS_I(d_inode(new_dentry)));
d_inode           864 fs/btrfs/ioctl.c 	inode = btrfs_lookup_dentry(d_inode(dentry->d_parent), dentry);
d_inode           914 fs/btrfs/ioctl.c 	BUG_ON(d_inode(victim->d_parent) != dir);
d_inode           922 fs/btrfs/ioctl.c 	if (check_sticky(dir, d_inode(victim)) || IS_APPEND(d_inode(victim)) ||
d_inode           923 fs/btrfs/ioctl.c 	    IS_IMMUTABLE(d_inode(victim)) || IS_SWAPFILE(d_inode(victim)))
d_inode           960 fs/btrfs/ioctl.c 	struct inode *dir = d_inode(parent->dentry);
d_inode          2845 fs/btrfs/ioctl.c 	struct inode *dir = d_inode(parent);
d_inode          2887 fs/btrfs/ioctl.c 	inode = d_inode(dentry);
d_inode          1373 fs/btrfs/super.c 		  BTRFS_I(d_inode(dentry))->root->root_key.objectid);
d_inode          1437 fs/btrfs/super.c 		struct inode *root_inode = d_inode(root);
d_inode          2129 fs/btrfs/super.c 		BTRFS_I(d_inode(dentry))->root->root_key.objectid >> 32;
d_inode          2131 fs/btrfs/super.c 		BTRFS_I(d_inode(dentry))->root->root_key.objectid;
d_inode          5467 fs/btrfs/tree-log.c 		inode = BTRFS_I(d_inode(parent));
d_inode          5480 fs/btrfs/tree-log.c 			inode = BTRFS_I(d_inode(parent));
d_inode          5489 fs/btrfs/tree-log.c 		inode = BTRFS_I(d_inode(parent));
d_inode          5875 fs/btrfs/tree-log.c 		inode = BTRFS_I(d_inode(parent));
d_inode          6146 fs/btrfs/tree-log.c 	ret = btrfs_log_inode_parent(trans, BTRFS_I(d_inode(dentry)), parent,
d_inode           252 fs/btrfs/xattr.c 	struct inode *inode = d_inode(dentry);
d_inode           464 fs/cachefiles/interface.c 	inode_lock(d_inode(object->backer));
d_inode           483 fs/cachefiles/interface.c 	inode_unlock(d_inode(object->backer));
d_inode           314 fs/cachefiles/namei.c 			ret = vfs_unlink(d_inode(dir), rep, NULL);
d_inode           320 fs/cachefiles/namei.c 		inode_unlock(d_inode(dir));
d_inode           331 fs/cachefiles/namei.c 	inode_unlock(d_inode(dir));
d_inode           343 fs/cachefiles/namei.c 	if (rep->d_parent != dir || IS_DEADDIR(d_inode(rep))) {
d_inode           416 fs/cachefiles/namei.c 		ret = vfs_rename(d_inode(dir), rep,
d_inode           417 fs/cachefiles/namei.c 				 d_inode(cache->graveyard), grave, NULL, 0);
d_inode           449 fs/cachefiles/namei.c 	inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
d_inode           455 fs/cachefiles/namei.c 		inode_unlock(d_inode(dir));
d_inode           468 fs/cachefiles/namei.c 			inode_unlock(d_inode(dir));
d_inode           528 fs/cachefiles/namei.c 	inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
d_inode           564 fs/cachefiles/namei.c 			ret = vfs_mkdir(d_inode(dir), next, 0);
d_inode           573 fs/cachefiles/namei.c 				inode_unlock(d_inode(dir));
d_inode           600 fs/cachefiles/namei.c 			ret = vfs_create(d_inode(dir), next, S_IFREG, true);
d_inode           624 fs/cachefiles/namei.c 		inode_unlock(d_inode(dir));
d_inode           663 fs/cachefiles/namei.c 	inode_unlock(d_inode(dir));
d_inode           742 fs/cachefiles/namei.c 	inode_unlock(d_inode(dir));
d_inode           766 fs/cachefiles/namei.c 	inode_lock(d_inode(dir));
d_inode           794 fs/cachefiles/namei.c 		ret = vfs_mkdir(d_inode(dir), subdir, 0700);
d_inode           810 fs/cachefiles/namei.c 	inode_unlock(d_inode(dir));
d_inode           840 fs/cachefiles/namei.c 	inode_unlock(d_inode(dir));
d_inode           846 fs/cachefiles/namei.c 	inode_unlock(d_inode(dir));
d_inode           852 fs/cachefiles/namei.c 	inode_unlock(d_inode(dir));
d_inode           877 fs/cachefiles/namei.c 	inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
d_inode           892 fs/cachefiles/namei.c 		inode_unlock(d_inode(dir));
d_inode           921 fs/cachefiles/namei.c 	inode_unlock(d_inode(dir));
d_inode           927 fs/cachefiles/namei.c 	inode_unlock(d_inode(dir));
d_inode           987 fs/cachefiles/namei.c 	inode_unlock(d_inode(dir));
d_inode          1022 fs/cachefiles/namei.c 	inode_unlock(d_inode(dir));
d_inode          4261 fs/ceph/caps.c 		dir = d_inode(parent);
d_inode            87 fs/ceph/debugfs.c 				   ceph_ino(d_inode(req->r_dentry->d_parent)),
d_inode           127 fs/ceph/dir.c  	struct inode *dir = d_inode(parent);
d_inode           182 fs/ceph/dir.c  	struct inode *dir = d_inode(parent);
d_inode           254 fs/ceph/dir.c  			     dentry, dentry, d_inode(dentry));
d_inode           259 fs/ceph/dir.c  							 d_inode(dentry)->i_ino),
d_inode           260 fs/ceph/dir.c  				      d_inode(dentry)->i_mode >> 12)) {
d_inode           669 fs/ceph/dir.c  	struct inode *parent = d_inode(dentry->d_parent); /* we hold i_mutex */
d_inode           705 fs/ceph/dir.c  			     dentry, d_inode(dentry));
d_inode           871 fs/ceph/dir.c  		ceph_init_inode_acls(d_inode(dentry), &as_ctx);
d_inode           994 fs/ceph/dir.c  		ceph_init_inode_acls(d_inode(dentry), &as_ctx);
d_inode          1032 fs/ceph/dir.c  		ihold(d_inode(old_dentry));
d_inode          1033 fs/ceph/dir.c  		d_instantiate(dentry, d_inode(old_dentry));
d_inode          1046 fs/ceph/dir.c  	struct inode *inode = d_inode(dentry);
d_inode          1128 fs/ceph/dir.c  			ceph_drop_caps_for_unlink(d_inode(new_dentry));
d_inode          1503 fs/ceph/dir.c  	dir = d_inode(dentry->d_parent);
d_inode          1537 fs/ceph/dir.c  		if (dir == d_inode(dentry->d_parent) &&
d_inode          1566 fs/ceph/dir.c  		dir = d_inode(parent);
d_inode          1567 fs/ceph/dir.c  		inode = d_inode(dentry);
d_inode          1619 fs/ceph/dir.c  				    d_inode(dentry) == req->r_target_inode)
d_inode          1656 fs/ceph/dir.c  	if (ceph_snap(d_inode(dentry)) != CEPH_NOSNAP)
d_inode          1706 fs/ceph/dir.c  	dir_ci = ceph_inode(d_inode(dentry->d_parent));
d_inode           143 fs/ceph/export.c 		if (ceph_security_xattr_wanted(d_inode(sb->s_root)))
d_inode           218 fs/ceph/export.c 	if (ceph_security_xattr_wanted(d_inode(sb->s_root)))
d_inode           302 fs/ceph/export.c 		req->r_inode = d_inode(child);
d_inode           303 fs/ceph/export.c 		ihold(d_inode(child));
d_inode           312 fs/ceph/export.c 	if (ceph_security_xattr_wanted(d_inode(sb->s_root)))
d_inode           335 fs/ceph/export.c 	struct inode *inode = d_inode(child);
d_inode           410 fs/ceph/export.c 	struct inode *inode = d_inode(child);
d_inode           411 fs/ceph/export.c 	struct inode *dir = d_inode(parent);
d_inode           509 fs/ceph/export.c 	struct inode *inode = d_inode(child);
d_inode           521 fs/ceph/export.c 	inode_lock(d_inode(parent));
d_inode           525 fs/ceph/export.c 	req->r_ino2 = ceph_vino(d_inode(parent));
d_inode           526 fs/ceph/export.c 	req->r_parent = d_inode(parent);
d_inode           531 fs/ceph/export.c 	inode_unlock(d_inode(parent));
d_inode           521 fs/ceph/file.c 			ceph_init_inode_acls(d_inode(dentry), &as_ctx);
d_inode          1121 fs/ceph/inode.c 	dir = d_inode(dentry->d_parent);
d_inode          1131 fs/ceph/inode.c 		if (!ceph_ino_compare(d_inode(dentry), ptvino))
d_inode          1155 fs/ceph/inode.c 	BUG_ON(d_inode(dn));
d_inode          1193 fs/ceph/inode.c 		     d_inode(realdn), ceph_vinop(d_inode(realdn)));
d_inode          1199 fs/ceph/inode.c 		     dn, d_inode(dn), ceph_vinop(d_inode(dn)));
d_inode          1281 fs/ceph/inode.c 				   (ceph_ino(d_inode(dn)) != tvino.ino ||
d_inode          1282 fs/ceph/inode.c 				    ceph_snap(d_inode(dn)) != tvino.snap)) {
d_inode          1284 fs/ceph/inode.c 				     dn, d_inode(dn));
d_inode          1340 fs/ceph/inode.c 		BUG_ON(d_inode(dn->d_parent) != dir);
d_inode          1421 fs/ceph/inode.c 		} else if (d_really_is_positive(dn) && d_inode(dn) != in) {
d_inode          1423 fs/ceph/inode.c 			     dn, d_inode(dn), ceph_vinop(d_inode(dn)),
d_inode          1561 fs/ceph/inode.c 	struct ceph_inode_info *ci = ceph_inode(d_inode(parent));
d_inode          1605 fs/ceph/inode.c 			ceph_fill_dirfrag(d_inode(parent), rinfo->dir_dir);
d_inode          1662 fs/ceph/inode.c 			   (ceph_ino(d_inode(dn)) != tvino.ino ||
d_inode          1663 fs/ceph/inode.c 			    ceph_snap(d_inode(dn)) != tvino.snap)) {
d_inode          1666 fs/ceph/inode.c 			     dn, d_inode(dn));
d_inode          1684 fs/ceph/inode.c 			in = d_inode(dn);
d_inode          1727 fs/ceph/inode.c 		update_dentry_lease(d_inode(parent), dn,
d_inode          1732 fs/ceph/inode.c 			ret = fill_readdir_cache(d_inode(parent), dn,
d_inode          2209 fs/ceph/inode.c 	struct inode *inode = d_inode(dentry);
d_inode          2332 fs/ceph/inode.c 	struct inode *inode = d_inode(path->dentry);
d_inode           929 fs/ceph/mds_client.c 			inode = d_inode(req->r_dentry);
d_inode           939 fs/ceph/mds_client.c 			inode = d_inode(req->r_dentry);
d_inode          2155 fs/ceph/mds_client.c 		inode = d_inode(temp);
d_inode          2185 fs/ceph/mds_client.c 	base = ceph_ino(d_inode(temp));
d_inode          2362 fs/ceph/mds_client.c 		      req->r_inode ? req->r_inode : d_inode(req->r_dentry),
d_inode          2375 fs/ceph/mds_client.c 		      d_inode(req->r_old_dentry),
d_inode          3988 fs/ceph/mds_client.c 	dir = d_inode(dentry->d_parent);
d_inode            30 fs/ceph/quota.c 	if (sb->s_root->d_inode &&
d_inode            31 fs/ceph/quota.c 	    (sb->s_root->d_inode->i_ino == CEPH_INO_ROOT))
d_inode           488 fs/ceph/quota.c 	realm = get_quota_realm(mdsc, d_inode(fsc->sb->s_root), true);
d_inode            48 fs/ceph/super.c 	struct ceph_fs_client *fsc = ceph_inode_to_client(d_inode(dentry));
d_inode          1154 fs/ceph/super.c 	     d_inode(res), ceph_vinop(d_inode(res)));
d_inode          1225 fs/ceph/super.c 		err = __ceph_do_getattr(d_inode(sb->s_root), NULL,
d_inode           906 fs/ceph/xattr.c 	struct inode *inode = d_inode(dentry);
d_inode           732 fs/cifs/cifsfs.c 		struct inode *dir = d_inode(dentry);
d_inode          2071 fs/cifs/cifssmb.c 	struct inode *inode = d_inode(wdata->cfile->dentry);
d_inode          2167 fs/cifs/cifssmb.c 	struct inode *inode = d_inode(wdata->cfile->dentry);
d_inode           706 fs/cifs/dir.c  		 full_path, d_inode(direntry));
d_inode           746 fs/cifs/dir.c  		inode = d_inode(direntry);
d_inode           298 fs/cifs/file.c 	struct inode *inode = d_inode(dentry);
d_inode           384 fs/cifs/file.c 	struct inode *inode = d_inode(cifs_file->dentry);
d_inode           443 fs/cifs/file.c 	struct inode *inode = d_inode(cifs_file->dentry);
d_inode           477 fs/cifs/file.c 			 d_inode(cifs_file->dentry));
d_inode           652 fs/cifs/file.c 	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
d_inode           700 fs/cifs/file.c 	inode = d_inode(cfile->dentry);
d_inode          1013 fs/cifs/file.c 	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
d_inode          1039 fs/cifs/file.c 	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
d_inode          1068 fs/cifs/file.c 	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
d_inode          1085 fs/cifs/file.c 	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
d_inode          1280 fs/cifs/file.c 	struct inode *inode = d_inode(cfile->dentry);
d_inode          1369 fs/cifs/file.c 	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
d_inode          1540 fs/cifs/file.c 	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
d_inode          1650 fs/cifs/file.c 	struct inode *inode = d_inode(cfile->dentry);
d_inode          1813 fs/cifs/file.c 	struct cifsInodeInfo *cifsi = CIFS_I(d_inode(dentry));
d_inode          1844 fs/cifs/file.c 			len = min(server->ops->wp_retry_size(d_inode(dentry)),
d_inode          1864 fs/cifs/file.c 			spin_lock(&d_inode(dentry)->i_lock);
d_inode          1866 fs/cifs/file.c 			spin_unlock(&d_inode(dentry)->i_lock);
d_inode          1874 fs/cifs/file.c 		spin_lock(&d_inode(dentry)->i_lock);
d_inode          1875 fs/cifs/file.c 		if (*offset > d_inode(dentry)->i_size)
d_inode          1876 fs/cifs/file.c 			i_size_write(d_inode(dentry), *offset);
d_inode          1877 fs/cifs/file.c 		spin_unlock(&d_inode(dentry)->i_lock);
d_inode          1879 fs/cifs/file.c 	mark_inode_dirty_sync(d_inode(dentry));
d_inode          2049 fs/cifs/file.c 		cinode = CIFS_I(d_inode(cfile->dentry));
d_inode          2084 fs/cifs/file.c 		cinode = CIFS_I(d_inode(cfile->dentry));
d_inode          2698 fs/cifs/file.c 	struct inode *inode = d_inode(wdata->cfile->dentry);
d_inode          3055 fs/cifs/file.c 	set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(dentry->d_inode)->flags);
d_inode          4673 fs/cifs/file.c 	struct inode *inode = d_inode(cfile->dentry);
d_inode          1199 fs/cifs/inode.c 	struct inode *inode = d_inode(dentry);
d_inode          1339 fs/cifs/inode.c 	struct inode *inode = d_inode(dentry);
d_inode          1691 fs/cifs/inode.c 		spin_lock(&d_inode(direntry)->i_lock);
d_inode          1692 fs/cifs/inode.c 		i_size_write(d_inode(direntry), 0);
d_inode          1693 fs/cifs/inode.c 		clear_nlink(d_inode(direntry));
d_inode          1694 fs/cifs/inode.c 		spin_unlock(&d_inode(direntry)->i_lock);
d_inode          1697 fs/cifs/inode.c 	cifsInode = CIFS_I(d_inode(direntry));
d_inode          1708 fs/cifs/inode.c 	d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
d_inode          2011 fs/cifs/inode.c 	struct inode *inode = d_inode(dentry);
d_inode          2067 fs/cifs/inode.c 	struct inode *inode = d_inode(dentry);
d_inode          2082 fs/cifs/inode.c 	struct inode *inode = d_inode(dentry);
d_inode          2279 fs/cifs/inode.c 	struct inode *inode = d_inode(direntry);
d_inode          2424 fs/cifs/inode.c 	struct inode *inode = d_inode(direntry);
d_inode           568 fs/cifs/link.c 		cifsInode = CIFS_I(d_inode(old_file));
d_inode           570 fs/cifs/link.c 			spin_lock(&d_inode(old_file)->i_lock);
d_inode           571 fs/cifs/link.c 			inc_nlink(d_inode(old_file));
d_inode           572 fs/cifs/link.c 			spin_unlock(&d_inode(old_file)->i_lock);
d_inode           486 fs/cifs/misc.c 				pCifsInode = CIFS_I(d_inode(netfile->dentry));
d_inode           103 fs/cifs/readdir.c 		inode = d_inode(dentry);
d_inode           715 fs/cifs/smb1ops.c 	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
d_inode           124 fs/cifs/smb2file.c 	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
d_inode           262 fs/cifs/smb2file.c 	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
d_inode           529 fs/cifs/smb2misc.c 		cinode = CIFS_I(d_inode(cfile->dentry));
d_inode           693 fs/cifs/smb2misc.c 				cinode = CIFS_I(d_inode(cfile->dentry));
d_inode          1341 fs/cifs/smb2ops.c 	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
d_inode          1848 fs/cifs/smb2ops.c 	inode = d_inode(cfile->dentry);
d_inode          2966 fs/cifs/smb2ops.c 	inode = d_inode(cfile->dentry);
d_inode          3028 fs/cifs/smb2ops.c 	inode = d_inode(cfile->dentry);
d_inode          3064 fs/cifs/smb2ops.c 	inode = d_inode(cfile->dentry);
d_inode          3157 fs/cifs/smb2ops.c 	inode = d_inode(cfile->dentry);
d_inode            98 fs/coda/cache.c 		if (d_inode(de) ) 
d_inode            99 fs/coda/cache.c 			coda_flag_inode(d_inode(de), flag);
d_inode           205 fs/coda/dir.c  	struct inode *inode = d_inode(source_de);
d_inode           270 fs/coda/dir.c  	drop_nlink(d_inode(de));
d_inode           284 fs/coda/dir.c  			clear_nlink(d_inode(de));
d_inode           318 fs/coda/dir.c  			coda_flag_inode(d_inode(new_dentry), C_VATTR);
d_inode           462 fs/coda/dir.c  	inode = d_inode(de);
d_inode           468 fs/coda/dir.c  	cii = ITOC(d_inode(de));
d_inode           503 fs/coda/dir.c  	flags = (ITOC(d_inode(dentry))->c_flags) & C_PURGE;
d_inode           504 fs/coda/dir.c  	if (is_bad_inode(d_inode(dentry)) || flags) {
d_inode           257 fs/coda/inode.c 	int err = coda_revalidate_inode(d_inode(path->dentry));
d_inode           259 fs/coda/inode.c 		generic_fillattr(d_inode(path->dentry), stat);
d_inode           265 fs/coda/inode.c 	struct inode *inode = d_inode(de);
d_inode            71 fs/coda/pioctl.c 	target_inode = d_inode(path.dentry);
d_inode           903 fs/coda/upcall.c 			coda_flag_inode(d_inode(sb->s_root), C_FLUSH);
d_inode           307 fs/configfs/dir.c 	inc_nlink(d_inode(p));
d_inode           389 fs/configfs/dir.c 		simple_rmdir(d_inode(parent),d);
d_inode           650 fs/configfs/dir.c 		inode_lock(d_inode(child));
d_inode           653 fs/configfs/dir.c 		d_inode(child)->i_flags |= S_DEAD;
d_inode           656 fs/configfs/dir.c 		inode_unlock(d_inode(child));
d_inode           699 fs/configfs/dir.c 			BUG_ON(d_inode(child));
d_inode           843 fs/configfs/dir.c 			inode_lock(d_inode(dentry));
d_inode           845 fs/configfs/dir.c 			d_inode(dentry)->i_flags |= S_DEAD;
d_inode           847 fs/configfs/dir.c 			inode_unlock(d_inode(dentry));
d_inode           884 fs/configfs/dir.c 		inode_lock_nested(d_inode(dentry), I_MUTEX_CHILD);
d_inode           889 fs/configfs/dir.c 			d_inode(dentry)->i_flags |= S_DEAD;
d_inode           893 fs/configfs/dir.c 		inode_unlock(d_inode(dentry));
d_inode          1145 fs/configfs/dir.c 	inode_lock(d_inode(root));
d_inode          1157 fs/configfs/dir.c 	inode_unlock(d_inode(root));
d_inode          1240 fs/configfs/dir.c 		inode_lock(d_inode(root->cg_item.ci_dentry));
d_inode          1264 fs/configfs/dir.c 		inode_unlock(d_inode(root->cg_item.ci_dentry));
d_inode          1511 fs/configfs/dir.c 			inode_lock(d_inode(wait));
d_inode          1512 fs/configfs/dir.c 			inode_unlock(d_inode(wait));
d_inode          1583 fs/configfs/dir.c 	inode_lock(d_inode(dentry));
d_inode          1596 fs/configfs/dir.c 	inode_unlock(d_inode(dentry));
d_inode          1606 fs/configfs/dir.c 	inode_lock(d_inode(dentry));
d_inode          1610 fs/configfs/dir.c 	inode_unlock(d_inode(dentry));
d_inode          1662 fs/configfs/dir.c 			inode = d_inode(dentry);
d_inode          1761 fs/configfs/dir.c 	inode_lock_nested(d_inode(parent), I_MUTEX_PARENT);
d_inode          1769 fs/configfs/dir.c 	inode_unlock(d_inode(parent));
d_inode          1773 fs/configfs/dir.c 	inode_unlock(d_inode(parent));
d_inode          1800 fs/configfs/dir.c 	inode_lock_nested(d_inode(parent), I_MUTEX_PARENT);
d_inode          1806 fs/configfs/dir.c 	d_inode(dentry)->i_flags |= S_DEAD;
d_inode          1808 fs/configfs/dir.c 	fsnotify_rmdir(d_inode(parent), dentry);
d_inode          1810 fs/configfs/dir.c 	inode_unlock(d_inode(parent));
d_inode          1889 fs/configfs/dir.c 	inode_lock_nested(d_inode(root), I_MUTEX_PARENT);
d_inode          1899 fs/configfs/dir.c 			BUG_ON(d_inode(dentry));
d_inode          1909 fs/configfs/dir.c 	inode_unlock(d_inode(root));
d_inode          1937 fs/configfs/dir.c 	inode_lock_nested(d_inode(root),
d_inode          1939 fs/configfs/dir.c 	inode_lock_nested(d_inode(dentry), I_MUTEX_CHILD);
d_inode          1948 fs/configfs/dir.c 	d_inode(dentry)->i_flags |= S_DEAD;
d_inode          1950 fs/configfs/dir.c 	fsnotify_rmdir(d_inode(root), dentry);
d_inode          1951 fs/configfs/dir.c 	inode_unlock(d_inode(dentry));
d_inode          1955 fs/configfs/dir.c 	inode_unlock(d_inode(root));
d_inode           528 fs/configfs/file.c 	inode_lock_nested(d_inode(dir), I_MUTEX_NORMAL);
d_inode           531 fs/configfs/file.c 	inode_unlock(d_inode(dir));
d_inode           550 fs/configfs/file.c 	inode_lock_nested(dir->d_inode, I_MUTEX_NORMAL);
d_inode           553 fs/configfs/file.c 	inode_unlock(dir->d_inode);
d_inode            45 fs/configfs/inode.c 	struct inode * inode = d_inode(dentry);
d_inode           181 fs/configfs/inode.c 	p_inode = d_inode(dentry->d_parent);
d_inode           222 fs/configfs/inode.c 			simple_unlink(d_inode(parent), dentry);
d_inode           237 fs/configfs/inode.c 	inode_lock(d_inode(dir));
d_inode           250 fs/configfs/inode.c 	inode_unlock(d_inode(dir));
d_inode           197 fs/configfs/symlink.c 	if (dentry->d_inode || d_unhashed(dentry))
d_inode           385 fs/crypto/crypto.c 	err = fscrypt_get_encryption_info(d_inode(dir));
d_inode           386 fs/crypto/crypto.c 	valid = !fscrypt_has_encryption_key(d_inode(dir));
d_inode            40 fs/crypto/hooks.c 	if (IS_ENCRYPTED(d_inode(dir)) &&
d_inode            41 fs/crypto/hooks.c 	    !fscrypt_has_permitted_context(d_inode(dir), inode)) {
d_inode            44 fs/crypto/hooks.c 			     d_inode(dir)->i_ino);
d_inode            94 fs/crypto/hooks.c 						   d_inode(old_dentry)))
d_inode           100 fs/crypto/hooks.c 						   d_inode(new_dentry)))
d_inode           318 fs/dcache.c    	dentry->d_inode = inode;
d_inode           331 fs/dcache.c    	dentry->d_inode = NULL;
d_inode           359 fs/dcache.c    	__releases(dentry->d_inode->i_lock)
d_inode           361 fs/dcache.c    	struct inode *inode = dentry->d_inode;
d_inode           578 fs/dcache.c    	if (dentry->d_inode)
d_inode           667 fs/dcache.c    	struct inode *inode = dentry->d_inode;
d_inode           677 fs/dcache.c    			if (likely(inode || !dentry->d_inode))
d_inode           682 fs/dcache.c    			inode = dentry->d_inode;
d_inode          1063 fs/dcache.c    	inode = dentry->d_inode;
d_inode          1071 fs/dcache.c    		if (unlikely(inode != dentry->d_inode))
d_inode          1589 fs/dcache.c    		       dentry->d_inode ?
d_inode          1590 fs/dcache.c    		       dentry->d_inode->i_ino : 0UL,
d_inode          1653 fs/dcache.c    	if (!dentry->d_inode)
d_inode          1729 fs/dcache.c    	dentry->d_inode = NULL;
d_inode          2440 fs/dcache.c    	struct inode *inode = dentry->d_inode;
d_inode          2528 fs/dcache.c    	seq = smp_load_acquire(&parent->d_inode->i_dir_seq);
d_inode          2556 fs/dcache.c    	if (unlikely(READ_ONCE(parent->d_inode->i_dir_seq) != seq)) {
d_inode          2645 fs/dcache.c    		dir = dentry->d_parent->d_inode;
d_inode          2809 fs/dcache.c    	WARN_ON(!dentry->d_inode);
d_inode          2834 fs/dcache.c    		dir = target->d_parent->d_inode;
d_inode          2908 fs/dcache.c    	WARN_ON(!dentry1->d_inode);
d_inode          2909 fs/dcache.c    	WARN_ON(!dentry2->d_inode);
d_inode          2961 fs/dcache.c    	if (!inode_trylock_shared(alias->d_parent->d_inode))
d_inode          2963 fs/dcache.c    	m2 = &alias->d_parent->d_inode->i_rwsem;
d_inode          3096 fs/dcache.c    		if (d_unhashed(dentry) || !dentry->d_inode)
d_inode           274 fs/debugfs/file.c 	replace_fops(filp, d_inode(dentry)->i_fop);
d_inode           338 fs/debugfs/file.c 			replace_fops(filp, d_inode(dentry)->i_fop);
d_inode           151 fs/debugfs/inode.c 	struct inode *inode = d_inode(sb->s_root);
d_inode           222 fs/debugfs/inode.c 	return f(path->dentry, d_inode(path->dentry)->i_private);
d_inode           338 fs/debugfs/inode.c 	inode_lock(d_inode(parent));
d_inode           352 fs/debugfs/inode.c 		inode_unlock(d_inode(parent));
d_inode           361 fs/debugfs/inode.c 	inode_unlock(d_inode(dentry->d_parent));
d_inode           369 fs/debugfs/inode.c 	inode_unlock(d_inode(dentry->d_parent));
d_inode           405 fs/debugfs/inode.c 	fsnotify_create(d_inode(dentry->d_parent), dentry);
d_inode           523 fs/debugfs/inode.c 		d_inode(de)->i_size = file_size;
d_inode           569 fs/debugfs/inode.c 	inc_nlink(d_inode(dentry->d_parent));
d_inode           570 fs/debugfs/inode.c 	fsnotify_mkdir(d_inode(dentry->d_parent), dentry);
d_inode           611 fs/debugfs/inode.c 	inc_nlink(d_inode(dentry->d_parent));
d_inode           612 fs/debugfs/inode.c 	fsnotify_mkdir(d_inode(dentry->d_parent), dentry);
d_inode           695 fs/debugfs/inode.c 			ret = simple_rmdir(d_inode(parent), dentry);
d_inode           697 fs/debugfs/inode.c 				fsnotify_rmdir(d_inode(parent), dentry);
d_inode           699 fs/debugfs/inode.c 			simple_unlink(d_inode(parent), dentry);
d_inode           700 fs/debugfs/inode.c 			fsnotify_unlink(d_inode(parent), dentry);
d_inode           734 fs/debugfs/inode.c 	inode_lock(d_inode(parent));
d_inode           736 fs/debugfs/inode.c 	inode_unlock(d_inode(parent));
d_inode           764 fs/debugfs/inode.c 	inode_lock(d_inode(parent));
d_inode           779 fs/debugfs/inode.c 			inode_unlock(d_inode(parent));
d_inode           800 fs/debugfs/inode.c 	inode_unlock(d_inode(parent));
d_inode           803 fs/debugfs/inode.c 	inode_lock(d_inode(parent));
d_inode           811 fs/debugfs/inode.c 	inode_unlock(d_inode(parent));
d_inode           863 fs/debugfs/inode.c 	error = simple_rename(d_inode(old_dir), old_dentry, d_inode(new_dir),
d_inode           870 fs/debugfs/inode.c 	fsnotify_move(d_inode(old_dir), d_inode(new_dir), &old_name.name,
d_inode           334 fs/devpts/inode.c 	inode_lock(d_inode(root));
d_inode           371 fs/devpts/inode.c 	inode_unlock(d_inode(root));
d_inode           379 fs/devpts/inode.c 		inode = d_inode(fsi->ptmx_dentry);
d_inode           590 fs/devpts/inode.c 		fsnotify_create(d_inode(root), dentry);
d_inode           623 fs/devpts/inode.c 	drop_nlink(dentry->d_inode);
d_inode           624 fs/devpts/inode.c 	fsnotify_unlink(d_inode(dentry->d_parent), dentry);
d_inode          1120 fs/ecryptfs/crypto.c 	struct inode *lower_inode = d_inode(lower_dentry);
d_inode          1305 fs/ecryptfs/crypto.c 		ecryptfs_i_size_init(page_virt, d_inode(ecryptfs_dentry));
d_inode          1404 fs/ecryptfs/crypto.c 	struct inode *ecryptfs_inode = d_inode(ecryptfs_dentry);
d_inode            43 fs/ecryptfs/dentry.c 		struct inode *inode = d_inode(dentry);
d_inode           129 fs/ecryptfs/file.c 	struct inode *inode = d_inode(dentry);
d_inode            29 fs/ecryptfs/inode.c 	inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
d_inode            35 fs/ecryptfs/inode.c 	inode_unlock(d_inode(dir));
d_inode           118 fs/ecryptfs/inode.c 	struct inode *inode = ecryptfs_get_inode(d_inode(lower_dentry), sb);
d_inode           136 fs/ecryptfs/inode.c 	lower_dir_inode = d_inode(lower_dir_dentry);
d_inode           183 fs/ecryptfs/inode.c 	rc = vfs_create(d_inode(lower_dir_dentry), lower_dentry, mode, true);
d_inode           190 fs/ecryptfs/inode.c 	inode = __ecryptfs_get_inode(d_inode(lower_dentry),
d_inode           193 fs/ecryptfs/inode.c 		vfs_unlink(d_inode(lower_dir_dentry), lower_dentry, NULL);
d_inode           196 fs/ecryptfs/inode.c 	fsstack_copy_attr_times(directory_inode, d_inode(lower_dir_dentry));
d_inode           197 fs/ecryptfs/inode.c 	fsstack_copy_inode_size(directory_inode, d_inode(lower_dir_dentry));
d_inode           333 fs/ecryptfs/inode.c 	fsstack_copy_attr_atime(d_inode(dentry->d_parent),
d_inode           334 fs/ecryptfs/inode.c 				d_inode(path->dentry));
d_inode           347 fs/ecryptfs/inode.c 	lower_inode = READ_ONCE(lower_dentry->d_inode);
d_inode           433 fs/ecryptfs/inode.c 	file_size_save = i_size_read(d_inode(old_dentry));
d_inode           439 fs/ecryptfs/inode.c 	rc = vfs_link(lower_old_dentry, d_inode(lower_dir_dentry),
d_inode           446 fs/ecryptfs/inode.c 	fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
d_inode           447 fs/ecryptfs/inode.c 	fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
d_inode           448 fs/ecryptfs/inode.c 	set_nlink(d_inode(old_dentry),
d_inode           449 fs/ecryptfs/inode.c 		  ecryptfs_inode_to_lower(d_inode(old_dentry))->i_nlink);
d_inode           450 fs/ecryptfs/inode.c 	i_size_write(d_inode(new_dentry), file_size_save);
d_inode           460 fs/ecryptfs/inode.c 	return ecryptfs_do_unlink(dir, dentry, d_inode(dentry));
d_inode           484 fs/ecryptfs/inode.c 	rc = vfs_symlink(d_inode(lower_dir_dentry), lower_dentry,
d_inode           492 fs/ecryptfs/inode.c 	fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
d_inode           493 fs/ecryptfs/inode.c 	fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
d_inode           510 fs/ecryptfs/inode.c 	rc = vfs_mkdir(d_inode(lower_dir_dentry), lower_dentry, mode);
d_inode           516 fs/ecryptfs/inode.c 	fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
d_inode           517 fs/ecryptfs/inode.c 	fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
d_inode           518 fs/ecryptfs/inode.c 	set_nlink(dir, d_inode(lower_dir_dentry)->i_nlink);
d_inode           535 fs/ecryptfs/inode.c 	lower_dir_inode = d_inode(lower_dir_dentry);
d_inode           546 fs/ecryptfs/inode.c 		clear_nlink(d_inode(dentry));
d_inode           566 fs/ecryptfs/inode.c 	rc = vfs_mknod(d_inode(lower_dir_dentry), lower_dentry, mode, dev);
d_inode           572 fs/ecryptfs/inode.c 	fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
d_inode           573 fs/ecryptfs/inode.c 	fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
d_inode           603 fs/ecryptfs/inode.c 	target_inode = d_inode(new_dentry);
d_inode           622 fs/ecryptfs/inode.c 	rc = vfs_rename(d_inode(lower_old_dir_dentry), lower_old_dentry,
d_inode           623 fs/ecryptfs/inode.c 			d_inode(lower_new_dir_dentry), lower_new_dentry,
d_inode           630 fs/ecryptfs/inode.c 	fsstack_copy_attr_all(new_dir, d_inode(lower_new_dir_dentry));
d_inode           632 fs/ecryptfs/inode.c 		fsstack_copy_attr_all(old_dir, d_inode(lower_old_dir_dentry));
d_inode           673 fs/ecryptfs/inode.c 	fsstack_copy_attr_atime(d_inode(dentry),
d_inode           674 fs/ecryptfs/inode.c 				d_inode(ecryptfs_dentry_to_lower(dentry)));
d_inode           729 fs/ecryptfs/inode.c 	struct inode *inode = d_inode(dentry);
d_inode           742 fs/ecryptfs/inode.c 	crypt_stat = &ecryptfs_inode_to_private(d_inode(dentry))->crypt_stat;
d_inode           849 fs/ecryptfs/inode.c 	rc = ecryptfs_inode_newsize_ok(d_inode(dentry), new_length);
d_inode           857 fs/ecryptfs/inode.c 		inode_lock(d_inode(lower_dentry));
d_inode           859 fs/ecryptfs/inode.c 		inode_unlock(d_inode(lower_dentry));
d_inode           891 fs/ecryptfs/inode.c 	crypt_stat = &ecryptfs_inode_to_private(d_inode(dentry))->crypt_stat;
d_inode           897 fs/ecryptfs/inode.c 	inode = d_inode(dentry);
d_inode           961 fs/ecryptfs/inode.c 	inode_lock(d_inode(lower_dentry));
d_inode           963 fs/ecryptfs/inode.c 	inode_unlock(d_inode(lower_dentry));
d_inode           978 fs/ecryptfs/inode.c 	generic_fillattr(d_inode(dentry), stat);
d_inode          1004 fs/ecryptfs/inode.c 		fsstack_copy_attr_all(d_inode(dentry),
d_inode          1005 fs/ecryptfs/inode.c 				      ecryptfs_inode_to_lower(d_inode(dentry)));
d_inode          1006 fs/ecryptfs/inode.c 		generic_fillattr(d_inode(dentry), stat);
d_inode          1021 fs/ecryptfs/inode.c 	if (!(d_inode(lower_dentry)->i_opflags & IOP_XATTR)) {
d_inode          1027 fs/ecryptfs/inode.c 		fsstack_copy_attr_all(inode, d_inode(lower_dentry));
d_inode          1065 fs/ecryptfs/inode.c 	if (!d_inode(lower_dentry)->i_op->listxattr) {
d_inode          1069 fs/ecryptfs/inode.c 	inode_lock(d_inode(lower_dentry));
d_inode          1070 fs/ecryptfs/inode.c 	rc = d_inode(lower_dentry)->i_op->listxattr(lower_dentry, list, size);
d_inode          1071 fs/ecryptfs/inode.c 	inode_unlock(d_inode(lower_dentry));
d_inode           133 fs/ecryptfs/kthread.c 	flags |= IS_RDONLY(d_inode(lower_dentry)) ? O_RDONLY : O_RDWR;
d_inode           534 fs/ecryptfs/main.c 	if (check_ruid && !uid_eq(d_inode(path.dentry)->i_uid, current_uid())) {
d_inode           538 fs/ecryptfs/main.c 			i_uid_read(d_inode(path.dentry)),
d_inode           571 fs/ecryptfs/main.c 	inode = ecryptfs_get_inode(d_inode(path.dentry), s);
d_inode           409 fs/ecryptfs/mmap.c 	struct inode *lower_inode = d_inode(lower_dentry);
d_inode           124 fs/efivarfs/inode.c 	struct efivar_entry *var = d_inode(dentry)->i_private;
d_inode           129 fs/efivarfs/inode.c 	drop_nlink(d_inode(dentry));
d_inode           144 fs/efivarfs/super.c 	inode = efivarfs_get_inode(sb, d_inode(root), S_IFREG | 0644, 0,
d_inode           115 fs/efs/namei.c 	ino = efs_find_entry(d_inode(child), "..", 2);
d_inode           299 fs/erofs/inode.c 	struct inode *const inode = d_inode(path->dentry);
d_inode           595 fs/erofs/xattr.c 	ret = inline_xattr_iter_begin(&it->it, d_inode(it->dentry));
d_inode           611 fs/erofs/xattr.c 	struct inode *const inode = d_inode(it->dentry);
d_inode           651 fs/erofs/xattr.c 	ret = init_inode_xattrs(d_inode(dentry));
d_inode          1538 fs/exec.c      	inode = bprm->file->f_path.dentry->d_inode;
d_inode            53 fs/exportfs/expfs.c 	inode = result->d_inode;
d_inode           129 fs/exportfs/expfs.c 	inode_lock(dentry->d_inode);
d_inode           132 fs/exportfs/expfs.c 	inode_unlock(dentry->d_inode);
d_inode           136 fs/exportfs/expfs.c 			__func__, dentry->d_inode->i_ino, PTR_ERR(parent));
d_inode           141 fs/exportfs/expfs.c 		dentry->d_inode->i_ino, parent->d_inode->i_ino);
d_inode           280 fs/exportfs/expfs.c 	struct inode *dir = path->dentry->d_inode;
d_inode           402 fs/exportfs/expfs.c 	struct inode *inode = dentry->d_inode, *parent = NULL;
d_inode           410 fs/exportfs/expfs.c 		parent = p->d_inode;
d_inode           527 fs/exportfs/expfs.c 		inode_lock(target_dir->d_inode);
d_inode           530 fs/exportfs/expfs.c 			if (unlikely(nresult->d_inode != result->d_inode)) {
d_inode           535 fs/exportfs/expfs.c 		inode_unlock(target_dir->d_inode);
d_inode           463 fs/ext2/dir.c  	struct inode *dir = d_inode(dentry->d_parent);
d_inode           278 fs/ext2/ialloc.c 	if ((parent == d_inode(sb->s_root)) ||
d_inode          1647 fs/ext2/inode.c 	struct inode *inode = d_inode(path->dentry);
d_inode          1672 fs/ext2/inode.c 	struct inode *inode = d_inode(dentry);
d_inode            81 fs/ext2/namei.c 	unsigned long ino = ext2_inode_by_name(d_inode(child), &dotdot);
d_inode           201 fs/ext2/namei.c 	struct inode *inode = d_inode(old_dentry);
d_inode           270 fs/ext2/namei.c 	struct inode * inode = d_inode(dentry);
d_inode           298 fs/ext2/namei.c 	struct inode * inode = d_inode(dentry);
d_inode           316 fs/ext2/namei.c 	struct inode * old_inode = d_inode(old_dentry);
d_inode           317 fs/ext2/namei.c 	struct inode * new_inode = d_inode(new_dentry);
d_inode          1599 fs/ext2/super.c 	inode = d_inode(path->dentry);
d_inode           290 fs/ext2/xattr.c 	struct inode *inode = d_inode(dentry);
d_inode           679 fs/ext4/dir.c  	const struct inode *inode = READ_ONCE(parent->d_inode);
d_inode           695 fs/ext4/dir.c  	const struct inode *inode = READ_ONCE(dentry->d_inode);
d_inode            59 fs/ext4/fsync.c 		next = igrab(d_inode(dentry->d_parent));
d_inode           448 fs/ext4/ialloc.c 	    ((parent == d_inode(sb->s_root)) ||
d_inode          5543 fs/ext4/inode.c 	struct inode *inode = d_inode(dentry);
d_inode          5735 fs/ext4/inode.c 	struct inode *inode = d_inode(path->dentry);
d_inode          5771 fs/ext4/inode.c 	struct inode *inode = d_inode(path->dentry);
d_inode           473 fs/ext4/migrate.c 	tmp_inode = ext4_new_inode(handle, d_inode(inode->i_sb->s_root),
d_inode          1740 fs/ext4/namei.c 	bh = ext4_find_entry(d_inode(child), &dotdot, &de, NULL);
d_inode          1749 fs/ext4/namei.c 		EXT4_ERROR_INODE(d_inode(child),
d_inode          2164 fs/ext4/namei.c 	struct inode *dir = d_inode(dentry->d_parent);
d_inode          3081 fs/ext4/namei.c 	retval = dquot_initialize(d_inode(dentry));
d_inode          3092 fs/ext4/namei.c 	inode = d_inode(dentry);
d_inode          3169 fs/ext4/namei.c 	retval = dquot_initialize(d_inode(dentry));
d_inode          3180 fs/ext4/namei.c 	inode = d_inode(dentry);
d_inode          3366 fs/ext4/namei.c 	struct inode *inode = d_inode(old_dentry);
d_inode          3378 fs/ext4/namei.c 			EXT4_I(old_dentry->d_inode)->i_projid)))
d_inode          3649 fs/ext4/namei.c 		.inode = d_inode(old_dentry),
d_inode          3654 fs/ext4/namei.c 		.inode = d_inode(new_dentry),
d_inode          3670 fs/ext4/namei.c 			EXT4_I(old_dentry->d_inode)->i_projid)))
d_inode          3855 fs/ext4/namei.c 		.inode = d_inode(old_dentry),
d_inode          3860 fs/ext4/namei.c 		.inode = d_inode(new_dentry),
d_inode          3868 fs/ext4/namei.c 			EXT4_I(old_dentry->d_inode)->i_projid)) ||
d_inode          3871 fs/ext4/namei.c 			EXT4_I(new_dentry->d_inode)->i_projid)))
d_inode          1977 fs/ext4/super.c 		journal_inode = d_inode(path.dentry);
d_inode          5658 fs/ext4/super.c 	if (ext4_test_inode_flag(dentry->d_inode, EXT4_INODE_PROJINHERIT) &&
d_inode          5660 fs/ext4/super.c 		ext4_statfs_project(sb, EXT4_I(dentry->d_inode)->i_projid, buf);
d_inode          5751 fs/ext4/super.c 	handle = ext4_journal_start(d_inode(sb->s_root), EXT4_HT_QUOTA, 2);
d_inode          5820 fs/ext4/super.c 	    ext4_should_journal_data(d_inode(path->dentry))) {
d_inode          5832 fs/ext4/super.c 	lockdep_set_quota_inode(path->dentry->d_inode, I_DATA_SEM_QUOTA);
d_inode          5835 fs/ext4/super.c 		lockdep_set_quota_inode(path->dentry->d_inode,
d_inode          5838 fs/ext4/super.c 		struct inode *inode = d_inode(path->dentry);
d_inode           691 fs/ext4/xattr.c 	struct inode *inode = d_inode(dentry);
d_inode           721 fs/ext4/xattr.c 	struct inode *inode = d_inode(dentry);
d_inode           764 fs/ext4/xattr.c 	down_read(&EXT4_I(d_inode(dentry))->xattr_sem);
d_inode           777 fs/ext4/xattr.c 	up_read(&EXT4_I(d_inode(dentry))->xattr_sem);
d_inode          1430 fs/ext4/xattr.c 	ea_inode = ext4_new_inode(handle, inode->i_sb->s_root->d_inode,
d_inode          1072 fs/f2fs/dir.c  	const struct inode *inode = READ_ONCE(parent->d_inode);
d_inode          1087 fs/f2fs/dir.c  	const struct inode *inode = READ_ONCE(dentry->d_inode);
d_inode          3011 fs/f2fs/f2fs.h 	return f2fs_do_add_link(d_inode(dentry->d_parent), &dentry->d_name,
d_inode           708 fs/f2fs/file.c 	struct inode *inode = d_inode(path->dentry);
d_inode           775 fs/f2fs/file.c 	struct inode *inode = d_inode(dentry);
d_inode           317 fs/f2fs/namei.c 	struct inode *inode = d_inode(old_dentry);
d_inode           332 fs/f2fs/namei.c 			F2FS_I(old_dentry->d_inode)->i_projid)))
d_inode           367 fs/f2fs/namei.c 	unsigned long ino = f2fs_inode_by_name(d_inode(child), &dotdot, &page);
d_inode           515 fs/f2fs/namei.c 	struct inode *inode = d_inode(dentry);
d_inode           709 fs/f2fs/namei.c 	struct inode *inode = d_inode(dentry);
d_inode           850 fs/f2fs/namei.c 	struct inode *old_inode = d_inode(old_dentry);
d_inode           851 fs/f2fs/namei.c 	struct inode *new_inode = d_inode(new_dentry);
d_inode           868 fs/f2fs/namei.c 			F2FS_I(old_dentry->d_inode)->i_projid)))
d_inode          1045 fs/f2fs/namei.c 	struct inode *old_inode = d_inode(old_dentry);
d_inode          1046 fs/f2fs/namei.c 	struct inode *new_inode = d_inode(new_dentry);
d_inode          1061 fs/f2fs/namei.c 			F2FS_I(old_dentry->d_inode)->i_projid)) ||
d_inode          1064 fs/f2fs/namei.c 			F2FS_I(new_dentry->d_inode)->i_projid)))
d_inode          1292 fs/f2fs/super.c 	if (is_inode_flag_set(dentry->d_inode, FI_PROJ_INHERIT) &&
d_inode          1294 fs/f2fs/super.c 		f2fs_statfs_project(sb, F2FS_I(dentry->d_inode)->i_projid, buf);
d_inode          2064 fs/f2fs/super.c 	inode = d_inode(path->dentry);
d_inode           541 fs/f2fs/xattr.c 	struct inode *inode = d_inode(dentry);
d_inode           411 fs/fat/file.c  	struct inode *inode = d_inode(path->dentry);
d_inode           483 fs/fat/file.c  	struct inode *inode = d_inode(dentry);
d_inode           313 fs/fat/namei_msdos.c 	struct inode *inode = d_inode(dentry);
d_inode           403 fs/fat/namei_msdos.c 	struct inode *inode = d_inode(dentry);
d_inode           441 fs/fat/namei_msdos.c 	old_inode = d_inode(old_dentry);
d_inode           442 fs/fat/namei_msdos.c 	new_inode = d_inode(new_dentry);
d_inode            50 fs/fat/namei_vfat.c 	if (!inode_eq_iversion(d_inode(dentry->d_parent), vfat_d_version(dentry)))
d_inode           794 fs/fat/namei_vfat.c 	struct inode *inode = d_inode(dentry);
d_inode           825 fs/fat/namei_vfat.c 	struct inode *inode = d_inode(dentry);
d_inode           912 fs/fat/namei_vfat.c 	old_inode = d_inode(old_dentry);
d_inode           913 fs/fat/namei_vfat.c 	new_inode = d_inode(new_dentry);
d_inode           270 fs/fat/nfs.c   	if (!fat_get_dotdot_entry(d_inode(child_dir), &bh, &de)) {
d_inode           198 fs/file_table.c 	file->f_inode = path->dentry->d_inode;
d_inode           199 fs/file_table.c 	file->f_mapping = path->dentry->d_inode->i_mapping;
d_inode           210 fs/file_table.c 		i_readcount_inc(path->dentry->d_inode);
d_inode           272 fs/fuse/control.c 	inc_nlink(d_inode(parent));
d_inode           311 fs/fuse/control.c 		d_inode(dentry)->i_private = NULL;
d_inode           318 fs/fuse/control.c 	drop_nlink(d_inode(fuse_control_sb->s_root));
d_inode           231 fs/fuse/dir.c  		fuse_lookup_init(fc, &args, get_node_id(d_inode(parent)),
d_inode           267 fs/fuse/dir.c  			fuse_advise_use_readdirplus(d_inode(parent));
d_inode           714 fs/fuse/dir.c  		struct inode *inode = d_inode(entry);
d_inode           750 fs/fuse/dir.c  		clear_nlink(d_inode(entry));
d_inode           782 fs/fuse/dir.c  		fuse_invalidate_attr(d_inode(oldent));
d_inode           783 fs/fuse/dir.c  		fuse_update_ctime(d_inode(oldent));
d_inode           786 fs/fuse/dir.c  			fuse_invalidate_attr(d_inode(newent));
d_inode           787 fs/fuse/dir.c  			fuse_update_ctime(d_inode(newent));
d_inode           796 fs/fuse/dir.c  			fuse_invalidate_attr(d_inode(newent));
d_inode           798 fs/fuse/dir.c  			fuse_update_ctime(d_inode(newent));
d_inode           849 fs/fuse/dir.c  	struct inode *inode = d_inode(entry);
d_inode          1036 fs/fuse/dir.c  		inode_lock(d_inode(entry));
d_inode          1037 fs/fuse/dir.c  		if (get_node_id(d_inode(entry)) != child_nodeid) {
d_inode          1051 fs/fuse/dir.c  			d_inode(entry)->i_flags |= S_DEAD;
d_inode          1054 fs/fuse/dir.c  		clear_nlink(d_inode(entry));
d_inode          1057 fs/fuse/dir.c  		inode_unlock(d_inode(entry));
d_inode          1493 fs/fuse/dir.c  	struct inode *inode = d_inode(dentry);
d_inode          1629 fs/fuse/dir.c  	struct inode *inode = d_inode(entry);
d_inode          1689 fs/fuse/dir.c  	struct inode *inode = d_inode(path->dentry);
d_inode           427 fs/fuse/inode.c 	args.nodeid = get_node_id(d_inode(dentry));
d_inode           779 fs/fuse/inode.c 	struct inode *child_inode = d_inode(child);
d_inode           158 fs/fuse/readdir.c 	struct inode *dir = d_inode(parent);
d_inode           202 fs/fuse/readdir.c 		inode = d_inode(dentry);
d_inode           109 fs/fuse/xattr.c 	struct inode *inode = d_inode(entry);
d_inode            48 fs/gfs2/dentry.c 	sdp = GFS2_SB(d_inode(parent));
d_inode            49 fs/gfs2/dentry.c 	dip = GFS2_I(d_inode(parent));
d_inode            50 fs/gfs2/dentry.c 	inode = d_inode(dentry);
d_inode            70 fs/gfs2/dentry.c 	error = gfs2_dir_check(d_inode(parent), &dentry->d_name, ip);
d_inode            93 fs/gfs2/dentry.c 	ginode = GFS2_I(d_inode(dentry));
d_inode            49 fs/gfs2/export.c 	if (!parent || inode == d_inode(sb->s_root))
d_inode            88 fs/gfs2/export.c 	struct inode *dir = d_inode(parent);
d_inode            89 fs/gfs2/export.c 	struct inode *inode = d_inode(child);
d_inode           128 fs/gfs2/export.c 	return d_obtain_alias(gfs2_lookupi(d_inode(child), &gfs2_qdotdot, 1));
d_inode           292 fs/gfs2/inode.c 	     dir == d_inode(sb->s_root))) {
d_inode           690 fs/gfs2/inode.c 	if ((GFS2_I(d_inode(sdp->sd_root_dir)) == dip) ||
d_inode           898 fs/gfs2/inode.c 	struct inode *inode = d_inode(old_dentry);
d_inode          1065 fs/gfs2/inode.c 	struct inode *inode = d_inode(dentry);
d_inode          1101 fs/gfs2/inode.c 	struct inode *inode = d_inode(dentry);
d_inode          1288 fs/gfs2/inode.c 		if (dir == d_inode(sb->s_root)) {
d_inode          1348 fs/gfs2/inode.c 	struct gfs2_inode *ip = GFS2_I(d_inode(odentry));
d_inode          1362 fs/gfs2/inode.c 		nip = GFS2_I(d_inode(ndentry));
d_inode          1500 fs/gfs2/inode.c 		error = gfs2_permission(d_inode(odentry), MAY_WRITE);
d_inode          1591 fs/gfs2/inode.c 	struct gfs2_inode *oip = GFS2_I(odentry->d_inode);
d_inode          1592 fs/gfs2/inode.c 	struct gfs2_inode *nip = GFS2_I(ndentry->d_inode);
d_inode          1662 fs/gfs2/inode.c 		error = gfs2_permission(odentry->d_inode, MAY_WRITE);
d_inode          1667 fs/gfs2/inode.c 		error = gfs2_permission(ndentry->d_inode, MAY_WRITE);
d_inode          1939 fs/gfs2/inode.c 	struct inode *inode = d_inode(dentry);
d_inode          1996 fs/gfs2/inode.c 	struct inode *inode = d_inode(path->dentry);
d_inode           645 fs/gfs2/ops_fstype.c 	struct inode *master = d_inode(sdp->sd_master_dir);
d_inode           782 fs/gfs2/ops_fstype.c 	struct inode *master = d_inode(sdp->sd_master_dir);
d_inode           848 fs/gfs2/ops_fstype.c 	struct inode *master = d_inode(sdp->sd_master_dir);
d_inode           400 fs/gfs2/xattr.c 	struct gfs2_inode *ip = GFS2_I(d_inode(dentry));
d_inode           256 fs/hfs/dir.c   	struct inode *inode = d_inode(dentry);
d_inode           298 fs/hfs/dir.c   	res = hfs_cat_move(d_inode(old_dentry)->i_ino,
d_inode           303 fs/hfs/dir.c   				  (btree_key *)&HFS_I(d_inode(old_dentry))->cat_key,
d_inode           606 fs/hfs/inode.c 	struct inode *inode = d_inode(dentry);
d_inode            24 fs/hfs/sysdep.c 	inode = d_inode(dentry);
d_inode            85 fs/hfsplus/dir.c 					HFSPLUS_I(d_inode(sb->s_root))->
d_inode           304 fs/hfsplus/dir.c 	struct inode *inode = d_inode(src_dentry);
d_inode           305 fs/hfsplus/dir.c 	struct inode *src_dir = d_inode(src_dentry->d_parent);
d_inode           361 fs/hfsplus/dir.c 	struct inode *inode = d_inode(dentry);
d_inode           418 fs/hfsplus/dir.c 	struct inode *inode = d_inode(dentry);
d_inode           246 fs/hfsplus/inode.c 	struct inode *inode = d_inode(dentry);
d_inode           276 fs/hfsplus/inode.c 	struct inode *inode = d_inode(path->dentry);
d_inode            30 fs/hfsplus/ioctl.c 	struct inode *inode = d_inode(dentry);
d_inode           611 fs/hfsplus/xattr.c 	struct inode *inode = d_inode(dentry);
d_inode           679 fs/hfsplus/xattr.c 	struct inode *inode = d_inode(dentry);
d_inode           790 fs/hostfs/hostfs_kern.c 	struct inode *inode = d_inode(dentry);
d_inode           262 fs/hpfs/inode.c 	struct inode *inode = d_inode(dentry);
d_inode           377 fs/hpfs/namei.c 	struct inode *inode = d_inode(dentry);
d_inode           428 fs/hpfs/namei.c 	struct inode *inode = d_inode(dentry);
d_inode           518 fs/hpfs/namei.c 	struct inode *i = d_inode(old_dentry);
d_inode           519 fs/hpfs/namei.c 	struct inode *new_inode = d_inode(new_dentry);
d_inode           696 fs/hugetlbfs/inode.c 	struct inode *inode = d_inode(dentry);
d_inode           964 fs/hugetlbfs/inode.c 	struct hstate *h = hstate_inode(d_inode(dentry));
d_inode          1741 fs/inode.c     	struct inode *inode = d_inode(path->dentry);
d_inode          1777 fs/inode.c     	umode_t mode = d_inode(dentry)->i_mode;
d_inode          1805 fs/inode.c     	struct inode *inode = d_inode(dentry);
d_inode            48 fs/isofs/export.c 	struct inode *child_inode = d_inode(child);
d_inode           228 fs/jffs2/dir.c 	struct jffs2_inode_info *dead_f = JFFS2_INODE_INFO(d_inode(dentry));
d_inode           235 fs/jffs2/dir.c 		set_nlink(d_inode(dentry), dead_f->inocache->pino_nlink);
d_inode           246 fs/jffs2/dir.c 	struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry));
d_inode           260 fs/jffs2/dir.c 	type = (d_inode(old_dentry)->i_mode & S_IFMT) >> 12;
d_inode           268 fs/jffs2/dir.c 		set_nlink(d_inode(old_dentry), ++f->inocache->pino_nlink);
d_inode           270 fs/jffs2/dir.c 		d_instantiate(dentry, d_inode(old_dentry));
d_inode           272 fs/jffs2/dir.c 		ihold(d_inode(old_dentry));
d_inode           588 fs/jffs2/dir.c 	struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(dentry));
d_inode           602 fs/jffs2/dir.c 		clear_nlink(d_inode(dentry));
d_inode           774 fs/jffs2/dir.c 		victim_f = JFFS2_INODE_INFO(d_inode(new_dentry));
d_inode           797 fs/jffs2/dir.c 	type = (d_inode(old_dentry)->i_mode & S_IFMT) >> 12;
d_inode           802 fs/jffs2/dir.c 			    d_inode(old_dentry)->i_ino, type,
d_inode           811 fs/jffs2/dir.c 			clear_nlink(d_inode(new_dentry));
d_inode           813 fs/jffs2/dir.c 			drop_nlink(d_inode(new_dentry));
d_inode           839 fs/jffs2/dir.c 		struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry));
d_inode           841 fs/jffs2/dir.c 		inc_nlink(d_inode(old_dentry));
d_inode           195 fs/jffs2/fs.c  	struct inode *inode = d_inode(dentry);
d_inode           142 fs/jffs2/super.c 	f = JFFS2_INODE_INFO(d_inode(child));
d_inode           963 fs/jffs2/xattr.c 	struct inode *inode = d_inode(dentry);
d_inode            90 fs/jfs/file.c  	struct inode *inode = d_inode(dentry);
d_inode           336 fs/jfs/namei.c 	struct inode *ip = d_inode(dentry);
d_inode           466 fs/jfs/namei.c 	struct inode *ip = d_inode(dentry);
d_inode           789 fs/jfs/namei.c 	struct inode *ip = d_inode(old_dentry);
d_inode           880 fs/jfs/namei.c 	struct inode *ip = d_inode(dentry);
d_inode          1094 fs/jfs/namei.c 	old_ip = d_inode(old_dentry);
d_inode          1095 fs/jfs/namei.c 	new_ip = d_inode(new_dentry);
d_inode          1507 fs/jfs/namei.c 		le32_to_cpu(JFS_IP(d_inode(dentry))->i_dtroot.header.idotdot);
d_inode           850 fs/jfs/super.c 	inode = d_inode(path->dentry);
d_inode           857 fs/jfs/xattr.c 	struct inode *inode = d_inode(dentry);
d_inode           115 fs/kernfs/inode.c 	struct inode *inode = d_inode(dentry);
d_inode           148 fs/kernfs/inode.c 	return simple_xattr_list(d_inode(dentry), &attrs->xattrs, buf, size);
d_inode           187 fs/kernfs/inode.c 	struct inode *inode = d_inode(path->dentry);
d_inode            79 fs/kernfs/kernfs-internal.h 	return d_inode(dentry)->i_private;
d_inode            30 fs/libfs.c     	struct inode *inode = d_inode(path->dentry);
d_inode           151 fs/libfs.c     		inode_lock_shared(dentry->d_inode);
d_inode           166 fs/libfs.c     		inode_unlock_shared(dentry->d_inode);
d_inode           204 fs/libfs.c     			      d_inode(next)->i_ino, dt_type(d_inode(next))))
d_inode           323 fs/libfs.c     	struct inode *inode = d_inode(old_dentry);
d_inode           357 fs/libfs.c     	struct inode *inode = d_inode(dentry);
d_inode           371 fs/libfs.c     	drop_nlink(d_inode(dentry));
d_inode           382 fs/libfs.c     	struct inode *inode = d_inode(old_dentry);
d_inode           394 fs/libfs.c     			drop_nlink(d_inode(new_dentry));
d_inode           425 fs/libfs.c     	struct inode *inode = d_inode(dentry);
d_inode          1232 fs/libfs.c     	struct inode *inode = d_inode(path->dentry);
d_inode           155 fs/minix/dir.c 	struct inode * dir = d_inode(dentry->d_parent);
d_inode           202 fs/minix/dir.c 	struct inode *dir = d_inode(dentry->d_parent);
d_inode            27 fs/minix/file.c 	struct inode *inode = d_inode(dentry);
d_inode           626 fs/minix/inode.c 	struct inode *inode = d_inode(path->dentry);
d_inode           104 fs/minix/namei.c 	struct inode *inode = d_inode(old_dentry);
d_inode           151 fs/minix/namei.c 	struct inode * inode = d_inode(dentry);
d_inode           171 fs/minix/namei.c 	struct inode * inode = d_inode(dentry);
d_inode           188 fs/minix/namei.c 	struct inode * old_inode = d_inode(old_dentry);
d_inode           189 fs/minix/namei.c 	struct inode * new_inode = d_inode(new_dentry);
d_inode           686 fs/namei.c     	BUG_ON(nd->inode != parent->d_inode);
d_inode           844 fs/namei.c     		nd->inode = d->d_inode;
d_inode           852 fs/namei.c     		nd->inode = nd->path.dentry->d_inode;
d_inode           868 fs/namei.c     	nd->inode = nd->path.dentry->d_inode;
d_inode           981 fs/namei.c     	struct inode *inode = link->dentry->d_inode;
d_inode          1155 fs/namei.c     	    path->dentry->d_inode)
d_inode          1338 fs/namei.c     		*inode = path->dentry->d_inode;
d_inode          1356 fs/namei.c     			inode = parent->d_inode;
d_inode          1369 fs/namei.c     			struct inode *inode2 = mountpoint->d_inode;
d_inode          1391 fs/namei.c     		inode = nd->path.dentry->d_inode;
d_inode          1489 fs/namei.c     	nd->inode = nd->path.dentry->d_inode;
d_inode          1526 fs/namei.c     	struct inode *dir = base->d_inode;
d_inode          1640 fs/namei.c     	struct inode *inode = dir->d_inode;
d_inode          1678 fs/namei.c     	struct inode *inode = dir->d_inode;
d_inode          2177 fs/namei.c     		struct inode *inode = root->d_inode;
d_inode          2210 fs/namei.c     				nd->inode = nd->path.dentry->d_inode;
d_inode          2215 fs/namei.c     			nd->inode = nd->path.dentry->d_inode;
d_inode          2235 fs/namei.c     			nd->inode = nd->path.dentry->d_inode;
d_inode          2239 fs/namei.c     			nd->inode = nd->path.dentry->d_inode;
d_inode          2413 fs/namei.c     	inode_lock_nested(path->dentry->d_inode, I_MUTEX_PARENT);
d_inode          2416 fs/namei.c     		inode_unlock(path->dentry->d_inode);
d_inode          2478 fs/namei.c     	return inode_permission(base->d_inode, MAY_EXEC);
d_inode          2500 fs/namei.c     	WARN_ON_ONCE(!inode_is_locked(base->d_inode));
d_inode          2527 fs/namei.c     	WARN_ON_ONCE(!inode_is_locked(base->d_inode));
d_inode          2790 fs/namei.c     	BUG_ON(victim->d_parent->d_inode != dir);
d_inode          2834 fs/namei.c     	if (child->d_inode)
d_inode          2853 fs/namei.c     		inode_lock_nested(p1->d_inode, I_MUTEX_PARENT);
d_inode          2861 fs/namei.c     		inode_lock_nested(p2->d_inode, I_MUTEX_PARENT);
d_inode          2862 fs/namei.c     		inode_lock_nested(p1->d_inode, I_MUTEX_CHILD);
d_inode          2868 fs/namei.c     		inode_lock_nested(p1->d_inode, I_MUTEX_PARENT);
d_inode          2869 fs/namei.c     		inode_lock_nested(p2->d_inode, I_MUTEX_CHILD);
d_inode          2873 fs/namei.c     	inode_lock_nested(p1->d_inode, I_MUTEX_PARENT);
d_inode          2874 fs/namei.c     	inode_lock_nested(p2->d_inode, I_MUTEX_PARENT2);
d_inode          2881 fs/namei.c     	inode_unlock(p1->d_inode);
d_inode          2883 fs/namei.c     		inode_unlock(p2->d_inode);
d_inode          2914 fs/namei.c     	struct inode *dir = dentry->d_parent->d_inode;
d_inode          2940 fs/namei.c     	struct inode *inode = dentry->d_inode;
d_inode          2988 fs/namei.c     	struct inode *inode = path->dentry->d_inode;
d_inode          3026 fs/namei.c     	error = inode_permission(dir->dentry->d_inode, MAY_WRITE | MAY_EXEC);
d_inode          3030 fs/namei.c     	return security_inode_create(dir->dentry->d_inode, dentry, mode);
d_inode          3052 fs/namei.c     	struct inode *dir =  nd->path.dentry->d_inode;
d_inode          3124 fs/namei.c     	struct inode *dir_inode = dir->d_inode;
d_inode          3154 fs/namei.c     	if (dentry->d_inode) {
d_inode          3169 fs/namei.c     		if (!IS_POSIXACL(dir->d_inode))
d_inode          3218 fs/namei.c     	if (!dentry->d_inode && (open_flag & O_CREAT)) {
d_inode          3231 fs/namei.c     	if (unlikely(create_error) && !dentry->d_inode) {
d_inode          3284 fs/namei.c     		BUG_ON(nd->inode != dir->d_inode);
d_inode          3314 fs/namei.c     		inode_lock(dir->d_inode);
d_inode          3316 fs/namei.c     		inode_lock_shared(dir->d_inode);
d_inode          3319 fs/namei.c     		inode_unlock(dir->d_inode);
d_inode          3321 fs/namei.c     		inode_unlock_shared(dir->d_inode);
d_inode          3431 fs/namei.c     	struct inode *dir = dentry->d_inode;
d_inode          3450 fs/namei.c     	inode = child->d_inode;
d_inode          3629 fs/namei.c     	inode_lock_nested(path->dentry->d_inode, I_MUTEX_PARENT);
d_inode          3658 fs/namei.c     	inode_unlock(path->dentry->d_inode);
d_inode          3678 fs/namei.c     	inode_unlock(path->dentry->d_inode);
d_inode          3752 fs/namei.c     	if (!IS_POSIXACL(path.dentry->d_inode))
d_inode          3759 fs/namei.c     			error = vfs_create(path.dentry->d_inode,dentry,mode,true);
d_inode          3764 fs/namei.c     			error = vfs_mknod(path.dentry->d_inode,dentry,mode,
d_inode          3768 fs/namei.c     			error = vfs_mknod(path.dentry->d_inode,dentry,mode,0);
d_inode          3829 fs/namei.c     	if (!IS_POSIXACL(path.dentry->d_inode))
d_inode          3833 fs/namei.c     		error = vfs_mkdir(path.dentry->d_inode, dentry, mode);
d_inode          3863 fs/namei.c     	inode_lock(dentry->d_inode);
d_inode          3878 fs/namei.c     	dentry->d_inode->i_flags |= S_DEAD;
d_inode          3884 fs/namei.c     	inode_unlock(dentry->d_inode);
d_inode          3923 fs/namei.c     	inode_lock_nested(path.dentry->d_inode, I_MUTEX_PARENT);
d_inode          3928 fs/namei.c     	if (!dentry->d_inode) {
d_inode          3935 fs/namei.c     	error = vfs_rmdir(path.dentry->d_inode, dentry);
d_inode          3939 fs/namei.c     	inode_unlock(path.dentry->d_inode);
d_inode          3976 fs/namei.c     	struct inode *target = dentry->d_inode;
d_inode          4044 fs/namei.c     	inode_lock_nested(path.dentry->d_inode, I_MUTEX_PARENT);
d_inode          4051 fs/namei.c     		inode = dentry->d_inode;
d_inode          4058 fs/namei.c     		error = vfs_unlink(path.dentry->d_inode, dentry, &delegated_inode);
d_inode          4062 fs/namei.c     	inode_unlock(path.dentry->d_inode);
d_inode          4149 fs/namei.c     		error = vfs_symlink(path.dentry->d_inode, dentry, from->name);
d_inode          4192 fs/namei.c     	struct inode *inode = old_dentry->d_inode;
d_inode          4304 fs/namei.c     	error = vfs_link(old_path.dentry, new_path.dentry->d_inode, new_dentry, &delegated_inode);
d_inode          4392 fs/namei.c     	struct inode *source = old_dentry->d_inode;
d_inode          4393 fs/namei.c     	struct inode *target = new_dentry->d_inode;
d_inode          4622 fs/namei.c     	error = vfs_rename(old_path.dentry->d_inode, old_dentry,
d_inode          4623 fs/namei.c     			   new_path.dentry->d_inode, new_dentry,
d_inode          4712 fs/namei.c     	struct inode *inode = d_inode(dentry);
d_inode          4755 fs/namei.c     	struct inode *inode = d_inode(dentry);
d_inode          4806 fs/namei.c     				page_get_link(dentry, d_inode(dentry),
d_inode          1745 fs/namespace.c 	mnt_ns = to_mnt_ns(get_proc_ns(dentry->d_inode));
d_inode          2134 fs/namespace.c 	inode_lock(dentry->d_inode);
d_inode          2136 fs/namespace.c 		inode_unlock(dentry->d_inode);
d_inode          2145 fs/namespace.c 			inode_unlock(dentry->d_inode);
d_inode          2151 fs/namespace.c 	inode_unlock(path->dentry->d_inode);
d_inode          2167 fs/namespace.c 	inode_unlock(dentry->d_inode);
d_inode          3887 fs/namespace.c 			struct inode *inode = child->mnt_mountpoint->d_inode;
d_inode           399 fs/nfs/dir.c   	inode = d_inode(dentry);
d_inode           463 fs/nfs/dir.c   	struct inode *dir = d_inode(parent);
d_inode           503 fs/nfs/dir.c   			status = nfs_refresh_inode(d_inode(dentry), entry->fattr);
d_inode           505 fs/nfs/dir.c   				nfs_setsecurity(d_inode(dentry), entry->fattr, entry->label);
d_inode           854 fs/nfs/dir.c   	struct inode	*inode = d_inode(dentry);
d_inode          1210 fs/nfs/dir.c   	inode = d_inode(dentry);
d_inode          1273 fs/nfs/dir.c   		ret = reval(d_inode(parent), dentry, flags);
d_inode          1295 fs/nfs/dir.c   	struct inode *inode = d_inode(dentry);
d_inode          1330 fs/nfs/dir.c   	if (d_really_is_positive(dentry) && NFS_STALE(d_inode(dentry)))
d_inode          1508 fs/nfs/dir.c   	if (S_ISREG(file->f_path.dentry->d_inode->i_mode))
d_inode          1531 fs/nfs/dir.c   	BUG_ON(d_inode(dentry));
d_inode          1651 fs/nfs/dir.c   	inode = d_inode(dentry);
d_inode          1699 fs/nfs/dir.c   	struct inode *dir = d_inode(parent);
d_inode          1849 fs/nfs/dir.c   		down_write(&NFS_I(d_inode(dentry))->rmdir_sem);
d_inode          1854 fs/nfs/dir.c   			clear_nlink(d_inode(dentry));
d_inode          1859 fs/nfs/dir.c   		up_write(&NFS_I(d_inode(dentry))->rmdir_sem);
d_inode          1877 fs/nfs/dir.c   	struct inode *dir = d_inode(dentry->d_parent);
d_inode          1878 fs/nfs/dir.c   	struct inode *inode = d_inode(dentry);
d_inode          1921 fs/nfs/dir.c   		write_inode_now(d_inode(dentry), 0);
d_inode          1998 fs/nfs/dir.c   	if (!add_to_page_cache_lru(page, d_inode(dentry)->i_mapping, 0,
d_inode          2017 fs/nfs/dir.c   	struct inode *inode = d_inode(old_dentry);
d_inode          2063 fs/nfs/dir.c   	struct inode *old_inode = d_inode(old_dentry);
d_inode          2064 fs/nfs/dir.c   	struct inode *new_inode = d_inode(new_dentry);
d_inode           129 fs/nfs/export.c 	struct inode *inode = d_inode(dentry), *pinode;
d_inode            55 fs/nfs/getroot.c 		spin_lock(&d_inode(sb->s_root)->i_lock);
d_inode            59 fs/nfs/getroot.c 		spin_unlock(&d_inode(sb->s_root)->i_lock);
d_inode           587 fs/nfs/inode.c 	struct inode *inode = d_inode(dentry);
d_inode           750 fs/nfs/inode.c 	if (!nfs_server_capable(d_inode(dentry), NFS_CAP_READDIRPLUS))
d_inode           753 fs/nfs/inode.c 	nfs_force_use_readdirplus(d_inode(parent));
d_inode           761 fs/nfs/inode.c 	if (!nfs_server_capable(d_inode(dentry), NFS_CAP_READDIRPLUS))
d_inode           764 fs/nfs/inode.c 	nfs_advise_use_readdirplus(d_inode(parent));
d_inode           781 fs/nfs/inode.c 	struct inode *inode = d_inode(path->dentry);
d_inode           878 fs/nfs/inode.c 	struct inode *inode = d_inode(ctx->dentry);
d_inode           910 fs/nfs/inode.c 	struct inode *inode = d_inode(ctx->dentry);
d_inode           940 fs/nfs/inode.c 	inode = d_inode(ctx->dentry);
d_inode           996 fs/nfs/inode.c 	struct inode *inode = d_inode(ctx->dentry);
d_inode          1033 fs/nfs/inode.c 	struct inode *inode = d_inode(ctx->dentry);
d_inode          1081 fs/nfs/inode.c 		struct inode *inode = d_inode(ctx->dentry);
d_inode           143 fs/nfs/namespace.c 	struct nfs_server *server = NFS_SERVER(d_inode(path->dentry));
d_inode           174 fs/nfs/namespace.c 	if (NFS_FH(d_inode(path->dentry))->size != 0)
d_inode           176 fs/nfs/namespace.c 	generic_fillattr(d_inode(path->dentry), stat);
d_inode           183 fs/nfs/namespace.c 	if (NFS_FH(d_inode(dentry))->size != 0)
d_inode           266 fs/nfs/namespace.c 	err = server->nfs_client->rpc_ops->lookup(d_inode(parent), &dentry->d_name, fh, fattr, NULL);
d_inode           330 fs/nfs/nfs3acl.c 	struct inode *inode = d_inode(dentry);
d_inode           125 fs/nfs/nfs3proc.c 	struct inode *inode = d_inode(dentry);
d_inode           379 fs/nfs/nfs3proc.c 		nfs_post_op_update_inode(d_inode(dentry), data->res.fattr);
d_inode           385 fs/nfs/nfs3proc.c 	status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl);
d_inode           580 fs/nfs/nfs3proc.c 	status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl);
d_inode           634 fs/nfs/nfs3proc.c 	struct inode		*dir = d_inode(dentry);
d_inode           731 fs/nfs/nfs3proc.c 	status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl);
d_inode          1222 fs/nfs/nfs4client.c 	struct inode *inode = d_inode(server->super->s_root);
d_inode            58 fs/nfs/nfs4file.c 	dir = d_inode(parent);
d_inode            86 fs/nfs/nfs4file.c 	if (inode != d_inode(dentry))
d_inode           375 fs/nfs/nfs4namespace.c 	err = nfs4_proc_fs_locations(client, d_inode(parent), &dentry->d_name, fs_locations, page);
d_inode           394 fs/nfs/nfs4namespace.c 	struct inode *dir = d_inode(parent);
d_inode           342 fs/nfs/nfs4proc.c 		p = xdr_encode_hyper(p, NFS_FILEID(d_inode(dentry)));
d_inode           355 fs/nfs/nfs4proc.c 	p = xdr_encode_hyper(p, NFS_FILEID(d_inode(dentry->d_parent)));
d_inode          1274 fs/nfs/nfs4proc.c 	struct inode *dir = d_inode(parent);
d_inode          1350 fs/nfs/nfs4proc.c 		p->o_arg.fh = NFS_FH(d_inode(dentry));
d_inode          1953 fs/nfs/nfs4proc.c 		inode = d_inode(data->dentry);
d_inode          2323 fs/nfs/nfs4proc.c 	struct nfs_server *server = NFS_SERVER(d_inode(data->dir));
d_inode          2485 fs/nfs/nfs4proc.c 	struct inode *dir = d_inode(data->dir);
d_inode          2535 fs/nfs/nfs4proc.c 	struct inode *dir = d_inode(data->dir);
d_inode          2603 fs/nfs/nfs4proc.c 	struct inode *dir = d_inode(data->dir);
d_inode          2965 fs/nfs/nfs4proc.c 	struct inode *dir = d_inode(opendata->dir);
d_inode          3022 fs/nfs/nfs4proc.c 	if (d_inode(dentry) == state->inode) {
d_inode          3068 fs/nfs/nfs4proc.c 		nfs4_return_incompatible_delegation(d_inode(dentry), fmode);
d_inode          3094 fs/nfs/nfs4proc.c 		opendata->state = nfs4_get_open_state(d_inode(dentry), sp);
d_inode          4131 fs/nfs/nfs4proc.c 	struct inode *inode = d_inode(dentry);
d_inode          4515 fs/nfs/nfs4proc.c 	struct inode *inode = d_inode(dentry);
d_inode          4596 fs/nfs/nfs4proc.c 	struct inode *old_inode = d_inode(old_dentry);
d_inode          4597 fs/nfs/nfs4proc.c 	struct inode *new_inode = d_inode(new_dentry);
d_inode          4870 fs/nfs/nfs4proc.c 	struct inode		*dir = d_inode(dentry);
d_inode          4876 fs/nfs/nfs4proc.c 		.bitmask = NFS_SERVER(d_inode(dentry))->attr_bitmask,
d_inode          4915 fs/nfs/nfs4proc.c 		trace_nfs4_readdir(d_inode(dentry), err);
d_inode          4916 fs/nfs/nfs4proc.c 		err = nfs4_handle_exception(NFS_SERVER(d_inode(dentry)), err,
d_inode          6802 fs/nfs/nfs4proc.c 		renew_lease(NFS_SERVER(d_inode(data->ctx->dentry)),
d_inode          7324 fs/nfs/nfs4proc.c 	return nfs4_server_supports_acls(NFS_SERVER(d_inode(dentry)));
d_inode          9992 fs/nfs/nfs4proc.c 	error2 = nfs4_listxattr_nfs4_label(d_inode(dentry), list, size);
d_inode          2064 fs/nfs/nfs4state.c 	inode = d_inode(server->super->s_root);
d_inode          2183 fs/nfs/nfs4state.c 		inode = d_inode(server->super->s_root);
d_inode           657 fs/nfs/nfs4trace.h 			__entry->dir = NFS_FILEID(d_inode(ctx->dentry->d_parent));
d_inode          1717 fs/nfs/nfs4trace.h 			const struct inode *inode = d_inode(ctx->dentry);
d_inode           802 fs/nfs/nfstrace.h 			struct inode *dir = d_inode(data->dentry->d_parent);
d_inode           118 fs/nfs/pagelist.c 	struct inode *inode = d_inode(l_ctx->open_context->dentry);
d_inode           429 fs/nfs/pagelist.c 				rpc_wake_up(&NFS_SERVER(d_inode(ctx->dentry))->uoc_rpcwaitq);
d_inode           926 fs/nfs/pagelist.c 		flctx = d_inode(nfs_req_openctx(req)->dentry)->i_flctx;
d_inode           965 fs/nfs/pnfs.c  		server = NFS_SERVER(parent_dir->d_inode);
d_inode          2168 fs/nfs/pnfs.c  	struct inode *ino = data->dentry->d_inode;
d_inode          2221 fs/nfs/pnfs.c  	struct nfs_server *server = NFS_SERVER(data->dir->d_inode);
d_inode          2227 fs/nfs/pnfs.c  	if (!nfs_server_capable(data->dir->d_inode, NFS_CAP_LGOPEN))
d_inode           466 fs/nfs/pnfs.h  	struct inode *inode = d_inode(nfs_req_openctx(req)->dentry);
d_inode           478 fs/nfs/pnfs.h  	struct inode *inode = d_inode(nfs_req_openctx(req)->dentry);
d_inode           123 fs/nfs/proc.c  	struct inode *inode = d_inode(dentry);
d_inode           496 fs/nfs/proc.c  	struct inode		*dir = d_inode(dentry);
d_inode            96 fs/nfs/read.c  	struct inode *inode = d_inode(nfs_req_openctx(req)->dentry);
d_inode           447 fs/nfs/super.c 	struct nfs_fh *fh = NFS_FH(d_inode(dentry));
d_inode           460 fs/nfs/super.c 		nfs_zap_caches(d_inode(pd_dentry));
d_inode          2630 fs/nfs/super.c 	if (d_inode(mntroot)->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops)
d_inode            49 fs/nfs/unlink.c 	struct inode *dir = d_inode(data->dentry->d_parent);
d_inode            69 fs/nfs/unlink.c 	up_read_non_owner(&NFS_I(d_inode(dentry->d_parent))->rmdir_sem);
d_inode            79 fs/nfs/unlink.c 	struct inode *dir = d_inode(data->dentry->d_parent);
d_inode           104 fs/nfs/unlink.c 	struct inode *dir = d_inode(data->dentry->d_parent);
d_inode           119 fs/nfs/unlink.c 	struct inode *dir = d_inode(dentry->d_parent);
d_inode           286 fs/nfs/unlink.c 		nfs_mark_for_revalidate(d_inode(data->old_dentry));
d_inode           437 fs/nfs/unlink.c 	struct inode *inode = d_inode(dentry);
d_inode           451 fs/nfs/unlink.c 	fileid = NFS_FILEID(d_inode(dentry));
d_inode           473 fs/nfs/unlink.c 	} while (d_inode(sdentry) != NULL); /* need negative lookup */
d_inode           970 fs/nfs/write.c 		struct inode *inode = d_inode(ctx->dentry);
d_inode          1749 fs/nfs/write.c 	struct inode *inode = d_inode(ctx->dentry);
d_inode          1855 fs/nfs/write.c 			(unsigned long long)NFS_FILEID(d_inode(nfs_req_openctx(req)->dentry)),
d_inode           617 fs/nfsd/export.c 		err = check_export(d_inode(exp.ex_path.dentry), &exp.ex_flags,
d_inode           908 fs/nfsd/export.c 	inode = d_inode(path.dentry);
d_inode           802 fs/nfsd/filecache.c 	inode = d_inode(fhp->fh_dentry);
d_inode            47 fs/nfsd/nfs2acl.c 	inode = d_inode(fh->fh_dentry);
d_inode           108 fs/nfsd/nfs2acl.c 	inode = d_inode(fh->fh_dentry);
d_inode           278 fs/nfsd/nfs2acl.c 	inode = d_inode(dentry);
d_inode            44 fs/nfsd/nfs3acl.c 	inode = d_inode(fh->fh_dentry);
d_inode            99 fs/nfsd/nfs3acl.c 	inode = d_inode(fh->fh_dentry);
d_inode           179 fs/nfsd/nfs3acl.c 		struct inode *inode = d_inode(dentry);
d_inode           220 fs/nfsd/nfs3xdr.c 			lease_get_mtime(d_inode(dentry), &stat.mtime);
d_inode           271 fs/nfsd/nfs3xdr.c 	inode = d_inode(fhp->fh_dentry);
d_inode           299 fs/nfsd/nfs3xdr.c 						     d_inode(fhp->fh_dentry));
d_inode           303 fs/nfsd/nfs3xdr.c 		fhp->fh_post_attr.ctime = d_inode(fhp->fh_dentry)->i_ctime;
d_inode           659 fs/nfsd/nfs3xdr.c 		lease_get_mtime(d_inode(resp->fh.fh_dentry),
d_inode           873 fs/nfsd/nfs3xdr.c 	if (dchild->d_inode->i_ino != ino)
d_inode           132 fs/nfsd/nfs4acl.c 	struct inode *inode = d_inode(dentry);
d_inode           771 fs/nfsd/nfs4acl.c 	inode = d_inode(dentry);
d_inode            57 fs/nfsd/nfs4proc.c 	struct inode *inode = d_inode(resfh->fh_dentry);
d_inode           104 fs/nfsd/nfs4proc.c 	if ((bmval[0] & FATTR4_WORD0_ACL) && !IS_POSIXACL(d_inode(dentry)))
d_inode           200 fs/nfsd/nfs4proc.c 	umode_t mode = d_inode(fh->fh_dentry)->i_mode;
d_inode          1663 fs/nfsd/nfs4proc.c 	nfserr = ops->proc_layoutget(d_inode(current_fh->fh_dentry),
d_inode          1704 fs/nfsd/nfs4proc.c 	inode = d_inode(current_fh->fh_dentry);
d_inode           227 fs/nfsd/nfs4recover.c 	inode_lock(d_inode(dir));
d_inode           244 fs/nfsd/nfs4recover.c 	status = vfs_mkdir(d_inode(dir), dentry, S_IRWXU);
d_inode           248 fs/nfsd/nfs4recover.c 	inode_unlock(d_inode(dir));
d_inode           319 fs/nfsd/nfs4recover.c 	inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
d_inode           335 fs/nfsd/nfs4recover.c 	inode_unlock(d_inode(dir));
d_inode           355 fs/nfsd/nfs4recover.c 	inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
d_inode           364 fs/nfsd/nfs4recover.c 	status = vfs_rmdir(d_inode(dir), dentry);
d_inode           368 fs/nfsd/nfs4recover.c 	inode_unlock(d_inode(dir));
d_inode           454 fs/nfsd/nfs4recover.c 	status = vfs_rmdir(d_inode(parent), child);
d_inode          5614 fs/nfsd/nfs4state.c 	struct inode *ino = d_inode(fhp->fh_dentry);
d_inode          6374 fs/nfsd/nfs4state.c 	struct inode *inode = d_inode(cstate->current_fh.fh_dentry);
d_inode          2482 fs/nfsd/nfs4xdr.c 			err = security_inode_getsecctx(d_inode(dentry),
d_inode          2511 fs/nfsd/nfs4xdr.c 		if (!IS_POSIXACL(dentry->d_inode))
d_inode          2557 fs/nfsd/nfs4xdr.c 		p = encode_change(p, &stat, d_inode(dentry), exp);
d_inode          2659 fs/nfsd/nfs4xdr.c 		*p++ = cpu_to_be32(IS_POSIXACL(dentry->d_inode) ?
d_inode          2832 fs/nfsd/nfs4xdr.c 		p = encode_time_delta(p, d_inode(dentry));
d_inode          2905 fs/nfsd/nfs4xdr.c 		if (IS_I_VERSION(d_inode(dentry)))
d_inode          1193 fs/nfsd/nfsctl.c 	struct inode *dir = parent->d_inode;
d_inode          1201 fs/nfsd/nfsctl.c 	ret = __nfsd_mkdir(d_inode(parent), dentry, S_IFDIR | 0600, ncl);
d_inode          1244 fs/nfsd/nfsctl.c 	clear_ncl(d_inode(dentry));
d_inode          1261 fs/nfsd/nfsctl.c 		nfsdfs_remove_file(d_inode(root), dentry);
d_inode          1270 fs/nfsd/nfsctl.c 	struct inode *dir = d_inode(root);
d_inode          1282 fs/nfsd/nfsctl.c 		inode = nfsd_get_inode(d_inode(root)->i_sb,
d_inode          1326 fs/nfsd/nfsctl.c 	struct inode *dir = d_inode(dentry->d_parent);
d_inode          1327 fs/nfsd/nfsctl.c 	struct inode *inode = d_inode(dentry);
d_inode            42 fs/nfsd/nfsfh.c 		err = inode_permission(d_inode(parent), MAY_EXEC);
d_inode            66 fs/nfsd/nfsfh.c 	umode_t mode = d_inode(dentry)->i_mode & S_IFMT;
d_inode           432 fs/nfsd/nfsfh.c 	fh->ofh_ino = ino_t_to_u32(d_inode(dentry)->i_ino);
d_inode           433 fs/nfsd/nfsfh.c 	fh->ofh_generation = d_inode(dentry)->i_generation;
d_inode           540 fs/nfsd/nfsfh.c 	struct inode * inode = d_inode(dentry);
d_inode           545 fs/nfsd/nfsfh.c 		(long) d_inode(exp->ex_path.dentry)->i_ino,
d_inode           578 fs/nfsd/nfsfh.c 			ino_t_to_u32(d_inode(exp->ex_path.dentry)->i_ino);
d_inode           590 fs/nfsd/nfsfh.c 			d_inode(exp->ex_path.dentry)->i_ino,
d_inode           298 fs/nfsd/nfsfh.h 	inode = d_inode(dentry);
d_inode           318 fs/nfsd/nfsfh.h 		inode_unlock(d_inode(fhp->fh_dentry));
d_inode           299 fs/nfsd/nfsproc.c 	inode = d_inode(newfhp->fh_dentry);
d_inode           177 fs/nfsd/nfsxdr.c 	lease_get_mtime(d_inode(dentry), &time); 
d_inode           157 fs/nfsd/vfs.c  	if (!d_inode(dentry))
d_inode           295 fs/nfsd/vfs.c  	struct inode *inode = d_inode(fhp->fh_dentry);
d_inode           335 fs/nfsd/vfs.c  	struct inode *inode = d_inode(fhp->fh_dentry);
d_inode           410 fs/nfsd/vfs.c  	inode = d_inode(dentry);
d_inode           494 fs/nfsd/vfs.c  	struct inode *inode = d_inode(dentry);
d_inode           520 fs/nfsd/vfs.c  	inode_lock(d_inode(dentry));
d_inode           522 fs/nfsd/vfs.c  	inode_unlock(d_inode(dentry));
d_inode           719 fs/nfsd/vfs.c  	inode = d_inode(path.dentry);
d_inode          1169 fs/nfsd/vfs.c  	dirp = d_inode(dentry);
d_inode          1334 fs/nfsd/vfs.c  	dirp = d_inode(dentry);
d_inode          1395 fs/nfsd/vfs.c  			if (   d_inode(dchild)->i_mtime.tv_sec == v_mtime
d_inode          1396 fs/nfsd/vfs.c  			    && d_inode(dchild)->i_atime.tv_sec == v_atime
d_inode          1397 fs/nfsd/vfs.c  			    && d_inode(dchild)->i_size  == 0 ) {
d_inode          1404 fs/nfsd/vfs.c  			if (   d_inode(dchild)->i_mtime.tv_sec == v_mtime
d_inode          1405 fs/nfsd/vfs.c  			    && d_inode(dchild)->i_atime.tv_sec == v_atime
d_inode          1406 fs/nfsd/vfs.c  			    && d_inode(dchild)->i_size  == 0 ) {
d_inode          1543 fs/nfsd/vfs.c  	host_err = vfs_symlink(d_inode(dentry), dnew, path);
d_inode          1599 fs/nfsd/vfs.c  	dirp = d_inode(ddir);
d_inode          1638 fs/nfsd/vfs.c  	struct inode *inode = d_inode(dentry);
d_inode          1648 fs/nfsd/vfs.c  	struct inode *inode = d_inode(dentry);
d_inode          1677 fs/nfsd/vfs.c  	fdir = d_inode(fdentry);
d_inode          1680 fs/nfsd/vfs.c  	tdir = d_inode(tdentry);
d_inode          1798 fs/nfsd/vfs.c  	dirp = d_inode(dentry);
d_inode          1812 fs/nfsd/vfs.c  		type = d_inode(rdentry)->i_mode & S_IFMT;
d_inode          2017 fs/nfsd/vfs.c  	struct inode	*inode = d_inode(dentry);
d_inode           719 fs/nfsd/xdr4.h 	cinfo->change_supported = IS_I_VERSION(d_inode(fhp->fh_dentry));
d_inode           440 fs/nilfs2/dir.c 	struct inode *dir = d_inode(dentry->d_parent);
d_inode           819 fs/nilfs2/inode.c 	struct inode *inode = d_inode(dentry);
d_inode           179 fs/nilfs2/namei.c 	struct inode *inode = d_inode(old_dentry);
d_inode           269 fs/nilfs2/namei.c 	inode = d_inode(dentry);
d_inode           304 fs/nilfs2/namei.c 		nilfs_mark_inode_dirty(d_inode(dentry));
d_inode           314 fs/nilfs2/namei.c 	struct inode *inode = d_inode(dentry);
d_inode           345 fs/nilfs2/namei.c 	struct inode *old_inode = d_inode(old_dentry);
d_inode           346 fs/nilfs2/namei.c 	struct inode *new_inode = d_inode(new_dentry);
d_inode           443 fs/nilfs2/namei.c 	ino = nilfs_inode_by_name(d_inode(child), &dotdot);
d_inode           447 fs/nilfs2/namei.c 	root = NILFS_I(d_inode(child))->i_root;
d_inode           590 fs/nilfs2/super.c 	struct nilfs_root *root = NILFS_I(d_inode(dentry))->i_root;
d_inode           660 fs/nilfs2/super.c 	struct nilfs_root *root = NILFS_I(d_inode(dentry))->i_root;
d_inode          1167 fs/nilfs2/super.c 		root = NILFS_I(d_inode(sb->s_root))->i_root;
d_inode           281 fs/notify/fanotify/fanotify.c 		return d_inode(((struct path *)data)->dentry);
d_inode           570 fs/notify/fanotify/fanotify_user.c 	ret = inode_permission(path->dentry->d_inode, MAY_READ);
d_inode          1068 fs/notify/fanotify/fanotify_user.c 		inode = path.dentry->d_inode;
d_inode           130 fs/notify/fsnotify.c 			if (!child->d_inode)
d_inode           159 fs/notify/fsnotify.c 	p_inode = parent->d_inode;
d_inode           175 fs/notify/fsnotify.c 			ret = fsnotify(p_inode, mask, dentry->d_inode, FSNOTIFY_EVENT_INODE,
d_inode           344 fs/notify/inotify/inotify_user.c 	error = inode_permission(path->dentry->d_inode, MAY_READ);
d_inode           751 fs/notify/inotify/inotify_user.c 	inode = path.dentry->d_inode;
d_inode            25 fs/nsfs.c      	struct inode *inode = d_inode(dentry);
d_inode            34 fs/nsfs.c      	struct inode *inode = d_inode(dentry);
d_inode           250 fs/nsfs.c      	struct inode *inode = d_inode(dentry);
d_inode          2860 fs/ntfs/inode.c 	struct inode *vi = d_inode(dentry);
d_inode           288 fs/ntfs/namei.c 	struct inode *vi = d_inode(child_dent);
d_inode            31 fs/ocfs2/dcache.c 		OCFS2_I(d_inode(dentry->d_parent))->ip_dir_lock_gen;
d_inode            32 fs/ocfs2/dcache.c 	BUG_ON(d_inode(dentry));
d_inode            46 fs/ocfs2/dcache.c 	inode = d_inode(dentry);
d_inode            60 fs/ocfs2/dcache.c 		pgen = OCFS2_I(d_inode(dentry->d_parent))->ip_dir_lock_gen;
d_inode           135 fs/ocfs2/dcache.c 	parent = d_inode(dentry->d_parent);
d_inode           447 fs/ocfs2/dcache.c 	struct inode *inode = d_inode(dentry);
d_inode            61 fs/ocfs2/dir.h 	return __ocfs2_add_entry(handle, d_inode(dentry->d_parent),
d_inode           196 fs/ocfs2/dlmfs/dlmfs.c 	struct inode *inode = d_inode(dentry);
d_inode           528 fs/ocfs2/dlmfs/dlmfs.c 	struct inode *inode = d_inode(dentry);
d_inode           136 fs/ocfs2/export.c 	struct inode *dir = d_inode(child);
d_inode          1119 fs/ocfs2/file.c 	struct inode *inode = d_inode(dentry);
d_inode          1304 fs/ocfs2/file.c 	struct inode *inode = d_inode(path->dentry);
d_inode          2166 fs/ocfs2/file.c 	struct inode *inode = d_inode(dentry);
d_inode          1251 fs/ocfs2/inode.c 	struct inode *inode = d_inode(dentry);
d_inode           678 fs/ocfs2/namei.c 	struct inode *inode = d_inode(old_dentry);
d_inode           679 fs/ocfs2/namei.c 	struct inode *old_dir = d_inode(old_dentry->d_parent);
d_inode           872 fs/ocfs2/namei.c 	struct inode *inode = d_inode(dentry);
d_inode           895 fs/ocfs2/namei.c 	BUG_ON(d_inode(dentry->d_parent) != dir);
d_inode          1200 fs/ocfs2/namei.c 	struct inode *old_inode = d_inode(old_dentry);
d_inode          1201 fs/ocfs2/namei.c 	struct inode *new_inode = d_inode(new_dentry);
d_inode          1461 fs/ocfs2/namei.c 		BUG_ON(d_inode(new_dentry->d_parent) != new_dir);
d_inode          4183 fs/ocfs2/refcounttree.c 	struct inode *inode = d_inode(old_dentry);
d_inode          4252 fs/ocfs2/refcounttree.c 	struct inode *inode = d_inode(old_dentry);
d_inode          4361 fs/ocfs2/refcounttree.c 	struct inode *inode = d_inode(old_dentry);
d_inode          4450 fs/ocfs2/refcounttree.c 				  d_inode(new_path.dentry),
d_inode          1033 fs/ocfs2/xattr.c 	struct ocfs2_inode_info *oi = OCFS2_I(d_inode(dentry));
d_inode          1041 fs/ocfs2/xattr.c 	ret = ocfs2_inode_lock(d_inode(dentry), &di_bh, 0);
d_inode          1050 fs/ocfs2/xattr.c 	i_ret = ocfs2_xattr_ibody_list(d_inode(dentry), di, buffer, size);
d_inode          1058 fs/ocfs2/xattr.c 		b_ret = ocfs2_xattr_block_list(d_inode(dentry), di,
d_inode          1064 fs/ocfs2/xattr.c 	ocfs2_inode_unlock(d_inode(dentry), 0);
d_inode           113 fs/omfs/dir.c  	struct inode *dir = d_inode(dentry->d_parent);
d_inode           158 fs/omfs/dir.c  	struct inode *dir = d_inode(dentry->d_parent);
d_inode           240 fs/omfs/dir.c  	struct inode *inode = d_inode(dentry);
d_inode           376 fs/omfs/dir.c  	struct inode *new_inode = d_inode(new_dentry);
d_inode           377 fs/omfs/dir.c  	struct inode *old_inode = d_inode(old_dentry);
d_inode           349 fs/omfs/file.c 	struct inode *inode = d_inode(dentry);
d_inode            62 fs/open.c      	inode_lock(dentry->d_inode);
d_inode            65 fs/open.c      	inode_unlock(dentry->d_inode);
d_inode            74 fs/open.c      	inode = path->dentry->d_inode;
d_inode           175 fs/open.c      	inode = dentry->d_inode;
d_inode           463 fs/open.c      	error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
d_inode           516 fs/open.c      	error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
d_inode           546 fs/open.c      	struct inode *inode = path->dentry->d_inode;
d_inode           622 fs/open.c      	struct inode *inode = path->dentry->d_inode;
d_inode            19 fs/orangefs/dcache.c 	struct inode *parent_inode = parent_dentry->d_inode;
d_inode            21 fs/orangefs/dcache.c 	struct inode *inode = dentry->d_inode;
d_inode           110 fs/orangefs/dcache.c 	if (dentry->d_inode && is_root_handle(dentry->d_inode))
d_inode           121 fs/orangefs/dcache.c 	if (!dentry->d_inode) {
d_inode           130 fs/orangefs/dcache.c 	ret = orangefs_inode_check_changed(dentry->d_inode);
d_inode            90 fs/orangefs/dir.c 	    get_interruptible_flag(dentry->d_inode));
d_inode           313 fs/orangefs/dir.c 	oi = ORANGEFS_I(dentry->d_inode);
d_inode           929 fs/orangefs/inode.c 	ret = __orangefs_setattr(d_inode(dentry), iattr);
d_inode           930 fs/orangefs/inode.c 	sync_inode_metadata(d_inode(dentry), 1);
d_inode           944 fs/orangefs/inode.c 	struct inode *inode = path->dentry->d_inode;
d_inode           174 fs/orangefs/namei.c 	struct inode *inode = dentry->d_inode;
d_inode           413 fs/orangefs/namei.c 				get_interruptible_flag(old_dentry->d_inode));
d_inode           419 fs/orangefs/namei.c 	if (new_dentry->d_inode)
d_inode           420 fs/orangefs/namei.c 		new_dentry->d_inode->i_ctime = current_time(new_dentry->d_inode);
d_inode           408 fs/orangefs/xattr.c 	struct inode *inode = dentry->d_inode;
d_inode            46 fs/overlayfs/copy_up.c 	if (!(old->d_inode->i_opflags & IOP_XATTR) ||
d_inode            47 fs/overlayfs/copy_up.c 	    !(new->d_inode->i_opflags & IOP_XATTR))
d_inode           335 fs/overlayfs/copy_up.c 	struct inode *dir = d_inode(indexdir);
d_inode           353 fs/overlayfs/copy_up.c 	if (WARN_ON(ovl_test_flag(OVL_INDEX, d_inode(dentry))))
d_inode           405 fs/overlayfs/copy_up.c 	struct inode *udir = d_inode(upperdir);
d_inode           485 fs/overlayfs/copy_up.c 	inode_lock(temp->d_inode);
d_inode           490 fs/overlayfs/copy_up.c 	inode_unlock(temp->d_inode);
d_inode           530 fs/overlayfs/copy_up.c 	struct inode *udir = d_inode(c->destdir), *wdir = d_inode(c->workdir);
d_inode           577 fs/overlayfs/copy_up.c 		ovl_set_upperdata(d_inode(c->dentry));
d_inode           578 fs/overlayfs/copy_up.c 	inode = d_inode(c->dentry);
d_inode           596 fs/overlayfs/copy_up.c 	struct inode *udir = d_inode(c->destdir);
d_inode           629 fs/overlayfs/copy_up.c 		ovl_set_upperdata(d_inode(c->dentry));
d_inode           630 fs/overlayfs/copy_up.c 	ovl_inode_update(d_inode(c->dentry), temp);
d_inode           698 fs/overlayfs/copy_up.c 		ovl_set_flag(OVL_INDEX, d_inode(c->dentry));
d_inode           704 fs/overlayfs/copy_up.c 		struct inode *udir = d_inode(c->destdir);
d_inode           780 fs/overlayfs/copy_up.c 	ovl_set_upperdata(d_inode(c->dentry));
d_inode           900 fs/overlayfs/copy_up.c 	if (special_file(d_inode(dentry)->i_mode))
d_inode            55 fs/overlayfs/dir.c 	if (!IS_ERR(temp) && temp->d_inode) {
d_inode            69 fs/overlayfs/dir.c 	struct inode *wdir = workdir->d_inode;
d_inode            88 fs/overlayfs/dir.c 	struct inode *wdir = workdir->d_inode;
d_inode           156 fs/overlayfs/dir.c 	if (newdentry->d_inode)
d_inode           188 fs/overlayfs/dir.c 	if (!err && WARN_ON(!newdentry->d_inode)) {
d_inode           205 fs/overlayfs/dir.c 	return ovl_create_real(d_inode(workdir), ovl_lookup_temp(workdir),
d_inode           263 fs/overlayfs/dir.c 		WARN_ON(ovl_inode_real(inode) != d_inode(newdentry));
d_inode           295 fs/overlayfs/dir.c 	struct inode *udir = upperdir->d_inode;
d_inode           334 fs/overlayfs/dir.c 	struct inode *wdir = workdir->d_inode;
d_inode           336 fs/overlayfs/dir.c 	struct inode *udir = upperdir->d_inode;
d_inode           360 fs/overlayfs/dir.c 	if (upper->d_parent->d_inode != udir)
d_inode           376 fs/overlayfs/dir.c 	inode_lock(opaquedir->d_inode);
d_inode           378 fs/overlayfs/dir.c 	inode_unlock(opaquedir->d_inode);
d_inode           433 fs/overlayfs/dir.c 	struct inode *wdir = workdir->d_inode;
d_inode           435 fs/overlayfs/dir.c 	struct inode *udir = upperdir->d_inode;
d_inode           446 fs/overlayfs/dir.c 		err = posix_acl_create(dentry->d_parent->d_inode,
d_inode           463 fs/overlayfs/dir.c 	if (d_is_negative(upper) || !IS_WHITEOUT(d_inode(upper)))
d_inode           476 fs/overlayfs/dir.c 	    newdentry->d_inode->i_mode != cattr->mode) {
d_inode           481 fs/overlayfs/dir.c 		inode_lock(newdentry->d_inode);
d_inode           483 fs/overlayfs/dir.c 		inode_unlock(newdentry->d_inode);
d_inode           610 fs/overlayfs/dir.c 	inode_init_owner(inode, dentry->d_parent->d_inode, mode);
d_inode           615 fs/overlayfs/dir.c 	if (inode != d_inode(dentry))
d_inode           691 fs/overlayfs/dir.c 	inode = d_inode(old);
d_inode           709 fs/overlayfs/dir.c 	return d_inode(ovl_dentry_upper(dentry)) == d_inode(upper);
d_inode           748 fs/overlayfs/dir.c 	err = ovl_cleanup_and_whiteout(workdir, d_inode(upperdir), upper);
d_inode           769 fs/overlayfs/dir.c 	struct inode *dir = upperdir->d_inode;
d_inode           819 fs/overlayfs/dir.c 	       !ovl_test_flag(OVL_WHITEOUTS, d_inode(dentry));
d_inode           857 fs/overlayfs/dir.c 			clear_nlink(dentry->d_inode);
d_inode           859 fs/overlayfs/dir.c 			drop_nlink(dentry->d_inode);
d_inode           871 fs/overlayfs/dir.c 		ovl_copyattr(d_inode(upperdentry), d_inode(dentry));
d_inode           987 fs/overlayfs/dir.c 	return (d_inode(lowerdentry)->i_nlink > 1);
d_inode          1091 fs/overlayfs/dir.c 	} else if (d_inode(new)) {
d_inode          1154 fs/overlayfs/dir.c 	if (d_inode(new) && ovl_dentry_upper(new)) {
d_inode          1173 fs/overlayfs/dir.c 	if (olddentry->d_inode == newdentry->d_inode)
d_inode          1192 fs/overlayfs/dir.c 	err = ovl_do_rename(old_upperdir->d_inode, olddentry,
d_inode          1193 fs/overlayfs/dir.c 			    new_upperdir->d_inode, newdentry, flags);
d_inode          1198 fs/overlayfs/dir.c 		ovl_cleanup(old_upperdir->d_inode, newdentry);
d_inode          1200 fs/overlayfs/dir.c 	if (overwrite && d_inode(new)) {
d_inode          1202 fs/overlayfs/dir.c 			clear_nlink(d_inode(new));
d_inode          1204 fs/overlayfs/dir.c 			drop_nlink(d_inode(new));
d_inode          1210 fs/overlayfs/dir.c 			 (d_inode(new) && ovl_type_origin(new)));
d_inode          1213 fs/overlayfs/dir.c 	ovl_copyattr(d_inode(olddentry), d_inode(old));
d_inode          1214 fs/overlayfs/dir.c 	if (d_inode(new) && ovl_dentry_upper(new))
d_inode          1215 fs/overlayfs/dir.c 		ovl_copyattr(d_inode(newdentry), d_inode(new));
d_inode            90 fs/overlayfs/export.c 	    !ovl_test_flag(OVL_INDEX, d_inode(dentry)))
d_inode           139 fs/overlayfs/export.c 		    ovl_test_flag(OVL_INDEX, d_inode(parent)))
d_inode           198 fs/overlayfs/export.c 	    !ovl_test_flag(OVL_INDEX, d_inode(dentry)))
d_inode           372 fs/overlayfs/export.c 	struct inode *dir = d_inode(connected);
d_inode           401 fs/overlayfs/export.c 	} else if (!this || !this->d_inode) {
d_inode            32 fs/overlayfs/inode.c 		struct inode *realinode = d_inode(ovl_dentry_real(dentry));
d_inode            52 fs/overlayfs/inode.c 			winode = d_inode(upperdentry);
d_inode            61 fs/overlayfs/inode.c 		inode_lock(upperdentry->d_inode);
d_inode            66 fs/overlayfs/inode.c 			ovl_copyattr(upperdentry->d_inode, dentry->d_inode);
d_inode            67 fs/overlayfs/inode.c 		inode_unlock(upperdentry->d_inode);
d_inode           115 fs/overlayfs/inode.c 	if (S_ISDIR(dentry->d_inode->i_mode)) {
d_inode           126 fs/overlayfs/inode.c 		stat->ino = dentry->d_inode->i_ino;
d_inode           148 fs/overlayfs/inode.c 	bool is_dir = S_ISDIR(dentry->d_inode->i_mode);
d_inode           200 fs/overlayfs/inode.c 			if (ovl_test_flag(OVL_INDEX, d_inode(dentry)) ||
d_inode           262 fs/overlayfs/inode.c 	if (!is_dir && ovl_test_flag(OVL_INDEX, d_inode(dentry)))
d_inode           263 fs/overlayfs/inode.c 		stat->nlink = dentry->d_inode->i_nlink;
d_inode           363 fs/overlayfs/inode.c 	ovl_copyattr(d_inode(realdentry), inode);
d_inode           457 fs/overlayfs/inode.c 			inode->i_atime = d_inode(upperpath.dentry)->i_atime;
d_inode           642 fs/overlayfs/inode.c 	struct inode *inode = d_inode(dentry);
d_inode           643 fs/overlayfs/inode.c 	struct inode *realinode = d_inode(realdentry);
d_inode           676 fs/overlayfs/inode.c 	if (!lowerdentry || !upperdentry || d_inode(lowerdentry)->i_nlink == 1)
d_inode           692 fs/overlayfs/inode.c 	nlink = d_inode(buf[0] == 'L' ? lowerdentry : upperdentry)->i_nlink;
d_inode           753 fs/overlayfs/inode.c 	if (lowerdentry && ovl_inode_lower(inode) != d_inode(lowerdentry))
d_inode           760 fs/overlayfs/inode.c 	if (upperdentry && ovl_inode_upper(inode) != d_inode(upperdentry))
d_inode           769 fs/overlayfs/inode.c 	struct inode *inode, *key = d_inode(real);
d_inode           786 fs/overlayfs/inode.c 	struct inode *key = d_inode(dir);
d_inode           808 fs/overlayfs/inode.c 	struct inode *key = d_inode(dir);
d_inode           854 fs/overlayfs/inode.c 	    !d_is_dir(lower) && d_inode(lower)->i_nlink > 1)
d_inode           879 fs/overlayfs/inode.c 	struct inode *realinode = upperdentry ? d_inode(upperdentry) : NULL;
d_inode           890 fs/overlayfs/inode.c 		realinode = d_inode(lowerdentry);
d_inode           898 fs/overlayfs/inode.c 		struct inode *key = d_inode(bylower ? lowerdentry :
d_inode           211 fs/overlayfs/namei.c 	if (!this->d_inode)
d_inode           348 fs/overlayfs/namei.c 	    ((d_inode(origin)->i_mode ^ d_inode(upperdentry)->i_mode) & S_IFMT))
d_inode           366 fs/overlayfs/namei.c 			    upperdentry, d_inode(upperdentry)->i_mode & S_IFMT,
d_inode           367 fs/overlayfs/namei.c 			    d_inode(origin)->i_mode & S_IFMT);
d_inode           453 fs/overlayfs/namei.c 	inode = d_inode(real);
d_inode           509 fs/overlayfs/namei.c 	if (!d_inode(index))
d_inode           579 fs/overlayfs/namei.c 	if (!d_is_dir(index) && d_inode(index)->i_nlink == 1) {
d_inode           595 fs/overlayfs/namei.c 			    index, d_inode(index)->i_mode & S_IFMT, err);
d_inode           600 fs/overlayfs/namei.c 			    index, d_inode(index)->i_mode & S_IFMT,
d_inode           601 fs/overlayfs/namei.c 			    d_inode(index)->i_nlink);
d_inode           705 fs/overlayfs/namei.c 				    d_inode(origin)->i_ino, name.len, name.name,
d_inode           710 fs/overlayfs/namei.c 	inode = d_inode(index);
d_inode           724 fs/overlayfs/namei.c 		   ((inode->i_mode ^ d_inode(origin)->i_mode) & S_IFMT)) {
d_inode           733 fs/overlayfs/namei.c 				    index, d_inode(index)->i_mode & S_IFMT,
d_inode           734 fs/overlayfs/namei.c 				    d_inode(origin)->i_mode & S_IFMT);
d_inode           752 fs/overlayfs/namei.c 	} else if (upper && d_inode(upper) != inode) {
d_inode          1129 fs/overlayfs/namei.c 	if (!dentry->d_inode)
d_inode          1159 fs/overlayfs/namei.c 			if (this->d_inode) {
d_inode           137 fs/overlayfs/readdir.c 	    ovl_test_flag(OVL_IMPURE, d_inode(rdd->dentry)))
d_inode           245 fs/overlayfs/readdir.c 		if (ovl_dir_cache(d_inode(dentry)) == cache)
d_inode           246 fs/overlayfs/readdir.c 			ovl_set_dir_cache(d_inode(dentry), NULL);
d_inode           276 fs/overlayfs/readdir.c 	err = down_write_killable(&dir->d_inode->i_rwsem);
d_inode           287 fs/overlayfs/readdir.c 		inode_unlock(dir->d_inode);
d_inode           331 fs/overlayfs/readdir.c 	return !ovl_test_flag(OVL_WHITEOUTS, d_inode(dir));
d_inode           410 fs/overlayfs/readdir.c 	cache = ovl_dir_cache(d_inode(dentry));
d_inode           416 fs/overlayfs/readdir.c 	ovl_set_dir_cache(d_inode(dentry), NULL);
d_inode           434 fs/overlayfs/readdir.c 	ovl_set_dir_cache(d_inode(dentry), cache);
d_inode           487 fs/overlayfs/readdir.c 	if (IS_ERR_OR_NULL(this) || !this->d_inode) {
d_inode           602 fs/overlayfs/readdir.c 	cache = ovl_dir_cache(d_inode(dentry));
d_inode           607 fs/overlayfs/readdir.c 	ovl_dir_cache_free(d_inode(dentry));
d_inode           608 fs/overlayfs/readdir.c 	ovl_set_dir_cache(d_inode(dentry), NULL);
d_inode           630 fs/overlayfs/readdir.c 		ovl_clear_flag(OVL_IMPURE, d_inode(dentry));
d_inode           636 fs/overlayfs/readdir.c 	ovl_set_dir_cache(d_inode(dentry), cache);
d_inode           677 fs/overlayfs/readdir.c 	struct inode *dir = d_inode(file->f_path.dentry);
d_inode           965 fs/overlayfs/readdir.c 	inode_lock_nested(upper->d_inode, I_MUTEX_CHILD);
d_inode           979 fs/overlayfs/readdir.c 		if (dentry->d_inode)
d_inode           980 fs/overlayfs/readdir.c 			ovl_cleanup(upper->d_inode, dentry);
d_inode           983 fs/overlayfs/readdir.c 	inode_unlock(upper->d_inode);
d_inode          1025 fs/overlayfs/readdir.c 	struct inode *dir = path->dentry->d_inode;
d_inode          1054 fs/overlayfs/readdir.c 		if (dentry->d_inode)
d_inode          1089 fs/overlayfs/readdir.c 	struct inode *dir = indexdir->d_inode;
d_inode            85 fs/overlayfs/super.c 	if (inode && d_inode(dentry) == inode)
d_inode            89 fs/overlayfs/super.c 		if (!inode || inode == d_inode(dentry))
d_inode            95 fs/overlayfs/super.c 	if (real && (inode == d_inode(real)))
d_inode            98 fs/overlayfs/super.c 	if (real && !inode && ovl_has_upperdata(d_inode(dentry)))
d_inode           108 fs/overlayfs/super.c 	if (!inode || inode == d_inode(real))
d_inode           617 fs/overlayfs/super.c 	struct inode *dir =  ofs->workbasedir->d_inode;
d_inode           636 fs/overlayfs/super.c 		if (work->d_inode) {
d_inode           677 fs/overlayfs/super.c 		inode_lock(work->d_inode);
d_inode           679 fs/overlayfs/super.c 		inode_unlock(work->d_inode);
d_inode           881 fs/overlayfs/super.c 	if (!IS_POSIXACL(d_inode(workdir)))
d_inode          1695 fs/overlayfs/super.c 			ovl_set_flag(OVL_IMPURE, d_inode(root_dentry));
d_inode          1699 fs/overlayfs/super.c 	ovl_set_flag(OVL_WHITEOUTS, d_inode(root_dentry));
d_inode          1701 fs/overlayfs/super.c 	ovl_set_upperdata(d_inode(root_dentry));
d_inode          1702 fs/overlayfs/super.c 	ovl_inode_init(d_inode(root_dentry), upperpath.dentry,
d_inode           132 fs/overlayfs/util.c 			if (ovl_test_flag(OVL_CONST_INO, d_inode(dentry)))
d_inode           135 fs/overlayfs/util.c 			    !ovl_has_upperdata(d_inode(dentry)))
d_inode           191 fs/overlayfs/util.c 	return ovl_upperdentry_dereference(OVL_I(d_inode(dentry)));
d_inode           235 fs/overlayfs/util.c 	return upperdentry ? d_inode(upperdentry) : NULL;
d_inode           301 fs/overlayfs/util.c 	return !dentry->d_inode && ovl_dentry_is_opaque(dentry);
d_inode           370 fs/overlayfs/util.c 	return !ovl_test_flag(OVL_UPPERDATA, d_inode(dentry));
d_inode           378 fs/overlayfs/util.c 	return !ovl_has_upperdata(d_inode(dentry));
d_inode           390 fs/overlayfs/util.c 	return OVL_I(d_inode(dentry))->redirect;
d_inode           395 fs/overlayfs/util.c 	struct ovl_inode *oi = OVL_I(d_inode(dentry));
d_inode           404 fs/overlayfs/util.c 	struct inode *realinode = d_inode(upperdentry ?: lowerdentry);
d_inode           409 fs/overlayfs/util.c 		OVL_I(inode)->lower = igrab(d_inode(lowerdentry));
d_inode           411 fs/overlayfs/util.c 		OVL_I(inode)->lowerdata = igrab(d_inode(lowerdata));
d_inode           421 fs/overlayfs/util.c 	struct inode *upperinode = d_inode(upperdentry);
d_inode           440 fs/overlayfs/util.c 	struct inode *inode = d_inode(dentry);
d_inode           456 fs/overlayfs/util.c 	ovl_copyattr(d_inode(ovl_dentry_upper(dentry)), d_inode(dentry));
d_inode           463 fs/overlayfs/util.c 	struct inode *inode = d_inode(dentry);
d_inode           471 fs/overlayfs/util.c 	struct inode *inode = dentry->d_inode;
d_inode           521 fs/overlayfs/util.c 	struct inode *inode = d_inode(dentry);
d_inode           535 fs/overlayfs/util.c 	ovl_inode_unlock(d_inode(dentry));
d_inode           591 fs/overlayfs/util.c 	if (ovl_test_flag(OVL_IMPURE, d_inode(dentry)))
d_inode           601 fs/overlayfs/util.c 		ovl_set_flag(OVL_IMPURE, d_inode(dentry));
d_inode           627 fs/overlayfs/util.c 	struct inode *inode = d_inode(dentry);
d_inode           643 fs/overlayfs/util.c 		struct inode *inode = d_inode(dentry);
d_inode           654 fs/overlayfs/util.c 	struct inode *inode = d_inode(dentry);
d_inode           679 fs/overlayfs/util.c 	if (!d_is_dir(lower) && d_inode(lower)->i_nlink > 1)
d_inode           689 fs/overlayfs/util.c 	struct inode *dir = indexdir->d_inode;
d_inode           701 fs/overlayfs/util.c 	inode = d_inode(upperdentry);
d_inode           714 fs/overlayfs/util.c 		set_nlink(d_inode(dentry), inode->i_nlink - 1);
d_inode           752 fs/overlayfs/util.c 	struct inode *inode = d_inode(dentry);
d_inode           805 fs/overlayfs/util.c 	struct inode *inode = d_inode(dentry);
d_inode           843 fs/overlayfs/util.c 	if (!S_ISREG(d_inode(dentry)->i_mode))
d_inode           867 fs/overlayfs/util.c 		if (!ovl_has_upperdata(d_inode(dentry)))
d_inode           721 fs/pipe.c      				d_inode(dentry)->i_ino);
d_inode           185 fs/proc/base.c 	struct task_struct *task = get_proc_task(d_inode(dentry));
d_inode           202 fs/proc/base.c 	struct task_struct *task = get_proc_task(d_inode(dentry));
d_inode           680 fs/proc/base.c 	struct inode *inode = d_inode(dentry);
d_inode          1597 fs/proc/base.c 	task = get_proc_task(d_inode(dentry));
d_inode          1662 fs/proc/base.c 	struct inode *inode = d_inode(dentry);
d_inode          1786 fs/proc/base.c 	struct inode *inode = d_inode(path->dentry);
d_inode          1837 fs/proc/base.c 	inode = d_inode(dentry);
d_inode          1859 fs/proc/base.c 	return proc_inode_is_dead(d_inode(dentry));
d_inode          1910 fs/proc/base.c 	inode = d_inode(child);
d_inode          1972 fs/proc/base.c 	inode = d_inode(dentry);
d_inode          2020 fs/proc/base.c 	task = get_proc_task(d_inode(dentry));
d_inode          3324 fs/proc/base.c 		struct inode *inode = d_inode(ns->proc_self);
d_inode          3330 fs/proc/base.c 		struct inode *inode = d_inode(ns->proc_thread_self);
d_inode          3691 fs/proc/base.c 	struct inode *inode = d_inode(path->dentry);
d_inode           126 fs/proc/fd.c   	inode = d_inode(dentry);
d_inode           153 fs/proc/fd.c   	task = get_proc_task(d_inode(dentry));
d_inode           160 fs/proc/fd.c   		unsigned int fd = proc_fd(d_inode(dentry));
d_inode           120 fs/proc/generic.c 	struct inode *inode = d_inode(dentry);
d_inode           139 fs/proc/generic.c 	struct inode *inode = d_inode(path->dentry);
d_inode           228 fs/proc/generic.c 	if (atomic_read(&PDE(d_inode(dentry))->in_use) < 0)
d_inode           235 fs/proc/generic.c 	return atomic_read(&PDE(d_inode(dentry))->in_use) < 0;
d_inode            65 fs/proc/namespaces.c 	struct inode *inode = d_inode(dentry);
d_inode           292 fs/proc/proc_net.c 	struct inode *inode = d_inode(path->dentry);
d_inode           730 fs/proc/proc_sysctl.c 	inode = d_inode(child);
d_inode           837 fs/proc/proc_sysctl.c 	struct inode *inode = d_inode(dentry);
d_inode           855 fs/proc/proc_sysctl.c 	struct inode *inode = d_inode(path->dentry);
d_inode           901 fs/proc/proc_sysctl.c 	return !PROC_I(d_inode(dentry))->sysctl->unregistering;
d_inode           906 fs/proc/proc_sysctl.c 	return !!PROC_I(d_inode(dentry))->sysctl->unregistering;
d_inode           241 fs/proc/root.c 	generic_fillattr(d_inode(path->dentry), stat);
d_inode            38 fs/proc/self.c 	struct inode *root_inode = d_inode(s->s_root);
d_inode            38 fs/proc/thread_self.c 	struct inode *root_inode = d_inode(s->s_root);
d_inode           179 fs/pstore/inode.c 	struct pstore_private *p = d_inode(dentry)->i_private;
d_inode           303 fs/pstore/inode.c 	WARN_ON(!inode_is_locked(d_inode(root)));
d_inode           377 fs/pstore/inode.c 	inode_lock(d_inode(root));
d_inode           379 fs/pstore/inode.c 	inode_unlock(d_inode(root));
d_inode           186 fs/qnx6/inode.c 	struct inode *root = d_inode(s->s_root);
d_inode          2460 fs/quota/dquot.c 		error = vfs_load_quota_inode(d_inode(path->dentry), type,
d_inode          2523 fs/quota/dquot.c 		error = vfs_load_quota_inode(d_inode(dentry), type, format_id,
d_inode           163 fs/ramfs/file-nommu.c 	struct inode *inode = d_inode(dentry);
d_inode            57 fs/reiserfs/dir.c 	        deh->deh_objectid == INODE_PKEY(d_inode(privroot))->k_objectid);
d_inode          3292 fs/reiserfs/inode.c 	struct inode *inode = d_inode(dentry);
d_inode           406 fs/reiserfs/namei.c 	struct inode *dir = d_inode(child);
d_inode           936 fs/reiserfs/namei.c 	inode = d_inode(dentry);
d_inode          1008 fs/reiserfs/namei.c 	inode = d_inode(dentry);
d_inode          1201 fs/reiserfs/namei.c 	struct inode *inode = d_inode(old_dentry);
d_inode          1348 fs/reiserfs/namei.c 	old_inode = d_inode(old_dentry);
d_inode          1349 fs/reiserfs/namei.c 	new_dentry_inode = d_inode(new_dentry);
d_inode          1741 fs/reiserfs/super.c 	inode = d_inode(s->s_root);
d_inode          2405 fs/reiserfs/super.c 	inode = d_inode(path->dentry);
d_inode            91 fs/reiserfs/xattr.c 	inode_lock_nested(d_inode(dentry), I_MUTEX_CHILD);
d_inode            93 fs/reiserfs/xattr.c 	inode_unlock(d_inode(dentry));
d_inode           106 fs/reiserfs/xattr.c 	inode_lock_nested(d_inode(dentry), I_MUTEX_CHILD);
d_inode           109 fs/reiserfs/xattr.c 		d_inode(dentry)->i_flags |= S_DEAD;
d_inode           110 fs/reiserfs/xattr.c 	inode_unlock(d_inode(dentry));
d_inode           127 fs/reiserfs/xattr.c 	inode_lock_nested(d_inode(privroot), I_MUTEX_XATTR);
d_inode           136 fs/reiserfs/xattr.c 			err = xattr_mkdir(d_inode(privroot), xaroot, 0700);
d_inode           143 fs/reiserfs/xattr.c 	inode_unlock(d_inode(privroot));
d_inode           160 fs/reiserfs/xattr.c 	inode_lock_nested(d_inode(xaroot), I_MUTEX_XATTR);
d_inode           167 fs/reiserfs/xattr.c 			err = xattr_mkdir(d_inode(xaroot), xadir, 0700);
d_inode           174 fs/reiserfs/xattr.c 	inode_unlock(d_inode(xaroot));
d_inode           200 fs/reiserfs/xattr.c 	WARN_ON_ONCE(!inode_is_locked(d_inode(dbuf->xadir)));
d_inode           261 fs/reiserfs/xattr.c 	inode_lock_nested(d_inode(dir), I_MUTEX_XATTR);
d_inode           265 fs/reiserfs/xattr.c 		err = reiserfs_readdir_inode(d_inode(dir), &buf.ctx);
d_inode           287 fs/reiserfs/xattr.c 	inode_unlock(d_inode(dir));
d_inode           309 fs/reiserfs/xattr.c 			inode_lock_nested(d_inode(dir->d_parent),
d_inode           315 fs/reiserfs/xattr.c 			inode_unlock(d_inode(dir->d_parent));
d_inode           334 fs/reiserfs/xattr.c 	struct inode *dir = d_inode(dentry->d_parent);
d_inode           399 fs/reiserfs/xattr.c 	inode_lock_nested(d_inode(xadir), I_MUTEX_XATTR);
d_inode           412 fs/reiserfs/xattr.c 			err = xattr_create(d_inode(xadir), xafile,
d_inode           419 fs/reiserfs/xattr.c 	inode_unlock(d_inode(xadir));
d_inode           493 fs/reiserfs/xattr.c 	inode_lock_nested(d_inode(xadir), I_MUTEX_XATTR);
d_inode           501 fs/reiserfs/xattr.c 		err = xattr_unlink(d_inode(xadir), dentry);
d_inode           507 fs/reiserfs/xattr.c 	inode_unlock(d_inode(xadir));
d_inode           557 fs/reiserfs/xattr.c 		page = reiserfs_get_page(d_inode(dentry), file_pos);
d_inode           597 fs/reiserfs/xattr.c 	if (!err && new_size < i_size_read(d_inode(dentry))) {
d_inode           604 fs/reiserfs/xattr.c 		inode_lock_nested(d_inode(dentry), I_MUTEX_XATTR);
d_inode           605 fs/reiserfs/xattr.c 		inode_dio_wait(d_inode(dentry));
d_inode           608 fs/reiserfs/xattr.c 		inode_unlock(d_inode(dentry));
d_inode           685 fs/reiserfs/xattr.c 	isize = i_size_read(d_inode(dentry));
d_inode           708 fs/reiserfs/xattr.c 		page = reiserfs_get_page(d_inode(dentry), file_pos);
d_inode           852 fs/reiserfs/xattr.c 	if (get_inode_sd_version(d_inode(dentry)) == STAT_DATA_V1)
d_inode           855 fs/reiserfs/xattr.c 	dir = open_xa_dir(d_inode(dentry), XATTR_REPLACE);
d_inode           863 fs/reiserfs/xattr.c 	inode_lock_nested(d_inode(dir), I_MUTEX_XATTR);
d_inode           864 fs/reiserfs/xattr.c 	err = reiserfs_readdir_inode(d_inode(dir), &buf.ctx);
d_inode           865 fs/reiserfs/xattr.c 	inode_unlock(d_inode(dir));
d_inode           878 fs/reiserfs/xattr.c 	struct inode *inode = d_inode(dentry->d_parent);
d_inode           891 fs/reiserfs/xattr.c 	d_inode(dentry)->i_flags |= S_PRIVATE;
d_inode           892 fs/reiserfs/xattr.c 	d_inode(dentry)->i_opflags &= ~IOP_XATTR;
d_inode           971 fs/reiserfs/xattr.c 	inode_lock(d_inode(s->s_root));
d_inode           978 fs/reiserfs/xattr.c 			d_inode(dentry)->i_flags |= S_PRIVATE;
d_inode           979 fs/reiserfs/xattr.c 			d_inode(dentry)->i_opflags &= ~IOP_XATTR;
d_inode           983 fs/reiserfs/xattr.c 	inode_unlock(d_inode(s->s_root));
d_inode          1003 fs/reiserfs/xattr.c 		inode_lock(d_inode(s->s_root));
d_inode          1005 fs/reiserfs/xattr.c 		inode_unlock(d_inode(s->s_root));
d_inode          1009 fs/reiserfs/xattr.c 		inode_lock(d_inode(privroot));
d_inode          1020 fs/reiserfs/xattr.c 		inode_unlock(d_inode(privroot));
d_inode            38 fs/reiserfs/xattr_security.c 	return !IS_PRIVATE(d_inode(dentry));
d_inode            37 fs/reiserfs/xattr_trusted.c 	return capable(CAP_SYS_ADMIN) && !IS_PRIVATE(d_inode(dentry));
d_inode           100 fs/squashfs/export.c 	struct inode *inode = d_inode(child);
d_inode            29 fs/squashfs/xattr.c 	struct inode *inode = d_inode(d);
d_inode           131 fs/sysv/dir.c  	struct inode * dir = d_inode(dentry->d_parent);
d_inode           175 fs/sysv/dir.c  	struct inode *dir = d_inode(dentry->d_parent);
d_inode            34 fs/sysv/file.c 	struct inode *inode = d_inode(dentry);
d_inode           448 fs/sysv/itree.c 	generic_fillattr(d_inode(path->dentry), stat);
d_inode           102 fs/sysv/namei.c 	struct inode *inode = d_inode(old_dentry);
d_inode           150 fs/sysv/namei.c 	struct inode * inode = d_inode(dentry);
d_inode           171 fs/sysv/namei.c 	struct inode *inode = d_inode(dentry);
d_inode           193 fs/sysv/namei.c 	struct inode * old_inode = d_inode(old_dentry);
d_inode           194 fs/sysv/namei.c 	struct inode * new_inode = d_inode(new_dentry);
d_inode           110 fs/tracefs/inode.c 	inode_unlock(dentry->d_inode);
d_inode           115 fs/tracefs/inode.c 	inode_lock(dentry->d_inode);
d_inode           213 fs/tracefs/inode.c 	struct inode *inode = sb->s_root->d_inode;
d_inode           332 fs/tracefs/inode.c 	inode_lock(parent->d_inode);
d_inode           334 fs/tracefs/inode.c 	if (!IS_ERR(dentry) && dentry->d_inode) {
d_inode           340 fs/tracefs/inode.c 		inode_unlock(parent->d_inode);
d_inode           349 fs/tracefs/inode.c 	inode_unlock(dentry->d_parent->d_inode);
d_inode           357 fs/tracefs/inode.c 	inode_unlock(dentry->d_parent->d_inode);
d_inode           413 fs/tracefs/inode.c 	fsnotify_create(dentry->d_parent->d_inode, dentry);
d_inode           437 fs/tracefs/inode.c 	inc_nlink(dentry->d_parent->d_inode);
d_inode           438 fs/tracefs/inode.c 	fsnotify_mkdir(dentry->d_parent->d_inode, dentry);
d_inode           507 fs/tracefs/inode.c 		if (dentry->d_inode) {
d_inode           509 fs/tracefs/inode.c 			switch (dentry->d_inode->i_mode & S_IFMT) {
d_inode           511 fs/tracefs/inode.c 				ret = simple_rmdir(parent->d_inode, dentry);
d_inode           513 fs/tracefs/inode.c 					fsnotify_rmdir(parent->d_inode, dentry);
d_inode           516 fs/tracefs/inode.c 				simple_unlink(parent->d_inode, dentry);
d_inode           517 fs/tracefs/inode.c 				fsnotify_unlink(parent->d_inode, dentry);
d_inode           546 fs/tracefs/inode.c 	inode_lock(parent->d_inode);
d_inode           548 fs/tracefs/inode.c 	inode_unlock(parent->d_inode);
d_inode           570 fs/tracefs/inode.c 	inode_lock(parent->d_inode);
d_inode           585 fs/tracefs/inode.c 			inode_unlock(parent->d_inode);
d_inode           606 fs/tracefs/inode.c 	inode_unlock(parent->d_inode);
d_inode           609 fs/tracefs/inode.c 	inode_lock(parent->d_inode);
d_inode           617 fs/tracefs/inode.c 	inode_unlock(parent->d_inode);
d_inode           691 fs/ubifs/dir.c 	struct inode *inode = d_inode(old_dentry);
d_inode           765 fs/ubifs/dir.c 	struct inode *inode = d_inode(dentry);
d_inode           871 fs/ubifs/dir.c 	struct inode *inode = d_inode(dentry);
d_inode           887 fs/ubifs/dir.c 	err = ubifs_check_dir_empty(d_inode(dentry));
d_inode          1252 fs/ubifs/dir.c 	struct inode *old_inode = d_inode(old_dentry);
d_inode          1253 fs/ubifs/dir.c 	struct inode *new_inode = d_inode(new_dentry);
d_inode          1495 fs/ubifs/dir.c 	struct inode *fst_inode = d_inode(old_dentry);
d_inode          1496 fs/ubifs/dir.c 	struct inode *snd_inode = d_inode(new_dentry);
d_inode          1571 fs/ubifs/dir.c 	struct inode *inode = d_inode(path->dentry);
d_inode          1263 fs/ubifs/file.c 	struct inode *inode = d_inode(dentry);
d_inode           399 fs/ubifs/xattr.c 	struct inode *host = d_inode(dentry);
d_inode           259 fs/udf/file.c  	struct inode *inode = d_inode(dentry);
d_inode           582 fs/udf/namei.c 	struct inode *dir = d_inode(dentry->d_parent);
d_inode           793 fs/udf/namei.c 	struct inode *inode = d_inode(dentry);
d_inode           838 fs/udf/namei.c 	struct inode *inode = d_inode(dentry);
d_inode          1033 fs/udf/namei.c 	struct inode *inode = d_inode(old_dentry);
d_inode          1073 fs/udf/namei.c 	struct inode *old_inode = d_inode(old_dentry);
d_inode          1074 fs/udf/namei.c 	struct inode *new_inode = d_inode(new_dentry);
d_inode          1221 fs/udf/namei.c 	if (!udf_find_entry(d_inode(child), &dotdot, &fibh, &cfi))
d_inode           307 fs/ufs/dir.c   	struct inode *dir = d_inode(dentry->d_parent);
d_inode          1216 fs/ufs/inode.c 	struct inode *inode = d_inode(dentry);
d_inode           151 fs/ufs/namei.c 	struct inode *inode = d_inode(old_dentry);
d_inode           207 fs/ufs/namei.c 	struct inode * inode = d_inode(dentry);
d_inode           229 fs/ufs/namei.c 	struct inode * inode = d_inode(dentry);
d_inode           247 fs/ufs/namei.c 	struct inode *old_inode = d_inode(old_dentry);
d_inode           248 fs/ufs/namei.c 	struct inode *new_inode = d_inode(new_dentry);
d_inode           134 fs/ufs/super.c 	ino = ufs_inode_by_name(d_inode(child), &dot_dot);
d_inode            23 fs/utimes.c    	struct inode *inode = path->dentry->d_inode;
d_inode           321 fs/verity/open.c 	if (IS_VERITY(d_inode(dentry)) && (attr->ia_valid & ATTR_SIZE)) {
d_inode           323 fs/verity/open.c 			 d_inode(dentry)->i_ino);
d_inode           173 fs/xattr.c     	struct inode *inode = dentry->d_inode;
d_inode           212 fs/xattr.c     	struct inode *inode = dentry->d_inode;
d_inode           271 fs/xattr.c     	struct inode *inode = dentry->d_inode;
d_inode           318 fs/xattr.c     	struct inode *inode = dentry->d_inode;
d_inode           349 fs/xattr.c     	struct inode *inode = d_inode(dentry);
d_inode           369 fs/xattr.c     	struct inode *inode = d_inode(dentry);
d_inode           384 fs/xattr.c     	struct inode *inode = dentry->d_inode;
d_inode           213 fs/xfs/xfs_export.c 	error = xfs_lookup(XFS_I(d_inode(child)), &xfs_name_dotdot, &cip, NULL);
d_inode           287 fs/xfs/xfs_filestream.c 	dir = igrab(d_inode(parent));
d_inode            73 fs/xfs/xfs_ioctl.c 		inode = d_inode(path.dentry);
d_inode           200 fs/xfs/xfs_ioctl.c 	inode = d_inode(dentry);
d_inode           350 fs/xfs/xfs_ioctl.c 	if (IS_IMMUTABLE(d_inode(dentry)) || IS_APPEND(d_inode(dentry))) {
d_inode           360 fs/xfs/xfs_ioctl.c 	error = xfs_set_dmattrs(XFS_I(d_inode(dentry)), fsd.fsd_dmevmask,
d_inode           404 fs/xfs/xfs_ioctl.c 	error = xfs_attr_list(XFS_I(d_inode(dentry)), kbuf, al_hreq.buflen,
d_inode           551 fs/xfs/xfs_ioctl.c 					d_inode(dentry), attr_name,
d_inode           560 fs/xfs/xfs_ioctl.c 					d_inode(dentry), attr_name,
d_inode           570 fs/xfs/xfs_ioctl.c 					d_inode(dentry), attr_name,
d_inode           389 fs/xfs/xfs_ioctl32.c 	error = xfs_attr_list(XFS_I(d_inode(dentry)), kbuf, al_hreq.buflen,
d_inode           466 fs/xfs/xfs_ioctl32.c 					d_inode(dentry), attr_name,
d_inode           475 fs/xfs/xfs_ioctl32.c 					d_inode(dentry), attr_name,
d_inode           485 fs/xfs/xfs_ioctl32.c 					d_inode(dentry), attr_name,
d_inode           525 fs/xfs/xfs_ioctl32.c 	if (IS_IMMUTABLE(d_inode(dentry)) || IS_APPEND(d_inode(dentry))) {
d_inode           535 fs/xfs/xfs_ioctl32.c 	error = xfs_set_dmattrs(XFS_I(d_inode(dentry)), fsd.fsd_dmevmask,
d_inode           315 fs/xfs/xfs_iops.c 	struct inode	*inode = d_inode(old_dentry);
d_inode           342 fs/xfs/xfs_iops.c 	error = xfs_remove(XFS_I(dir), &name, XFS_I(d_inode(dentry)));
d_inode           406 fs/xfs/xfs_iops.c 	struct inode	*new_inode = d_inode(ndentry);
d_inode           417 fs/xfs/xfs_iops.c 		omode = d_inode(ndentry)->i_mode;
d_inode           424 fs/xfs/xfs_iops.c 					d_inode(odentry)->i_mode);
d_inode           428 fs/xfs/xfs_iops.c 	return xfs_rename(XFS_I(odir), &oname, XFS_I(d_inode(odentry)),
d_inode           454 fs/xfs/xfs_iops.c 	error = xfs_readlink(XFS_I(d_inode(dentry)), link);
d_inode           494 fs/xfs/xfs_iops.c 	struct inode		*inode = d_inode(path->dentry);
d_inode           599 fs/xfs/xfs_iops.c 	struct xfs_mount	*mp = XFS_I(d_inode(dentry))->i_mount;
d_inode           808 fs/xfs/xfs_iops.c 	struct xfs_inode	*ip = XFS_I(d_inode(dentry));
d_inode          1020 fs/xfs/xfs_iops.c 	struct xfs_inode	*ip = XFS_I(d_inode(dentry));
d_inode          1039 fs/xfs/xfs_iops.c 		struct inode		*inode = d_inode(dentry);
d_inode          1083 fs/xfs/xfs_super.c 	struct xfs_inode	*ip = XFS_I(d_inode(dentry));
d_inode           217 fs/xfs/xfs_xattr.c 	struct inode	*inode = d_inode(dentry);
d_inode            96 include/linux/dcache.h 	struct inode *d_inode;		/* Where the name belongs to - NULL is
d_inode           465 include/linux/dcache.h 	return dentry->d_inode == NULL;
d_inode           483 include/linux/dcache.h 	return dentry->d_inode != NULL;
d_inode           515 include/linux/dcache.h 	return dentry->d_inode;
d_inode           527 include/linux/dcache.h 	return READ_ONCE(dentry->d_inode);
d_inode           542 include/linux/dcache.h 	struct inode *inode = upper->d_inode;
d_inode          3434 include/linux/fs.h 	res = dentry->d_parent->d_inode->i_ino;
d_inode          3543 include/linux/fs.h 	return inode == inode->i_sb->s_root->d_inode;
d_inode          3555 include/linux/fs.h 			  file->f_path.dentry->d_inode->i_ino, DT_DIR) == 0;
d_inode           610 include/linux/fscrypt.h 		return __fscrypt_prepare_link(d_inode(old_dentry), dir, dentry);
d_inode           701 include/linux/fscrypt.h 		return fscrypt_require_key(d_inode(dentry));
d_inode            29 include/linux/fsnotify.h 	return fsnotify(dir, mask, d_inode(dentry), FSNOTIFY_EVENT_INODE,
d_inode           109 include/linux/fsnotify.h 	struct inode *source = moved->d_inode;
d_inode           298 include/linux/fsnotify.h 	struct inode *inode = dentry->d_inode;
d_inode           314 include/linux/fsnotify.h 	struct inode *inode = dentry->d_inode;
d_inode           386 include/linux/fsnotify_backend.h 	if (fsnotify_inode_watches_children(dentry->d_parent->d_inode))
d_inode           169 include/linux/fsverity.h 	return IS_VERITY(d_inode(dentry)) ? -EOPNOTSUPP : 0;
d_inode           665 include/trace/events/btrfs.h 		const struct inode *inode = d_inode(dentry);
d_inode           669 include/trace/events/btrfs.h 		__entry->parent		= btrfs_ino(BTRFS_I(d_inode(dentry->d_parent)));
d_inode           899 include/trace/events/ext4.h 		__entry->ino		= d_inode(dentry)->i_ino;
d_inode           901 include/trace/events/ext4.h 		__entry->parent		= d_inode(dentry->d_parent)->i_ino;
d_inode          1459 include/trace/events/ext4.h 		__entry->ino		= d_inode(dentry)->i_ino;
d_inode          1461 include/trace/events/ext4.h 		__entry->size		= d_inode(dentry)->i_size;
d_inode          1483 include/trace/events/ext4.h 		__entry->ino		= d_inode(dentry)->i_ino;
d_inode           495 ipc/mqueue.c   	struct inode *dir = dentry->d_parent->d_inode;
d_inode           546 ipc/mqueue.c   	struct inode *inode = d_inode(dentry);
d_inode           812 ipc/mqueue.c   	return inode_permission(d_inode(dentry), acc);
d_inode           835 ipc/mqueue.c   	inode_lock(d_inode(root));
d_inode           856 ipc/mqueue.c   	inode_unlock(d_inode(root));
d_inode           891 ipc/mqueue.c   	inode_lock_nested(d_inode(mnt->mnt_root), I_MUTEX_PARENT);
d_inode           899 ipc/mqueue.c   	inode = d_inode(dentry);
d_inode           904 ipc/mqueue.c   		err = vfs_unlink(d_inode(dentry->d_parent), dentry, NULL);
d_inode           909 ipc/mqueue.c   	inode_unlock(d_inode(mnt->mnt_root));
d_inode            88 kernel/audit_fsnotify.c 	inode = path.dentry->d_inode;
d_inode           100 kernel/audit_fsnotify.c 	audit_update_mark(audit_mark, dentry->d_inode);
d_inode           171 kernel/audit_fsnotify.c 		inode = ((const struct path *)data)->dentry->d_inode;
d_inode           310 kernel/bpf/inode.c 	struct inode *dir = dentry->d_parent->d_inode;
d_inode           401 kernel/bpf/inode.c 	dir = d_inode(path.dentry);
d_inode           559 kernel/bpf/inode.c 	umode_t mode = d_inode(root)->i_mode & S_IALLUGO & ~S_ISVTX;
d_inode           638 kernel/bpf/inode.c 	inode = sb->s_root->d_inode;
d_inode           335 kernel/bpf/offload.c 	ns_inode = ns_path.dentry->d_inode;
d_inode           538 kernel/bpf/offload.c 	ns_inode = ns_path.dentry->d_inode;
d_inode          7286 kernel/events/core.c 		ns_inode = ns_path.dentry->d_inode;
d_inode          7572 kernel/events/core.c 	if (d_inode(filter->path.dentry) != file_inode(file))
d_inode          9468 kernel/events/core.c 				    !S_ISREG(d_inode(filter->path.dentry)
d_inode           412 kernel/relay.c 	d_inode(buf->dentry)->i_size = buf->early_bytes;
d_inode           760 kernel/relay.c 			d_inode(buf->dentry)->i_size +=
d_inode          7814 kernel/trace/trace.c 		d_inode(ret)->i_cdev = (void *)(cpu + 1);
d_inode           715 kernel/trace/trace_events.c 				d_inode(child)->i_private = NULL;
d_inode          1000 mm/shmem.c     	struct inode *inode = path->dentry->d_inode;
d_inode          1019 mm/shmem.c     	struct inode *inode = d_inode(dentry);
d_inode          2955 mm/shmem.c     	struct inode *inode = d_inode(old_dentry);
d_inode          2983 mm/shmem.c     	struct inode *inode = d_inode(dentry);
d_inode          3000 mm/shmem.c     	drop_nlink(d_inode(dentry));
d_inode          3021 mm/shmem.c     	d_inode(old_dentry)->i_ctime =
d_inode          3022 mm/shmem.c     	d_inode(new_dentry)->i_ctime = current_time(old_dir);
d_inode          3061 mm/shmem.c     	struct inode *inode = d_inode(old_dentry);
d_inode          3084 mm/shmem.c     			drop_nlink(d_inode(new_dentry));
d_inode          3275 mm/shmem.c     	struct shmem_inode_info *info = SHMEM_I(d_inode(dentry));
d_inode          3276 mm/shmem.c     	return simple_xattr_list(d_inode(dentry), &info->xattrs, buffer, size);
d_inode           294 net/socket.c   				d_inode(dentry)->i_ino);
d_inode           502 net/socket.c   	len = security_inode_listsecurity(d_inode(dentry), buffer, size);
d_inode           529 net/socket.c   		struct socket *sock = SOCKET_I(d_inode(dentry));
d_inode            99 net/sunrpc/rpc_pipe.c 	rpc_purge_list(dentry ? &RPC_I(d_inode(dentry))->waitq : NULL,
d_inode           157 net/sunrpc/rpc_pipe.c 		wake_up(&RPC_I(d_inode(dentry))->waitq);
d_inode           589 net/sunrpc/rpc_pipe.c 	rpci = RPC_I(d_inode(dentry));
d_inode           624 net/sunrpc/rpc_pipe.c 	struct inode *inode = d_inode(dentry);
d_inode           653 net/sunrpc/rpc_pipe.c 	struct inode *dir = d_inode(parent);
d_inode           667 net/sunrpc/rpc_pipe.c 		switch (d_inode(dentry)->i_mode & S_IFMT) {
d_inode           685 net/sunrpc/rpc_pipe.c 	struct inode *dir = d_inode(parent);
d_inode           697 net/sunrpc/rpc_pipe.c 	struct inode *dir = d_inode(parent);
d_inode           740 net/sunrpc/rpc_pipe.c 	struct inode *dir = d_inode(parent);
d_inode           773 net/sunrpc/rpc_pipe.c 	dir = d_inode(parent);
d_inode           805 net/sunrpc/rpc_pipe.c 	struct inode *dir = d_inode(parent);
d_inode           850 net/sunrpc/rpc_pipe.c 	dir = d_inode(parent);
d_inode          1349 net/sunrpc/rpc_pipe.c 	__rpc_rmpipe(d_inode(clnt_dir), pipe_dentry);
d_inode           985 net/unix/af_unix.c 		err = vfs_mknod(d_inode(path.dentry), dentry, mode, 0);
d_inode           119 security/apparmor/apparmorfs.c 	seq_printf(seq, "%s:[%lu]", AAFS_NAME, d_inode(dentry)->i_ino);
d_inode           250 security/apparmor/apparmorfs.c 	dir = d_inode(parent);
d_inode           357 security/apparmor/apparmorfs.c 	dir = d_inode(dentry->d_parent);
d_inode          1397 security/apparmor/apparmorfs.c 	d_inode(dent)->i_size = rawdata->size;
d_inode          1433 security/apparmor/apparmorfs.c 		proxy = d_inode(profile->dents[i])->i_private;
d_inode          1456 security/apparmor/apparmorfs.c 			new->dents[i]->d_inode->i_mtime = current_time(new->dents[i]->d_inode);
d_inode          1704 security/apparmor/apparmorfs.c 	AA_BUG(d_inode(ns_subns_dir(parent)) != dir);
d_inode          1758 security/apparmor/apparmorfs.c 	inode_unlock(dentry->d_inode);
d_inode          1775 security/apparmor/apparmorfs.c 	inode_lock(dentry->d_inode);
d_inode          1823 security/apparmor/apparmorfs.c 		sub = d_inode(ns_subns_dir(ns))->i_private;
d_inode          1827 security/apparmor/apparmorfs.c 		sub = d_inode(ns_subload(ns))->i_private;
d_inode          1831 security/apparmor/apparmorfs.c 		sub = d_inode(ns_subreplace(ns))->i_private;
d_inode          1835 security/apparmor/apparmorfs.c 		sub = d_inode(ns_subremove(ns))->i_private;
d_inode          1839 security/apparmor/apparmorfs.c 		sub = d_inode(ns_subrevision(ns))->i_private;
d_inode          2420 security/apparmor/apparmorfs.c 	inode_lock(d_inode(parent));
d_inode          2426 security/apparmor/apparmorfs.c 	inode = new_inode(parent->d_inode->i_sb);
d_inode          2446 security/apparmor/apparmorfs.c 	inode_unlock(d_inode(parent));
d_inode          2478 security/apparmor/apparmorfs.c 		       d_inode(dentry)->i_ino);
d_inode           298 security/apparmor/mount.c 		(S_ISDIR(path->dentry->d_inode->i_mode) ? PATH_IS_DIR : 0);
d_inode           132 security/apparmor/policy_unpack.c 	d_inode(data->dents[AAFS_LOADDATA_DIR])->i_mtime =
d_inode           133 security/apparmor/policy_unpack.c 		current_time(d_inode(data->dents[AAFS_LOADDATA_DIR]));
d_inode           134 security/apparmor/policy_unpack.c 	d_inode(data->dents[AAFS_LOADDATA_REVISION])->i_mtime =
d_inode           135 security/apparmor/policy_unpack.c 		current_time(d_inode(data->dents[AAFS_LOADDATA_REVISION]));
d_inode           128 security/inode.c 	dir = d_inode(parent);
d_inode           302 security/inode.c 	dir = d_inode(dentry->d_parent);
d_inode           344 security/integrity/evm/evm_main.c 				    dentry->d_inode, dentry->d_name.name,
d_inode           441 security/integrity/evm/evm_main.c 	evm_reset_status(dentry->d_inode);
d_inode           461 security/integrity/evm/evm_main.c 	evm_reset_status(dentry->d_inode);
d_inode           222 security/integrity/evm/evm_secfs.c 		inode = evm_xattrs->d_inode;
d_inode           481 security/integrity/ima/ima_main.c 	struct inode *inode = dentry->d_inode;
d_inode           263 security/lsm_audit.c 		inode = a->u.op->path.dentry->d_inode;
d_inode          2875 security/selinux/hooks.c 					   d_inode(dentry->d_parent), name,
d_inode          2895 security/selinux/hooks.c 					   d_inode(dentry->d_parent), name,
d_inode          3438 security/selinux/hooks.c 	selinux_inode_getsecid(d_inode(src), &sid);
d_inode          1888 security/selinux/selinuxfs.c 	inc_nlink(d_inode(dir));
d_inode          4518 security/smack/smack_lsm.c 	isp = smack_inode(d_inode(dentry->d_parent));
d_inode          4555 security/smack/smack_lsm.c 	isp = smack_inode(d_inode(dentry->d_parent));