Lines Matching refs:inode
24 * Ceph inode operations
26 * Implement basic inode helpers (get, alloc) and inode ops (getattr,
40 * find or create an inode, given the ceph ino number
42 static int ceph_set_ino_cb(struct inode *inode, void *data)
44 struct ceph_inode_info *ci = ceph_inode(inode);
45 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb);
48 inode->i_ino = ceph_vino_to_ino_t(ci->i_vino);
49 inode_set_iversion_raw(inode, 0);
55 struct inode *ceph_get_inode(struct super_block *sb, struct ceph_vino vino)
57 struct inode *inode;
62 inode = iget5_locked(sb, (unsigned long)vino.ino, ceph_ino_compare,
64 if (!inode)
67 dout("get_inode on %llu=%llx.%llx got %p new %d\n", ceph_present_inode(inode),
68 ceph_vinop(inode), inode, !!(inode->i_state & I_NEW));
69 return inode;
73 * get/constuct snapdir inode for a given directory
75 struct inode *ceph_get_snapdir(struct inode *parent)
81 struct inode *inode = ceph_get_inode(parent->i_sb, vino);
82 struct ceph_inode_info *ci = ceph_inode(inode);
85 if (IS_ERR(inode))
86 return inode;
87 inode->i_mode = parent->i_mode;
88 inode->i_uid = parent->i_uid;
89 inode->i_gid = parent->i_gid;
90 inode->i_mtime = parent->i_mtime;
91 inode->i_ctime = parent->i_ctime;
92 inode->i_atime = parent->i_atime;
96 if (inode->i_state & I_NEW) {
97 inode->i_op = &ceph_snapdir_iops;
98 inode->i_fop = &ceph_snapdir_fops;
100 unlock_new_inode(inode);
103 return inode;
118 * for a given inode (usually there is just a single fragment). We
248 static int ceph_fill_dirfrag(struct inode *inode,
251 struct ceph_inode_info *ci = ceph_inode(inode);
277 " (no ref)\n", ceph_vinop(inode), id);
283 " referral\n", ceph_vinop(inode), id);
297 ceph_vinop(inode), le32_to_cpu(dirinfo->frag));
307 ceph_vinop(inode), frag->frag, frag->ndist);
331 static int ceph_fill_fragtree(struct inode *inode,
335 struct ceph_inode_info *ci = ceph_inode(inode);
370 dout("fill_fragtree %llx.%llx\n", ceph_vinop(inode));
377 "frag %x split by %d\n", ceph_vinop(inode),
431 * initialize a newly allocated inode.
433 struct inode *ceph_alloc_inode(struct super_block *sb)
535 void ceph_free_inode(struct inode *inode)
537 struct ceph_inode_info *ci = ceph_inode(inode);
543 void ceph_evict_inode(struct inode *inode)
545 struct ceph_inode_info *ci = ceph_inode(inode);
546 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb);
550 dout("evict_inode %p ino %llx.%llx\n", inode, ceph_vinop(inode));
554 truncate_inode_pages_final(&inode->i_data);
555 clear_inode(inode);
562 ceph_adjust_quota_realms_count(inode, false);
569 if (ceph_snap(inode) == CEPH_NOSNAP) {
577 realm->inode = NULL;
616 int ceph_fill_file_size(struct inode *inode, int issued,
619 struct ceph_inode_info *ci = ceph_inode(inode);
623 (truncate_seq == ci->i_truncate_seq && size > inode->i_size)) {
624 dout("size %lld -> %llu\n", inode->i_size, size);
625 if (size > 0 && S_ISDIR(inode->i_mode)) {
629 i_size_write(inode, size);
630 inode->i_blocks = calc_inode_blocks(size);
648 mapping_mapped(inode->i_mapping) ||
663 ceph_fscache_invalidate(inode);
668 void ceph_fill_file_time(struct inode *inode, int issued,
672 struct ceph_inode_info *ci = ceph_inode(inode);
681 timespec64_compare(ctime, &inode->i_ctime) > 0) {
683 inode->i_ctime.tv_sec, inode->i_ctime.tv_nsec,
685 inode->i_ctime = *ctime;
692 inode->i_mtime.tv_sec, inode->i_mtime.tv_nsec,
696 inode->i_mtime = *mtime;
697 inode->i_atime = *atime;
701 if (timespec64_compare(mtime, &inode->i_mtime) > 0) {
703 inode->i_mtime.tv_sec,
704 inode->i_mtime.tv_nsec,
706 inode->i_mtime = *mtime;
708 if (timespec64_compare(atime, &inode->i_atime) > 0) {
710 inode->i_atime.tv_sec,
711 inode->i_atime.tv_nsec,
713 inode->i_atime = *atime;
723 inode->i_ctime = *ctime;
724 inode->i_mtime = *mtime;
725 inode->i_atime = *atime;
733 inode, time_warp_seq, ci->i_time_warp_seq);
737 * Populate an inode based on info from mds. May be called on new or
740 int ceph_fill_inode(struct inode *inode, struct page *locked_page,
746 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb);
748 struct ceph_inode_info *ci = ceph_inode(inode);
764 inode, ceph_vinop(inode), le64_to_cpu(info->version),
770 if (info_caps && ceph_snap(inode) == CEPH_NOSNAP) {
792 if (ceph_snap(inode) != CEPH_NOSNAP && !ci->i_snapid_map)
793 ci->i_snapid_map = ceph_get_snapid_map(mdsc, ceph_snap(inode));
798 * provided version will be odd if inode value is projected,
814 inode_set_max_iversion_raw(inode, iinfo->change_attr);
820 /* update inode */
821 inode->i_rdev = le32_to_cpu(info->rdev);
824 inode->i_blkbits =
827 inode->i_blkbits = CEPH_BLOCK_SHIFT;
833 inode->i_mode = le32_to_cpu(info->mode);
834 inode->i_uid = make_kuid(&init_user_ns, le32_to_cpu(info->uid));
835 inode->i_gid = make_kgid(&init_user_ns, le32_to_cpu(info->gid));
836 dout("%p mode 0%o uid.gid %d.%d\n", inode, inode->i_mode,
837 from_kuid(&init_user_ns, inode->i_uid),
838 from_kgid(&init_user_ns, inode->i_gid));
845 set_nlink(inode, le32_to_cpu(info->nlink));
852 ceph_fill_file_time(inode, issued,
877 queue_trunc = ceph_fill_file_size(inode, issued,
891 * the inode info is from auth mds */
893 if (S_ISDIR(inode->i_mode)) {
914 ceph_forget_all_cached_acls(inode);
915 ceph_security_invalidate_secctx(inode);
923 inode->i_mapping->a_ops = &ceph_aops;
925 switch (inode->i_mode & S_IFMT) {
930 inode->i_blkbits = PAGE_SHIFT;
931 init_special_inode(inode, inode->i_mode, inode->i_rdev);
932 inode->i_op = &ceph_file_iops;
935 inode->i_op = &ceph_file_iops;
936 inode->i_fop = &ceph_file_fops;
939 inode->i_op = &ceph_symlink_iops;
946 if (symlen != i_size_read(inode)) {
949 ceph_vinop(inode),
950 i_size_read(inode));
951 i_size_write(inode, symlen);
952 inode->i_blocks = calc_inode_blocks(symlen);
966 inode->i_link = ci->i_symlink;
969 inode->i_op = &ceph_dir_iops;
970 inode->i_fop = &ceph_dir_fops;
974 ceph_vinop(inode), inode->i_mode);
979 if (ceph_snap(inode) == CEPH_NOSNAP) {
980 ceph_add_cap(inode, session,
990 if (S_ISDIR(inode->i_mode) &&
995 dout(" marking %p complete (empty)\n", inode);
996 i_size_write(inode, 0);
1004 dout(" %p got snap_caps %s\n", inode,
1022 ceph_vinop(inode));
1029 ceph_fill_inline_data(inode, locked_page,
1037 ceph_queue_vmtruncate(inode);
1040 if (S_ISDIR(inode->i_mode))
1041 ceph_fill_fragtree(inode, &info->fragtree, dirinfo);
1045 ceph_fill_dirfrag(inode, dirinfo);
1060 static void __update_dentry_lease(struct inode *dir, struct dentry *dentry,
1110 static inline void update_dentry_lease(struct inode *dir, struct dentry *dentry,
1124 * update dentry lease without having parent inode locked
1135 struct inode *dir;
1149 /* make sure dentry's inode matches target. NULL ptvino means that
1169 * splice a dentry to an inode.
1172 static int splice_dentry(struct dentry **pdn, struct inode *in)
1180 /* If inode is directory, d_splice_alias() below will remove
1205 pr_err("splice_dentry error %ld %p inode %p ino %llx.%llx\n",
1212 "inode %p ino %llx.%llx\n",
1228 * one inode, or a directory, dentry, and possibly linked-to inode (e.g.,
1232 * a directory inode along with a dentry.
1233 * and/or a target inode
1241 struct inode *in = NULL;
1257 struct inode *dir = req->r_parent;
1304 dout(" dn %p points to wrong inode %p\n",
1358 * lookup link rename : null -> possibly existing inode
1359 * mknod symlink mkdir : null -> new inode
1362 struct inode *dir = req->r_parent;
1389 struct inode *olddir = req->r_old_dentry_dir;
1441 /* attach proper inode */
1467 struct inode *dir = req->r_parent;
1480 /* parent inode is not locked, be carefull */
1511 struct inode *in;
1514 vino.ino = le64_to_cpu(rde->inode.in->ino);
1515 vino.snap = le64_to_cpu(rde->inode.in->snapid);
1523 rc = ceph_fill_inode(in, NULL, &rde->inode, NULL, session,
1553 static int fill_readdir_cache(struct inode *dir, struct dentry *dn,
1600 struct inode *in;
1667 tvino.ino = le64_to_cpu(rde->inode.in->ino);
1668 tvino.snap = le64_to_cpu(rde->inode.in->snapid);
1700 dout(" dn %p points to wrong inode %p\n",
1717 /* inode */
1731 ret = ceph_fill_inode(in, NULL, &rde->inode, NULL, session,
1753 dout(" skip splicing dn %p to inode %p"
1790 bool ceph_inode_set_size(struct inode *inode, loff_t size)
1792 struct ceph_inode_info *ci = ceph_inode(inode);
1796 dout("set_size %p %llu -> %llu\n", inode, inode->i_size, size);
1797 i_size_write(inode, size);
1798 inode->i_blocks = calc_inode_blocks(size);
1807 * Put reference to inode, but avoid calling iput_final() in current thread.
1811 void ceph_async_iput(struct inode *inode)
1813 if (!inode)
1816 if (atomic_add_unless(&inode->i_count, -1, 1))
1818 if (queue_work(ceph_inode_to_client(inode)->inode_wq,
1819 &ceph_inode(inode)->i_work))
1826 * Write back inode data in a worker thread. (This can't be done
1829 void ceph_queue_writeback(struct inode *inode)
1831 struct ceph_inode_info *ci = ceph_inode(inode);
1834 ihold(inode);
1835 if (queue_work(ceph_inode_to_client(inode)->inode_wq,
1837 dout("ceph_queue_writeback %p\n", inode);
1840 inode, ci->i_work_mask);
1841 iput(inode);
1848 void ceph_queue_invalidate(struct inode *inode)
1850 struct ceph_inode_info *ci = ceph_inode(inode);
1853 ihold(inode);
1854 if (queue_work(ceph_inode_to_client(inode)->inode_wq,
1855 &ceph_inode(inode)->i_work)) {
1856 dout("ceph_queue_invalidate %p\n", inode);
1859 inode, ci->i_work_mask);
1860 iput(inode);
1868 void ceph_queue_vmtruncate(struct inode *inode)
1870 struct ceph_inode_info *ci = ceph_inode(inode);
1873 ihold(inode);
1874 if (queue_work(ceph_inode_to_client(inode)->inode_wq,
1876 dout("ceph_queue_vmtruncate %p\n", inode);
1879 inode, ci->i_work_mask);
1880 iput(inode);
1884 static void ceph_do_invalidate_pages(struct inode *inode)
1886 struct ceph_inode_info *ci = ceph_inode(inode);
1887 struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
1895 inode, ceph_ino(inode));
1896 mapping_set_error(inode->i_mapping, -EIO);
1897 truncate_pagecache(inode, 0);
1903 dout("invalidate_pages %p gen %d revoking %d\n", inode,
1915 ceph_fscache_invalidate(inode);
1916 if (invalidate_inode_pages2(inode->i_mapping) < 0) {
1917 pr_err("invalidate_pages %p fails\n", inode);
1923 dout("invalidate_pages %p gen %d successful\n", inode,
1929 inode, orig_gen, ci->i_rdcache_gen,
1945 void __ceph_do_pending_vmtruncate(struct inode *inode)
1947 struct ceph_inode_info *ci = ceph_inode(inode);
1955 dout("__do_pending_vmtruncate %p none pending\n", inode);
1968 inode);
1969 filemap_write_and_wait_range(&inode->i_data, 0,
1970 inode->i_sb->s_maxbytes);
1979 dout("__do_pending_vmtruncate %p (%d) to %lld\n", inode,
1983 truncate_pagecache(inode, to);
2006 struct inode *inode = &ci->vfs_inode;
2009 dout("writeback %p\n", inode);
2010 filemap_fdatawrite(&inode->i_data);
2013 ceph_do_invalidate_pages(inode);
2016 __ceph_do_pending_vmtruncate(inode);
2018 iput(inode);
2031 int __ceph_setattr(struct inode *inode, struct iattr *attr)
2033 struct ceph_inode_info *ci = ceph_inode(inode);
2036 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
2070 dout("setattr %p issued %s\n", inode, ceph_cap_string(issued));
2073 dout("setattr %p uid %d -> %d\n", inode,
2074 from_kuid(&init_user_ns, inode->i_uid),
2077 inode->i_uid = attr->ia_uid;
2080 !uid_eq(attr->ia_uid, inode->i_uid)) {
2088 dout("setattr %p gid %d -> %d\n", inode,
2089 from_kgid(&init_user_ns, inode->i_gid),
2092 inode->i_gid = attr->ia_gid;
2095 !gid_eq(attr->ia_gid, inode->i_gid)) {
2103 dout("setattr %p mode 0%o -> 0%o\n", inode, inode->i_mode,
2106 inode->i_mode = attr->ia_mode;
2109 attr->ia_mode != inode->i_mode) {
2110 inode->i_mode = attr->ia_mode;
2118 dout("setattr %p atime %lld.%ld -> %lld.%ld\n", inode,
2119 inode->i_atime.tv_sec, inode->i_atime.tv_nsec,
2123 inode->i_atime = attr->ia_atime;
2126 timespec64_compare(&inode->i_atime,
2128 inode->i_atime = attr->ia_atime;
2131 !timespec64_equal(&inode->i_atime, &attr->ia_atime)) {
2140 dout("setattr %p size %lld -> %lld\n", inode,
2141 inode->i_size, attr->ia_size);
2143 attr->ia_size > inode->i_size) {
2144 i_size_write(inode, attr->ia_size);
2145 inode->i_blocks = calc_inode_blocks(attr->ia_size);
2150 attr->ia_size != inode->i_size) {
2153 cpu_to_le64(inode->i_size);
2160 dout("setattr %p mtime %lld.%ld -> %lld.%ld\n", inode,
2161 inode->i_mtime.tv_sec, inode->i_mtime.tv_nsec,
2165 inode->i_mtime = attr->ia_mtime;
2168 timespec64_compare(&inode->i_mtime,
2170 inode->i_mtime = attr->ia_mtime;
2173 !timespec64_equal(&inode->i_mtime, &attr->ia_mtime)) {
2186 dout("setattr %p ctime %lld.%ld -> %lld.%ld (%s)\n", inode,
2187 inode->i_ctime.tv_sec, inode->i_ctime.tv_nsec,
2207 dout("setattr %p ATTR_FILE ... hrm!\n", inode);
2212 inode->i_ctime = attr->ia_ctime;
2221 __mark_inode_dirty(inode, inode_dirty_flags);
2225 req->r_inode = inode;
2226 ihold(inode);
2233 dout("setattr %p result=%d (%s locally, %d remote)\n", inode, err,
2240 __ceph_do_pending_vmtruncate(inode);
2250 struct inode *inode = d_inode(dentry);
2251 struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
2254 if (ceph_snap(inode) != CEPH_NOSNAP)
2262 attr->ia_size > max(inode->i_size, fsc->max_file_size))
2266 ceph_quota_is_max_bytes_exceeded(inode, attr->ia_size))
2269 err = __ceph_setattr(inode, attr);
2272 err = posix_acl_chmod(inode, attr->ia_mode);
2281 int __ceph_do_getattr(struct inode *inode, struct page *locked_page,
2284 struct ceph_fs_client *fsc = ceph_sb_to_client(inode->i_sb);
2290 if (ceph_snap(inode) == CEPH_SNAPDIR) {
2291 dout("do_getattr inode %p SNAPDIR\n", inode);
2295 dout("do_getattr inode %p mask %s mode 0%o\n",
2296 inode, ceph_cap_string(mask), inode->i_mode);
2297 if (!force && ceph_caps_issued_mask_metric(ceph_inode(inode), mask, 1))
2304 req->r_inode = inode;
2305 ihold(inode);
2328 * Check inode permissions. We verify we have a valid value for
2331 int ceph_permission(struct inode *inode, int mask)
2338 err = ceph_do_getattr(inode, CEPH_CAP_AUTH_SHARED, false);
2341 err = generic_permission(inode, mask);
2373 struct inode *inode = d_inode(path->dentry);
2374 struct ceph_inode_info *ci = ceph_inode(inode);
2380 err = ceph_do_getattr(inode, statx_to_caps(request_mask),
2386 generic_fillattr(inode, stat);
2387 stat->ino = ceph_present_inode(inode);
2398 if (ceph_snap(inode) == CEPH_NOSNAP)
2399 stat->dev = inode->i_sb->s_dev;
2403 if (S_ISDIR(inode->i_mode)) {
2404 if (ceph_test_mount_opt(ceph_sb_to_client(inode->i_sb),