Lines Matching defs:inode
88 struct inode *inode, pgoff_t index)
90 vma->vm_policy = mpol_shared_policy_lookup(&HUGETLBFS_I(inode)->policy,
100 struct inode *inode, pgoff_t index)
121 struct inode *inode = file_inode(file);
122 struct hugetlbfs_inode_info *info = HUGETLBFS_I(inode);
164 inode_lock(inode);
172 * reserving here. Note: only for SHM hugetlbfs file, the inode
175 if (inode->i_flags & S_PRIVATE)
178 if (!hugetlb_reserve_pages(inode,
185 if (vma->vm_flags & VM_WRITE && inode->i_size < len)
186 i_size_write(inode, len);
188 inode_unlock(inode);
340 struct inode *inode = mapping->host;
353 isize = i_size_read(inode);
437 * Called with i_mmap_rwsem held for inode based vma maps. This makes
613 static bool remove_inode_single_folio(struct hstate *h, struct inode *inode,
641 if (unlikely(hugetlb_unreserve_pages(inode, index,
643 hugetlb_fix_reserve_counts(inode);
670 static void remove_inode_hugepages(struct inode *inode, loff_t lstart,
673 struct hstate *h = hstate_inode(inode);
674 struct address_space *mapping = &inode->i_data;
696 if (remove_inode_single_folio(h, inode, mapping, folio,
707 (void)hugetlb_unreserve_pages(inode, start, LONG_MAX, freed);
710 static void hugetlbfs_evict_inode(struct inode *inode)
714 remove_inode_hugepages(inode, 0, LLONG_MAX);
717 * Get the resv_map from the address space embedded in the inode.
719 * at inode creation time. If this is a device special inode,
722 resv_map = (struct resv_map *)(&inode->i_data)->private_data;
726 clear_inode(inode);
729 static void hugetlb_vmtruncate(struct inode *inode, loff_t offset)
732 struct address_space *mapping = inode->i_mapping;
733 struct hstate *h = hstate_inode(inode);
738 i_size_write(inode, offset);
744 remove_inode_hugepages(inode, offset, LLONG_MAX);
770 static long hugetlbfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
772 struct hugetlbfs_inode_info *info = HUGETLBFS_I(inode);
773 struct address_space *mapping = inode->i_mapping;
774 struct hstate *h = hstate_inode(inode);
784 inode_lock(inode);
788 inode_unlock(inode);
816 remove_inode_hugepages(inode, hole_start, hole_end);
818 inode_unlock(inode);
826 struct inode *inode = file_inode(file);
827 struct hugetlbfs_inode_info *info = HUGETLBFS_I(inode);
828 struct address_space *mapping = inode->i_mapping;
829 struct hstate *h = hstate_inode(inode);
842 return hugetlbfs_punch_hole(inode, offset, len);
852 inode_lock(inode);
855 error = inode_newsize_ok(inode, offset + len);
859 if ((info->seals & F_SEAL_GROW) && offset + len > inode->i_size) {
911 * reserves for the file at the inode level. If we fallocate
915 hugetlb_set_vma_policy(&pseudo_vma, inode, index);
944 if (!(mode & FALLOC_FL_KEEP_SIZE) && offset + len > inode->i_size)
945 i_size_write(inode, offset + len);
946 inode_set_ctime_current(inode);
948 inode_unlock(inode);
955 struct inode *inode = d_inode(dentry);
956 struct hstate *h = hstate_inode(inode);
959 struct hugetlbfs_inode_info *info = HUGETLBFS_I(inode);
966 loff_t oldsize = inode->i_size;
975 hugetlb_vmtruncate(inode, newsize);
978 setattr_copy(&nop_mnt_idmap, inode, attr);
979 mark_inode_dirty(inode);
983 static struct inode *hugetlbfs_get_root(struct super_block *sb,
986 struct inode *inode;
988 inode = new_inode(sb);
989 if (inode) {
990 inode->i_ino = get_next_ino();
991 inode->i_mode = S_IFDIR | ctx->mode;
992 inode->i_uid = ctx->uid;
993 inode->i_gid = ctx->gid;
994 inode->i_atime = inode->i_mtime = inode_set_ctime_current(inode);
995 inode->i_op = &hugetlbfs_dir_inode_operations;
996 inode->i_fop = &simple_dir_operations;
998 inc_nlink(inode);
999 lockdep_annotate_inode_mutex_key(inode);
1001 return inode;
1012 static struct inode *hugetlbfs_get_inode(struct super_block *sb,
1013 struct inode *dir,
1016 struct inode *inode;
1029 inode = new_inode(sb);
1030 if (inode) {
1031 struct hugetlbfs_inode_info *info = HUGETLBFS_I(inode);
1033 inode->i_ino = get_next_ino();
1034 inode_init_owner(&nop_mnt_idmap, inode, dir, mode);
1035 lockdep_set_class(&inode->i_mapping->i_mmap_rwsem,
1037 inode->i_mapping->a_ops = &hugetlbfs_aops;
1038 inode->i_atime = inode->i_mtime = inode_set_ctime_current(inode);
1039 inode->i_mapping->private_data = resv_map;
1043 init_special_inode(inode, mode, dev);
1046 inode->i_op = &hugetlbfs_inode_operations;
1047 inode->i_fop = &hugetlbfs_file_operations;
1050 inode->i_op = &hugetlbfs_dir_inode_operations;
1051 inode->i_fop = &simple_dir_operations;
1054 inc_nlink(inode);
1057 inode->i_op = &page_symlink_inode_operations;
1058 inode_nohighmem(inode);
1061 lockdep_annotate_inode_mutex_key(inode);
1067 return inode;
1071 * File creation. Allocate an inode, and we're done..
1073 static int hugetlbfs_mknod(struct mnt_idmap *idmap, struct inode *dir,
1076 struct inode *inode;
1078 inode = hugetlbfs_get_inode(dir->i_sb, dir, mode, dev);
1079 if (!inode)
1082 d_instantiate(dentry, inode);
1087 static int hugetlbfs_mkdir(struct mnt_idmap *idmap, struct inode *dir,
1098 struct inode *dir, struct dentry *dentry,
1105 struct inode *dir, struct file *file,
1108 struct inode *inode;
1110 inode = hugetlbfs_get_inode(dir->i_sb, dir, mode | S_IFREG, 0);
1111 if (!inode)
1114 d_tmpfile(file, inode);
1119 struct inode *dir, struct dentry *dentry,
1122 struct inode *inode;
1125 inode = hugetlbfs_get_inode(dir->i_sb, dir, S_IFLNK|S_IRWXUGO, 0);
1126 if (inode) {
1128 error = page_symlink(inode, symname, l);
1130 d_instantiate(dentry, inode);
1133 iput(inode);
1284 static struct inode *hugetlbfs_alloc_inode(struct super_block *sb)
1299 * for the inode. mpol_free_shared_policy is unconditionally called
1304 * private inode. This simplifies hugetlbfs_destroy_inode.
1311 static void hugetlbfs_free_inode(struct inode *inode)
1313 kmem_cache_free(hugetlbfs_inode_cachep, HUGETLBFS_I(inode));
1316 static void hugetlbfs_destroy_inode(struct inode *inode)
1318 hugetlbfs_inc_free_inodes(HUGETLBFS_SB(inode->i_sb));
1319 mpol_free_shared_policy(&HUGETLBFS_I(inode)->policy);
1633 struct inode *inode;
1658 inode = hugetlbfs_get_inode(mnt->mnt_sb, NULL, S_IFREG | S_IRWXUGO, 0);
1659 if (!inode)
1662 inode->i_flags |= S_PRIVATE;
1664 inode->i_size = size;
1665 clear_nlink(inode);
1667 if (!hugetlb_reserve_pages(inode, 0,
1668 size >> huge_page_shift(hstate_inode(inode)), NULL,
1672 file = alloc_file_pseudo(inode, mnt, name, O_RDWR,
1677 iput(inode);