Lines Matching refs:inode
2 * fs/cifs/inode.c
42 static void cifs_set_ops(struct inode *inode)
44 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
46 switch (inode->i_mode & S_IFMT) {
48 inode->i_op = &cifs_file_inode_ops;
51 inode->i_fop = &cifs_file_direct_nobrl_ops;
53 inode->i_fop = &cifs_file_direct_ops;
56 inode->i_fop = &cifs_file_strict_nobrl_ops;
58 inode->i_fop = &cifs_file_strict_ops;
60 inode->i_fop = &cifs_file_nobrl_ops;
62 inode->i_fop = &cifs_file_ops;
68 inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
70 inode->i_data.a_ops = &cifs_addr_ops;
74 if (IS_AUTOMOUNT(inode)) {
75 inode->i_op = &cifs_dfs_referral_inode_operations;
80 inode->i_op = &cifs_dir_inode_ops;
81 inode->i_fop = &cifs_dir_ops;
85 inode->i_op = &cifs_symlink_inode_ops;
88 init_special_inode(inode, inode->i_mode, inode->i_rdev);
93 /* check inode attributes against fattr. If they don't match, tag the
94 * inode for cache invalidation
97 cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
99 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
101 cifs_dbg(FYI, "%s: revalidating inode %llu\n",
104 if (inode->i_state & I_NEW) {
105 cifs_dbg(FYI, "%s: inode %llu is new\n",
112 cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
118 fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);
119 if (timespec64_equal(&inode->i_mtime, &fattr->cf_mtime) &&
121 cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
126 cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
132 * copy nlink to the inode, unless it wasn't provided. Provide
136 cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
144 /* only provide fake values on a new inode */
145 if (inode->i_state & I_NEW) {
147 set_nlink(inode, 2);
149 set_nlink(inode, 1);
155 set_nlink(inode, fattr->cf_nlink);
158 /* populate an inode with info from a cifs_fattr struct */
160 cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
162 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
163 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
165 cifs_revalidate_cache(inode, fattr);
167 spin_lock(&inode->i_lock);
168 fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);
169 fattr->cf_atime = timestamp_truncate(fattr->cf_atime, inode);
170 fattr->cf_ctime = timestamp_truncate(fattr->cf_ctime, inode);
173 inode->i_atime = fattr->cf_mtime;
175 inode->i_atime = fattr->cf_atime;
176 inode->i_mtime = fattr->cf_mtime;
177 inode->i_ctime = fattr->cf_ctime;
178 inode->i_rdev = fattr->cf_rdev;
179 cifs_nlink_fattr_to_inode(inode, fattr);
180 inode->i_uid = fattr->cf_uid;
181 inode->i_gid = fattr->cf_gid;
184 if (inode->i_state & I_NEW ||
186 inode->i_mode = fattr->cf_mode;
206 i_size_write(inode, fattr->cf_eof);
213 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
215 spin_unlock(&inode->i_lock);
218 inode->i_flags |= S_AUTOMOUNT;
219 if (inode->i_state & I_NEW)
220 cifs_set_ops(inode);
252 * Since we set the inode type below we need to mask off
321 * Fill a cifs_fattr struct with fake inode info.
351 struct inode *inode = file_inode(filp);
352 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
361 cifs_create_dfs_fattr(&fattr, inode->i_sb);
365 cifs_fattr_to_inode(inode, &fattr);
370 int cifs_get_inode_info_unix(struct inode **pinode,
411 /* get new inode */
417 /* we already have inode, update it */
744 struct inode *inode = file_inode(filp);
757 cifs_all_info_to_fattr(&fattr, &find_data, inode->i_sb, false,
761 cifs_create_dfs_fattr(&fattr, inode->i_sb);
768 * for now, just skip revalidating and mark inode for
772 CIFS_I(inode)->time = 0;
778 * don't bother with SFU junk here -- just mark inode as needing
781 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
783 cifs_fattr_to_inode(inode, &fattr);
854 struct inode **inode,
864 if (*inode)
865 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
872 * If we have an inode pass a NULL tcon to ensure we don't
876 *inode ? NULL : tcon,
885 if (*inode)
886 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
894 /* If no errors, check for zero root inode (invalid) */
897 if (*inode) {
899 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
908 static inline bool is_inode_cache_good(struct inode *ino)
914 cifs_get_inode_info(struct inode **inode,
946 if (is_inode_cache_good(*inode)) {
947 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
1025 * 3. Get or update inode number (fattr.cf_uniqueid)
1028 cifs_set_fattr_ino(xid, tcon, sb, inode, full_path, data, &fattr);
1045 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, true,
1055 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, false,
1079 * 5. Update inode with final fattr data
1082 if (!*inode) {
1083 *inode = cifs_iget(sb, &fattr);
1084 if (!*inode)
1087 /* we already have inode, update it */
1091 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
1092 CIFS_I(*inode)->time = 0; /* force reval */
1098 if (unlikely(((*inode)->i_mode & S_IFMT) !=
1100 CIFS_I(*inode)->time = 0; /* force reval */
1105 cifs_fattr_to_inode(*inode, &fattr);
1115 smb311_posix_get_inode_info(struct inode **inode,
1138 if (is_inode_cache_good(*inode)) {
1139 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
1192 * 4. Update inode with final fattr data
1195 if (!*inode) {
1196 *inode = cifs_iget(sb, &fattr);
1197 if (!*inode)
1200 /* we already have inode, update it */
1204 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
1205 CIFS_I(*inode)->time = 0; /* force reval */
1211 if (unlikely(((*inode)->i_mode & S_IFMT) !=
1213 CIFS_I(*inode)->time = 0; /* force reval */
1218 cifs_fattr_to_inode(*inode, &fattr);
1232 cifs_find_inode(struct inode *inode, void *opaque)
1236 /* don't match inode with different uniqueid */
1237 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
1241 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
1244 /* don't match inode of different type */
1245 if (inode_wrong_type(inode, fattr->cf_mode))
1249 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
1256 cifs_init_inode(struct inode *inode, void *opaque)
1260 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
1261 CIFS_I(inode)->createtime = fattr->cf_createtime;
1266 * walk dentry list for an inode and report whether it has aliases that
1267 * are hashed. We use this to determine if a directory inode can actually
1271 inode_has_hashed_dentries(struct inode *inode)
1275 spin_lock(&inode->i_lock);
1276 hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
1278 spin_unlock(&inode->i_lock);
1282 spin_unlock(&inode->i_lock);
1286 /* Given fattrs, get a corresponding inode */
1287 struct inode *
1291 struct inode *inode;
1299 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
1300 if (inode) {
1301 /* was there a potentially problematic inode collision? */
1305 if (inode_has_hashed_dentries(inode)) {
1307 iput(inode);
1313 cifs_fattr_to_inode(inode, fattr);
1315 inode->i_flags |= S_NOATIME | S_NOCMTIME;
1316 if (inode->i_state & I_NEW) {
1317 inode->i_ino = hash;
1319 /* initialize per-inode cache cookie pointer */
1320 CIFS_I(inode)->fscache = NULL;
1322 unlock_new_inode(inode);
1326 return inode;
1329 /* gets root inode */
1330 struct inode *cifs_root_iget(struct super_block *sb)
1334 struct inode *inode = NULL;
1356 rc = cifs_get_inode_info_unix(&inode, path, sb, xid);
1366 rc = smb311_posix_get_inode_info(&inode, path, sb, xid);
1368 rc = cifs_get_inode_info(&inode, path, NULL, sb, xid, NULL);
1371 if (!inode) {
1372 inode = ERR_PTR(rc);
1378 tcon->resource_id = CIFS_I(inode)->uniqueid;
1382 cifs_dbg(FYI, "ipc connection - fake read inode\n");
1383 spin_lock(&inode->i_lock);
1384 inode->i_mode |= S_IFDIR;
1385 set_nlink(inode, 2);
1386 inode->i_op = &cifs_ipc_inode_ops;
1387 inode->i_fop = &simple_dir_operations;
1388 inode->i_uid = cifs_sb->mnt_uid;
1389 inode->i_gid = cifs_sb->mnt_gid;
1390 spin_unlock(&inode->i_lock);
1392 iget_failed(inode);
1393 inode = ERR_PTR(rc);
1399 return inode;
1403 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1407 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1450 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1466 struct inode *inode = d_inode(dentry);
1467 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1468 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1586 cifs_drop_nlink(struct inode *inode)
1588 spin_lock(&inode->i_lock);
1589 if (inode->i_nlink > 0)
1590 drop_nlink(inode);
1591 spin_unlock(&inode->i_lock);
1601 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1606 struct inode *inode = d_inode(dentry);
1659 if (inode)
1660 cifs_drop_nlink(inode);
1668 cifs_drop_nlink(inode);
1670 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1678 cifs_inode = CIFS_I(inode);
1687 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1696 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1699 if (inode) {
1700 cifs_inode = CIFS_I(inode);
1703 inode->i_ctime = current_time(inode);
1717 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1722 struct inode *inode = NULL;
1725 rc = smb311_posix_get_inode_info(&inode, full_path, parent->i_sb, xid);
1727 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1730 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1739 * inode, no need to grab the i_lock before setting the i_nlink.
1741 if (inode->i_nlink < 2)
1742 set_nlink(inode, 2);
1773 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1776 inode->i_mode = (mode | S_IFDIR);
1779 inode->i_uid = current_fsuid();
1780 if (inode->i_mode & S_ISGID)
1781 inode->i_gid = parent->i_gid;
1783 inode->i_gid = current_fsgid();
1786 d_instantiate(dentry, inode);
1791 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1798 struct inode *newinode = NULL;
1828 cifs_fill_uniqueid(inode->i_sb, &fattr);
1829 newinode = cifs_iget(inode->i_sb, &fattr);
1836 cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1848 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1853 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1863 cifs_dbg(FYI, "In cifs_mkdir, mode = %04ho inode = 0x%p\n",
1864 mode, inode);
1866 cifs_sb = CIFS_SB(inode->i_sb);
1883 rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,
1885 d_drop(direntry); /* for time being always refresh inode info */
1891 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1903 rc = server->ops->mkdir(xid, inode, mode, tcon, full_path, cifs_sb);
1911 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1918 CIFS_I(inode)->time = 0;
1925 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1936 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1946 cifs_sb = CIFS_SB(inode->i_sb);
1981 cifsInode = CIFS_I(inode);
1988 d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
1989 current_time(inode);
2063 cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
2064 struct inode *target_dir, struct dentry *target_dentry,
2115 * Are src and dst hardlinks of same inode? We can only tell
2180 cifs_inode_needs_reval(struct inode *inode)
2182 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2183 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2203 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
2213 cifs_invalidate_mapping(struct inode *inode)
2217 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
2218 rc = invalidate_inode_pages2(inode->i_mapping);
2220 cifs_dbg(VFS, "%s: Could not invalidate inode %p\n",
2221 __func__, inode);
2224 cifs_fscache_reset_inode_cookie(inode);
2242 cifs_revalidate_mapping(struct inode *inode)
2245 unsigned long *flags = &CIFS_I(inode)->flags;
2248 if (IS_SWAPFILE(inode))
2257 rc = cifs_invalidate_mapping(inode);
2270 cifs_zap_mapping(struct inode *inode)
2272 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
2273 return cifs_revalidate_mapping(inode);
2279 struct inode *inode = file_inode(filp);
2282 if (!cifs_inode_needs_reval(inode))
2297 struct inode *inode = d_inode(dentry);
2302 if (inode == NULL)
2305 if (!cifs_inode_needs_reval(inode))
2318 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2319 full_path, inode, inode->i_count.counter,
2324 rc = smb311_posix_get_inode_info(&inode, full_path, sb, xid);
2326 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2328 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2342 struct inode *inode = file_inode(filp);
2348 return cifs_revalidate_mapping(inode);
2351 /* revalidate a dentry's inode attributes */
2355 struct inode *inode = d_inode(dentry);
2361 return cifs_revalidate_mapping(inode);
2370 struct inode *inode = d_inode(dentry);
2378 !CIFS_CACHE_READ(CIFS_I(inode)) &&
2379 inode->i_mapping && inode->i_mapping->nrpages != 0) {
2380 rc = filemap_fdatawait(inode->i_mapping);
2382 mapping_set_error(inode->i_mapping, rc);
2388 CIFS_I(inode)->time = 0; /* force revalidate */
2396 (CIFS_I(inode)->time == 0)) {
2402 generic_fillattr(inode, stat);
2404 stat->ino = CIFS_I(inode)->uniqueid;
2407 if (CIFS_I(inode)->createtime) {
2410 cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
2414 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2416 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2435 int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start,
2438 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2449 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2450 inode->i_mapping->nrpages != 0) {
2451 rc = filemap_fdatawait(inode->i_mapping);
2453 mapping_set_error(inode->i_mapping, rc);
2489 void cifs_setsize(struct inode *inode, loff_t offset)
2491 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2493 spin_lock(&inode->i_lock);
2494 i_size_write(inode, offset);
2495 spin_unlock(&inode->i_lock);
2497 /* Cached inode must be refreshed on truncate */
2499 truncate_pagecache(inode, offset);
2503 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2508 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2509 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2566 cifs_setsize(inode, attrs->ia_size);
2574 inode->i_blocks = (512 - 1 + attrs->ia_size) >> 9;
2581 attrs->ia_ctime = attrs->ia_mtime = current_time(inode);
2584 cifs_truncate_page(inode->i_mapping, inode->i_size);
2596 struct inode *inode = d_inode(direntry);
2597 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2598 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2633 rc = filemap_write_and_wait(inode->i_mapping);
2639 mapping_set_error(inode->i_mapping, rc);
2643 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2714 attrs->ia_size != i_size_read(inode))
2715 truncate_setsize(inode, attrs->ia_size);
2717 setattr_copy(inode, attrs);
2718 mark_inode_dirty(inode);
2741 struct inode *inode = d_inode(direntry);
2742 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2743 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2782 rc = filemap_write_and_wait(inode->i_mapping);
2787 mapping_set_error(inode->i_mapping, rc);
2808 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2822 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2843 rc = id_mode_to_cifs_acl(inode, full_path, mode,
2858 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2867 /* reset local inode permissions to normal */
2870 if (S_ISDIR(inode->i_mode))
2885 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2904 attrs->ia_size != i_size_read(inode))
2905 truncate_setsize(inode, attrs->ia_size);
2907 setattr_copy(inode, attrs);
2908 mark_inode_dirty(inode);
2936 void cifs_delete_inode(struct inode *inode)
2938 cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);