blob: 2f9e7d2f81b6f5bab7866b8ba0fb73d6f1ebfd51 [file] [log] [blame]
Steve French929be902021-06-18 00:31:49 -05001// SPDX-License-Identifier: LGPL-2.1
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
Steve Frenchf19159d2010-04-21 04:12:10 +00004 * Copyright (C) International Business Machines Corp., 2002,2010
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 */
8#include <linux/fs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include <linux/stat.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090010#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#include <linux/pagemap.h>
Jeff Layton4f73c7d2014-04-30 09:31:47 -040012#include <linux/freezer.h>
Ingo Molnar174cd4b2017-02-02 19:15:33 +010013#include <linux/sched/signal.h>
Ingo Molnar5dd43ce2017-06-20 12:19:09 +020014#include <linux/wait_bit.h>
Christoph Hellwig10c5db22020-05-23 09:30:11 +020015#include <linux/fiemap.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <asm/div64.h>
17#include "cifsfs.h"
18#include "cifspdu.h"
19#include "cifsglob.h"
20#include "cifsproto.h"
Steve French6a5f6592020-06-11 19:25:47 -050021#include "smb2proto.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include "cifs_debug.h"
23#include "cifs_fs_sb.h"
Steve French2baa2682014-09-27 02:19:01 -050024#include "cifs_unicode.h"
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +053025#include "fscache.h"
Ronnie Sahlberg8401e932020-12-12 13:40:50 -060026#include "fs_context.h"
Steve French087f7572021-04-29 00:18:43 -050027#include "cifs_ioctl.h"
Christoph Hellwig70eff552008-02-15 20:55:05 +000028
David Howells01c64fe2011-01-14 18:45:47 +000029static void cifs_set_ops(struct inode *inode)
Christoph Hellwig70eff552008-02-15 20:55:05 +000030{
31 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
32
33 switch (inode->i_mode & S_IFMT) {
34 case S_IFREG:
35 inode->i_op = &cifs_file_inode_ops;
36 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
37 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
38 inode->i_fop = &cifs_file_direct_nobrl_ops;
39 else
40 inode->i_fop = &cifs_file_direct_ops;
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +030041 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
42 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
43 inode->i_fop = &cifs_file_strict_nobrl_ops;
44 else
45 inode->i_fop = &cifs_file_strict_ops;
Christoph Hellwig70eff552008-02-15 20:55:05 +000046 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
47 inode->i_fop = &cifs_file_nobrl_ops;
48 else { /* not direct, send byte range locks */
49 inode->i_fop = &cifs_file_ops;
50 }
51
Matthew Wilcox (Oracle)704528d2022-03-23 21:29:04 -040052 /* check if server can support readahead */
Jones Syue1f641d92020-04-13 09:37:23 +080053 if (cifs_sb_master_tcon(cifs_sb)->ses->server->max_read <
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +030054 PAGE_SIZE + MAX_CIFS_HDR_SIZE)
Christoph Hellwig70eff552008-02-15 20:55:05 +000055 inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
56 else
57 inode->i_data.a_ops = &cifs_addr_ops;
58 break;
59 case S_IFDIR:
Steve Frenchbc5b6e22008-03-11 21:07:48 +000060#ifdef CONFIG_CIFS_DFS_UPCALL
David Howells01c64fe2011-01-14 18:45:47 +000061 if (IS_AUTOMOUNT(inode)) {
Igor Mammedov79626702008-03-09 03:44:18 +000062 inode->i_op = &cifs_dfs_referral_inode_operations;
63 } else {
Steve Frenchbc5b6e22008-03-11 21:07:48 +000064#else /* NO DFS support, treat as a directory */
65 {
66#endif
Igor Mammedov79626702008-03-09 03:44:18 +000067 inode->i_op = &cifs_dir_inode_ops;
68 inode->i_fop = &cifs_dir_ops;
69 }
Christoph Hellwig70eff552008-02-15 20:55:05 +000070 break;
71 case S_IFLNK:
72 inode->i_op = &cifs_symlink_inode_ops;
73 break;
74 default:
75 init_special_inode(inode, inode->i_mode, inode->i_rdev);
76 break;
77 }
78}
79
Jeff Laytondf2cf172010-02-12 07:44:16 -050080/* check inode attributes against fattr. If they don't match, tag the
81 * inode for cache invalidation
82 */
83static void
84cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
85{
Rohith Surabattula40c845c2022-02-01 07:22:02 +000086 struct cifs_fscache_inode_coherency_data cd;
Jeff Laytondf2cf172010-02-12 07:44:16 -050087 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
88
Joe Perchesf96637b2013-05-04 22:12:25 -050089 cifs_dbg(FYI, "%s: revalidating inode %llu\n",
90 __func__, cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -050091
92 if (inode->i_state & I_NEW) {
Joe Perchesf96637b2013-05-04 22:12:25 -050093 cifs_dbg(FYI, "%s: inode %llu is new\n",
94 __func__, cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -050095 return;
96 }
97
98 /* don't bother with revalidation if we have an oplock */
Pavel Shilovsky18cceb62013-09-05 13:01:06 +040099 if (CIFS_CACHE_READ(cifs_i)) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500100 cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
101 __func__, cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -0500102 return;
103 }
104
105 /* revalidate if mtime or size have changed */
Deepa Dinamani918c9002019-12-02 21:19:41 -0800106 fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);
Arnd Bergmann95390202018-06-19 17:27:58 +0200107 if (timespec64_equal(&inode->i_mtime, &fattr->cf_mtime) &&
Jeff Laytondf2cf172010-02-12 07:44:16 -0500108 cifs_i->server_eof == fattr->cf_eof) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500109 cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
110 __func__, cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -0500111 return;
112 }
113
Joe Perchesf96637b2013-05-04 22:12:25 -0500114 cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
115 __func__, cifs_i->uniqueid);
Jeff Laytonaff8d5c2014-04-30 09:31:45 -0400116 set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags);
Rohith Surabattula40c845c2022-02-01 07:22:02 +0000117 /* Invalidate fscache cookie */
118 cifs_fscache_fill_coherency(&cifs_i->vfs_inode, &cd);
119 fscache_invalidate(cifs_inode_cookie(inode), &cd, i_size_read(inode), 0);
Jeff Laytondf2cf172010-02-12 07:44:16 -0500120}
121
Jim McDonough74d290d2013-09-21 10:36:10 -0500122/*
123 * copy nlink to the inode, unless it wasn't provided. Provide
124 * sane values if we don't have an existing one and none was provided
125 */
126static void
127cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
128{
129 /*
130 * if we're in a situation where we can't trust what we
131 * got from the server (readdir, some non-unix cases)
132 * fake reasonable values
133 */
134 if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
135 /* only provide fake values on a new inode */
136 if (inode->i_state & I_NEW) {
137 if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
138 set_nlink(inode, 2);
139 else
140 set_nlink(inode, 1);
141 }
142 return;
143 }
144
145 /* we trust the server, so update it */
146 set_nlink(inode, fattr->cf_nlink);
147}
148
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400149/* populate an inode with info from a cifs_fattr struct */
Al Viro4d669522021-02-10 21:23:04 -0500150int
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400151cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
Christoph Hellwig75f12982008-02-25 20:25:21 +0000152{
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400153 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400154 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Christoph Hellwig75f12982008-02-25 20:25:21 +0000155
Al Viro4d669522021-02-10 21:23:04 -0500156 if (!(inode->i_state & I_NEW) &&
157 unlikely(inode_wrong_type(inode, fattr->cf_mode))) {
158 CIFS_I(inode)->time = 0; /* force reval */
159 return -ESTALE;
160 }
161
Jeff Laytondf2cf172010-02-12 07:44:16 -0500162 cifs_revalidate_cache(inode, fattr);
163
Steve Frenchb7ca6922012-08-03 08:43:01 -0500164 spin_lock(&inode->i_lock);
Deepa Dinamani918c9002019-12-02 21:19:41 -0800165 fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);
166 fattr->cf_atime = timestamp_truncate(fattr->cf_atime, inode);
167 fattr->cf_ctime = timestamp_truncate(fattr->cf_ctime, inode);
Steve French9b9c5be2018-09-22 12:07:06 -0500168 /* we do not want atime to be less than mtime, it broke some apps */
Deepa Dinamani69738cf2019-11-29 21:30:25 -0800169 if (timespec64_compare(&fattr->cf_atime, &fattr->cf_mtime) < 0)
Steve French9b9c5be2018-09-22 12:07:06 -0500170 inode->i_atime = fattr->cf_mtime;
171 else
172 inode->i_atime = fattr->cf_atime;
Arnd Bergmann95390202018-06-19 17:27:58 +0200173 inode->i_mtime = fattr->cf_mtime;
174 inode->i_ctime = fattr->cf_ctime;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400175 inode->i_rdev = fattr->cf_rdev;
Jim McDonough74d290d2013-09-21 10:36:10 -0500176 cifs_nlink_fattr_to_inode(inode, fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400177 inode->i_uid = fattr->cf_uid;
178 inode->i_gid = fattr->cf_gid;
179
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400180 /* if dynperm is set, don't clobber existing mode */
181 if (inode->i_state & I_NEW ||
182 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
183 inode->i_mode = fattr->cf_mode;
184
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400185 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400186
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400187 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
188 cifs_i->time = 0;
189 else
190 cifs_i->time = jiffies;
191
Jeff Laytonaff8d5c2014-04-30 09:31:45 -0400192 if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING)
193 set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
194 else
195 clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
Christoph Hellwig75f12982008-02-25 20:25:21 +0000196
Jeff Layton835a36c2010-02-10 16:21:33 -0500197 cifs_i->server_eof = fattr->cf_eof;
Christoph Hellwig75f12982008-02-25 20:25:21 +0000198 /*
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400199 * Can't safely change the file size here if the client is writing to
200 * it due to potential races.
Christoph Hellwig75f12982008-02-25 20:25:21 +0000201 */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400202 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
203 i_size_write(inode, fattr->cf_eof);
Christoph Hellwig75f12982008-02-25 20:25:21 +0000204
205 /*
206 * i_blocks is not related to (i_size / i_blksize),
207 * but instead 512 byte (2**9) size is required for
208 * calculating num blocks.
209 */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400210 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
Christoph Hellwig75f12982008-02-25 20:25:21 +0000211 }
212 spin_unlock(&inode->i_lock);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400213
David Howells01c64fe2011-01-14 18:45:47 +0000214 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
215 inode->i_flags |= S_AUTOMOUNT;
Jeff Laytonc2b93e02013-05-07 11:28:31 -0400216 if (inode->i_state & I_NEW)
217 cifs_set_ops(inode);
Al Viro4d669522021-02-10 21:23:04 -0500218 return 0;
Christoph Hellwig75f12982008-02-25 20:25:21 +0000219}
220
Jeff Layton4065c802010-05-17 07:18:58 -0400221void
222cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
223{
224 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
225
226 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
227 return;
228
229 fattr->cf_uniqueid = iunique(sb, ROOT_I);
230}
231
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400232/* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
233void
234cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
235 struct cifs_sb_info *cifs_sb)
236{
237 memset(fattr, 0, sizeof(*fattr));
238 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
239 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
240 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
241
242 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
243 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
244 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
Steve French6e70e262017-09-21 21:32:29 -0500245 /* old POSIX extensions don't get create time */
246
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400247 fattr->cf_mode = le64_to_cpu(info->Permissions);
248
249 /*
250 * Since we set the inode type below we need to mask off
251 * to avoid strange results if bits set above.
252 */
253 fattr->cf_mode &= ~S_IFMT;
254 switch (le32_to_cpu(info->Type)) {
255 case UNIX_FILE:
256 fattr->cf_mode |= S_IFREG;
257 fattr->cf_dtype = DT_REG;
258 break;
259 case UNIX_SYMLINK:
260 fattr->cf_mode |= S_IFLNK;
261 fattr->cf_dtype = DT_LNK;
262 break;
263 case UNIX_DIR:
264 fattr->cf_mode |= S_IFDIR;
265 fattr->cf_dtype = DT_DIR;
266 break;
267 case UNIX_CHARDEV:
268 fattr->cf_mode |= S_IFCHR;
269 fattr->cf_dtype = DT_CHR;
270 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
271 le64_to_cpu(info->DevMinor) & MINORMASK);
272 break;
273 case UNIX_BLOCKDEV:
274 fattr->cf_mode |= S_IFBLK;
275 fattr->cf_dtype = DT_BLK;
276 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
277 le64_to_cpu(info->DevMinor) & MINORMASK);
278 break;
279 case UNIX_FIFO:
280 fattr->cf_mode |= S_IFIFO;
281 fattr->cf_dtype = DT_FIFO;
282 break;
283 case UNIX_SOCKET:
284 fattr->cf_mode |= S_IFSOCK;
285 fattr->cf_dtype = DT_SOCK;
286 break;
287 default:
288 /* safest to call it a file if we do not know */
289 fattr->cf_mode |= S_IFREG;
290 fattr->cf_dtype = DT_REG;
Joe Perchesf96637b2013-05-04 22:12:25 -0500291 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400292 break;
293 }
294
Ronnie Sahlberg8401e932020-12-12 13:40:50 -0600295 fattr->cf_uid = cifs_sb->ctx->linux_uid;
Eric W. Biederman46bbc252013-02-05 23:55:44 -0800296 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
297 u64 id = le64_to_cpu(info->Uid);
Eric W. Biederman4a2c8cf52013-02-06 01:53:25 -0800298 if (id < ((uid_t)-1)) {
299 kuid_t uid = make_kuid(&init_user_ns, id);
300 if (uid_valid(uid))
301 fattr->cf_uid = uid;
302 }
Eric W. Biederman46bbc252013-02-05 23:55:44 -0800303 }
304
Ronnie Sahlberg8401e932020-12-12 13:40:50 -0600305 fattr->cf_gid = cifs_sb->ctx->linux_gid;
Eric W. Biederman46bbc252013-02-05 23:55:44 -0800306 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
307 u64 id = le64_to_cpu(info->Gid);
Eric W. Biederman4a2c8cf52013-02-06 01:53:25 -0800308 if (id < ((gid_t)-1)) {
309 kgid_t gid = make_kgid(&init_user_ns, id);
310 if (gid_valid(gid))
311 fattr->cf_gid = gid;
312 }
Eric W. Biederman46bbc252013-02-05 23:55:44 -0800313 }
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400314
315 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
316}
Steve Frenchb9a3260f2008-05-20 21:52:32 +0000317
318/*
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400319 * Fill a cifs_fattr struct with fake inode info.
320 *
321 * Needed to setup cifs_fattr data for the directory which is the
322 * junction to the new submount (ie to setup the fake directory
323 * which represents a DFS referral).
Steve Frenchb9a3260f2008-05-20 21:52:32 +0000324 */
Steve Frenchf1230c92009-07-22 23:13:01 +0000325static void
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400326cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
Steve French0e4bbde2008-05-20 19:50:46 +0000327{
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400328 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Steve French0e4bbde2008-05-20 19:50:46 +0000329
Joe Perchesf96637b2013-05-04 22:12:25 -0500330 cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
Steve French0e4bbde2008-05-20 19:50:46 +0000331
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400332 memset(fattr, 0, sizeof(*fattr));
333 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
Ronnie Sahlberg8401e932020-12-12 13:40:50 -0600334 fattr->cf_uid = cifs_sb->ctx->linux_uid;
335 fattr->cf_gid = cifs_sb->ctx->linux_gid;
Deepa Dinamani918c9002019-12-02 21:19:41 -0800336 ktime_get_coarse_real_ts64(&fattr->cf_mtime);
Deepa Dinamanie37fea52017-05-08 15:59:16 -0700337 fattr->cf_atime = fattr->cf_ctime = fattr->cf_mtime;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400338 fattr->cf_nlink = 2;
Steve French97aa4952018-11-15 00:33:05 -0600339 fattr->cf_flags = CIFS_FATTR_DFS_REFERRAL;
Steve French0e4bbde2008-05-20 19:50:46 +0000340}
341
Pavel Shilovsky4ad65042012-09-18 16:20:26 -0700342static int
343cifs_get_file_info_unix(struct file *filp)
Jeff Laytonabab0952010-02-12 07:44:18 -0500344{
345 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400346 unsigned int xid;
Jeff Laytonabab0952010-02-12 07:44:18 -0500347 FILE_UNIX_BASIC_INFO find_data;
348 struct cifs_fattr fattr;
Al Viro496ad9a2013-01-23 17:07:38 -0500349 struct inode *inode = file_inode(filp);
Jeff Laytonabab0952010-02-12 07:44:18 -0500350 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Joe Perchesc21dfb62010-07-12 13:50:14 -0700351 struct cifsFileInfo *cfile = filp->private_data;
Steve French96daf2b2011-05-27 04:34:02 +0000352 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Jeff Laytonabab0952010-02-12 07:44:18 -0500353
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400354 xid = get_xid();
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700355 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
Jeff Laytonabab0952010-02-12 07:44:18 -0500356 if (!rc) {
357 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
358 } else if (rc == -EREMOTE) {
359 cifs_create_dfs_fattr(&fattr, inode->i_sb);
360 rc = 0;
Steve Frenche39df242021-06-19 15:53:18 -0500361 } else
362 goto cifs_gfiunix_out;
Jeff Laytonabab0952010-02-12 07:44:18 -0500363
Al Viro4d669522021-02-10 21:23:04 -0500364 rc = cifs_fattr_to_inode(inode, &fattr);
Steve Frenche39df242021-06-19 15:53:18 -0500365
366cifs_gfiunix_out:
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400367 free_xid(xid);
Jeff Laytonabab0952010-02-12 07:44:18 -0500368 return rc;
369}
370
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371int cifs_get_inode_info_unix(struct inode **pinode,
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400372 const unsigned char *full_path,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400373 struct super_block *sb, unsigned int xid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374{
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400375 int rc;
Steve French0e4bbde2008-05-20 19:50:46 +0000376 FILE_UNIX_BASIC_INFO find_data;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400377 struct cifs_fattr fattr;
Steve French96daf2b2011-05-27 04:34:02 +0000378 struct cifs_tcon *tcon;
Jeff Layton7ffec372010-09-29 19:51:11 -0400379 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
Joe Perchesf96637b2013-05-04 22:12:25 -0500382 cifs_dbg(FYI, "Getting info on %s\n", full_path);
Igor Mammedov79626702008-03-09 03:44:18 +0000383
Jeff Layton7ffec372010-09-29 19:51:11 -0400384 tlink = cifs_sb_tlink(cifs_sb);
385 if (IS_ERR(tlink))
386 return PTR_ERR(tlink);
387 tcon = tlink_tcon(tlink);
388
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 /* could have done a find first instead but this returns more info */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400390 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
Nakajima Akirabc8ebdc42015-02-13 15:35:58 +0900391 cifs_sb->local_nls, cifs_remap(cifs_sb));
Jeff Layton7ffec372010-09-29 19:51:11 -0400392 cifs_put_tlink(tlink);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400393
394 if (!rc) {
395 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
396 } else if (rc == -EREMOTE) {
397 cifs_create_dfs_fattr(&fattr, sb);
Jeff Laytone911d0c2008-07-12 13:47:59 -0700398 rc = 0;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400399 } else {
400 return rc;
Steve French0e4bbde2008-05-20 19:50:46 +0000401 }
402
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200403 /* check for Minshall+French symlinks */
404 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
Sachin Prabhucb084b12013-11-25 17:09:50 +0000405 int tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
406 full_path);
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200407 if (tmprc)
Sachin Prabhucb084b12013-11-25 17:09:50 +0000408 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200409 }
410
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400411 if (*pinode == NULL) {
412 /* get new inode */
Jeff Layton4065c802010-05-17 07:18:58 -0400413 cifs_fill_uniqueid(sb, &fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400414 *pinode = cifs_iget(sb, &fattr);
415 if (!*pinode)
416 rc = -ENOMEM;
417 } else {
418 /* we already have inode, update it */
Nakajima Akira7196ac12015-04-22 15:24:44 +0900419
420 /* if uniqueid is different, return error */
421 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
422 CIFS_I(*pinode)->uniqueid != fattr.cf_uniqueid)) {
Pavel Shilovskyc82e5ac2019-09-30 10:06:19 -0700423 CIFS_I(*pinode)->time = 0; /* force reval */
Nakajima Akira7196ac12015-04-22 15:24:44 +0900424 rc = -ESTALE;
425 goto cgiiu_exit;
426 }
427
428 /* if filetype is different, return error */
Al Viro4d669522021-02-10 21:23:04 -0500429 rc = cifs_fattr_to_inode(*pinode, &fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400430 }
Steve French0e4bbde2008-05-20 19:50:46 +0000431
Nakajima Akira7196ac12015-04-22 15:24:44 +0900432cgiiu_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 return rc;
434}
435
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400436static int
Pavel Shilovsky0360d602014-01-16 15:53:35 +0400437cifs_sfu_type(struct cifs_fattr *fattr, const char *path,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400438 struct cifs_sb_info *cifs_sb, unsigned int xid)
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800439{
440 int rc;
Steve Frenchdb8b6312014-09-22 05:13:55 -0500441 __u32 oplock;
Jeff Layton7ffec372010-09-29 19:51:11 -0400442 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +0000443 struct cifs_tcon *tcon;
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +0400444 struct cifs_fid fid;
445 struct cifs_open_parms oparms;
Aurelien Aptel7c065142020-06-04 17:23:55 +0200446 struct cifs_io_parms io_parms = {0};
Steve French86c96b42005-11-18 20:25:31 -0800447 char buf[24];
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800448 unsigned int bytes_read;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000449 char *pbuf;
Pavel Shilovsky0360d602014-01-16 15:53:35 +0400450 int buf_type = CIFS_NO_BUFFER;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800451
452 pbuf = buf;
453
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400454 fattr->cf_mode &= ~S_IFMT;
455
456 if (fattr->cf_eof == 0) {
457 fattr->cf_mode |= S_IFIFO;
458 fattr->cf_dtype = DT_FIFO;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800459 return 0;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400460 } else if (fattr->cf_eof < 8) {
461 fattr->cf_mode |= S_IFREG;
462 fattr->cf_dtype = DT_REG;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800463 return -EINVAL; /* EOPNOTSUPP? */
464 }
Steve French50c2f752007-07-13 00:33:32 +0000465
Jeff Layton7ffec372010-09-29 19:51:11 -0400466 tlink = cifs_sb_tlink(cifs_sb);
467 if (IS_ERR(tlink))
468 return PTR_ERR(tlink);
469 tcon = tlink_tcon(tlink);
470
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +0400471 oparms.tcon = tcon;
472 oparms.cifs_sb = cifs_sb;
473 oparms.desired_access = GENERIC_READ;
Amir Goldstein0f060932020-02-03 21:46:43 +0200474 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +0400475 oparms.disposition = FILE_OPEN;
476 oparms.path = path;
477 oparms.fid = &fid;
478 oparms.reconnect = false;
479
Steve Frenchdb8b6312014-09-22 05:13:55 -0500480 if (tcon->ses->server->oplocks)
481 oplock = REQ_OPLOCK;
482 else
483 oplock = 0;
484 rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);
Pavel Shilovsky0360d602014-01-16 15:53:35 +0400485 if (rc) {
Steve Frenchdb8b6312014-09-22 05:13:55 -0500486 cifs_dbg(FYI, "check sfu type of %s, open rc = %d\n", path, rc);
Pavel Shilovsky0360d602014-01-16 15:53:35 +0400487 cifs_put_tlink(tlink);
488 return rc;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800489 }
Pavel Shilovsky0360d602014-01-16 15:53:35 +0400490
491 /* Read header */
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +0400492 io_parms.netfid = fid.netfid;
Pavel Shilovsky0360d602014-01-16 15:53:35 +0400493 io_parms.pid = current->tgid;
494 io_parms.tcon = tcon;
495 io_parms.offset = 0;
496 io_parms.length = 24;
497
Steve Frenchdb8b6312014-09-22 05:13:55 -0500498 rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,
499 &bytes_read, &pbuf, &buf_type);
Pavel Shilovsky0360d602014-01-16 15:53:35 +0400500 if ((rc == 0) && (bytes_read >= 8)) {
501 if (memcmp("IntxBLK", pbuf, 8) == 0) {
502 cifs_dbg(FYI, "Block device\n");
503 fattr->cf_mode |= S_IFBLK;
504 fattr->cf_dtype = DT_BLK;
505 if (bytes_read == 24) {
506 /* we have enough to decode dev num */
507 __u64 mjr; /* major */
508 __u64 mnr; /* minor */
509 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
510 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
511 fattr->cf_rdev = MKDEV(mjr, mnr);
512 }
513 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
514 cifs_dbg(FYI, "Char device\n");
515 fattr->cf_mode |= S_IFCHR;
516 fattr->cf_dtype = DT_CHR;
517 if (bytes_read == 24) {
518 /* we have enough to decode dev num */
519 __u64 mjr; /* major */
520 __u64 mnr; /* minor */
521 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
522 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
523 fattr->cf_rdev = MKDEV(mjr, mnr);
524 }
525 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
526 cifs_dbg(FYI, "Symlink\n");
527 fattr->cf_mode |= S_IFLNK;
528 fattr->cf_dtype = DT_LNK;
529 } else {
530 fattr->cf_mode |= S_IFREG; /* file? */
531 fattr->cf_dtype = DT_REG;
532 rc = -EOPNOTSUPP;
533 }
534 } else {
535 fattr->cf_mode |= S_IFREG; /* then it is a file */
536 fattr->cf_dtype = DT_REG;
537 rc = -EOPNOTSUPP; /* or some unknown SFU type */
538 }
Steve Frenchdb8b6312014-09-22 05:13:55 -0500539
540 tcon->ses->server->ops->close(xid, tcon, &fid);
Jeff Layton7ffec372010-09-29 19:51:11 -0400541 cifs_put_tlink(tlink);
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800542 return rc;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800543}
544
Steve French9e294f12005-11-17 16:59:21 -0800545#define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
546
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400547/*
548 * Fetch mode bits as provided by SFU.
549 *
550 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
551 */
552static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400553 struct cifs_sb_info *cifs_sb, unsigned int xid)
Steve French9e294f12005-11-17 16:59:21 -0800554{
Steve French3020a1f2005-11-18 11:31:10 -0800555#ifdef CONFIG_CIFS_XATTR
Steve French9e294f12005-11-17 16:59:21 -0800556 ssize_t rc;
557 char ea_value[4];
558 __u32 mode;
Jeff Layton7ffec372010-09-29 19:51:11 -0400559 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +0000560 struct cifs_tcon *tcon;
Steve French9e294f12005-11-17 16:59:21 -0800561
Jeff Layton7ffec372010-09-29 19:51:11 -0400562 tlink = cifs_sb_tlink(cifs_sb);
563 if (IS_ERR(tlink))
564 return PTR_ERR(tlink);
565 tcon = tlink_tcon(tlink);
566
Steve Frenchd979f3b2014-02-01 23:27:18 -0600567 if (tcon->ses->server->ops->query_all_EAs == NULL) {
568 cifs_put_tlink(tlink);
569 return -EOPNOTSUPP;
570 }
571
572 rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
573 "SETFILEBITS", ea_value, 4 /* size of buf */,
Steve French67b4c882017-05-12 20:59:10 -0500574 cifs_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400575 cifs_put_tlink(tlink);
Steve French4523cc32007-04-30 20:13:06 +0000576 if (rc < 0)
Steve French9e294f12005-11-17 16:59:21 -0800577 return (int)rc;
578 else if (rc > 3) {
579 mode = le32_to_cpu(*((__le32 *)ea_value));
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400580 fattr->cf_mode &= ~SFBITS_MASK;
Joe Perchesf96637b2013-05-04 22:12:25 -0500581 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
582 mode, fattr->cf_mode);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400583 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
Joe Perchesf96637b2013-05-04 22:12:25 -0500584 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
Steve French9e294f12005-11-17 16:59:21 -0800585 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400586
587 return 0;
Steve French3020a1f2005-11-18 11:31:10 -0800588#else
589 return -EOPNOTSUPP;
590#endif
Steve French9e294f12005-11-17 16:59:21 -0800591}
592
Steve French6a5f6592020-06-11 19:25:47 -0500593/* Fill a cifs_fattr struct with info from POSIX info struct */
594static void
595smb311_posix_info_to_fattr(struct cifs_fattr *fattr, struct smb311_posix_qinfo *info,
596 struct super_block *sb, bool adjust_tz, bool symlink)
597{
598 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
599 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
600
601 memset(fattr, 0, sizeof(*fattr));
602
603 /* no fattr->flags to set */
604 fattr->cf_cifsattrs = le32_to_cpu(info->DosAttributes);
605 fattr->cf_uniqueid = le64_to_cpu(info->Inode);
606
607 if (info->LastAccessTime)
608 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
609 else
610 ktime_get_coarse_real_ts64(&fattr->cf_atime);
611
612 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
613 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
614
615 if (adjust_tz) {
616 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
617 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
618 }
619
620 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
621 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
622 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
623
624 fattr->cf_nlink = le32_to_cpu(info->HardLinks);
625 fattr->cf_mode = (umode_t) le32_to_cpu(info->Mode);
626 /* The srv fs device id is overridden on network mount so setting rdev isn't needed here */
627 /* fattr->cf_rdev = le32_to_cpu(info->DeviceId); */
628
629 if (symlink) {
630 fattr->cf_mode |= S_IFLNK;
631 fattr->cf_dtype = DT_LNK;
632 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
633 fattr->cf_mode |= S_IFDIR;
634 fattr->cf_dtype = DT_DIR;
635 } else { /* file */
636 fattr->cf_mode |= S_IFREG;
637 fattr->cf_dtype = DT_REG;
638 }
639 /* else if reparse point ... TODO: add support for FIFO and blk dev; special file types */
640
Ronnie Sahlberg8401e932020-12-12 13:40:50 -0600641 fattr->cf_uid = cifs_sb->ctx->linux_uid; /* TODO: map uid and gid from SID */
642 fattr->cf_gid = cifs_sb->ctx->linux_gid;
Steve French6a5f6592020-06-11 19:25:47 -0500643
644 cifs_dbg(FYI, "POSIX query info: mode 0x%x uniqueid 0x%llx nlink %d\n",
645 fattr->cf_mode, fattr->cf_uniqueid, fattr->cf_nlink);
646}
647
648
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400649/* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
Steve Frenchf1230c92009-07-22 23:13:01 +0000650static void
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400651cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
Deepa Dinamanie37fea52017-05-08 15:59:16 -0700652 struct super_block *sb, bool adjust_tz,
Steve French2e4564b2020-10-22 22:03:14 -0500653 bool symlink, u32 reparse_tag)
Steve Frenchb9a3260f2008-05-20 21:52:32 +0000654{
Deepa Dinamanie37fea52017-05-08 15:59:16 -0700655 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Steve French96daf2b2011-05-27 04:34:02 +0000656 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Jeff Layton0d424ad2010-09-20 16:01:35 -0700657
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400658 memset(fattr, 0, sizeof(*fattr));
659 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
660 if (info->DeletePending)
661 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
Steve Frenchb9a3260f2008-05-20 21:52:32 +0000662
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400663 if (info->LastAccessTime)
664 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
Deepa Dinamani918c9002019-12-02 21:19:41 -0800665 else
666 ktime_get_coarse_real_ts64(&fattr->cf_atime);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400667
668 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
669 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
670
671 if (adjust_tz) {
Jeff Layton0d424ad2010-09-20 16:01:35 -0700672 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
673 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400674 }
675
676 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
677 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
Jeff Layton20054bd2011-01-07 11:30:27 -0500678 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400679
Jim McDonough74d290d2013-09-21 10:36:10 -0500680 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
Steve French2e4564b2020-10-22 22:03:14 -0500681 if (reparse_tag == IO_REPARSE_TAG_LX_SYMLINK) {
Ronnie Sahlberg8401e932020-12-12 13:40:50 -0600682 fattr->cf_mode |= S_IFLNK | cifs_sb->ctx->file_mode;
Steve French2e4564b2020-10-22 22:03:14 -0500683 fattr->cf_dtype = DT_LNK;
684 } else if (reparse_tag == IO_REPARSE_TAG_LX_FIFO) {
Ronnie Sahlberg8401e932020-12-12 13:40:50 -0600685 fattr->cf_mode |= S_IFIFO | cifs_sb->ctx->file_mode;
Steve French2e4564b2020-10-22 22:03:14 -0500686 fattr->cf_dtype = DT_FIFO;
687 } else if (reparse_tag == IO_REPARSE_TAG_AF_UNIX) {
Ronnie Sahlberg8401e932020-12-12 13:40:50 -0600688 fattr->cf_mode |= S_IFSOCK | cifs_sb->ctx->file_mode;
Steve French2e4564b2020-10-22 22:03:14 -0500689 fattr->cf_dtype = DT_SOCK;
690 } else if (reparse_tag == IO_REPARSE_TAG_LX_CHR) {
Ronnie Sahlberg8401e932020-12-12 13:40:50 -0600691 fattr->cf_mode |= S_IFCHR | cifs_sb->ctx->file_mode;
Steve French2e4564b2020-10-22 22:03:14 -0500692 fattr->cf_dtype = DT_CHR;
693 } else if (reparse_tag == IO_REPARSE_TAG_LX_BLK) {
Ronnie Sahlberg8401e932020-12-12 13:40:50 -0600694 fattr->cf_mode |= S_IFBLK | cifs_sb->ctx->file_mode;
Steve French2e4564b2020-10-22 22:03:14 -0500695 fattr->cf_dtype = DT_BLK;
696 } else if (symlink) { /* TODO add more reparse tag checks */
Pavel Shilovskyeb85d94b2013-10-23 17:49:47 +0400697 fattr->cf_mode = S_IFLNK;
698 fattr->cf_dtype = DT_LNK;
699 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
Ronnie Sahlberg8401e932020-12-12 13:40:50 -0600700 fattr->cf_mode = S_IFDIR | cifs_sb->ctx->dir_mode;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400701 fattr->cf_dtype = DT_DIR;
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +0300702 /*
703 * Server can return wrong NumberOfLinks value for directories
704 * when Unix extensions are disabled - fake it.
705 */
Jim McDonough74d290d2013-09-21 10:36:10 -0500706 if (!tcon->unix_ext)
707 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400708 } else {
Ronnie Sahlberg8401e932020-12-12 13:40:50 -0600709 fattr->cf_mode = S_IFREG | cifs_sb->ctx->file_mode;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400710 fattr->cf_dtype = DT_REG;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400711
Jeff Laytond0c280d2009-07-09 01:46:44 -0400712 /* clear write bits if ATTR_READONLY is set */
713 if (fattr->cf_cifsattrs & ATTR_READONLY)
714 fattr->cf_mode &= ~(S_IWUGO);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400715
Jim McDonough74d290d2013-09-21 10:36:10 -0500716 /*
717 * Don't accept zero nlink from non-unix servers unless
718 * delete is pending. Instead mark it as unknown.
719 */
720 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
721 !info->DeletePending) {
Joe Perchesfb4b5f12020-02-21 05:20:45 -0800722 cifs_dbg(VFS, "bogus file nlink value %u\n",
723 fattr->cf_nlink);
Jim McDonough74d290d2013-09-21 10:36:10 -0500724 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
Steve French6658b9f2013-07-04 14:38:48 -0500725 }
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +0300726 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400727
Ronnie Sahlberg8401e932020-12-12 13:40:50 -0600728 fattr->cf_uid = cifs_sb->ctx->linux_uid;
729 fattr->cf_gid = cifs_sb->ctx->linux_gid;
Steve Frenchb9a3260f2008-05-20 21:52:32 +0000730}
731
Pavel Shilovsky4ad65042012-09-18 16:20:26 -0700732static int
733cifs_get_file_info(struct file *filp)
Jeff Laytonabab0952010-02-12 07:44:18 -0500734{
735 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400736 unsigned int xid;
Jeff Laytonabab0952010-02-12 07:44:18 -0500737 FILE_ALL_INFO find_data;
738 struct cifs_fattr fattr;
Al Viro496ad9a2013-01-23 17:07:38 -0500739 struct inode *inode = file_inode(filp);
Joe Perchesc21dfb62010-07-12 13:50:14 -0700740 struct cifsFileInfo *cfile = filp->private_data;
Steve French96daf2b2011-05-27 04:34:02 +0000741 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky4ad65042012-09-18 16:20:26 -0700742 struct TCP_Server_Info *server = tcon->ses->server;
743
744 if (!server->ops->query_file_info)
745 return -ENOSYS;
Jeff Laytonabab0952010-02-12 07:44:18 -0500746
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400747 xid = get_xid();
Pavel Shilovsky4ad65042012-09-18 16:20:26 -0700748 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400749 switch (rc) {
750 case 0:
Steve French2e4564b2020-10-22 22:03:14 -0500751 /* TODO: add support to query reparse tag */
Deepa Dinamanie37fea52017-05-08 15:59:16 -0700752 cifs_all_info_to_fattr(&fattr, &find_data, inode->i_sb, false,
Steve French2e4564b2020-10-22 22:03:14 -0500753 false, 0 /* no reparse tag */);
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400754 break;
755 case -EREMOTE:
756 cifs_create_dfs_fattr(&fattr, inode->i_sb);
757 rc = 0;
758 break;
759 case -EOPNOTSUPP:
760 case -EINVAL:
Jeff Laytonabab0952010-02-12 07:44:18 -0500761 /*
762 * FIXME: legacy server -- fall back to path-based call?
Steve Frenchff2157132010-03-09 20:30:42 +0000763 * for now, just skip revalidating and mark inode for
764 * immediate reval.
765 */
Jeff Laytonabab0952010-02-12 07:44:18 -0500766 rc = 0;
767 CIFS_I(inode)->time = 0;
Gustavo A. R. Silva21ac58f42020-11-20 12:24:14 -0600768 goto cgfi_exit;
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400769 default:
Jeff Laytonabab0952010-02-12 07:44:18 -0500770 goto cgfi_exit;
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400771 }
Jeff Laytonabab0952010-02-12 07:44:18 -0500772
773 /*
774 * don't bother with SFU junk here -- just mark inode as needing
775 * revalidation.
776 */
Jeff Laytonabab0952010-02-12 07:44:18 -0500777 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
778 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
Al Viro4d669522021-02-10 21:23:04 -0500779 /* if filetype is different, return error */
780 rc = cifs_fattr_to_inode(inode, &fattr);
Jeff Laytonabab0952010-02-12 07:44:18 -0500781cgfi_exit:
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400782 free_xid(xid);
Jeff Laytonabab0952010-02-12 07:44:18 -0500783 return rc;
784}
785
Steve French7ea884c2018-03-31 18:13:38 -0500786/* Simple function to return a 64 bit hash of string. Rarely called */
787static __u64 simple_hashstr(const char *str)
788{
Geert Uytterhoeven3995bbf2018-04-05 14:57:11 +0200789 const __u64 hash_mult = 1125899906842597ULL; /* a big enough prime */
Steve French7ea884c2018-03-31 18:13:38 -0500790 __u64 hash = 0;
791
792 while (*str)
793 hash = (hash + (__u64) *str++) * hash_mult;
794
795 return hash;
796}
797
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100798/**
799 * cifs_backup_query_path_info - SMB1 fallback code to get ino
800 *
801 * Fallback code to get file metadata when we don't have access to
Steve French607dfc72020-12-12 12:08:58 -0600802 * full_path (EACCES) and have backup creds.
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100803 *
Steve French607dfc72020-12-12 12:08:58 -0600804 * @xid: transaction id used to identify original request in logs
805 * @tcon: information about the server share we have mounted
806 * @sb: the superblock stores info such as disk space available
807 * @full_path: name of the file we are getting the metadata for
808 * @resp_buf: will be set to cifs resp buf and needs to be freed with
809 * cifs_buf_release() when done with @data
810 * @data: will be set to search info result buffer
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100811 */
812static int
813cifs_backup_query_path_info(int xid,
814 struct cifs_tcon *tcon,
815 struct super_block *sb,
816 const char *full_path,
817 void **resp_buf,
818 FILE_ALL_INFO **data)
819{
820 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
821 struct cifs_search_info info = {0};
822 u16 flags;
823 int rc;
824
825 *resp_buf = NULL;
826 info.endOfSearch = false;
827 if (tcon->unix_ext)
828 info.info_level = SMB_FIND_FILE_UNIX;
829 else if ((tcon->ses->capabilities &
830 tcon->ses->server->vals->cap_nt_find) == 0)
831 info.info_level = SMB_FIND_FILE_INFO_STANDARD;
832 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
833 info.info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
834 else /* no srvino useful for fallback to some netapp */
835 info.info_level = SMB_FIND_FILE_DIRECTORY_INFO;
836
837 flags = CIFS_SEARCH_CLOSE_ALWAYS |
838 CIFS_SEARCH_CLOSE_AT_END |
839 CIFS_SEARCH_BACKUP_SEARCH;
840
841 rc = CIFSFindFirst(xid, tcon, full_path,
842 cifs_sb, NULL, flags, &info, false);
843 if (rc)
844 return rc;
845
846 *resp_buf = (void *)info.ntwrk_buf_start;
847 *data = (FILE_ALL_INFO *)info.srch_entries_start;
848 return 0;
849}
850
851static void
852cifs_set_fattr_ino(int xid,
853 struct cifs_tcon *tcon,
854 struct super_block *sb,
855 struct inode **inode,
856 const char *full_path,
857 FILE_ALL_INFO *data,
858 struct cifs_fattr *fattr)
859{
860 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
861 struct TCP_Server_Info *server = tcon->ses->server;
862 int rc;
863
864 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
865 if (*inode)
866 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
867 else
868 fattr->cf_uniqueid = iunique(sb, ROOT_I);
869 return;
870 }
871
872 /*
873 * If we have an inode pass a NULL tcon to ensure we don't
874 * make a round trip to the server. This only works for SMB2+.
875 */
876 rc = server->ops->get_srv_inum(xid,
877 *inode ? NULL : tcon,
878 cifs_sb, full_path,
879 &fattr->cf_uniqueid,
880 data);
881 if (rc) {
882 /*
883 * If that fails reuse existing ino or generate one
884 * and disable server ones
885 */
886 if (*inode)
887 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
888 else {
889 fattr->cf_uniqueid = iunique(sb, ROOT_I);
890 cifs_autodisable_serverino(cifs_sb);
891 }
892 return;
893 }
894
895 /* If no errors, check for zero root inode (invalid) */
896 if (fattr->cf_uniqueid == 0 && strlen(full_path) == 0) {
897 cifs_dbg(FYI, "Invalid (0) inodenum\n");
898 if (*inode) {
899 /* reuse */
900 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
901 } else {
902 /* make an ino by hashing the UNC */
903 fattr->cf_flags |= CIFS_FATTR_FAKE_ROOT_INO;
904 fattr->cf_uniqueid = simple_hashstr(tcon->treeName);
905 }
906 }
907}
908
909static inline bool is_inode_cache_good(struct inode *ino)
910{
911 return ino && CIFS_CACHE_READ(CIFS_I(ino)) && CIFS_I(ino)->time != 0;
912}
913
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400914int
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100915cifs_get_inode_info(struct inode **inode,
916 const char *full_path,
917 FILE_ALL_INFO *in_data,
918 struct super_block *sb, int xid,
Steve French42eacf92014-02-10 14:08:16 -0600919 const struct cifs_fid *fid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920{
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100921
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400922 struct cifs_tcon *tcon;
923 struct TCP_Server_Info *server;
Jeff Layton7ffec372010-09-29 19:51:11 -0400924 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400926 bool adjust_tz = false;
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100927 struct cifs_fattr fattr = {0};
Steve French2e4564b2020-10-22 22:03:14 -0500928 bool is_reparse_point = false;
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100929 FILE_ALL_INFO *data = in_data;
930 FILE_ALL_INFO *tmp_data = NULL;
931 void *smb1_backup_rsp_buf = NULL;
932 int rc = 0;
933 int tmprc = 0;
Steve French2e4564b2020-10-22 22:03:14 -0500934 __u32 reparse_tag = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935
Jeff Layton7ffec372010-09-29 19:51:11 -0400936 tlink = cifs_sb_tlink(cifs_sb);
937 if (IS_ERR(tlink))
938 return PTR_ERR(tlink);
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400939 tcon = tlink_tcon(tlink);
940 server = tcon->ses->server;
Jeff Layton7ffec372010-09-29 19:51:11 -0400941
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100942 /*
943 * 1. Fetch file metadata if not provided (data)
944 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100946 if (!data) {
947 if (is_inode_cache_good(*inode)) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500948 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100949 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 }
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100951 tmp_data = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
952 if (!tmp_data) {
Jeff Layton7ffec372010-09-29 19:51:11 -0400953 rc = -ENOMEM;
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100954 goto out;
Jeff Layton7ffec372010-09-29 19:51:11 -0400955 }
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100956 rc = server->ops->query_path_info(xid, tcon, cifs_sb,
Steve French2e4564b2020-10-22 22:03:14 -0500957 full_path, tmp_data,
958 &adjust_tz, &is_reparse_point);
Eugene Korenevskya2809d02022-01-14 22:53:40 +0300959#ifdef CONFIG_CIFS_DFS_UPCALL
960 if (rc == -ENOENT && is_tcon_dfs(tcon))
961 rc = cifs_dfs_query_info_nonascii_quirk(xid, tcon,
962 cifs_sb,
963 full_path);
964#endif
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100965 data = tmp_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400967
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400968 /*
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100969 * 2. Convert it to internal cifs metadata (fattr)
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400970 */
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100971
972 switch (rc) {
973 case 0:
Steve French2e4564b2020-10-22 22:03:14 -0500974 /*
975 * If the file is a reparse point, it is more complicated
976 * since we have to check if its reparse tag matches a known
977 * special file type e.g. symlink or fifo or char etc.
978 */
979 if ((le32_to_cpu(data->Attributes) & ATTR_REPARSE) &&
980 server->ops->query_reparse_tag) {
981 rc = server->ops->query_reparse_tag(xid, tcon, cifs_sb,
982 full_path, &reparse_tag);
983 cifs_dbg(FYI, "reparse tag 0x%x\n", reparse_tag);
984 }
985 cifs_all_info_to_fattr(&fattr, data, sb, adjust_tz,
986 is_reparse_point, reparse_tag);
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100987 break;
988 case -EREMOTE:
989 /* DFS link, no metadata available on this server */
990 cifs_create_dfs_fattr(&fattr, sb);
991 rc = 0;
992 break;
993 case -EACCES:
994 /*
995 * perm errors, try again with backup flags if possible
996 *
997 * For SMB2 and later the backup intent flag
998 * is already sent if needed on open and there
999 * is no path based FindFirst operation to use
1000 * to retry with
1001 */
1002 if (backup_cred(cifs_sb) && is_smb1_server(server)) {
1003 /* for easier reading */
1004 FILE_DIRECTORY_INFO *fdi;
1005 SEARCH_ID_FULL_DIR_INFO *si;
1006
1007 rc = cifs_backup_query_path_info(xid, tcon, sb,
1008 full_path,
1009 &smb1_backup_rsp_buf,
1010 &data);
1011 if (rc)
1012 goto out;
1013
1014 fdi = (FILE_DIRECTORY_INFO *)data;
1015 si = (SEARCH_ID_FULL_DIR_INFO *)data;
1016
1017 cifs_dir_info_to_fattr(&fattr, fdi, cifs_sb);
1018 fattr.cf_uniqueid = le64_to_cpu(si->UniqueId);
1019 /* uniqueid set, skip get inum step */
1020 goto handle_mnt_opt;
1021 } else {
1022 /* nothing we can do, bail out */
1023 goto out;
1024 }
1025 break;
1026 default:
1027 cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc);
1028 goto out;
Ross Lagerwalla108471b2015-12-02 14:46:08 +00001029 }
Steve Frenchb9a3260f2008-05-20 21:52:32 +00001030
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +01001031 /*
1032 * 3. Get or update inode number (fattr.cf_uniqueid)
1033 */
1034
1035 cifs_set_fattr_ino(xid, tcon, sb, inode, full_path, data, &fattr);
1036
1037 /*
1038 * 4. Tweak fattr based on mount options
1039 */
1040
1041handle_mnt_opt:
Jeff Layton0b8f18e2009-07-09 01:46:37 -04001042 /* query for SFU type info if supported and needed */
1043 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
1044 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
1045 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
1046 if (tmprc)
Joe Perchesf96637b2013-05-04 22:12:25 -05001047 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
Steve Frenchb9a3260f2008-05-20 21:52:32 +00001048 }
Steve Frenchb9a3260f2008-05-20 21:52:32 +00001049
Steve Frenchb9a3260f2008-05-20 21:52:32 +00001050 /* fill in 0777 bits from ACL */
Steve Frenche2f8fbf2019-07-19 06:30:07 +00001051 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID) {
1052 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, true,
1053 full_path, fid);
Ronnie Sahlberg01ec3722020-09-03 10:02:39 +10001054 if (rc == -EREMOTE)
1055 rc = 0;
Steve Frenche2f8fbf2019-07-19 06:30:07 +00001056 if (rc) {
1057 cifs_dbg(FYI, "%s: Get mode from SID failed. rc=%d\n",
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +01001058 __func__, rc);
1059 goto out;
Steve Frenche2f8fbf2019-07-19 06:30:07 +00001060 }
1061 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
1062 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, false,
Dan Carpenter via samba-technical68464b82019-11-26 15:11:15 +03001063 full_path, fid);
Ronnie Sahlberg01ec3722020-09-03 10:02:39 +10001064 if (rc == -EREMOTE)
1065 rc = 0;
Dan Carpenter via samba-technical68464b82019-11-26 15:11:15 +03001066 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001067 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
1068 __func__, rc);
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +01001069 goto out;
Shirish Pargaonkar78415d22010-11-27 11:37:26 -06001070 }
Steve Frenchb9a3260f2008-05-20 21:52:32 +00001071 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -04001072
1073 /* fill in remaining high mode bits e.g. SUID, VTX */
1074 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
1075 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
1076
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +02001077 /* check for Minshall+French symlinks */
1078 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
Sachin Prabhucb084b12013-11-25 17:09:50 +00001079 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
1080 full_path);
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +02001081 if (tmprc)
Sachin Prabhucb084b12013-11-25 17:09:50 +00001082 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +02001083 }
1084
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +01001085 /*
1086 * 5. Update inode with final fattr data
1087 */
1088
Pavel Shilovsky1208ef12012-05-27 17:34:43 +04001089 if (!*inode) {
1090 *inode = cifs_iget(sb, &fattr);
1091 if (!*inode)
Jeff Layton0b8f18e2009-07-09 01:46:37 -04001092 rc = -ENOMEM;
1093 } else {
Nakajima Akira7196ac12015-04-22 15:24:44 +09001094 /* we already have inode, update it */
1095
Ross Lagerwalla108471b2015-12-02 14:46:08 +00001096 /* if uniqueid is different, return error */
1097 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
1098 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
Pavel Shilovskyc82e5ac2019-09-30 10:06:19 -07001099 CIFS_I(*inode)->time = 0; /* force reval */
Ross Lagerwalla108471b2015-12-02 14:46:08 +00001100 rc = -ESTALE;
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +01001101 goto out;
Ross Lagerwalla108471b2015-12-02 14:46:08 +00001102 }
Nakajima Akira7196ac12015-04-22 15:24:44 +09001103 /* if filetype is different, return error */
Al Viro4d669522021-02-10 21:23:04 -05001104 rc = cifs_fattr_to_inode(*inode, &fattr);
Steve Frenchb9a3260f2008-05-20 21:52:32 +00001105 }
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +01001106out:
1107 cifs_buf_release(smb1_backup_rsp_buf);
Jeff Layton7ffec372010-09-29 19:51:11 -04001108 cifs_put_tlink(tlink);
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +01001109 kfree(tmp_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110 return rc;
1111}
1112
Steve French6a5f6592020-06-11 19:25:47 -05001113int
1114smb311_posix_get_inode_info(struct inode **inode,
1115 const char *full_path,
1116 struct super_block *sb, unsigned int xid)
1117{
1118 struct cifs_tcon *tcon;
Steve French6a5f6592020-06-11 19:25:47 -05001119 struct tcon_link *tlink;
1120 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1121 bool adjust_tz = false;
1122 struct cifs_fattr fattr = {0};
1123 bool symlink = false;
1124 struct smb311_posix_qinfo *data = NULL;
1125 int rc = 0;
1126 int tmprc = 0;
1127
1128 tlink = cifs_sb_tlink(cifs_sb);
1129 if (IS_ERR(tlink))
1130 return PTR_ERR(tlink);
1131 tcon = tlink_tcon(tlink);
Steve French6a5f6592020-06-11 19:25:47 -05001132
1133 /*
1134 * 1. Fetch file metadata
1135 */
1136
1137 if (is_inode_cache_good(*inode)) {
1138 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
1139 goto out;
1140 }
1141 data = kmalloc(sizeof(struct smb311_posix_qinfo), GFP_KERNEL);
1142 if (!data) {
1143 rc = -ENOMEM;
1144 goto out;
1145 }
1146
1147 rc = smb311_posix_query_path_info(xid, tcon, cifs_sb,
1148 full_path, data,
1149 &adjust_tz, &symlink);
1150
1151 /*
1152 * 2. Convert it to internal cifs metadata (fattr)
1153 */
1154
1155 switch (rc) {
1156 case 0:
1157 smb311_posix_info_to_fattr(&fattr, data, sb, adjust_tz, symlink);
1158 break;
1159 case -EREMOTE:
1160 /* DFS link, no metadata available on this server */
1161 cifs_create_dfs_fattr(&fattr, sb);
1162 rc = 0;
1163 break;
1164 case -EACCES:
1165 /*
1166 * For SMB2 and later the backup intent flag
1167 * is already sent if needed on open and there
1168 * is no path based FindFirst operation to use
1169 * to retry with so nothing we can do, bail out
1170 */
1171 goto out;
1172 default:
1173 cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc);
1174 goto out;
1175 }
1176
1177
1178 /*
Steve Frencha7a519a2020-06-12 14:49:47 -05001179 * 3. Tweak fattr based on mount options
Steve French6a5f6592020-06-11 19:25:47 -05001180 */
1181
1182 /* check for Minshall+French symlinks */
1183 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
1184 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
1185 full_path);
1186 if (tmprc)
1187 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
1188 }
1189
1190 /*
Steve Frencha7a519a2020-06-12 14:49:47 -05001191 * 4. Update inode with final fattr data
Steve French6a5f6592020-06-11 19:25:47 -05001192 */
1193
1194 if (!*inode) {
1195 *inode = cifs_iget(sb, &fattr);
1196 if (!*inode)
1197 rc = -ENOMEM;
1198 } else {
1199 /* we already have inode, update it */
1200
1201 /* if uniqueid is different, return error */
1202 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
1203 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
1204 CIFS_I(*inode)->time = 0; /* force reval */
1205 rc = -ESTALE;
1206 goto out;
1207 }
1208
1209 /* if filetype is different, return error */
Al Viro4d669522021-02-10 21:23:04 -05001210 rc = cifs_fattr_to_inode(*inode, &fattr);
Steve French6a5f6592020-06-11 19:25:47 -05001211 }
1212out:
1213 cifs_put_tlink(tlink);
1214 kfree(data);
1215 return rc;
1216}
1217
1218
Steve French7f8ed422007-09-28 22:28:55 +00001219static const struct inode_operations cifs_ipc_inode_ops = {
1220 .lookup = cifs_lookup,
1221};
1222
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001223static int
1224cifs_find_inode(struct inode *inode, void *opaque)
1225{
1226 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
1227
Jeff Laytonf30b9c12010-07-19 18:00:17 -04001228 /* don't match inode with different uniqueid */
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001229 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
1230 return 0;
1231
Jeff Layton20054bd2011-01-07 11:30:27 -05001232 /* use createtime like an i_generation field */
1233 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
1234 return 0;
1235
Jeff Laytonf30b9c12010-07-19 18:00:17 -04001236 /* don't match inode of different type */
Al Viro6e3e2c42021-03-01 20:37:10 -05001237 if (inode_wrong_type(inode, fattr->cf_mode))
Jeff Laytonf30b9c12010-07-19 18:00:17 -04001238 return 0;
1239
Jeff Layton5acfec22010-08-02 17:43:54 -04001240 /* if it's not a directory or has no dentries, then flag it */
Al Virob3d9b7a2012-06-09 13:51:19 -04001241 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
Jeff Layton3d694382010-05-11 14:59:55 -04001242 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
Jeff Layton3d694382010-05-11 14:59:55 -04001243
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001244 return 1;
1245}
1246
1247static int
1248cifs_init_inode(struct inode *inode, void *opaque)
1249{
1250 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
1251
1252 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
Jeff Layton20054bd2011-01-07 11:30:27 -05001253 CIFS_I(inode)->createtime = fattr->cf_createtime;
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001254 return 0;
1255}
1256
Jeff Layton5acfec22010-08-02 17:43:54 -04001257/*
1258 * walk dentry list for an inode and report whether it has aliases that
1259 * are hashed. We use this to determine if a directory inode can actually
1260 * be used.
1261 */
1262static bool
1263inode_has_hashed_dentries(struct inode *inode)
1264{
1265 struct dentry *dentry;
1266
Nick Piggin873feea2011-01-07 17:50:06 +11001267 spin_lock(&inode->i_lock);
Al Viro946e51f2014-10-26 19:19:16 -04001268 hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
Jeff Layton5acfec22010-08-02 17:43:54 -04001269 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
Nick Piggin873feea2011-01-07 17:50:06 +11001270 spin_unlock(&inode->i_lock);
Jeff Layton5acfec22010-08-02 17:43:54 -04001271 return true;
1272 }
1273 }
Nick Piggin873feea2011-01-07 17:50:06 +11001274 spin_unlock(&inode->i_lock);
Jeff Layton5acfec22010-08-02 17:43:54 -04001275 return false;
1276}
1277
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001278/* Given fattrs, get a corresponding inode */
1279struct inode *
1280cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
1281{
1282 unsigned long hash;
1283 struct inode *inode;
1284
Jeff Layton3d694382010-05-11 14:59:55 -04001285retry_iget5_locked:
Joe Perchesf96637b2013-05-04 22:12:25 -05001286 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001287
1288 /* hash down to 32-bits on 32-bit arch */
1289 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
1290
1291 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001292 if (inode) {
Jeff Layton5acfec22010-08-02 17:43:54 -04001293 /* was there a potentially problematic inode collision? */
Jeff Layton3d694382010-05-11 14:59:55 -04001294 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
Jeff Layton3d694382010-05-11 14:59:55 -04001295 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
Jeff Layton5acfec22010-08-02 17:43:54 -04001296
1297 if (inode_has_hashed_dentries(inode)) {
1298 cifs_autodisable_serverino(CIFS_SB(sb));
1299 iput(inode);
1300 fattr->cf_uniqueid = iunique(sb, ROOT_I);
1301 goto retry_iget5_locked;
1302 }
Jeff Layton3d694382010-05-11 14:59:55 -04001303 }
1304
Al Viro4d669522021-02-10 21:23:04 -05001305 /* can't fail - see cifs_find_inode() */
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001306 cifs_fattr_to_inode(inode, fattr);
Linus Torvalds1751e8a2017-11-27 13:05:09 -08001307 if (sb->s_flags & SB_NOATIME)
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001308 inode->i_flags |= S_NOATIME | S_NOCMTIME;
1309 if (inode->i_state & I_NEW) {
1310 inode->i_ino = hash;
David Howells70431bf2020-11-17 15:56:59 +00001311 cifs_fscache_get_inode_cookie(inode);
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001312 unlock_new_inode(inode);
1313 }
1314 }
1315
1316 return inode;
1317}
1318
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319/* gets root inode */
Shirish Pargaonkar9b6763e2011-02-21 23:56:59 -06001320struct inode *cifs_root_iget(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001322 unsigned int xid;
Jeff Layton0d424ad2010-09-20 16:01:35 -07001323 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001324 struct inode *inode = NULL;
David Howellsce634ab2008-02-07 00:15:33 -08001325 long rc;
Steve French96daf2b2011-05-27 04:34:02 +00001326 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Aurelien Aptela6b50582016-05-25 19:59:09 +02001327 char *path = NULL;
1328 int len;
1329
1330 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
1331 && cifs_sb->prepath) {
1332 len = strlen(cifs_sb->prepath);
1333 path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
1334 if (path == NULL)
1335 return ERR_PTR(-ENOMEM);
1336 path[0] = '/';
1337 memcpy(path+1, cifs_sb->prepath, len);
1338 } else {
1339 path = kstrdup("", GFP_KERNEL);
1340 if (path == NULL)
1341 return ERR_PTR(-ENOMEM);
1342 }
David Howellsce634ab2008-02-07 00:15:33 -08001343
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001344 xid = get_xid();
Steve Frenchb5b374e2014-10-06 01:01:03 -05001345 if (tcon->unix_ext) {
Aurelien Aptela6b50582016-05-25 19:59:09 +02001346 rc = cifs_get_inode_info_unix(&inode, path, sb, xid);
Steve Frenchb5b374e2014-10-06 01:01:03 -05001347 /* some servers mistakenly claim POSIX support */
1348 if (rc != -EOPNOTSUPP)
1349 goto iget_no_retry;
Joe Perchesa0a30362020-04-14 22:42:53 -07001350 cifs_dbg(VFS, "server does not support POSIX extensions\n");
Steve Frenchb5b374e2014-10-06 01:01:03 -05001351 tcon->unix_ext = false;
1352 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -04001353
Aurelien Aptela6b50582016-05-25 19:59:09 +02001354 convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
Steve Frenchd3138522020-06-11 22:43:01 -05001355 if (tcon->posix_extensions)
1356 rc = smb311_posix_get_inode_info(&inode, path, sb, xid);
1357 else
1358 rc = cifs_get_inode_info(&inode, path, NULL, sb, xid, NULL);
Steve Frenchb5b374e2014-10-06 01:01:03 -05001359
1360iget_no_retry:
Oskar Schirmera7851ce2010-11-10 21:06:13 +00001361 if (!inode) {
1362 inode = ERR_PTR(rc);
1363 goto out;
1364 }
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001365
Aurelien Aptelb327a712018-01-24 13:46:10 +01001366 if (rc && tcon->pipe) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001367 cifs_dbg(FYI, "ipc connection - fake read inode\n");
Steve Frenchb7ca6922012-08-03 08:43:01 -05001368 spin_lock(&inode->i_lock);
Steve French7f8ed422007-09-28 22:28:55 +00001369 inode->i_mode |= S_IFDIR;
Miklos Szeredibfe86842011-10-28 14:13:29 +02001370 set_nlink(inode, 2);
Steve French7f8ed422007-09-28 22:28:55 +00001371 inode->i_op = &cifs_ipc_inode_ops;
1372 inode->i_fop = &simple_dir_operations;
Ronnie Sahlberg8401e932020-12-12 13:40:50 -06001373 inode->i_uid = cifs_sb->ctx->linux_uid;
1374 inode->i_gid = cifs_sb->ctx->linux_gid;
Steve Frenchb7ca6922012-08-03 08:43:01 -05001375 spin_unlock(&inode->i_lock);
Steve Frenchad661332008-08-12 14:14:40 +00001376 } else if (rc) {
David Howellsce634ab2008-02-07 00:15:33 -08001377 iget_failed(inode);
Oskar Schirmera7851ce2010-11-10 21:06:13 +00001378 inode = ERR_PTR(rc);
Steve French7f8ed422007-09-28 22:28:55 +00001379 }
David Howells70431bf2020-11-17 15:56:59 +00001380
Oskar Schirmera7851ce2010-11-10 21:06:13 +00001381out:
Aurelien Aptela6b50582016-05-25 19:59:09 +02001382 kfree(path);
Phillip Potter31cd1062018-03-17 21:06:56 +00001383 free_xid(xid);
David Howellsce634ab2008-02-07 00:15:33 -08001384 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385}
1386
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001387int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001388cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
Al Virof6f1f172021-03-18 15:44:05 -04001389 const char *full_path, __u32 dosattr)
Steve French388e57b2008-09-16 23:50:58 +00001390{
Steve French388e57b2008-09-16 23:50:58 +00001391 bool set_time = false;
Steve French388e57b2008-09-16 23:50:58 +00001392 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Pavel Shilovsky6bdf6db2012-09-18 16:20:32 -07001393 struct TCP_Server_Info *server;
Steve French388e57b2008-09-16 23:50:58 +00001394 FILE_BASIC_INFO info_buf;
1395
Steve French1adcb712009-02-25 14:19:56 +00001396 if (attrs == NULL)
1397 return -EINVAL;
1398
Pavel Shilovsky6bdf6db2012-09-18 16:20:32 -07001399 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1400 if (!server->ops->set_file_info)
1401 return -ENOSYS;
1402
Steve Frenchfd09b7d2018-08-02 20:28:18 -05001403 info_buf.Pad = 0;
1404
Steve French388e57b2008-09-16 23:50:58 +00001405 if (attrs->ia_valid & ATTR_ATIME) {
1406 set_time = true;
1407 info_buf.LastAccessTime =
Arnd Bergmann95390202018-06-19 17:27:58 +02001408 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
Steve French388e57b2008-09-16 23:50:58 +00001409 } else
1410 info_buf.LastAccessTime = 0;
1411
1412 if (attrs->ia_valid & ATTR_MTIME) {
1413 set_time = true;
1414 info_buf.LastWriteTime =
Arnd Bergmann95390202018-06-19 17:27:58 +02001415 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
Steve French388e57b2008-09-16 23:50:58 +00001416 } else
1417 info_buf.LastWriteTime = 0;
1418
1419 /*
1420 * Samba throws this field away, but windows may actually use it.
1421 * Do not set ctime unless other time stamps are changed explicitly
1422 * (i.e. by utimes()) since we would then have a mix of client and
1423 * server times.
1424 */
1425 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001426 cifs_dbg(FYI, "CIFS - CTIME changed\n");
Steve French388e57b2008-09-16 23:50:58 +00001427 info_buf.ChangeTime =
Arnd Bergmann95390202018-06-19 17:27:58 +02001428 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
Steve French388e57b2008-09-16 23:50:58 +00001429 } else
1430 info_buf.ChangeTime = 0;
1431
1432 info_buf.CreationTime = 0; /* don't change */
1433 info_buf.Attributes = cpu_to_le32(dosattr);
1434
Pavel Shilovsky6bdf6db2012-09-18 16:20:32 -07001435 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
Steve French388e57b2008-09-16 23:50:58 +00001436}
1437
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001438/*
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001439 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001440 * and rename it to a random name that hopefully won't conflict with
1441 * anything else.
1442 */
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001443int
1444cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1445 const unsigned int xid)
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001446{
1447 int oplock = 0;
1448 int rc;
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001449 struct cifs_fid fid;
1450 struct cifs_open_parms oparms;
David Howells2b0143b2015-03-17 22:25:59 +00001451 struct inode *inode = d_inode(dentry);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001452 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1453 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001454 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001455 struct cifs_tcon *tcon;
Steve French32709582008-10-20 00:44:19 +00001456 __u32 dosattr, origattr;
1457 FILE_BASIC_INFO *info_buf = NULL;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001458
Jeff Layton7ffec372010-09-29 19:51:11 -04001459 tlink = cifs_sb_tlink(cifs_sb);
1460 if (IS_ERR(tlink))
1461 return PTR_ERR(tlink);
1462 tcon = tlink_tcon(tlink);
1463
Sachin Prabhuc483a982013-03-05 19:25:56 +00001464 /*
1465 * We cannot rename the file if the server doesn't support
1466 * CAP_INFOLEVEL_PASSTHRU
1467 */
1468 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1469 rc = -EBUSY;
1470 goto out;
1471 }
1472
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001473 oparms.tcon = tcon;
1474 oparms.cifs_sb = cifs_sb;
1475 oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
Amir Goldstein0f060932020-02-03 21:46:43 +02001476 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001477 oparms.disposition = FILE_OPEN;
1478 oparms.path = full_path;
1479 oparms.fid = &fid;
1480 oparms.reconnect = false;
1481
1482 rc = CIFS_open(xid, &oparms, &oplock, NULL);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001483 if (rc != 0)
1484 goto out;
1485
Steve French32709582008-10-20 00:44:19 +00001486 origattr = cifsInode->cifsAttrs;
1487 if (origattr == 0)
1488 origattr |= ATTR_NORMAL;
1489
1490 dosattr = origattr & ~ATTR_READONLY;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001491 if (dosattr == 0)
1492 dosattr |= ATTR_NORMAL;
1493 dosattr |= ATTR_HIDDEN;
1494
Steve French32709582008-10-20 00:44:19 +00001495 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1496 if (dosattr != origattr) {
1497 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1498 if (info_buf == NULL) {
1499 rc = -ENOMEM;
1500 goto out_close;
1501 }
1502 info_buf->Attributes = cpu_to_le32(dosattr);
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001503 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
Steve French32709582008-10-20 00:44:19 +00001504 current->tgid);
1505 /* although we would like to mark the file hidden
1506 if that fails we will still try to rename it */
Sachin Prabhu72d282d2013-03-05 19:25:55 +00001507 if (!rc)
Steve French32709582008-10-20 00:44:19 +00001508 cifsInode->cifsAttrs = dosattr;
1509 else
1510 dosattr = origattr; /* since not able to change them */
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001511 }
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001512
Jeff Laytondd1db2d2008-10-16 19:27:12 -04001513 /* rename the file */
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001514 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1515 cifs_sb->local_nls,
Steve French2baa2682014-09-27 02:19:01 -05001516 cifs_remap(cifs_sb));
Steve French32709582008-10-20 00:44:19 +00001517 if (rc != 0) {
Sachin Prabhu47c78f42013-03-11 13:08:49 +00001518 rc = -EBUSY;
Steve French32709582008-10-20 00:44:19 +00001519 goto undo_setattr;
1520 }
Jeff Layton6d22f092008-09-23 11:48:35 -04001521
Steve French32709582008-10-20 00:44:19 +00001522 /* try to set DELETE_ON_CLOSE */
Jeff Laytonaff8d5c2014-04-30 09:31:45 -04001523 if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001524 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
Steve French32709582008-10-20 00:44:19 +00001525 current->tgid);
1526 /*
1527 * some samba versions return -ENOENT when we try to set the
1528 * file disposition here. Likely a samba bug, but work around
1529 * it for now. This means that some cifsXXX files may hang
1530 * around after they shouldn't.
1531 *
1532 * BB: remove this hack after more servers have the fix
1533 */
1534 if (rc == -ENOENT)
1535 rc = 0;
1536 else if (rc != 0) {
Sachin Prabhu47c78f42013-03-11 13:08:49 +00001537 rc = -EBUSY;
Steve French32709582008-10-20 00:44:19 +00001538 goto undo_rename;
1539 }
Jeff Laytonaff8d5c2014-04-30 09:31:45 -04001540 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
Steve French32709582008-10-20 00:44:19 +00001541 }
Jeff Layton7ce86d52008-09-24 11:32:59 -04001542
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001543out_close:
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001544 CIFSSMBClose(xid, tcon, fid.netfid);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001545out:
Steve French32709582008-10-20 00:44:19 +00001546 kfree(info_buf);
Jeff Layton7ffec372010-09-29 19:51:11 -04001547 cifs_put_tlink(tlink);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001548 return rc;
Steve French32709582008-10-20 00:44:19 +00001549
1550 /*
1551 * reset everything back to the original state. Don't bother
1552 * dealing with errors here since we can't do anything about
1553 * them anyway.
1554 */
1555undo_rename:
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001556 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
Steve French2baa2682014-09-27 02:19:01 -05001557 cifs_sb->local_nls, cifs_remap(cifs_sb));
Steve French32709582008-10-20 00:44:19 +00001558undo_setattr:
1559 if (dosattr != origattr) {
1560 info_buf->Attributes = cpu_to_le32(origattr);
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001561 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
Steve French32709582008-10-20 00:44:19 +00001562 current->tgid))
1563 cifsInode->cifsAttrs = origattr;
1564 }
1565
1566 goto out_close;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001567}
1568
Steve Frenchb7ca6922012-08-03 08:43:01 -05001569/* copied from fs/nfs/dir.c with small changes */
1570static void
1571cifs_drop_nlink(struct inode *inode)
1572{
1573 spin_lock(&inode->i_lock);
1574 if (inode->i_nlink > 0)
1575 drop_nlink(inode);
1576 spin_unlock(&inode->i_lock);
1577}
Steve Frenchff694522009-04-20 19:45:13 +00001578
1579/*
David Howells2b0143b2015-03-17 22:25:59 +00001580 * If d_inode(dentry) is null (usually meaning the cached dentry
Steve Frenchff694522009-04-20 19:45:13 +00001581 * is a negative dentry) then we would attempt a standard SMB delete, but
Colin Ian King413d6102018-10-26 19:07:21 +01001582 * if that fails we can not attempt the fall back mechanisms on EACCES
1583 * but will return the EACCES to the caller. Note that the VFS does not call
Steve Frenchff694522009-04-20 19:45:13 +00001584 * unlink on negative dentries currently.
1585 */
Jeff Layton5f0319a2008-09-16 14:05:16 -04001586int cifs_unlink(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587{
1588 int rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001589 unsigned int xid;
Al Virof6a9bc32021-03-05 17:36:04 -05001590 const char *full_path;
1591 void *page;
David Howells2b0143b2015-03-17 22:25:59 +00001592 struct inode *inode = d_inode(dentry);
Steve Frenchff694522009-04-20 19:45:13 +00001593 struct cifsInodeInfo *cifs_inode;
Jeff Layton5f0319a2008-09-16 14:05:16 -04001594 struct super_block *sb = dir->i_sb;
1595 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001596 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001597 struct cifs_tcon *tcon;
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001598 struct TCP_Server_Info *server;
Steve French60502472008-10-07 18:42:52 +00001599 struct iattr *attrs = NULL;
1600 __u32 dosattr = 0, origattr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601
Joe Perchesf96637b2013-05-04 22:12:25 -05001602 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603
Steve French087f7572021-04-29 00:18:43 -05001604 if (unlikely(cifs_forced_shutdown(cifs_sb)))
1605 return -EIO;
1606
Jeff Layton7ffec372010-09-29 19:51:11 -04001607 tlink = cifs_sb_tlink(cifs_sb);
1608 if (IS_ERR(tlink))
1609 return PTR_ERR(tlink);
1610 tcon = tlink_tcon(tlink);
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001611 server = tcon->ses->server;
Jeff Layton7ffec372010-09-29 19:51:11 -04001612
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001613 xid = get_xid();
Al Virof6a9bc32021-03-05 17:36:04 -05001614 page = alloc_dentry_path();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615
Steve French82e93672020-05-19 03:06:57 -05001616 if (tcon->nodelete) {
1617 rc = -EACCES;
1618 goto unlink_out;
1619 }
1620
Jeff Layton5f0319a2008-09-16 14:05:16 -04001621 /* Unlink can be called from rename so we can not take the
1622 * sb->s_vfs_rename_mutex here */
Al Virof6a9bc32021-03-05 17:36:04 -05001623 full_path = build_path_from_dentry(dentry, page);
1624 if (IS_ERR(full_path)) {
1625 rc = PTR_ERR(full_path);
Jeff Layton7ffec372010-09-29 19:51:11 -04001626 goto unlink_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 }
Steve French2d785a52007-07-15 01:48:57 +00001628
Rohith Surabattulae3fc0652021-09-17 18:14:26 +00001629 cifs_close_deferred_file_under_dentry(tcon, full_path);
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001630 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1631 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001632 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
Steve French2d785a52007-07-15 01:48:57 +00001633 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
Steve French2baa2682014-09-27 02:19:01 -05001634 cifs_remap(cifs_sb));
Joe Perchesf96637b2013-05-04 22:12:25 -05001635 cifs_dbg(FYI, "posix del rc %d\n", rc);
Steve French2d785a52007-07-15 01:48:57 +00001636 if ((rc == 0) || (rc == -ENOENT))
1637 goto psx_del_no_retry;
1638 }
1639
Steve French60502472008-10-07 18:42:52 +00001640retry_std_delete:
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001641 if (!server->ops->unlink) {
1642 rc = -ENOSYS;
1643 goto psx_del_no_retry;
1644 }
1645
1646 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
Steve French60502472008-10-07 18:42:52 +00001647
Steve French2d785a52007-07-15 01:48:57 +00001648psx_del_no_retry:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 if (!rc) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001650 if (inode)
Steve Frenchb7ca6922012-08-03 08:43:01 -05001651 cifs_drop_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652 } else if (rc == -ENOENT) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001653 d_drop(dentry);
Sachin Prabhu47c78f42013-03-11 13:08:49 +00001654 } else if (rc == -EBUSY) {
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001655 if (server->ops->rename_pending_delete) {
1656 rc = server->ops->rename_pending_delete(full_path,
1657 dentry, xid);
1658 if (rc == 0)
1659 cifs_drop_nlink(inode);
1660 }
Steve Frenchff694522009-04-20 19:45:13 +00001661 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
Steve French388e57b2008-09-16 23:50:58 +00001662 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1663 if (attrs == NULL) {
1664 rc = -ENOMEM;
1665 goto out_reval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 }
Steve French388e57b2008-09-16 23:50:58 +00001667
1668 /* try to reset dos attributes */
Steve Frenchff694522009-04-20 19:45:13 +00001669 cifs_inode = CIFS_I(inode);
1670 origattr = cifs_inode->cifsAttrs;
Steve French60502472008-10-07 18:42:52 +00001671 if (origattr == 0)
1672 origattr |= ATTR_NORMAL;
1673 dosattr = origattr & ~ATTR_READONLY;
Steve French388e57b2008-09-16 23:50:58 +00001674 if (dosattr == 0)
1675 dosattr |= ATTR_NORMAL;
1676 dosattr |= ATTR_HIDDEN;
1677
1678 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
Steve French388e57b2008-09-16 23:50:58 +00001679 if (rc != 0)
1680 goto out_reval;
Steve French60502472008-10-07 18:42:52 +00001681
1682 goto retry_std_delete;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 }
Steve French60502472008-10-07 18:42:52 +00001684
1685 /* undo the setattr if we errored out and it's needed */
1686 if (rc != 0 && dosattr != 0)
1687 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1688
Steve French388e57b2008-09-16 23:50:58 +00001689out_reval:
Jeff Layton5f0319a2008-09-16 14:05:16 -04001690 if (inode) {
Steve Frenchff694522009-04-20 19:45:13 +00001691 cifs_inode = CIFS_I(inode);
1692 cifs_inode->time = 0; /* will force revalidate to get info
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001693 when needed */
Deepa Dinamanie37fea52017-05-08 15:59:16 -07001694 inode->i_ctime = current_time(inode);
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001695 }
Deepa Dinamanie37fea52017-05-08 15:59:16 -07001696 dir->i_ctime = dir->i_mtime = current_time(dir);
Steve Frenchff694522009-04-20 19:45:13 +00001697 cifs_inode = CIFS_I(dir);
Steve French60502472008-10-07 18:42:52 +00001698 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
Jeff Layton7ffec372010-09-29 19:51:11 -04001699unlink_out:
Al Virof6a9bc32021-03-05 17:36:04 -05001700 free_dentry_path(page);
Steve French60502472008-10-07 18:42:52 +00001701 kfree(attrs);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001702 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001703 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 return rc;
1705}
1706
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001707static int
Jeff Layton101b92d2012-09-19 06:22:45 -07001708cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001709 const char *full_path, struct cifs_sb_info *cifs_sb,
1710 struct cifs_tcon *tcon, const unsigned int xid)
1711{
1712 int rc = 0;
Jeff Layton101b92d2012-09-19 06:22:45 -07001713 struct inode *inode = NULL;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001714
Steve Frenchd3138522020-06-11 22:43:01 -05001715 if (tcon->posix_extensions)
1716 rc = smb311_posix_get_inode_info(&inode, full_path, parent->i_sb, xid);
1717 else if (tcon->unix_ext)
Jeff Layton101b92d2012-09-19 06:22:45 -07001718 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001719 xid);
1720 else
Jeff Layton101b92d2012-09-19 06:22:45 -07001721 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1722 xid, NULL);
1723
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001724 if (rc)
1725 return rc;
1726
Al Viro3bcb39b2021-02-10 22:13:03 -05001727 if (!S_ISDIR(inode->i_mode)) {
1728 /*
1729 * mkdir succeeded, but another client has managed to remove the
1730 * sucker and replace it with non-directory. Return success,
1731 * but don't leave the child in dcache.
1732 */
1733 iput(inode);
1734 d_drop(dentry);
1735 return 0;
1736 }
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001737 /*
1738 * setting nlink not necessary except in cases where we failed to get it
Jeff Layton101b92d2012-09-19 06:22:45 -07001739 * from the server or was set bogus. Also, since this is a brand new
1740 * inode, no need to grab the i_lock before setting the i_nlink.
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001741 */
Jeff Layton101b92d2012-09-19 06:22:45 -07001742 if (inode->i_nlink < 2)
1743 set_nlink(inode, 2);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001744 mode &= ~current_umask();
1745 /* must turn on setgid bit if parent dir has it */
Jeff Layton101b92d2012-09-19 06:22:45 -07001746 if (parent->i_mode & S_ISGID)
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001747 mode |= S_ISGID;
1748
1749 if (tcon->unix_ext) {
1750 struct cifs_unix_set_info_args args = {
1751 .mode = mode,
1752 .ctime = NO_CHANGE_64,
1753 .atime = NO_CHANGE_64,
1754 .mtime = NO_CHANGE_64,
1755 .device = 0,
1756 };
1757 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
Eric W. Biederman49418b22013-02-06 00:57:56 -08001758 args.uid = current_fsuid();
Jeff Layton101b92d2012-09-19 06:22:45 -07001759 if (parent->i_mode & S_ISGID)
Eric W. Biederman49418b22013-02-06 00:57:56 -08001760 args.gid = parent->i_gid;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001761 else
Eric W. Biederman49418b22013-02-06 00:57:56 -08001762 args.gid = current_fsgid();
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001763 } else {
Eric W. Biederman49418b22013-02-06 00:57:56 -08001764 args.uid = INVALID_UID; /* no change */
1765 args.gid = INVALID_GID; /* no change */
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001766 }
1767 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1768 cifs_sb->local_nls,
Steve French2baa2682014-09-27 02:19:01 -05001769 cifs_remap(cifs_sb));
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001770 } else {
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001771 struct TCP_Server_Info *server = tcon->ses->server;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001772 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001773 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
Jeff Layton101b92d2012-09-19 06:22:45 -07001774 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001775 tcon, xid);
Jeff Layton101b92d2012-09-19 06:22:45 -07001776 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1777 inode->i_mode = (mode | S_IFDIR);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001778
Jeff Layton101b92d2012-09-19 06:22:45 -07001779 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1780 inode->i_uid = current_fsuid();
1781 if (inode->i_mode & S_ISGID)
1782 inode->i_gid = parent->i_gid;
1783 else
1784 inode->i_gid = current_fsgid();
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001785 }
1786 }
Jeff Layton101b92d2012-09-19 06:22:45 -07001787 d_instantiate(dentry, inode);
Al Viro3bcb39b2021-02-10 22:13:03 -05001788 return 0;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001789}
1790
1791static int
1792cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1793 const char *full_path, struct cifs_sb_info *cifs_sb,
1794 struct cifs_tcon *tcon, const unsigned int xid)
1795{
1796 int rc = 0;
1797 u32 oplock = 0;
1798 FILE_UNIX_BASIC_INFO *info = NULL;
1799 struct inode *newinode = NULL;
1800 struct cifs_fattr fattr;
1801
1802 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1803 if (info == NULL) {
1804 rc = -ENOMEM;
1805 goto posix_mkdir_out;
1806 }
1807
1808 mode &= ~current_umask();
1809 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1810 NULL /* netfid */, info, &oplock, full_path,
Steve French2baa2682014-09-27 02:19:01 -05001811 cifs_sb->local_nls, cifs_remap(cifs_sb));
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001812 if (rc == -EOPNOTSUPP)
1813 goto posix_mkdir_out;
1814 else if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001815 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001816 d_drop(dentry);
1817 goto posix_mkdir_out;
1818 }
1819
1820 if (info->Type == cpu_to_le32(-1))
1821 /* no return info, go query for it */
1822 goto posix_mkdir_get_info;
1823 /*
1824 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1825 * need to set uid/gid.
1826 */
1827
1828 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1829 cifs_fill_uniqueid(inode->i_sb, &fattr);
1830 newinode = cifs_iget(inode->i_sb, &fattr);
1831 if (!newinode)
1832 goto posix_mkdir_get_info;
1833
1834 d_instantiate(dentry, newinode);
1835
1836#ifdef CONFIG_CIFS_DEBUG2
Al Viro35c265e2014-08-19 20:25:34 -04001837 cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1838 dentry, dentry, newinode);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001839
1840 if (newinode->i_nlink != 2)
Joe Perchesf96637b2013-05-04 22:12:25 -05001841 cifs_dbg(FYI, "unexpected number of links %d\n",
1842 newinode->i_nlink);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001843#endif
1844
1845posix_mkdir_out:
1846 kfree(info);
1847 return rc;
1848posix_mkdir_get_info:
1849 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1850 xid);
1851 goto posix_mkdir_out;
1852}
1853
Christian Brauner549c7292021-01-21 14:19:43 +01001854int cifs_mkdir(struct user_namespace *mnt_userns, struct inode *inode,
1855 struct dentry *direntry, umode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856{
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001857 int rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001858 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001860 struct tcon_link *tlink;
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001861 struct cifs_tcon *tcon;
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001862 struct TCP_Server_Info *server;
Al Viro8e33cf22021-03-18 15:47:35 -04001863 const char *full_path;
Al Virof6a9bc32021-03-05 17:36:04 -05001864 void *page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865
Frank Sorensonf52aa792020-02-12 15:31:48 -06001866 cifs_dbg(FYI, "In cifs_mkdir, mode = %04ho inode = 0x%p\n",
Joe Perchesf96637b2013-05-04 22:12:25 -05001867 mode, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869 cifs_sb = CIFS_SB(inode->i_sb);
Steve French087f7572021-04-29 00:18:43 -05001870 if (unlikely(cifs_forced_shutdown(cifs_sb)))
1871 return -EIO;
Jeff Layton7ffec372010-09-29 19:51:11 -04001872 tlink = cifs_sb_tlink(cifs_sb);
1873 if (IS_ERR(tlink))
1874 return PTR_ERR(tlink);
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001875 tcon = tlink_tcon(tlink);
Jeff Layton7ffec372010-09-29 19:51:11 -04001876
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001877 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878
Al Virof6a9bc32021-03-05 17:36:04 -05001879 page = alloc_dentry_path();
1880 full_path = build_path_from_dentry(direntry, page);
1881 if (IS_ERR(full_path)) {
1882 rc = PTR_ERR(full_path);
Jeff Layton7ffec372010-09-29 19:51:11 -04001883 goto mkdir_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884 }
Steve French50c2f752007-07-13 00:33:32 +00001885
Steve Frenchbea851b2018-06-14 21:56:32 -05001886 server = tcon->ses->server;
1887
Steve Frenchbea851b2018-06-14 21:56:32 -05001888 if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) {
1889 rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,
1890 cifs_sb);
1891 d_drop(direntry); /* for time being always refresh inode info */
1892 goto mkdir_out;
1893 }
Steve Frenchbea851b2018-06-14 21:56:32 -05001894
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001895 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1896 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001897 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1898 tcon, xid);
1899 if (rc != -EOPNOTSUPP)
Steve French2dd29d32007-04-23 22:07:35 +00001900 goto mkdir_out;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001901 }
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001902
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001903 if (!server->ops->mkdir) {
1904 rc = -ENOSYS;
1905 goto mkdir_out;
1906 }
1907
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908 /* BB add setting the equivalent of mode via CreateX w/ACLs */
Steve Frenchc3ca78e2019-09-25 00:32:13 -05001909 rc = server->ops->mkdir(xid, inode, mode, tcon, full_path, cifs_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001911 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912 d_drop(direntry);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001913 goto mkdir_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914 }
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001915
Steve Frenchc3ca78e2019-09-25 00:32:13 -05001916 /* TODO: skip this for smb2/smb3 */
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001917 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1918 xid);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001919mkdir_out:
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +03001920 /*
1921 * Force revalidate to get parent dir info when needed since cached
1922 * attributes are invalid now.
1923 */
1924 CIFS_I(inode)->time = 0;
Al Virof6a9bc32021-03-05 17:36:04 -05001925 free_dentry_path(page);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001926 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001927 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928 return rc;
1929}
1930
1931int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1932{
1933 int rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001934 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001936 struct tcon_link *tlink;
Pavel Shilovskyf958ca52012-07-10 16:14:18 +04001937 struct cifs_tcon *tcon;
1938 struct TCP_Server_Info *server;
Al Virof6a9bc32021-03-05 17:36:04 -05001939 const char *full_path;
1940 void *page = alloc_dentry_path();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941 struct cifsInodeInfo *cifsInode;
1942
Joe Perchesf96637b2013-05-04 22:12:25 -05001943 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001945 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946
Al Virof6a9bc32021-03-05 17:36:04 -05001947 full_path = build_path_from_dentry(direntry, page);
1948 if (IS_ERR(full_path)) {
1949 rc = PTR_ERR(full_path);
Jeff Layton7ffec372010-09-29 19:51:11 -04001950 goto rmdir_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 }
1952
Jeff Layton7ffec372010-09-29 19:51:11 -04001953 cifs_sb = CIFS_SB(inode->i_sb);
Steve French087f7572021-04-29 00:18:43 -05001954 if (unlikely(cifs_forced_shutdown(cifs_sb))) {
1955 rc = -EIO;
1956 goto rmdir_exit;
1957 }
1958
Jeff Layton7ffec372010-09-29 19:51:11 -04001959 tlink = cifs_sb_tlink(cifs_sb);
1960 if (IS_ERR(tlink)) {
1961 rc = PTR_ERR(tlink);
1962 goto rmdir_exit;
1963 }
Pavel Shilovskyf958ca52012-07-10 16:14:18 +04001964 tcon = tlink_tcon(tlink);
1965 server = tcon->ses->server;
Jeff Layton7ffec372010-09-29 19:51:11 -04001966
Pavel Shilovskyf958ca52012-07-10 16:14:18 +04001967 if (!server->ops->rmdir) {
1968 rc = -ENOSYS;
1969 cifs_put_tlink(tlink);
1970 goto rmdir_exit;
1971 }
1972
Steve French82e93672020-05-19 03:06:57 -05001973 if (tcon->nodelete) {
1974 rc = -EACCES;
1975 cifs_put_tlink(tlink);
1976 goto rmdir_exit;
1977 }
1978
Pavel Shilovskyf958ca52012-07-10 16:14:18 +04001979 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001980 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981
1982 if (!rc) {
David Howells2b0143b2015-03-17 22:25:59 +00001983 spin_lock(&d_inode(direntry)->i_lock);
1984 i_size_write(d_inode(direntry), 0);
1985 clear_nlink(d_inode(direntry));
1986 spin_unlock(&d_inode(direntry)->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987 }
1988
David Howells2b0143b2015-03-17 22:25:59 +00001989 cifsInode = CIFS_I(d_inode(direntry));
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +03001990 /* force revalidate to go get info when needed */
1991 cifsInode->time = 0;
Steve French42c245442009-01-13 22:03:55 +00001992
1993 cifsInode = CIFS_I(inode);
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +03001994 /*
1995 * Force revalidate to get parent dir info when needed since cached
1996 * attributes are invalid now.
1997 */
1998 cifsInode->time = 0;
Steve French42c245442009-01-13 22:03:55 +00001999
David Howells2b0143b2015-03-17 22:25:59 +00002000 d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
Deepa Dinamanie37fea52017-05-08 15:59:16 -07002001 current_time(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002
Jeff Layton7ffec372010-09-29 19:51:11 -04002003rmdir_exit:
Al Virof6a9bc32021-03-05 17:36:04 -05002004 free_dentry_path(page);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002005 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006 return rc;
2007}
2008
Steve Frenchee2fd962008-09-23 18:23:33 +00002009static int
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07002010cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
2011 const char *from_path, struct dentry *to_dentry,
2012 const char *to_path)
Steve Frenchee2fd962008-09-23 18:23:33 +00002013{
2014 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04002015 struct tcon_link *tlink;
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07002016 struct cifs_tcon *tcon;
2017 struct TCP_Server_Info *server;
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04002018 struct cifs_fid fid;
2019 struct cifs_open_parms oparms;
Steve Frenchee2fd962008-09-23 18:23:33 +00002020 int oplock, rc;
2021
Jeff Layton7ffec372010-09-29 19:51:11 -04002022 tlink = cifs_sb_tlink(cifs_sb);
2023 if (IS_ERR(tlink))
2024 return PTR_ERR(tlink);
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07002025 tcon = tlink_tcon(tlink);
2026 server = tcon->ses->server;
2027
2028 if (!server->ops->rename)
2029 return -ENOSYS;
Jeff Layton7ffec372010-09-29 19:51:11 -04002030
Steve Frenchee2fd962008-09-23 18:23:33 +00002031 /* try path-based rename first */
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07002032 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
Steve Frenchee2fd962008-09-23 18:23:33 +00002033
2034 /*
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07002035 * Don't bother with rename by filehandle unless file is busy and
2036 * source. Note that cross directory moves do not work with
Steve Frenchee2fd962008-09-23 18:23:33 +00002037 * rename by filehandle to various Windows servers.
2038 */
Sachin Prabhu47c78f42013-03-11 13:08:49 +00002039 if (rc == 0 || rc != -EBUSY)
Jeff Layton7ffec372010-09-29 19:51:11 -04002040 goto do_rename_exit;
Steve Frenchee2fd962008-09-23 18:23:33 +00002041
Frank Sorenson652727b2019-04-16 08:37:27 -05002042 /* Don't fall back to using SMB on SMB 2+ mount */
2043 if (server->vals->protocol_id != 0)
2044 goto do_rename_exit;
2045
Jeff Laytoned0e3ac2010-06-01 16:21:01 -04002046 /* open-file renames don't work across directories */
2047 if (to_dentry->d_parent != from_dentry->d_parent)
Jeff Layton7ffec372010-09-29 19:51:11 -04002048 goto do_rename_exit;
Jeff Laytoned0e3ac2010-06-01 16:21:01 -04002049
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04002050 oparms.tcon = tcon;
2051 oparms.cifs_sb = cifs_sb;
Steve Frenchee2fd962008-09-23 18:23:33 +00002052 /* open the file to be renamed -- we need DELETE perms */
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04002053 oparms.desired_access = DELETE;
Amir Goldstein0f060932020-02-03 21:46:43 +02002054 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04002055 oparms.disposition = FILE_OPEN;
2056 oparms.path = from_path;
2057 oparms.fid = &fid;
2058 oparms.reconnect = false;
2059
2060 rc = CIFS_open(xid, &oparms, &oplock, NULL);
Steve Frenchee2fd962008-09-23 18:23:33 +00002061 if (rc == 0) {
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04002062 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
Steve Frenchee2fd962008-09-23 18:23:33 +00002063 (const char *) to_dentry->d_name.name,
Steve French2baa2682014-09-27 02:19:01 -05002064 cifs_sb->local_nls, cifs_remap(cifs_sb));
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04002065 CIFSSMBClose(xid, tcon, fid.netfid);
Steve Frenchee2fd962008-09-23 18:23:33 +00002066 }
Jeff Layton7ffec372010-09-29 19:51:11 -04002067do_rename_exit:
Steve Frenchc7e9f782020-02-25 18:08:54 -06002068 if (rc == 0)
2069 d_move(from_dentry, to_dentry);
Jeff Layton7ffec372010-09-29 19:51:11 -04002070 cifs_put_tlink(tlink);
Steve Frenchee2fd962008-09-23 18:23:33 +00002071 return rc;
2072}
2073
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07002074int
Christian Brauner549c7292021-01-21 14:19:43 +01002075cifs_rename2(struct user_namespace *mnt_userns, struct inode *source_dir,
2076 struct dentry *source_dentry, struct inode *target_dir,
2077 struct dentry *target_dentry, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002078{
Al Virof6a9bc32021-03-05 17:36:04 -05002079 const char *from_name, *to_name;
2080 void *page1, *page2;
Jeff Layton639e7a92010-09-03 11:50:09 -04002081 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04002082 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00002083 struct cifs_tcon *tcon;
Steve Frenchee2fd962008-09-23 18:23:33 +00002084 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
2085 FILE_UNIX_BASIC_INFO *info_buf_target;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002086 unsigned int xid;
2087 int rc, tmprc;
Rohith Surabattula41535702021-07-29 07:45:29 +00002088 int retry_count = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089
Miklos Szeredi7c33d592014-07-23 15:15:36 +02002090 if (flags & ~RENAME_NOREPLACE)
2091 return -EINVAL;
2092
Jeff Layton639e7a92010-09-03 11:50:09 -04002093 cifs_sb = CIFS_SB(source_dir->i_sb);
Steve French087f7572021-04-29 00:18:43 -05002094 if (unlikely(cifs_forced_shutdown(cifs_sb)))
2095 return -EIO;
2096
Jeff Layton7ffec372010-09-29 19:51:11 -04002097 tlink = cifs_sb_tlink(cifs_sb);
2098 if (IS_ERR(tlink))
2099 return PTR_ERR(tlink);
2100 tcon = tlink_tcon(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002101
Al Virof6a9bc32021-03-05 17:36:04 -05002102 page1 = alloc_dentry_path();
2103 page2 = alloc_dentry_path();
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002104 xid = get_xid();
Steve Frenchee2fd962008-09-23 18:23:33 +00002105
Al Virof6a9bc32021-03-05 17:36:04 -05002106 from_name = build_path_from_dentry(source_dentry, page1);
2107 if (IS_ERR(from_name)) {
2108 rc = PTR_ERR(from_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109 goto cifs_rename_exit;
2110 }
2111
Al Virof6a9bc32021-03-05 17:36:04 -05002112 to_name = build_path_from_dentry(target_dentry, page2);
2113 if (IS_ERR(to_name)) {
2114 rc = PTR_ERR(to_name);
Steve Frenchee2fd962008-09-23 18:23:33 +00002115 goto cifs_rename_exit;
2116 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002117
Rohith Surabattulae3fc0652021-09-17 18:14:26 +00002118 cifs_close_deferred_file_under_dentry(tcon, from_name);
Rohith Surabattula41535702021-07-29 07:45:29 +00002119 if (d_inode(target_dentry) != NULL)
Rohith Surabattulae3fc0652021-09-17 18:14:26 +00002120 cifs_close_deferred_file_under_dentry(tcon, to_name);
Rohith Surabattula41535702021-07-29 07:45:29 +00002121
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07002122 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2123 to_name);
Steve Frenchee2fd962008-09-23 18:23:33 +00002124
Rohith Surabattula41535702021-07-29 07:45:29 +00002125 if (rc == -EACCES) {
2126 while (retry_count < 3) {
2127 cifs_close_all_deferred_files(tcon);
2128 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2129 to_name);
2130 if (rc != -EACCES)
2131 break;
2132 retry_count++;
2133 }
2134 }
2135
Miklos Szeredi7c33d592014-07-23 15:15:36 +02002136 /*
2137 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
2138 */
2139 if (flags & RENAME_NOREPLACE)
2140 goto cifs_rename_exit;
2141
Jeff Layton14121bd2008-10-20 14:45:22 -04002142 if (rc == -EEXIST && tcon->unix_ext) {
Steve Frenchee2fd962008-09-23 18:23:33 +00002143 /*
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07002144 * Are src and dst hardlinks of same inode? We can only tell
2145 * with unix extensions enabled.
Steve Frenchee2fd962008-09-23 18:23:33 +00002146 */
Jeff Layton14121bd2008-10-20 14:45:22 -04002147 info_buf_source =
Kees Cook6da2ec52018-06-12 13:55:00 -07002148 kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
Jeff Layton14121bd2008-10-20 14:45:22 -04002149 GFP_KERNEL);
2150 if (info_buf_source == NULL) {
2151 rc = -ENOMEM;
2152 goto cifs_rename_exit;
2153 }
2154
2155 info_buf_target = info_buf_source + 1;
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07002156 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
2157 info_buf_source,
2158 cifs_sb->local_nls,
Steve French2baa2682014-09-27 02:19:01 -05002159 cifs_remap(cifs_sb));
Jeff Layton8d281ef2008-10-22 13:57:01 -04002160 if (tmprc != 0)
Jeff Layton14121bd2008-10-20 14:45:22 -04002161 goto unlink_target;
2162
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07002163 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
2164 info_buf_target,
2165 cifs_sb->local_nls,
Steve French2baa2682014-09-27 02:19:01 -05002166 cifs_remap(cifs_sb));
Jeff Layton14121bd2008-10-20 14:45:22 -04002167
Jeff Layton8d281ef2008-10-22 13:57:01 -04002168 if (tmprc == 0 && (info_buf_source->UniqueId ==
Jeff Laytonae6884a2008-11-03 14:05:08 -05002169 info_buf_target->UniqueId)) {
Jeff Layton14121bd2008-10-20 14:45:22 -04002170 /* same file, POSIX says that this is a noop */
Jeff Laytonae6884a2008-11-03 14:05:08 -05002171 rc = 0;
Jeff Layton14121bd2008-10-20 14:45:22 -04002172 goto cifs_rename_exit;
Jeff Laytonae6884a2008-11-03 14:05:08 -05002173 }
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07002174 }
2175 /*
2176 * else ... BB we could add the same check for Windows by
2177 * checking the UniqueId via FILE_INTERNAL_INFO
2178 */
Jeff Layton14121bd2008-10-20 14:45:22 -04002179
Jeff Layton14121bd2008-10-20 14:45:22 -04002180unlink_target:
Steve French0e670512020-07-23 14:41:29 -05002181 /* Try unlinking the target dentry if it's not negative */
2182 if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
Pavel Shilovskya07d3222014-08-22 13:32:09 +04002183 if (d_is_dir(target_dentry))
2184 tmprc = cifs_rmdir(target_dir, target_dentry);
2185 else
2186 tmprc = cifs_unlink(target_dir, target_dentry);
Jeff Layton14121bd2008-10-20 14:45:22 -04002187 if (tmprc)
2188 goto cifs_rename_exit;
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07002189 rc = cifs_do_rename(xid, source_dentry, from_name,
2190 target_dentry, to_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191 }
2192
Pavel Shilovskyb46799a2014-08-18 20:49:58 +04002193 /* force revalidate to go get info when needed */
2194 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
2195
2196 source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
Deepa Dinamanie37fea52017-05-08 15:59:16 -07002197 target_dir->i_mtime = current_time(source_dir);
Pavel Shilovskyb46799a2014-08-18 20:49:58 +04002198
Linus Torvalds1da177e2005-04-16 15:20:36 -07002199cifs_rename_exit:
Steve Frenchee2fd962008-09-23 18:23:33 +00002200 kfree(info_buf_source);
Al Virof6a9bc32021-03-05 17:36:04 -05002201 free_dentry_path(page2);
2202 free_dentry_path(page1);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002203 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04002204 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205 return rc;
2206}
2207
Jeff Laytondf2cf172010-02-12 07:44:16 -05002208static bool
Ronnie Sahlberged8561f2021-03-09 09:07:34 +10002209cifs_dentry_needs_reval(struct dentry *dentry)
Jeff Laytondf2cf172010-02-12 07:44:16 -05002210{
Ronnie Sahlberged8561f2021-03-09 09:07:34 +10002211 struct inode *inode = d_inode(dentry);
Jeff Laytondf2cf172010-02-12 07:44:16 -05002212 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05302213 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Ronnie Sahlbergf6d23532021-03-09 09:07:35 +10002214 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2215 struct cached_fid *cfid = NULL;
Jeff Laytondf2cf172010-02-12 07:44:16 -05002216
Ronnie Sahlberg57c55cd2018-05-24 06:54:27 +10002217 if (cifs_i->time == 0)
2218 return true;
2219
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04002220 if (CIFS_CACHE_READ(cifs_i))
Jeff Laytondf2cf172010-02-12 07:44:16 -05002221 return false;
2222
2223 if (!lookupCacheEnabled)
2224 return true;
2225
Ronnie Sahlbergf6d23532021-03-09 09:07:35 +10002226 if (!open_cached_dir_by_dentry(tcon, dentry->d_parent, &cfid)) {
2227 mutex_lock(&cfid->fid_mutex);
2228 if (cfid->time && cifs_i->time > cfid->time) {
2229 mutex_unlock(&cfid->fid_mutex);
2230 close_cached_dir(cfid);
2231 return false;
2232 }
2233 mutex_unlock(&cfid->fid_mutex);
2234 close_cached_dir(cfid);
2235 }
Steve Frenchddaf6d42021-02-23 16:16:09 -06002236 /*
2237 * depending on inode type, check if attribute caching disabled for
2238 * files or directories
2239 */
2240 if (S_ISDIR(inode->i_mode)) {
2241 if (!cifs_sb->ctx->acdirmax)
2242 return true;
2243 if (!time_in_range(jiffies, cifs_i->time,
2244 cifs_i->time + cifs_sb->ctx->acdirmax))
2245 return true;
2246 } else { /* file */
Steve French57804642021-02-24 12:12:53 -06002247 if (!cifs_sb->ctx->acregmax)
Steve Frenchddaf6d42021-02-23 16:16:09 -06002248 return true;
2249 if (!time_in_range(jiffies, cifs_i->time,
Steve French57804642021-02-24 12:12:53 -06002250 cifs_i->time + cifs_sb->ctx->acregmax))
Steve Frenchddaf6d42021-02-23 16:16:09 -06002251 return true;
2252 }
Jeff Laytondf2cf172010-02-12 07:44:16 -05002253
Jeff Laytondb192722010-05-17 14:51:49 -04002254 /* hardlinked files w/ noserverino get "special" treatment */
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05302255 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
Jeff Laytondb192722010-05-17 14:51:49 -04002256 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
2257 return true;
2258
Jeff Laytondf2cf172010-02-12 07:44:16 -05002259 return false;
2260}
2261
Suresh Jayaraman523fb8c2010-11-29 22:39:47 +05302262/*
2263 * Zap the cache. Called when invalid_mapping flag is set.
2264 */
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002265int
Jeff Laytondf2cf172010-02-12 07:44:16 -05002266cifs_invalidate_mapping(struct inode *inode)
2267{
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002268 int rc = 0;
Jeff Laytondf2cf172010-02-12 07:44:16 -05002269
Jeff Laytondf2cf172010-02-12 07:44:16 -05002270 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
Pavel Shilovsky257fb1f2011-03-16 01:55:32 +03002271 rc = invalidate_inode_pages2(inode->i_mapping);
Jeff Layton4f73c7d2014-04-30 09:31:47 -04002272 if (rc)
Joe Perchesa0a30362020-04-14 22:42:53 -07002273 cifs_dbg(VFS, "%s: Could not invalidate inode %p\n",
Joe Perchesf96637b2013-05-04 22:12:25 -05002274 __func__, inode);
Jeff Laytondf2cf172010-02-12 07:44:16 -05002275 }
Pavel Shilovsky257fb1f2011-03-16 01:55:32 +03002276
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002277 return rc;
Jeff Laytondf2cf172010-02-12 07:44:16 -05002278}
2279
Jeff Layton4f73c7d2014-04-30 09:31:47 -04002280/**
2281 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
Steve French607dfc72020-12-12 12:08:58 -06002282 *
2283 * @key: currently unused
2284 * @mode: the task state to sleep in
Jeff Layton4f73c7d2014-04-30 09:31:47 -04002285 */
2286static int
Peter Zijlstradfd01f02015-12-13 22:11:16 +01002287cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
Jeff Layton4f73c7d2014-04-30 09:31:47 -04002288{
Jeff Layton4f73c7d2014-04-30 09:31:47 -04002289 freezable_schedule_unsafe();
Peter Zijlstradfd01f02015-12-13 22:11:16 +01002290 if (signal_pending_state(mode, current))
2291 return -ERESTARTSYS;
Jeff Layton4f73c7d2014-04-30 09:31:47 -04002292 return 0;
2293}
2294
Jeff Laytone284e532014-04-30 09:31:46 -04002295int
2296cifs_revalidate_mapping(struct inode *inode)
2297{
Jeff Layton4f73c7d2014-04-30 09:31:47 -04002298 int rc;
2299 unsigned long *flags = &CIFS_I(inode)->flags;
Shyam Prasad N18d04062021-08-10 10:22:28 +00002300 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton4f73c7d2014-04-30 09:31:47 -04002301
Steve French4e8aea32020-04-09 21:42:18 -05002302 /* swapfiles are not supposed to be shared */
2303 if (IS_SWAPFILE(inode))
2304 return 0;
2305
NeilBrown74316202014-07-07 15:16:04 +10002306 rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
2307 TASK_KILLABLE);
Jeff Layton4f73c7d2014-04-30 09:31:47 -04002308 if (rc)
2309 return rc;
2310
2311 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
Shyam Prasad N18d04062021-08-10 10:22:28 +00002312 /* for cache=singleclient, do not invalidate */
2313 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE)
2314 goto skip_invalidate;
2315
Jeff Layton4f73c7d2014-04-30 09:31:47 -04002316 rc = cifs_invalidate_mapping(inode);
2317 if (rc)
2318 set_bit(CIFS_INO_INVALID_MAPPING, flags);
2319 }
2320
Shyam Prasad N18d04062021-08-10 10:22:28 +00002321skip_invalidate:
Jeff Layton4f73c7d2014-04-30 09:31:47 -04002322 clear_bit_unlock(CIFS_INO_LOCK, flags);
Linus Torvaldsb1cce802014-06-09 19:08:43 -07002323 smp_mb__after_atomic();
Jeff Layton4f73c7d2014-04-30 09:31:47 -04002324 wake_up_bit(flags, CIFS_INO_LOCK);
2325
2326 return rc;
2327}
2328
2329int
2330cifs_zap_mapping(struct inode *inode)
2331{
2332 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
2333 return cifs_revalidate_mapping(inode);
Jeff Laytone284e532014-04-30 09:31:46 -04002334}
2335
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002336int cifs_revalidate_file_attr(struct file *filp)
Jeff Laytonabab0952010-02-12 07:44:18 -05002337{
2338 int rc = 0;
Ronnie Sahlberged8561f2021-03-09 09:07:34 +10002339 struct dentry *dentry = file_dentry(filp);
Jeff Laytonba00ba642010-09-20 16:01:31 -07002340 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
Jeff Laytonabab0952010-02-12 07:44:18 -05002341
Ronnie Sahlberged8561f2021-03-09 09:07:34 +10002342 if (!cifs_dentry_needs_reval(dentry))
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002343 return rc;
Jeff Laytonabab0952010-02-12 07:44:18 -05002344
Jeff Layton13cfb732010-09-29 19:51:11 -04002345 if (tlink_tcon(cfile->tlink)->unix_ext)
Jeff Laytonabab0952010-02-12 07:44:18 -05002346 rc = cifs_get_file_info_unix(filp);
2347 else
2348 rc = cifs_get_file_info(filp);
2349
Jeff Laytonabab0952010-02-12 07:44:18 -05002350 return rc;
2351}
2352
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002353int cifs_revalidate_dentry_attr(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002354{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002355 unsigned int xid;
Jeff Laytondf2cf172010-02-12 07:44:16 -05002356 int rc = 0;
David Howells2b0143b2015-03-17 22:25:59 +00002357 struct inode *inode = d_inode(dentry);
Jeff Laytondf2cf172010-02-12 07:44:16 -05002358 struct super_block *sb = dentry->d_sb;
Al Virof6a9bc32021-03-05 17:36:04 -05002359 const char *full_path;
2360 void *page;
Ronnie Sahlbergfc513fa2020-02-19 06:01:03 +10002361 int count = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002362
Jeff Laytondf2cf172010-02-12 07:44:16 -05002363 if (inode == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002364 return -ENOENT;
2365
Ronnie Sahlberged8561f2021-03-09 09:07:34 +10002366 if (!cifs_dentry_needs_reval(dentry))
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002367 return rc;
2368
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002369 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002370
Al Virof6a9bc32021-03-05 17:36:04 -05002371 page = alloc_dentry_path();
2372 full_path = build_path_from_dentry(dentry, page);
2373 if (IS_ERR(full_path)) {
2374 rc = PTR_ERR(full_path);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002375 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002376 }
Jeff Laytondf2cf172010-02-12 07:44:16 -05002377
Joe Perchesf96637b2013-05-04 22:12:25 -05002378 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2379 full_path, inode, inode->i_count.counter,
Miklos Szeredia00be0e2016-09-16 12:44:21 +02002380 dentry, cifs_get_time(dentry), jiffies);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002381
Ronnie Sahlbergfc513fa2020-02-19 06:01:03 +10002382again:
Steve French6a5f6592020-06-11 19:25:47 -05002383 if (cifs_sb_master_tcon(CIFS_SB(sb))->posix_extensions)
2384 rc = smb311_posix_get_inode_info(&inode, full_path, sb, xid);
2385 else if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
Jeff Laytondf2cf172010-02-12 07:44:16 -05002386 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2387 else
2388 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2389 xid, NULL);
Ronnie Sahlbergfc513fa2020-02-19 06:01:03 +10002390 if (rc == -EAGAIN && count++ < 10)
2391 goto again;
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002392out:
Al Virof6a9bc32021-03-05 17:36:04 -05002393 free_dentry_path(page);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002394 free_xid(xid);
Ronnie Sahlbergfc513fa2020-02-19 06:01:03 +10002395
Linus Torvalds1da177e2005-04-16 15:20:36 -07002396 return rc;
2397}
2398
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002399int cifs_revalidate_file(struct file *filp)
2400{
2401 int rc;
Al Viro496ad9a2013-01-23 17:07:38 -05002402 struct inode *inode = file_inode(filp);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002403
2404 rc = cifs_revalidate_file_attr(filp);
2405 if (rc)
2406 return rc;
2407
Jeff Laytone284e532014-04-30 09:31:46 -04002408 return cifs_revalidate_mapping(inode);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002409}
2410
2411/* revalidate a dentry's inode attributes */
2412int cifs_revalidate_dentry(struct dentry *dentry)
2413{
2414 int rc;
David Howells2b0143b2015-03-17 22:25:59 +00002415 struct inode *inode = d_inode(dentry);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002416
2417 rc = cifs_revalidate_dentry_attr(dentry);
2418 if (rc)
2419 return rc;
2420
Jeff Laytone284e532014-04-30 09:31:46 -04002421 return cifs_revalidate_mapping(inode);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002422}
2423
Christian Brauner549c7292021-01-21 14:19:43 +01002424int cifs_getattr(struct user_namespace *mnt_userns, const struct path *path,
2425 struct kstat *stat, u32 request_mask, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002426{
David Howellsa528d352017-01-31 16:46:22 +00002427 struct dentry *dentry = path->dentry;
Jeff Layton3aa1c8c2010-10-07 14:46:28 -04002428 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
Steve French96daf2b2011-05-27 04:34:02 +00002429 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
David Howells2b0143b2015-03-17 22:25:59 +00002430 struct inode *inode = d_inode(dentry);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002431 int rc;
Jeff Layton3aa1c8c2010-10-07 14:46:28 -04002432
Steve French087f7572021-04-29 00:18:43 -05002433 if (unlikely(cifs_forced_shutdown(CIFS_SB(inode->i_sb))))
2434 return -EIO;
2435
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002436 /*
2437 * We need to be sure that all dirty pages are written and the server
2438 * has actual ctime, mtime and file length.
2439 */
Steve French65af8f02021-03-19 00:05:48 -05002440 if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_SIZE | STATX_BLOCKS)) &&
Steve Frenchffdec8d2020-02-18 18:07:57 -06002441 !CIFS_CACHE_READ(CIFS_I(inode)) &&
2442 inode->i_mapping && inode->i_mapping->nrpages != 0) {
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002443 rc = filemap_fdatawait(inode->i_mapping);
Steve French156ecb22011-05-20 17:00:01 +00002444 if (rc) {
2445 mapping_set_error(inode->i_mapping, rc);
2446 return rc;
2447 }
Steve French5fe14c82006-11-07 19:26:33 +00002448 }
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002449
Steve Frenchffdec8d2020-02-18 18:07:57 -06002450 if ((flags & AT_STATX_SYNC_TYPE) == AT_STATX_FORCE_SYNC)
2451 CIFS_I(inode)->time = 0; /* force revalidate */
2452
2453 /*
2454 * If the caller doesn't require syncing, only sync if
2455 * necessary (e.g. due to earlier truncate or setattr
2456 * invalidating the cached metadata)
2457 */
2458 if (((flags & AT_STATX_SYNC_TYPE) != AT_STATX_DONT_SYNC) ||
2459 (CIFS_I(inode)->time == 0)) {
2460 rc = cifs_revalidate_dentry_attr(dentry);
2461 if (rc)
2462 return rc;
2463 }
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002464
Christian Brauner0d56a452021-01-21 14:19:30 +01002465 generic_fillattr(&init_user_ns, inode, stat);
Ronnie Sahlberg522aa3b2020-12-14 16:40:17 +10002466 stat->blksize = cifs_sb->ctx->bsize;
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002467 stat->ino = CIFS_I(inode)->uniqueid;
2468
Steve French6e70e262017-09-21 21:32:29 -05002469 /* old CIFS Unix Extensions doesn't return create time */
2470 if (CIFS_I(inode)->createtime) {
2471 stat->result_mask |= STATX_BTIME;
Arnd Bergmann95390202018-06-19 17:27:58 +02002472 stat->btime =
2473 cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
Steve French6e70e262017-09-21 21:32:29 -05002474 }
2475
2476 stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2477 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2478 stat->attributes |= STATX_ATTR_COMPRESSED;
2479 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2480 stat->attributes |= STATX_ATTR_ENCRYPTED;
2481
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002482 /*
Jeff Laytond3d1fce2012-11-25 08:00:40 -05002483 * If on a multiuser mount without unix extensions or cifsacl being
2484 * enabled, and the admin hasn't overridden them, set the ownership
2485 * to the fsuid/fsgid of the current process.
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002486 */
2487 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
Jeff Laytond3d1fce2012-11-25 08:00:40 -05002488 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002489 !tcon->unix_ext) {
2490 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2491 stat->uid = current_fsuid();
2492 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2493 stat->gid = current_fsgid();
2494 }
Dan Carpenter39946882020-02-28 12:22:59 +03002495 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002496}
2497
Ronnie Sahlberg2f3ebab2019-04-25 16:45:29 +10002498int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start,
2499 u64 len)
2500{
2501 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2502 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_i->vfs_inode.i_sb);
2503 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2504 struct TCP_Server_Info *server = tcon->ses->server;
2505 struct cifsFileInfo *cfile;
2506 int rc;
2507
Steve French087f7572021-04-29 00:18:43 -05002508 if (unlikely(cifs_forced_shutdown(cifs_sb)))
2509 return -EIO;
2510
Ronnie Sahlberg2f3ebab2019-04-25 16:45:29 +10002511 /*
2512 * We need to be sure that all dirty pages are written as they
2513 * might fill holes on the server.
2514 */
2515 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2516 inode->i_mapping->nrpages != 0) {
2517 rc = filemap_fdatawait(inode->i_mapping);
2518 if (rc) {
2519 mapping_set_error(inode->i_mapping, rc);
2520 return rc;
2521 }
2522 }
2523
2524 cfile = find_readable_file(cifs_i, false);
2525 if (cfile == NULL)
2526 return -EINVAL;
2527
2528 if (server->ops->fiemap) {
2529 rc = server->ops->fiemap(tcon, cfile, fei, start, len);
2530 cifsFileInfo_put(cfile);
2531 return rc;
2532 }
2533
2534 cifsFileInfo_put(cfile);
2535 return -ENOTSUPP;
2536}
2537
Ronnie Sahlberg8bd0d702020-01-17 11:45:02 +10002538int cifs_truncate_page(struct address_space *mapping, loff_t from)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002539{
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002540 pgoff_t index = from >> PAGE_SHIFT;
2541 unsigned offset = from & (PAGE_SIZE - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002542 struct page *page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002543 int rc = 0;
2544
2545 page = grab_cache_page(mapping, index);
2546 if (!page)
2547 return -ENOMEM;
2548
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002549 zero_user_segment(page, offset, PAGE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002550 unlock_page(page);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002551 put_page(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002552 return rc;
2553}
2554
Ronnie Sahlberg8bd0d702020-01-17 11:45:02 +10002555void cifs_setsize(struct inode *inode, loff_t offset)
Steve French3677db12007-02-26 16:46:11 +00002556{
Ronnie Sahlberg57c55cd2018-05-24 06:54:27 +10002557 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2558
Steve Frenchba6a46a2007-02-26 20:06:29 +00002559 spin_lock(&inode->i_lock);
Steve French3677db12007-02-26 16:46:11 +00002560 i_size_write(inode, offset);
Steve Frenchba6a46a2007-02-26 20:06:29 +00002561 spin_unlock(&inode->i_lock);
Christoph Hellwig1b947462010-07-18 17:51:21 -04002562
Ronnie Sahlberg57c55cd2018-05-24 06:54:27 +10002563 /* Cached inode must be refreshed on truncate */
2564 cifs_i->time = 0;
Kirill A. Shutemov7caef262013-09-12 15:13:56 -07002565 truncate_pagecache(inode, offset);
Steve French3677db12007-02-26 16:46:11 +00002566}
2567
Jeff Layton8efdbde2008-07-23 21:28:12 +00002568static int
2569cifs_set_file_size(struct inode *inode, struct iattr *attrs,
Al Virof6f1f172021-03-18 15:44:05 -04002570 unsigned int xid, const char *full_path)
Jeff Layton8efdbde2008-07-23 21:28:12 +00002571{
2572 int rc;
2573 struct cifsFileInfo *open_file;
2574 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2575 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04002576 struct tcon_link *tlink = NULL;
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002577 struct cifs_tcon *tcon = NULL;
2578 struct TCP_Server_Info *server;
Jeff Layton8efdbde2008-07-23 21:28:12 +00002579
2580 /*
2581 * To avoid spurious oplock breaks from server, in the case of
2582 * inodes that we already have open, avoid doing path based
2583 * setting of file size if we can do it by handle.
2584 * This keeps our caching token (oplock) and avoids timeouts
2585 * when the local oplock break takes longer to flush
2586 * writebehind data than the SMB timeout for the SetPathInfo
2587 * request would allow
2588 */
Aurelien Aptel86f740f2020-02-21 11:19:06 +01002589 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
Jeff Layton8efdbde2008-07-23 21:28:12 +00002590 if (open_file) {
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002591 tcon = tlink_tcon(open_file->tlink);
2592 server = tcon->ses->server;
2593 if (server->ops->set_file_size)
2594 rc = server->ops->set_file_size(xid, tcon, open_file,
2595 attrs->ia_size, false);
2596 else
2597 rc = -ENOSYS;
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04002598 cifsFileInfo_put(open_file);
Joe Perchesf96637b2013-05-04 22:12:25 -05002599 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00002600 } else
2601 rc = -EINVAL;
2602
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002603 if (!rc)
2604 goto set_size_out;
Jeff Laytonba00ba642010-09-20 16:01:31 -07002605
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002606 if (tcon == NULL) {
2607 tlink = cifs_sb_tlink(cifs_sb);
2608 if (IS_ERR(tlink))
2609 return PTR_ERR(tlink);
2610 tcon = tlink_tcon(tlink);
2611 server = tcon->ses->server;
Jeff Layton8efdbde2008-07-23 21:28:12 +00002612 }
2613
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002614 /*
2615 * Set file size by pathname rather than by handle either because no
2616 * valid, writeable file handle for it was found or because there was
2617 * an error setting it by handle.
2618 */
2619 if (server->ops->set_path_size)
2620 rc = server->ops->set_path_size(xid, tcon, full_path,
2621 attrs->ia_size, cifs_sb, false);
2622 else
2623 rc = -ENOSYS;
Joe Perchesf96637b2013-05-04 22:12:25 -05002624 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002625
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002626 if (tlink)
2627 cifs_put_tlink(tlink);
2628
2629set_size_out:
Jeff Layton8efdbde2008-07-23 21:28:12 +00002630 if (rc == 0) {
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04002631 cifsInode->server_eof = attrs->ia_size;
Christoph Hellwig1b947462010-07-18 17:51:21 -04002632 cifs_setsize(inode, attrs->ia_size);
Steve French65af8f02021-03-19 00:05:48 -05002633 /*
2634 * i_blocks is not related to (i_size / i_blksize), but instead
2635 * 512 byte (2**9) size is required for calculating num blocks.
2636 * Until we can query the server for actual allocation size,
2637 * this is best estimate we have for blocks allocated for a file
2638 * Number of blocks must be rounded up so size 1 is not 0 blocks
2639 */
2640 inode->i_blocks = (512 - 1 + attrs->ia_size) >> 9;
Zhang Xiaoxu56183032020-06-19 22:51:29 -04002641
2642 /*
2643 * The man page of truncate says if the size changed,
2644 * then the st_ctime and st_mtime fields for the file
2645 * are updated.
2646 */
2647 attrs->ia_ctime = attrs->ia_mtime = current_time(inode);
2648 attrs->ia_valid |= ATTR_CTIME | ATTR_MTIME;
2649
Jeff Layton8efdbde2008-07-23 21:28:12 +00002650 cifs_truncate_page(inode->i_mapping, inode->i_size);
2651 }
2652
2653 return rc;
2654}
2655
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002656static int
2657cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2658{
2659 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002660 unsigned int xid;
Al Virof6a9bc32021-03-05 17:36:04 -05002661 const char *full_path;
2662 void *page = alloc_dentry_path();
David Howells2b0143b2015-03-17 22:25:59 +00002663 struct inode *inode = d_inode(direntry);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002664 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2665 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04002666 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00002667 struct cifs_tcon *pTcon;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002668 struct cifs_unix_set_info_args *args = NULL;
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002669 struct cifsFileInfo *open_file;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002670
Al Viro35c265e2014-08-19 20:25:34 -04002671 cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2672 direntry, attrs->ia_valid);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002673
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002674 xid = get_xid();
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002675
Christoph Hellwigdb78b8772010-06-04 11:30:03 +02002676 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2677 attrs->ia_valid |= ATTR_FORCE;
2678
Christian Brauner2f221d62021-01-21 14:19:26 +01002679 rc = setattr_prepare(&init_user_ns, direntry, attrs);
Christoph Hellwigdb78b8772010-06-04 11:30:03 +02002680 if (rc < 0)
2681 goto out;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002682
Al Virof6a9bc32021-03-05 17:36:04 -05002683 full_path = build_path_from_dentry(direntry, page);
2684 if (IS_ERR(full_path)) {
2685 rc = PTR_ERR(full_path);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002686 goto out;
2687 }
2688
Jeff Layton0f4d6342009-03-26 13:35:37 -04002689 /*
2690 * Attempt to flush data before changing attributes. We need to do
2691 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2692 * ownership or mode then we may also need to do this. Here, we take
2693 * the safe way out and just do the flush on all setattr requests. If
2694 * the flush returns error, store it to report later and continue.
2695 *
2696 * BB: This should be smarter. Why bother flushing pages that
2697 * will be truncated anyway? Also, should we error out here if
2698 * the flush returns error?
2699 */
2700 rc = filemap_write_and_wait(inode->i_mapping);
Pavel Shilovsky9a663962019-01-08 11:15:28 -08002701 if (is_interrupt_error(rc)) {
2702 rc = -ERESTARTSYS;
2703 goto out;
2704 }
2705
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002706 mapping_set_error(inode->i_mapping, rc);
2707 rc = 0;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002708
2709 if (attrs->ia_valid & ATTR_SIZE) {
2710 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2711 if (rc != 0)
2712 goto out;
2713 }
2714
2715 /* skip mode change if it's just for clearing setuid/setgid */
2716 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2717 attrs->ia_valid &= ~ATTR_MODE;
2718
2719 args = kmalloc(sizeof(*args), GFP_KERNEL);
2720 if (args == NULL) {
2721 rc = -ENOMEM;
2722 goto out;
2723 }
2724
2725 /* set up the struct */
2726 if (attrs->ia_valid & ATTR_MODE)
2727 args->mode = attrs->ia_mode;
2728 else
2729 args->mode = NO_CHANGE_64;
2730
2731 if (attrs->ia_valid & ATTR_UID)
2732 args->uid = attrs->ia_uid;
2733 else
Eric W. Biederman49418b22013-02-06 00:57:56 -08002734 args->uid = INVALID_UID; /* no change */
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002735
2736 if (attrs->ia_valid & ATTR_GID)
2737 args->gid = attrs->ia_gid;
2738 else
Eric W. Biederman49418b22013-02-06 00:57:56 -08002739 args->gid = INVALID_GID; /* no change */
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002740
2741 if (attrs->ia_valid & ATTR_ATIME)
Arnd Bergmann95390202018-06-19 17:27:58 +02002742 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002743 else
2744 args->atime = NO_CHANGE_64;
2745
2746 if (attrs->ia_valid & ATTR_MTIME)
Arnd Bergmann95390202018-06-19 17:27:58 +02002747 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002748 else
2749 args->mtime = NO_CHANGE_64;
2750
2751 if (attrs->ia_valid & ATTR_CTIME)
Arnd Bergmann95390202018-06-19 17:27:58 +02002752 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002753 else
2754 args->ctime = NO_CHANGE_64;
2755
2756 args->device = 0;
Aurelien Aptel86f740f2020-02-21 11:19:06 +01002757 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002758 if (open_file) {
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07002759 u16 nfid = open_file->fid.netfid;
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002760 u32 npid = open_file->pid;
Jeff Layton13cfb732010-09-29 19:51:11 -04002761 pTcon = tlink_tcon(open_file->tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002762 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04002763 cifsFileInfo_put(open_file);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002764 } else {
Jeff Layton7ffec372010-09-29 19:51:11 -04002765 tlink = cifs_sb_tlink(cifs_sb);
2766 if (IS_ERR(tlink)) {
2767 rc = PTR_ERR(tlink);
2768 goto out;
2769 }
2770 pTcon = tlink_tcon(tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002771 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
Jeff Layton01ea95e2009-07-09 20:02:49 -04002772 cifs_sb->local_nls,
Nakajima Akirabc8ebdc42015-02-13 15:35:58 +09002773 cifs_remap(cifs_sb));
Jeff Layton7ffec372010-09-29 19:51:11 -04002774 cifs_put_tlink(tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002775 }
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002776
Christoph Hellwig10257742010-06-04 11:30:02 +02002777 if (rc)
2778 goto out;
Steve Frenchccd4bb12010-02-08 17:39:58 +00002779
Christoph Hellwig10257742010-06-04 11:30:02 +02002780 if ((attrs->ia_valid & ATTR_SIZE) &&
David Howells70431bf2020-11-17 15:56:59 +00002781 attrs->ia_size != i_size_read(inode)) {
Christoph Hellwig1b947462010-07-18 17:51:21 -04002782 truncate_setsize(inode, attrs->ia_size);
David Howells70431bf2020-11-17 15:56:59 +00002783 fscache_resize_cookie(cifs_inode_cookie(inode), attrs->ia_size);
2784 }
Christoph Hellwig10257742010-06-04 11:30:02 +02002785
Christian Brauner2f221d62021-01-21 14:19:26 +01002786 setattr_copy(&init_user_ns, inode, attrs);
Christoph Hellwig10257742010-06-04 11:30:02 +02002787 mark_inode_dirty(inode);
2788
2789 /* force revalidate when any of these times are set since some
2790 of the fs types (eg ext3, fat) do not have fine enough
2791 time granularity to match protocol, and we do not have a
2792 a way (yet) to query the server fs's time granularity (and
2793 whether it rounds times down).
2794 */
2795 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2796 cifsInode->time = 0;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002797out:
2798 kfree(args);
Al Virof6a9bc32021-03-05 17:36:04 -05002799 free_dentry_path(page);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002800 free_xid(xid);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002801 return rc;
2802}
2803
Jeff Layton0510eeb2008-08-02 07:26:12 -04002804static int
2805cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002806{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002807 unsigned int xid;
Eric W. Biederman8abf2772013-02-06 00:33:17 -08002808 kuid_t uid = INVALID_UID;
2809 kgid_t gid = INVALID_GID;
David Howells2b0143b2015-03-17 22:25:59 +00002810 struct inode *inode = d_inode(direntry);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002811 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002812 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
Ronnie Sahlbergaa081852019-07-19 08:12:11 +10002813 struct cifsFileInfo *wfile;
2814 struct cifs_tcon *tcon;
Al Virof6a9bc32021-03-05 17:36:04 -05002815 const char *full_path;
2816 void *page = alloc_dentry_path();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002817 int rc = -EACCES;
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002818 __u32 dosattr = 0;
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04002819 __u64 mode = NO_CHANGE_64;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002820
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002821 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002822
Colin Ian King63d614a2019-06-24 17:39:43 +01002823 cifs_dbg(FYI, "setattr on file %pd attrs->ia_valid 0x%x\n",
Al Viro35c265e2014-08-19 20:25:34 -04002824 direntry, attrs->ia_valid);
Steve French6473a552005-11-29 20:20:10 -08002825
Christoph Hellwigdb78b8772010-06-04 11:30:03 +02002826 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2827 attrs->ia_valid |= ATTR_FORCE;
2828
Christian Brauner2f221d62021-01-21 14:19:26 +01002829 rc = setattr_prepare(&init_user_ns, direntry, attrs);
Al Virof6a9bc32021-03-05 17:36:04 -05002830 if (rc < 0)
2831 goto cifs_setattr_exit;
Steve French50c2f752007-07-13 00:33:32 +00002832
Al Virof6a9bc32021-03-05 17:36:04 -05002833 full_path = build_path_from_dentry(direntry, page);
2834 if (IS_ERR(full_path)) {
2835 rc = PTR_ERR(full_path);
2836 goto cifs_setattr_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002837 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002838
Jeff Layton0f4d6342009-03-26 13:35:37 -04002839 /*
2840 * Attempt to flush data before changing attributes. We need to do
Steve Frenchcf5371a2020-02-24 17:37:39 -06002841 * this for ATTR_SIZE and ATTR_MTIME. If the flush of the data
2842 * returns error, store it to report later and continue.
Jeff Layton0f4d6342009-03-26 13:35:37 -04002843 *
2844 * BB: This should be smarter. Why bother flushing pages that
2845 * will be truncated anyway? Also, should we error out here if
Steve Frenchcf5371a2020-02-24 17:37:39 -06002846 * the flush returns error? Do we need to check for ATTR_MTIME_SET flag?
Jeff Layton0f4d6342009-03-26 13:35:37 -04002847 */
Steve Frenchcf5371a2020-02-24 17:37:39 -06002848 if (attrs->ia_valid & (ATTR_MTIME | ATTR_SIZE | ATTR_CTIME)) {
2849 rc = filemap_write_and_wait(inode->i_mapping);
2850 if (is_interrupt_error(rc)) {
2851 rc = -ERESTARTSYS;
2852 goto cifs_setattr_exit;
2853 }
2854 mapping_set_error(inode->i_mapping, rc);
Pavel Shilovsky9a663962019-01-08 11:15:28 -08002855 }
2856
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002857 rc = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +00002858
Steve Frenchcf5371a2020-02-24 17:37:39 -06002859 if ((attrs->ia_valid & ATTR_MTIME) &&
2860 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
Aurelien Aptel86f740f2020-02-21 11:19:06 +01002861 rc = cifs_get_writable_file(cifsInode, FIND_WR_ANY, &wfile);
Ronnie Sahlbergaa081852019-07-19 08:12:11 +10002862 if (!rc) {
2863 tcon = tlink_tcon(wfile->tlink);
2864 rc = tcon->ses->server->ops->flush(xid, tcon, &wfile->fid);
2865 cifsFileInfo_put(wfile);
2866 if (rc)
Chuhong Yuan783bf7b2019-10-14 15:15:31 +08002867 goto cifs_setattr_exit;
Ronnie Sahlbergaa081852019-07-19 08:12:11 +10002868 } else if (rc != -EBADF)
Chuhong Yuan783bf7b2019-10-14 15:15:31 +08002869 goto cifs_setattr_exit;
Ronnie Sahlbergaa081852019-07-19 08:12:11 +10002870 else
2871 rc = 0;
2872 }
2873
Steve French50531442008-03-14 19:21:31 +00002874 if (attrs->ia_valid & ATTR_SIZE) {
Jeff Layton8efdbde2008-07-23 21:28:12 +00002875 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2876 if (rc != 0)
Steve Frenche30dcf32005-09-20 20:49:16 -07002877 goto cifs_setattr_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002878 }
Jeff Layton4ca691a2008-05-22 09:33:34 -04002879
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002880 if (attrs->ia_valid & ATTR_UID)
2881 uid = attrs->ia_uid;
2882
2883 if (attrs->ia_valid & ATTR_GID)
2884 gid = attrs->ia_gid;
2885
Steve French22442172019-07-19 08:15:55 +00002886 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2887 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
Eric W. Biederman8abf2772013-02-06 00:33:17 -08002888 if (uid_valid(uid) || gid_valid(gid)) {
Shyam Prasad N0f220532020-08-17 03:23:12 -07002889 mode = NO_CHANGE_64;
2890 rc = id_mode_to_cifs_acl(inode, full_path, &mode,
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002891 uid, gid);
2892 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002893 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2894 __func__, rc);
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002895 goto cifs_setattr_exit;
2896 }
2897 }
2898 } else
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002899 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
Jeff Layton4ca691a2008-05-22 09:33:34 -04002900 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002901
Jeff Laytond32c4f22007-10-18 03:05:22 -07002902 /* skip mode change if it's just for clearing setuid/setgid */
2903 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2904 attrs->ia_valid &= ~ATTR_MODE;
2905
Linus Torvalds1da177e2005-04-16 15:20:36 -07002906 if (attrs->ia_valid & ATTR_MODE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002907 mode = attrs->ia_mode;
Steve Frenchcdbce9c82005-11-19 21:04:52 -08002908 rc = 0;
Steve French22442172019-07-19 08:15:55 +00002909 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2910 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
Shyam Prasad N0f220532020-08-17 03:23:12 -07002911 rc = id_mode_to_cifs_acl(inode, full_path, &mode,
Eric W. Biederman8abf2772013-02-06 00:33:17 -08002912 INVALID_UID, INVALID_GID);
Shirish Pargaonkar78415d22010-11-27 11:37:26 -06002913 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002914 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2915 __func__, rc);
Shirish Pargaonkar78415d22010-11-27 11:37:26 -06002916 goto cifs_setattr_exit;
2917 }
Shyam Prasad N0f220532020-08-17 03:23:12 -07002918
2919 /*
2920 * In case of CIFS_MOUNT_CIFS_ACL, we cannot support all modes.
2921 * Pick up the actual mode bits that were set.
2922 */
2923 if (mode != attrs->ia_mode)
2924 attrs->ia_mode = mode;
Shirish Pargaonkar78415d22010-11-27 11:37:26 -06002925 } else
Jeff Layton51328612008-05-22 09:33:34 -04002926 if (((mode & S_IWUGO) == 0) &&
2927 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002928
2929 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2930
Jeff Layton51328612008-05-22 09:33:34 -04002931 /* fix up mode if we're not using dynperm */
2932 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2933 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2934 } else if ((mode & S_IWUGO) &&
2935 (cifsInode->cifsAttrs & ATTR_READONLY)) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002936
2937 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2938 /* Attributes of 0 are ignored */
2939 if (dosattr == 0)
2940 dosattr |= ATTR_NORMAL;
Jeff Layton51328612008-05-22 09:33:34 -04002941
2942 /* reset local inode permissions to normal */
2943 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2944 attrs->ia_mode &= ~(S_IALLUGO);
2945 if (S_ISDIR(inode->i_mode))
2946 attrs->ia_mode |=
Ronnie Sahlberg8401e932020-12-12 13:40:50 -06002947 cifs_sb->ctx->dir_mode;
Jeff Layton51328612008-05-22 09:33:34 -04002948 else
2949 attrs->ia_mode |=
Ronnie Sahlberg8401e932020-12-12 13:40:50 -06002950 cifs_sb->ctx->file_mode;
Jeff Layton51328612008-05-22 09:33:34 -04002951 }
2952 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2953 /* ignore mode change - ATTR_READONLY hasn't changed */
2954 attrs->ia_valid &= ~ATTR_MODE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002955 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002956 }
2957
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002958 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2959 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2960 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2961 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002962
Steve Frenche30dcf32005-09-20 20:49:16 -07002963 /* Even if error on time set, no sense failing the call if
2964 the server would set the time to a reasonable value anyway,
2965 and this check ensures that we are not being called from
2966 sys_utimes in which case we ought to fail the call back to
2967 the user when the server rejects the call */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002968 if ((rc) && (attrs->ia_valid &
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002969 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
Steve Frenche30dcf32005-09-20 20:49:16 -07002970 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002971 }
2972
2973 /* do not need local check to inode_check_ok since the server does
2974 that */
Christoph Hellwig10257742010-06-04 11:30:02 +02002975 if (rc)
2976 goto cifs_setattr_exit;
2977
2978 if ((attrs->ia_valid & ATTR_SIZE) &&
David Howells70431bf2020-11-17 15:56:59 +00002979 attrs->ia_size != i_size_read(inode)) {
Christoph Hellwig1b947462010-07-18 17:51:21 -04002980 truncate_setsize(inode, attrs->ia_size);
David Howells70431bf2020-11-17 15:56:59 +00002981 fscache_resize_cookie(cifs_inode_cookie(inode), attrs->ia_size);
2982 }
Christoph Hellwig10257742010-06-04 11:30:02 +02002983
Christian Brauner2f221d62021-01-21 14:19:26 +01002984 setattr_copy(&init_user_ns, inode, attrs);
Christoph Hellwig10257742010-06-04 11:30:02 +02002985 mark_inode_dirty(inode);
Christoph Hellwig10257742010-06-04 11:30:02 +02002986
Steve Frenche30dcf32005-09-20 20:49:16 -07002987cifs_setattr_exit:
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002988 free_xid(xid);
Al Virof6a9bc32021-03-05 17:36:04 -05002989 free_dentry_path(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002990 return rc;
2991}
2992
Jeff Layton0510eeb2008-08-02 07:26:12 -04002993int
Christian Brauner549c7292021-01-21 14:19:43 +01002994cifs_setattr(struct user_namespace *mnt_userns, struct dentry *direntry,
2995 struct iattr *attrs)
Jeff Layton0510eeb2008-08-02 07:26:12 -04002996{
Al Virofc640052016-04-10 01:33:30 -04002997 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
Steve French96daf2b2011-05-27 04:34:02 +00002998 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
Ronnie Sahlbergc6cc4c52020-10-09 09:32:56 +10002999 int rc, retries = 0;
Jeff Layton0510eeb2008-08-02 07:26:12 -04003000
Steve French087f7572021-04-29 00:18:43 -05003001 if (unlikely(cifs_forced_shutdown(cifs_sb)))
3002 return -EIO;
3003
Ronnie Sahlbergc6cc4c52020-10-09 09:32:56 +10003004 do {
3005 if (pTcon->unix_ext)
3006 rc = cifs_setattr_unix(direntry, attrs);
3007 else
3008 rc = cifs_setattr_nounix(direntry, attrs);
3009 retries++;
3010 } while (is_retryable_error(rc) && retries < 2);
Jeff Layton0510eeb2008-08-02 07:26:12 -04003011
3012 /* BB: add cifs_setattr_legacy for really old servers */
Ronnie Sahlbergc6cc4c52020-10-09 09:32:56 +10003013 return rc;
Jeff Layton0510eeb2008-08-02 07:26:12 -04003014}