blob: 1e8a4b1579db49791592fdba227672f01c97d806 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/inode.c
3 *
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 *
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21#include <linux/fs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/stat.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090023#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/pagemap.h>
Jeff Layton4f73c7d2014-04-30 09:31:47 -040025#include <linux/freezer.h>
Ingo Molnar174cd4b2017-02-02 19:15:33 +010026#include <linux/sched/signal.h>
Ingo Molnar5dd43ce2017-06-20 12:19:09 +020027#include <linux/wait_bit.h>
Ingo Molnar174cd4b2017-02-02 19:15:33 +010028
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <asm/div64.h>
30#include "cifsfs.h"
31#include "cifspdu.h"
32#include "cifsglob.h"
33#include "cifsproto.h"
34#include "cifs_debug.h"
35#include "cifs_fs_sb.h"
Steve French2baa2682014-09-27 02:19:01 -050036#include "cifs_unicode.h"
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +053037#include "fscache.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
Christoph Hellwig70eff552008-02-15 20:55:05 +000039
David Howells01c64fe2011-01-14 18:45:47 +000040static void cifs_set_ops(struct inode *inode)
Christoph Hellwig70eff552008-02-15 20:55:05 +000041{
42 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
43
44 switch (inode->i_mode & S_IFMT) {
45 case S_IFREG:
46 inode->i_op = &cifs_file_inode_ops;
47 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
48 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
49 inode->i_fop = &cifs_file_direct_nobrl_ops;
50 else
51 inode->i_fop = &cifs_file_direct_ops;
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +030052 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
53 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
54 inode->i_fop = &cifs_file_strict_nobrl_ops;
55 else
56 inode->i_fop = &cifs_file_strict_ops;
Christoph Hellwig70eff552008-02-15 20:55:05 +000057 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
58 inode->i_fop = &cifs_file_nobrl_ops;
59 else { /* not direct, send byte range locks */
60 inode->i_fop = &cifs_file_ops;
61 }
62
Christoph Hellwig70eff552008-02-15 20:55:05 +000063 /* check if server can support readpages */
Jeff Layton0d424ad2010-09-20 16:01:35 -070064 if (cifs_sb_master_tcon(cifs_sb)->ses->server->maxBuf <
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +030065 PAGE_SIZE + MAX_CIFS_HDR_SIZE)
Christoph Hellwig70eff552008-02-15 20:55:05 +000066 inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
67 else
68 inode->i_data.a_ops = &cifs_addr_ops;
69 break;
70 case S_IFDIR:
Steve Frenchbc5b6e22008-03-11 21:07:48 +000071#ifdef CONFIG_CIFS_DFS_UPCALL
David Howells01c64fe2011-01-14 18:45:47 +000072 if (IS_AUTOMOUNT(inode)) {
Igor Mammedov79626702008-03-09 03:44:18 +000073 inode->i_op = &cifs_dfs_referral_inode_operations;
74 } else {
Steve Frenchbc5b6e22008-03-11 21:07:48 +000075#else /* NO DFS support, treat as a directory */
76 {
77#endif
Igor Mammedov79626702008-03-09 03:44:18 +000078 inode->i_op = &cifs_dir_inode_ops;
79 inode->i_fop = &cifs_dir_ops;
80 }
Christoph Hellwig70eff552008-02-15 20:55:05 +000081 break;
82 case S_IFLNK:
83 inode->i_op = &cifs_symlink_inode_ops;
84 break;
85 default:
86 init_special_inode(inode, inode->i_mode, inode->i_rdev);
87 break;
88 }
89}
90
Jeff Laytondf2cf172010-02-12 07:44:16 -050091/* check inode attributes against fattr. If they don't match, tag the
92 * inode for cache invalidation
93 */
94static void
95cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
96{
97 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
98
Joe Perchesf96637b2013-05-04 22:12:25 -050099 cifs_dbg(FYI, "%s: revalidating inode %llu\n",
100 __func__, cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -0500101
102 if (inode->i_state & I_NEW) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500103 cifs_dbg(FYI, "%s: inode %llu is new\n",
104 __func__, cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -0500105 return;
106 }
107
108 /* don't bother with revalidation if we have an oplock */
Pavel Shilovsky18cceb62013-09-05 13:01:06 +0400109 if (CIFS_CACHE_READ(cifs_i)) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500110 cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
111 __func__, cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -0500112 return;
113 }
114
115 /* revalidate if mtime or size have changed */
Deepa Dinamani918c9002019-12-02 21:19:41 -0800116 fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);
Arnd Bergmann95390202018-06-19 17:27:58 +0200117 if (timespec64_equal(&inode->i_mtime, &fattr->cf_mtime) &&
Jeff Laytondf2cf172010-02-12 07:44:16 -0500118 cifs_i->server_eof == fattr->cf_eof) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500119 cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
120 __func__, cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -0500121 return;
122 }
123
Joe Perchesf96637b2013-05-04 22:12:25 -0500124 cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
125 __func__, cifs_i->uniqueid);
Jeff Laytonaff8d5c2014-04-30 09:31:45 -0400126 set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags);
Jeff Laytondf2cf172010-02-12 07:44:16 -0500127}
128
Jim McDonough74d290d2013-09-21 10:36:10 -0500129/*
130 * copy nlink to the inode, unless it wasn't provided. Provide
131 * sane values if we don't have an existing one and none was provided
132 */
133static void
134cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
135{
136 /*
137 * if we're in a situation where we can't trust what we
138 * got from the server (readdir, some non-unix cases)
139 * fake reasonable values
140 */
141 if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
142 /* only provide fake values on a new inode */
143 if (inode->i_state & I_NEW) {
144 if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
145 set_nlink(inode, 2);
146 else
147 set_nlink(inode, 1);
148 }
149 return;
150 }
151
152 /* we trust the server, so update it */
153 set_nlink(inode, fattr->cf_nlink);
154}
155
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400156/* populate an inode with info from a cifs_fattr struct */
157void
158cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
Christoph Hellwig75f12982008-02-25 20:25:21 +0000159{
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400160 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400161 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Christoph Hellwig75f12982008-02-25 20:25:21 +0000162
Jeff Laytondf2cf172010-02-12 07:44:16 -0500163 cifs_revalidate_cache(inode, fattr);
164
Steve Frenchb7ca6922012-08-03 08:43:01 -0500165 spin_lock(&inode->i_lock);
Deepa Dinamani918c9002019-12-02 21:19:41 -0800166 fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);
167 fattr->cf_atime = timestamp_truncate(fattr->cf_atime, inode);
168 fattr->cf_ctime = timestamp_truncate(fattr->cf_ctime, inode);
Steve French9b9c5be2018-09-22 12:07:06 -0500169 /* we do not want atime to be less than mtime, it broke some apps */
Deepa Dinamani69738cf2019-11-29 21:30:25 -0800170 if (timespec64_compare(&fattr->cf_atime, &fattr->cf_mtime) < 0)
Steve French9b9c5be2018-09-22 12:07:06 -0500171 inode->i_atime = fattr->cf_mtime;
172 else
173 inode->i_atime = fattr->cf_atime;
Arnd Bergmann95390202018-06-19 17:27:58 +0200174 inode->i_mtime = fattr->cf_mtime;
175 inode->i_ctime = fattr->cf_ctime;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400176 inode->i_rdev = fattr->cf_rdev;
Jim McDonough74d290d2013-09-21 10:36:10 -0500177 cifs_nlink_fattr_to_inode(inode, fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400178 inode->i_uid = fattr->cf_uid;
179 inode->i_gid = fattr->cf_gid;
180
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400181 /* if dynperm is set, don't clobber existing mode */
182 if (inode->i_state & I_NEW ||
183 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
184 inode->i_mode = fattr->cf_mode;
185
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400186 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400187
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400188 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
189 cifs_i->time = 0;
190 else
191 cifs_i->time = jiffies;
192
Jeff Laytonaff8d5c2014-04-30 09:31:45 -0400193 if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING)
194 set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
195 else
196 clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
Christoph Hellwig75f12982008-02-25 20:25:21 +0000197
Jeff Layton835a36c2010-02-10 16:21:33 -0500198 cifs_i->server_eof = fattr->cf_eof;
Christoph Hellwig75f12982008-02-25 20:25:21 +0000199 /*
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400200 * Can't safely change the file size here if the client is writing to
201 * it due to potential races.
Christoph Hellwig75f12982008-02-25 20:25:21 +0000202 */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400203 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
204 i_size_write(inode, fattr->cf_eof);
Christoph Hellwig75f12982008-02-25 20:25:21 +0000205
206 /*
207 * i_blocks is not related to (i_size / i_blksize),
208 * but instead 512 byte (2**9) size is required for
209 * calculating num blocks.
210 */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400211 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
Christoph Hellwig75f12982008-02-25 20:25:21 +0000212 }
213 spin_unlock(&inode->i_lock);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400214
David Howells01c64fe2011-01-14 18:45:47 +0000215 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
216 inode->i_flags |= S_AUTOMOUNT;
Jeff Laytonc2b93e02013-05-07 11:28:31 -0400217 if (inode->i_state & I_NEW)
218 cifs_set_ops(inode);
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
Eric W. Biederman46bbc252013-02-05 23:55:44 -0800295 fattr->cf_uid = cifs_sb->mnt_uid;
296 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
297 u64 id = le64_to_cpu(info->Uid);
Eric W. Biederman4a2c8cf2013-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
305 fattr->cf_gid = cifs_sb->mnt_gid;
306 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
307 u64 id = le64_to_cpu(info->Gid);
Eric W. Biederman4a2c8cf2013-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;
334 fattr->cf_uid = cifs_sb->mnt_uid;
335 fattr->cf_gid = cifs_sb->mnt_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;
361 }
362
363 cifs_fattr_to_inode(inode, &fattr);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400364 free_xid(xid);
Jeff Laytonabab0952010-02-12 07:44:18 -0500365 return rc;
366}
367
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368int cifs_get_inode_info_unix(struct inode **pinode,
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400369 const unsigned char *full_path,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400370 struct super_block *sb, unsigned int xid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371{
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400372 int rc;
Steve French0e4bbde2008-05-20 19:50:46 +0000373 FILE_UNIX_BASIC_INFO find_data;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400374 struct cifs_fattr fattr;
Steve French96daf2b2011-05-27 04:34:02 +0000375 struct cifs_tcon *tcon;
Jeff Layton7ffec372010-09-29 19:51:11 -0400376 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378
Joe Perchesf96637b2013-05-04 22:12:25 -0500379 cifs_dbg(FYI, "Getting info on %s\n", full_path);
Igor Mammedov79626702008-03-09 03:44:18 +0000380
Jeff Layton7ffec372010-09-29 19:51:11 -0400381 tlink = cifs_sb_tlink(cifs_sb);
382 if (IS_ERR(tlink))
383 return PTR_ERR(tlink);
384 tcon = tlink_tcon(tlink);
385
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 /* could have done a find first instead but this returns more info */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400387 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
Nakajima Akirabc8ebdc42015-02-13 15:35:58 +0900388 cifs_sb->local_nls, cifs_remap(cifs_sb));
Jeff Layton7ffec372010-09-29 19:51:11 -0400389 cifs_put_tlink(tlink);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400390
391 if (!rc) {
392 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
393 } else if (rc == -EREMOTE) {
394 cifs_create_dfs_fattr(&fattr, sb);
Jeff Laytone911d0c2008-07-12 13:47:59 -0700395 rc = 0;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400396 } else {
397 return rc;
Steve French0e4bbde2008-05-20 19:50:46 +0000398 }
399
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200400 /* check for Minshall+French symlinks */
401 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
Sachin Prabhucb084b12013-11-25 17:09:50 +0000402 int tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
403 full_path);
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200404 if (tmprc)
Sachin Prabhucb084b12013-11-25 17:09:50 +0000405 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200406 }
407
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400408 if (*pinode == NULL) {
409 /* get new inode */
Jeff Layton4065c802010-05-17 07:18:58 -0400410 cifs_fill_uniqueid(sb, &fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400411 *pinode = cifs_iget(sb, &fattr);
412 if (!*pinode)
413 rc = -ENOMEM;
414 } else {
415 /* we already have inode, update it */
Nakajima Akira7196ac12015-04-22 15:24:44 +0900416
417 /* if uniqueid is different, return error */
418 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
419 CIFS_I(*pinode)->uniqueid != fattr.cf_uniqueid)) {
Pavel Shilovskyc82e5ac2019-09-30 10:06:19 -0700420 CIFS_I(*pinode)->time = 0; /* force reval */
Nakajima Akira7196ac12015-04-22 15:24:44 +0900421 rc = -ESTALE;
422 goto cgiiu_exit;
423 }
424
425 /* if filetype is different, return error */
426 if (unlikely(((*pinode)->i_mode & S_IFMT) !=
427 (fattr.cf_mode & S_IFMT))) {
Pavel Shilovskyc82e5ac2019-09-30 10:06:19 -0700428 CIFS_I(*pinode)->time = 0; /* force reval */
Nakajima Akira7196ac12015-04-22 15:24:44 +0900429 rc = -ESTALE;
430 goto cgiiu_exit;
431 }
432
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400433 cifs_fattr_to_inode(*pinode, &fattr);
434 }
Steve French0e4bbde2008-05-20 19:50:46 +0000435
Nakajima Akira7196ac12015-04-22 15:24:44 +0900436cgiiu_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 return rc;
438}
439
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400440static int
Pavel Shilovsky0360d602014-01-16 15:53:35 +0400441cifs_sfu_type(struct cifs_fattr *fattr, const char *path,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400442 struct cifs_sb_info *cifs_sb, unsigned int xid)
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800443{
444 int rc;
Steve Frenchdb8b6312014-09-22 05:13:55 -0500445 __u32 oplock;
Jeff Layton7ffec372010-09-29 19:51:11 -0400446 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +0000447 struct cifs_tcon *tcon;
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +0400448 struct cifs_fid fid;
449 struct cifs_open_parms oparms;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000450 struct cifs_io_parms io_parms;
Steve French86c96b42005-11-18 20:25:31 -0800451 char buf[24];
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800452 unsigned int bytes_read;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000453 char *pbuf;
Pavel Shilovsky0360d602014-01-16 15:53:35 +0400454 int buf_type = CIFS_NO_BUFFER;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800455
456 pbuf = buf;
457
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400458 fattr->cf_mode &= ~S_IFMT;
459
460 if (fattr->cf_eof == 0) {
461 fattr->cf_mode |= S_IFIFO;
462 fattr->cf_dtype = DT_FIFO;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800463 return 0;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400464 } else if (fattr->cf_eof < 8) {
465 fattr->cf_mode |= S_IFREG;
466 fattr->cf_dtype = DT_REG;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800467 return -EINVAL; /* EOPNOTSUPP? */
468 }
Steve French50c2f752007-07-13 00:33:32 +0000469
Jeff Layton7ffec372010-09-29 19:51:11 -0400470 tlink = cifs_sb_tlink(cifs_sb);
471 if (IS_ERR(tlink))
472 return PTR_ERR(tlink);
473 tcon = tlink_tcon(tlink);
474
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +0400475 oparms.tcon = tcon;
476 oparms.cifs_sb = cifs_sb;
477 oparms.desired_access = GENERIC_READ;
Amir Goldstein0f060932020-02-03 21:46:43 +0200478 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +0400479 oparms.disposition = FILE_OPEN;
480 oparms.path = path;
481 oparms.fid = &fid;
482 oparms.reconnect = false;
483
Steve Frenchdb8b6312014-09-22 05:13:55 -0500484 if (tcon->ses->server->oplocks)
485 oplock = REQ_OPLOCK;
486 else
487 oplock = 0;
488 rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);
Pavel Shilovsky0360d602014-01-16 15:53:35 +0400489 if (rc) {
Steve Frenchdb8b6312014-09-22 05:13:55 -0500490 cifs_dbg(FYI, "check sfu type of %s, open rc = %d\n", path, rc);
Pavel Shilovsky0360d602014-01-16 15:53:35 +0400491 cifs_put_tlink(tlink);
492 return rc;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800493 }
Pavel Shilovsky0360d602014-01-16 15:53:35 +0400494
495 /* Read header */
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +0400496 io_parms.netfid = fid.netfid;
Pavel Shilovsky0360d602014-01-16 15:53:35 +0400497 io_parms.pid = current->tgid;
498 io_parms.tcon = tcon;
499 io_parms.offset = 0;
500 io_parms.length = 24;
501
Steve Frenchdb8b6312014-09-22 05:13:55 -0500502 rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,
503 &bytes_read, &pbuf, &buf_type);
Pavel Shilovsky0360d602014-01-16 15:53:35 +0400504 if ((rc == 0) && (bytes_read >= 8)) {
505 if (memcmp("IntxBLK", pbuf, 8) == 0) {
506 cifs_dbg(FYI, "Block device\n");
507 fattr->cf_mode |= S_IFBLK;
508 fattr->cf_dtype = DT_BLK;
509 if (bytes_read == 24) {
510 /* we have enough to decode dev num */
511 __u64 mjr; /* major */
512 __u64 mnr; /* minor */
513 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
514 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
515 fattr->cf_rdev = MKDEV(mjr, mnr);
516 }
517 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
518 cifs_dbg(FYI, "Char device\n");
519 fattr->cf_mode |= S_IFCHR;
520 fattr->cf_dtype = DT_CHR;
521 if (bytes_read == 24) {
522 /* we have enough to decode dev num */
523 __u64 mjr; /* major */
524 __u64 mnr; /* minor */
525 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
526 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
527 fattr->cf_rdev = MKDEV(mjr, mnr);
528 }
529 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
530 cifs_dbg(FYI, "Symlink\n");
531 fattr->cf_mode |= S_IFLNK;
532 fattr->cf_dtype = DT_LNK;
533 } else {
534 fattr->cf_mode |= S_IFREG; /* file? */
535 fattr->cf_dtype = DT_REG;
536 rc = -EOPNOTSUPP;
537 }
538 } else {
539 fattr->cf_mode |= S_IFREG; /* then it is a file */
540 fattr->cf_dtype = DT_REG;
541 rc = -EOPNOTSUPP; /* or some unknown SFU type */
542 }
Steve Frenchdb8b6312014-09-22 05:13:55 -0500543
544 tcon->ses->server->ops->close(xid, tcon, &fid);
Jeff Layton7ffec372010-09-29 19:51:11 -0400545 cifs_put_tlink(tlink);
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800546 return rc;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800547}
548
Steve French9e294f12005-11-17 16:59:21 -0800549#define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
550
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400551/*
552 * Fetch mode bits as provided by SFU.
553 *
554 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
555 */
556static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400557 struct cifs_sb_info *cifs_sb, unsigned int xid)
Steve French9e294f12005-11-17 16:59:21 -0800558{
Steve French3020a1f2005-11-18 11:31:10 -0800559#ifdef CONFIG_CIFS_XATTR
Steve French9e294f12005-11-17 16:59:21 -0800560 ssize_t rc;
561 char ea_value[4];
562 __u32 mode;
Jeff Layton7ffec372010-09-29 19:51:11 -0400563 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +0000564 struct cifs_tcon *tcon;
Steve French9e294f12005-11-17 16:59:21 -0800565
Jeff Layton7ffec372010-09-29 19:51:11 -0400566 tlink = cifs_sb_tlink(cifs_sb);
567 if (IS_ERR(tlink))
568 return PTR_ERR(tlink);
569 tcon = tlink_tcon(tlink);
570
Steve Frenchd979f3b2014-02-01 23:27:18 -0600571 if (tcon->ses->server->ops->query_all_EAs == NULL) {
572 cifs_put_tlink(tlink);
573 return -EOPNOTSUPP;
574 }
575
576 rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
577 "SETFILEBITS", ea_value, 4 /* size of buf */,
Steve French67b4c882017-05-12 20:59:10 -0500578 cifs_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400579 cifs_put_tlink(tlink);
Steve French4523cc32007-04-30 20:13:06 +0000580 if (rc < 0)
Steve French9e294f12005-11-17 16:59:21 -0800581 return (int)rc;
582 else if (rc > 3) {
583 mode = le32_to_cpu(*((__le32 *)ea_value));
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400584 fattr->cf_mode &= ~SFBITS_MASK;
Joe Perchesf96637b2013-05-04 22:12:25 -0500585 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
586 mode, fattr->cf_mode);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400587 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
Joe Perchesf96637b2013-05-04 22:12:25 -0500588 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
Steve French9e294f12005-11-17 16:59:21 -0800589 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400590
591 return 0;
Steve French3020a1f2005-11-18 11:31:10 -0800592#else
593 return -EOPNOTSUPP;
594#endif
Steve French9e294f12005-11-17 16:59:21 -0800595}
596
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400597/* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
Steve Frenchf1230c92009-07-22 23:13:01 +0000598static void
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400599cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
Deepa Dinamanie37fea52017-05-08 15:59:16 -0700600 struct super_block *sb, bool adjust_tz,
Pavel Shilovskyeb85d94b2013-10-23 17:49:47 +0400601 bool symlink)
Steve Frenchb9a3260f2008-05-20 21:52:32 +0000602{
Deepa Dinamanie37fea52017-05-08 15:59:16 -0700603 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Steve French96daf2b2011-05-27 04:34:02 +0000604 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Jeff Layton0d424ad2010-09-20 16:01:35 -0700605
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400606 memset(fattr, 0, sizeof(*fattr));
607 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
608 if (info->DeletePending)
609 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
Steve Frenchb9a3260f2008-05-20 21:52:32 +0000610
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400611 if (info->LastAccessTime)
612 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
Deepa Dinamani918c9002019-12-02 21:19:41 -0800613 else
614 ktime_get_coarse_real_ts64(&fattr->cf_atime);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400615
616 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
617 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
618
619 if (adjust_tz) {
Jeff Layton0d424ad2010-09-20 16:01:35 -0700620 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
621 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400622 }
623
624 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
625 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
Jeff Layton20054bd2011-01-07 11:30:27 -0500626 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400627
Jim McDonough74d290d2013-09-21 10:36:10 -0500628 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
Pavel Shilovskyeb85d94b2013-10-23 17:49:47 +0400629
630 if (symlink) {
631 fattr->cf_mode = S_IFLNK;
632 fattr->cf_dtype = DT_LNK;
633 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400634 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
635 fattr->cf_dtype = DT_DIR;
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +0300636 /*
637 * Server can return wrong NumberOfLinks value for directories
638 * when Unix extensions are disabled - fake it.
639 */
Jim McDonough74d290d2013-09-21 10:36:10 -0500640 if (!tcon->unix_ext)
641 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400642 } else {
643 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
644 fattr->cf_dtype = DT_REG;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400645
Jeff Laytond0c280d2009-07-09 01:46:44 -0400646 /* clear write bits if ATTR_READONLY is set */
647 if (fattr->cf_cifsattrs & ATTR_READONLY)
648 fattr->cf_mode &= ~(S_IWUGO);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400649
Jim McDonough74d290d2013-09-21 10:36:10 -0500650 /*
651 * Don't accept zero nlink from non-unix servers unless
652 * delete is pending. Instead mark it as unknown.
653 */
654 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
655 !info->DeletePending) {
Joe Perchesfb4b5f12020-02-21 05:20:45 -0800656 cifs_dbg(VFS, "bogus file nlink value %u\n",
657 fattr->cf_nlink);
Jim McDonough74d290d2013-09-21 10:36:10 -0500658 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
Steve French6658b9f2013-07-04 14:38:48 -0500659 }
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +0300660 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400661
662 fattr->cf_uid = cifs_sb->mnt_uid;
663 fattr->cf_gid = cifs_sb->mnt_gid;
Steve Frenchb9a3260f2008-05-20 21:52:32 +0000664}
665
Pavel Shilovsky4ad65042012-09-18 16:20:26 -0700666static int
667cifs_get_file_info(struct file *filp)
Jeff Laytonabab0952010-02-12 07:44:18 -0500668{
669 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400670 unsigned int xid;
Jeff Laytonabab0952010-02-12 07:44:18 -0500671 FILE_ALL_INFO find_data;
672 struct cifs_fattr fattr;
Al Viro496ad9a2013-01-23 17:07:38 -0500673 struct inode *inode = file_inode(filp);
Joe Perchesc21dfb62010-07-12 13:50:14 -0700674 struct cifsFileInfo *cfile = filp->private_data;
Steve French96daf2b2011-05-27 04:34:02 +0000675 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky4ad65042012-09-18 16:20:26 -0700676 struct TCP_Server_Info *server = tcon->ses->server;
677
678 if (!server->ops->query_file_info)
679 return -ENOSYS;
Jeff Laytonabab0952010-02-12 07:44:18 -0500680
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400681 xid = get_xid();
Pavel Shilovsky4ad65042012-09-18 16:20:26 -0700682 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400683 switch (rc) {
684 case 0:
Deepa Dinamanie37fea52017-05-08 15:59:16 -0700685 cifs_all_info_to_fattr(&fattr, &find_data, inode->i_sb, false,
Pavel Shilovskyeb85d94b2013-10-23 17:49:47 +0400686 false);
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400687 break;
688 case -EREMOTE:
689 cifs_create_dfs_fattr(&fattr, inode->i_sb);
690 rc = 0;
691 break;
692 case -EOPNOTSUPP:
693 case -EINVAL:
Jeff Laytonabab0952010-02-12 07:44:18 -0500694 /*
695 * FIXME: legacy server -- fall back to path-based call?
Steve Frenchff2157132010-03-09 20:30:42 +0000696 * for now, just skip revalidating and mark inode for
697 * immediate reval.
698 */
Jeff Laytonabab0952010-02-12 07:44:18 -0500699 rc = 0;
700 CIFS_I(inode)->time = 0;
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400701 default:
Jeff Laytonabab0952010-02-12 07:44:18 -0500702 goto cgfi_exit;
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400703 }
Jeff Laytonabab0952010-02-12 07:44:18 -0500704
705 /*
706 * don't bother with SFU junk here -- just mark inode as needing
707 * revalidation.
708 */
Jeff Laytonabab0952010-02-12 07:44:18 -0500709 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
710 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
711 cifs_fattr_to_inode(inode, &fattr);
712cgfi_exit:
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400713 free_xid(xid);
Jeff Laytonabab0952010-02-12 07:44:18 -0500714 return rc;
715}
716
Steve French7ea884c2018-03-31 18:13:38 -0500717/* Simple function to return a 64 bit hash of string. Rarely called */
718static __u64 simple_hashstr(const char *str)
719{
Geert Uytterhoeven3995bbf2018-04-05 14:57:11 +0200720 const __u64 hash_mult = 1125899906842597ULL; /* a big enough prime */
Steve French7ea884c2018-03-31 18:13:38 -0500721 __u64 hash = 0;
722
723 while (*str)
724 hash = (hash + (__u64) *str++) * hash_mult;
725
726 return hash;
727}
728
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100729/**
730 * cifs_backup_query_path_info - SMB1 fallback code to get ino
731 *
732 * Fallback code to get file metadata when we don't have access to
733 * @full_path (EACCESS) and have backup creds.
734 *
735 * @data will be set to search info result buffer
736 * @resp_buf will be set to cifs resp buf and needs to be freed with
737 * cifs_buf_release() when done with @data.
738 */
739static int
740cifs_backup_query_path_info(int xid,
741 struct cifs_tcon *tcon,
742 struct super_block *sb,
743 const char *full_path,
744 void **resp_buf,
745 FILE_ALL_INFO **data)
746{
747 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
748 struct cifs_search_info info = {0};
749 u16 flags;
750 int rc;
751
752 *resp_buf = NULL;
753 info.endOfSearch = false;
754 if (tcon->unix_ext)
755 info.info_level = SMB_FIND_FILE_UNIX;
756 else if ((tcon->ses->capabilities &
757 tcon->ses->server->vals->cap_nt_find) == 0)
758 info.info_level = SMB_FIND_FILE_INFO_STANDARD;
759 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
760 info.info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
761 else /* no srvino useful for fallback to some netapp */
762 info.info_level = SMB_FIND_FILE_DIRECTORY_INFO;
763
764 flags = CIFS_SEARCH_CLOSE_ALWAYS |
765 CIFS_SEARCH_CLOSE_AT_END |
766 CIFS_SEARCH_BACKUP_SEARCH;
767
768 rc = CIFSFindFirst(xid, tcon, full_path,
769 cifs_sb, NULL, flags, &info, false);
770 if (rc)
771 return rc;
772
773 *resp_buf = (void *)info.ntwrk_buf_start;
774 *data = (FILE_ALL_INFO *)info.srch_entries_start;
775 return 0;
776}
777
778static void
779cifs_set_fattr_ino(int xid,
780 struct cifs_tcon *tcon,
781 struct super_block *sb,
782 struct inode **inode,
783 const char *full_path,
784 FILE_ALL_INFO *data,
785 struct cifs_fattr *fattr)
786{
787 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
788 struct TCP_Server_Info *server = tcon->ses->server;
789 int rc;
790
791 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
792 if (*inode)
793 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
794 else
795 fattr->cf_uniqueid = iunique(sb, ROOT_I);
796 return;
797 }
798
799 /*
800 * If we have an inode pass a NULL tcon to ensure we don't
801 * make a round trip to the server. This only works for SMB2+.
802 */
803 rc = server->ops->get_srv_inum(xid,
804 *inode ? NULL : tcon,
805 cifs_sb, full_path,
806 &fattr->cf_uniqueid,
807 data);
808 if (rc) {
809 /*
810 * If that fails reuse existing ino or generate one
811 * and disable server ones
812 */
813 if (*inode)
814 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
815 else {
816 fattr->cf_uniqueid = iunique(sb, ROOT_I);
817 cifs_autodisable_serverino(cifs_sb);
818 }
819 return;
820 }
821
822 /* If no errors, check for zero root inode (invalid) */
823 if (fattr->cf_uniqueid == 0 && strlen(full_path) == 0) {
824 cifs_dbg(FYI, "Invalid (0) inodenum\n");
825 if (*inode) {
826 /* reuse */
827 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
828 } else {
829 /* make an ino by hashing the UNC */
830 fattr->cf_flags |= CIFS_FATTR_FAKE_ROOT_INO;
831 fattr->cf_uniqueid = simple_hashstr(tcon->treeName);
832 }
833 }
834}
835
836static inline bool is_inode_cache_good(struct inode *ino)
837{
838 return ino && CIFS_CACHE_READ(CIFS_I(ino)) && CIFS_I(ino)->time != 0;
839}
840
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400841int
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100842cifs_get_inode_info(struct inode **inode,
843 const char *full_path,
844 FILE_ALL_INFO *in_data,
845 struct super_block *sb, int xid,
Steve French42eacf92014-02-10 14:08:16 -0600846 const struct cifs_fid *fid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847{
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100848
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400849 struct cifs_tcon *tcon;
850 struct TCP_Server_Info *server;
Jeff Layton7ffec372010-09-29 19:51:11 -0400851 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400853 bool adjust_tz = false;
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100854 struct cifs_fattr fattr = {0};
Pavel Shilovskyeb85d94b2013-10-23 17:49:47 +0400855 bool symlink = false;
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100856 FILE_ALL_INFO *data = in_data;
857 FILE_ALL_INFO *tmp_data = NULL;
858 void *smb1_backup_rsp_buf = NULL;
859 int rc = 0;
860 int tmprc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861
Jeff Layton7ffec372010-09-29 19:51:11 -0400862 tlink = cifs_sb_tlink(cifs_sb);
863 if (IS_ERR(tlink))
864 return PTR_ERR(tlink);
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400865 tcon = tlink_tcon(tlink);
866 server = tcon->ses->server;
Jeff Layton7ffec372010-09-29 19:51:11 -0400867
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100868 /*
869 * 1. Fetch file metadata if not provided (data)
870 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100872 if (!data) {
873 if (is_inode_cache_good(*inode)) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500874 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100875 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 }
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100877 tmp_data = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
878 if (!tmp_data) {
Jeff Layton7ffec372010-09-29 19:51:11 -0400879 rc = -ENOMEM;
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100880 goto out;
Jeff Layton7ffec372010-09-29 19:51:11 -0400881 }
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100882 rc = server->ops->query_path_info(xid, tcon, cifs_sb,
883 full_path, tmp_data,
884 &adjust_tz, &symlink);
885 data = tmp_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400887
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400888 /*
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100889 * 2. Convert it to internal cifs metadata (fattr)
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400890 */
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100891
892 switch (rc) {
893 case 0:
894 cifs_all_info_to_fattr(&fattr, data, sb, adjust_tz, symlink);
895 break;
896 case -EREMOTE:
897 /* DFS link, no metadata available on this server */
898 cifs_create_dfs_fattr(&fattr, sb);
899 rc = 0;
900 break;
901 case -EACCES:
902 /*
903 * perm errors, try again with backup flags if possible
904 *
905 * For SMB2 and later the backup intent flag
906 * is already sent if needed on open and there
907 * is no path based FindFirst operation to use
908 * to retry with
909 */
910 if (backup_cred(cifs_sb) && is_smb1_server(server)) {
911 /* for easier reading */
912 FILE_DIRECTORY_INFO *fdi;
913 SEARCH_ID_FULL_DIR_INFO *si;
914
915 rc = cifs_backup_query_path_info(xid, tcon, sb,
916 full_path,
917 &smb1_backup_rsp_buf,
918 &data);
919 if (rc)
920 goto out;
921
922 fdi = (FILE_DIRECTORY_INFO *)data;
923 si = (SEARCH_ID_FULL_DIR_INFO *)data;
924
925 cifs_dir_info_to_fattr(&fattr, fdi, cifs_sb);
926 fattr.cf_uniqueid = le64_to_cpu(si->UniqueId);
927 /* uniqueid set, skip get inum step */
928 goto handle_mnt_opt;
929 } else {
930 /* nothing we can do, bail out */
931 goto out;
932 }
933 break;
934 default:
935 cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc);
936 goto out;
Ross Lagerwalla108471b2015-12-02 14:46:08 +0000937 }
Steve Frenchb9a3260f2008-05-20 21:52:32 +0000938
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100939 /*
940 * 3. Get or update inode number (fattr.cf_uniqueid)
941 */
942
943 cifs_set_fattr_ino(xid, tcon, sb, inode, full_path, data, &fattr);
944
945 /*
946 * 4. Tweak fattr based on mount options
947 */
948
949handle_mnt_opt:
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400950 /* query for SFU type info if supported and needed */
951 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
952 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
953 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
954 if (tmprc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500955 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
Steve Frenchb9a3260f2008-05-20 21:52:32 +0000956 }
Steve Frenchb9a3260f2008-05-20 21:52:32 +0000957
Steve Frenchb9a3260f2008-05-20 21:52:32 +0000958 /* fill in 0777 bits from ACL */
Steve Frenche2f8fbf2019-07-19 06:30:07 +0000959 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID) {
960 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, true,
961 full_path, fid);
962 if (rc) {
963 cifs_dbg(FYI, "%s: Get mode from SID failed. rc=%d\n",
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100964 __func__, rc);
965 goto out;
Steve Frenche2f8fbf2019-07-19 06:30:07 +0000966 }
967 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
968 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, false,
Dan Carpenter via samba-technical68464b82019-11-26 15:11:15 +0300969 full_path, fid);
970 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500971 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
972 __func__, rc);
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100973 goto out;
Shirish Pargaonkar78415d22010-11-27 11:37:26 -0600974 }
Steve Frenchb9a3260f2008-05-20 21:52:32 +0000975 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400976
977 /* fill in remaining high mode bits e.g. SUID, VTX */
978 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
979 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
980
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200981 /* check for Minshall+French symlinks */
982 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
Sachin Prabhucb084b12013-11-25 17:09:50 +0000983 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
984 full_path);
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200985 if (tmprc)
Sachin Prabhucb084b12013-11-25 17:09:50 +0000986 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200987 }
988
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +0100989 /*
990 * 5. Update inode with final fattr data
991 */
992
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400993 if (!*inode) {
994 *inode = cifs_iget(sb, &fattr);
995 if (!*inode)
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400996 rc = -ENOMEM;
997 } else {
Nakajima Akira7196ac12015-04-22 15:24:44 +0900998 /* we already have inode, update it */
999
Ross Lagerwalla108471b2015-12-02 14:46:08 +00001000 /* if uniqueid is different, return error */
1001 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
1002 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
Pavel Shilovskyc82e5ac2019-09-30 10:06:19 -07001003 CIFS_I(*inode)->time = 0; /* force reval */
Ross Lagerwalla108471b2015-12-02 14:46:08 +00001004 rc = -ESTALE;
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +01001005 goto out;
Ross Lagerwalla108471b2015-12-02 14:46:08 +00001006 }
1007
Nakajima Akira7196ac12015-04-22 15:24:44 +09001008 /* if filetype is different, return error */
1009 if (unlikely(((*inode)->i_mode & S_IFMT) !=
1010 (fattr.cf_mode & S_IFMT))) {
Pavel Shilovskyc82e5ac2019-09-30 10:06:19 -07001011 CIFS_I(*inode)->time = 0; /* force reval */
Nakajima Akira7196ac12015-04-22 15:24:44 +09001012 rc = -ESTALE;
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +01001013 goto out;
Nakajima Akira7196ac12015-04-22 15:24:44 +09001014 }
1015
Pavel Shilovsky1208ef12012-05-27 17:34:43 +04001016 cifs_fattr_to_inode(*inode, &fattr);
Steve Frenchb9a3260f2008-05-20 21:52:32 +00001017 }
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +01001018out:
1019 cifs_buf_release(smb1_backup_rsp_buf);
Jeff Layton7ffec372010-09-29 19:51:11 -04001020 cifs_put_tlink(tlink);
Aurelien Aptelb8f7442b2019-11-18 21:04:08 +01001021 kfree(tmp_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 return rc;
1023}
1024
Steve French7f8ed422007-09-28 22:28:55 +00001025static const struct inode_operations cifs_ipc_inode_ops = {
1026 .lookup = cifs_lookup,
1027};
1028
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001029static int
1030cifs_find_inode(struct inode *inode, void *opaque)
1031{
1032 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
1033
Jeff Laytonf30b9c12010-07-19 18:00:17 -04001034 /* don't match inode with different uniqueid */
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001035 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
1036 return 0;
1037
Jeff Layton20054bd2011-01-07 11:30:27 -05001038 /* use createtime like an i_generation field */
1039 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
1040 return 0;
1041
Jeff Laytonf30b9c12010-07-19 18:00:17 -04001042 /* don't match inode of different type */
1043 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
1044 return 0;
1045
Jeff Layton5acfec22010-08-02 17:43:54 -04001046 /* if it's not a directory or has no dentries, then flag it */
Al Virob3d9b7a2012-06-09 13:51:19 -04001047 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
Jeff Layton3d694382010-05-11 14:59:55 -04001048 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
Jeff Layton3d694382010-05-11 14:59:55 -04001049
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001050 return 1;
1051}
1052
1053static int
1054cifs_init_inode(struct inode *inode, void *opaque)
1055{
1056 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
1057
1058 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
Jeff Layton20054bd2011-01-07 11:30:27 -05001059 CIFS_I(inode)->createtime = fattr->cf_createtime;
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001060 return 0;
1061}
1062
Jeff Layton5acfec22010-08-02 17:43:54 -04001063/*
1064 * walk dentry list for an inode and report whether it has aliases that
1065 * are hashed. We use this to determine if a directory inode can actually
1066 * be used.
1067 */
1068static bool
1069inode_has_hashed_dentries(struct inode *inode)
1070{
1071 struct dentry *dentry;
1072
Nick Piggin873feea2011-01-07 17:50:06 +11001073 spin_lock(&inode->i_lock);
Al Viro946e51f2014-10-26 19:19:16 -04001074 hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
Jeff Layton5acfec22010-08-02 17:43:54 -04001075 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
Nick Piggin873feea2011-01-07 17:50:06 +11001076 spin_unlock(&inode->i_lock);
Jeff Layton5acfec22010-08-02 17:43:54 -04001077 return true;
1078 }
1079 }
Nick Piggin873feea2011-01-07 17:50:06 +11001080 spin_unlock(&inode->i_lock);
Jeff Layton5acfec22010-08-02 17:43:54 -04001081 return false;
1082}
1083
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001084/* Given fattrs, get a corresponding inode */
1085struct inode *
1086cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
1087{
1088 unsigned long hash;
1089 struct inode *inode;
1090
Jeff Layton3d694382010-05-11 14:59:55 -04001091retry_iget5_locked:
Joe Perchesf96637b2013-05-04 22:12:25 -05001092 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001093
1094 /* hash down to 32-bits on 32-bit arch */
1095 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
1096
1097 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001098 if (inode) {
Jeff Layton5acfec22010-08-02 17:43:54 -04001099 /* was there a potentially problematic inode collision? */
Jeff Layton3d694382010-05-11 14:59:55 -04001100 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
Jeff Layton3d694382010-05-11 14:59:55 -04001101 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
Jeff Layton5acfec22010-08-02 17:43:54 -04001102
1103 if (inode_has_hashed_dentries(inode)) {
1104 cifs_autodisable_serverino(CIFS_SB(sb));
1105 iput(inode);
1106 fattr->cf_uniqueid = iunique(sb, ROOT_I);
1107 goto retry_iget5_locked;
1108 }
Jeff Layton3d694382010-05-11 14:59:55 -04001109 }
1110
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001111 cifs_fattr_to_inode(inode, fattr);
Linus Torvalds1751e8a2017-11-27 13:05:09 -08001112 if (sb->s_flags & SB_NOATIME)
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001113 inode->i_flags |= S_NOATIME | S_NOCMTIME;
1114 if (inode->i_state & I_NEW) {
1115 inode->i_ino = hash;
Steve French0ccd4802010-07-16 04:31:02 +00001116#ifdef CONFIG_CIFS_FSCACHE
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +05301117 /* initialize per-inode cache cookie pointer */
1118 CIFS_I(inode)->fscache = NULL;
Steve French0ccd4802010-07-16 04:31:02 +00001119#endif
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001120 unlock_new_inode(inode);
1121 }
1122 }
1123
1124 return inode;
1125}
1126
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127/* gets root inode */
Shirish Pargaonkar9b6763e2011-02-21 23:56:59 -06001128struct inode *cifs_root_iget(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001130 unsigned int xid;
Jeff Layton0d424ad2010-09-20 16:01:35 -07001131 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001132 struct inode *inode = NULL;
David Howellsce634ab2008-02-07 00:15:33 -08001133 long rc;
Steve French96daf2b2011-05-27 04:34:02 +00001134 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Aurelien Aptela6b50582016-05-25 19:59:09 +02001135 char *path = NULL;
1136 int len;
1137
1138 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
1139 && cifs_sb->prepath) {
1140 len = strlen(cifs_sb->prepath);
1141 path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
1142 if (path == NULL)
1143 return ERR_PTR(-ENOMEM);
1144 path[0] = '/';
1145 memcpy(path+1, cifs_sb->prepath, len);
1146 } else {
1147 path = kstrdup("", GFP_KERNEL);
1148 if (path == NULL)
1149 return ERR_PTR(-ENOMEM);
1150 }
David Howellsce634ab2008-02-07 00:15:33 -08001151
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001152 xid = get_xid();
Steve Frenchb5b374e2014-10-06 01:01:03 -05001153 if (tcon->unix_ext) {
Aurelien Aptela6b50582016-05-25 19:59:09 +02001154 rc = cifs_get_inode_info_unix(&inode, path, sb, xid);
Steve Frenchb5b374e2014-10-06 01:01:03 -05001155 /* some servers mistakenly claim POSIX support */
1156 if (rc != -EOPNOTSUPP)
1157 goto iget_no_retry;
1158 cifs_dbg(VFS, "server does not support POSIX extensions");
1159 tcon->unix_ext = false;
1160 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -04001161
Aurelien Aptela6b50582016-05-25 19:59:09 +02001162 convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
1163 rc = cifs_get_inode_info(&inode, path, NULL, sb, xid, NULL);
Steve Frenchb5b374e2014-10-06 01:01:03 -05001164
1165iget_no_retry:
Oskar Schirmera7851ce2010-11-10 21:06:13 +00001166 if (!inode) {
1167 inode = ERR_PTR(rc);
1168 goto out;
1169 }
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001170
Steve French0ccd4802010-07-16 04:31:02 +00001171#ifdef CONFIG_CIFS_FSCACHE
Suresh Jayaramand03382c2010-07-05 18:12:27 +05301172 /* populate tcon->resource_id */
Jeff Layton0d424ad2010-09-20 16:01:35 -07001173 tcon->resource_id = CIFS_I(inode)->uniqueid;
Steve French0ccd4802010-07-16 04:31:02 +00001174#endif
Suresh Jayaramand03382c2010-07-05 18:12:27 +05301175
Aurelien Aptelb327a712018-01-24 13:46:10 +01001176 if (rc && tcon->pipe) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001177 cifs_dbg(FYI, "ipc connection - fake read inode\n");
Steve Frenchb7ca6922012-08-03 08:43:01 -05001178 spin_lock(&inode->i_lock);
Steve French7f8ed422007-09-28 22:28:55 +00001179 inode->i_mode |= S_IFDIR;
Miklos Szeredibfe86842011-10-28 14:13:29 +02001180 set_nlink(inode, 2);
Steve French7f8ed422007-09-28 22:28:55 +00001181 inode->i_op = &cifs_ipc_inode_ops;
1182 inode->i_fop = &simple_dir_operations;
1183 inode->i_uid = cifs_sb->mnt_uid;
1184 inode->i_gid = cifs_sb->mnt_gid;
Steve Frenchb7ca6922012-08-03 08:43:01 -05001185 spin_unlock(&inode->i_lock);
Steve Frenchad661332008-08-12 14:14:40 +00001186 } else if (rc) {
David Howellsce634ab2008-02-07 00:15:33 -08001187 iget_failed(inode);
Oskar Schirmera7851ce2010-11-10 21:06:13 +00001188 inode = ERR_PTR(rc);
Steve French7f8ed422007-09-28 22:28:55 +00001189 }
1190
Oskar Schirmera7851ce2010-11-10 21:06:13 +00001191out:
Aurelien Aptela6b50582016-05-25 19:59:09 +02001192 kfree(path);
Phillip Potter31cd1062018-03-17 21:06:56 +00001193 free_xid(xid);
David Howellsce634ab2008-02-07 00:15:33 -08001194 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195}
1196
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001197int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001198cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001199 char *full_path, __u32 dosattr)
Steve French388e57b2008-09-16 23:50:58 +00001200{
Steve French388e57b2008-09-16 23:50:58 +00001201 bool set_time = false;
Steve French388e57b2008-09-16 23:50:58 +00001202 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Pavel Shilovsky6bdf6db2012-09-18 16:20:32 -07001203 struct TCP_Server_Info *server;
Steve French388e57b2008-09-16 23:50:58 +00001204 FILE_BASIC_INFO info_buf;
1205
Steve French1adcb712009-02-25 14:19:56 +00001206 if (attrs == NULL)
1207 return -EINVAL;
1208
Pavel Shilovsky6bdf6db2012-09-18 16:20:32 -07001209 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1210 if (!server->ops->set_file_info)
1211 return -ENOSYS;
1212
Steve Frenchfd09b7d2018-08-02 20:28:18 -05001213 info_buf.Pad = 0;
1214
Steve French388e57b2008-09-16 23:50:58 +00001215 if (attrs->ia_valid & ATTR_ATIME) {
1216 set_time = true;
1217 info_buf.LastAccessTime =
Arnd Bergmann95390202018-06-19 17:27:58 +02001218 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
Steve French388e57b2008-09-16 23:50:58 +00001219 } else
1220 info_buf.LastAccessTime = 0;
1221
1222 if (attrs->ia_valid & ATTR_MTIME) {
1223 set_time = true;
1224 info_buf.LastWriteTime =
Arnd Bergmann95390202018-06-19 17:27:58 +02001225 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
Steve French388e57b2008-09-16 23:50:58 +00001226 } else
1227 info_buf.LastWriteTime = 0;
1228
1229 /*
1230 * Samba throws this field away, but windows may actually use it.
1231 * Do not set ctime unless other time stamps are changed explicitly
1232 * (i.e. by utimes()) since we would then have a mix of client and
1233 * server times.
1234 */
1235 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001236 cifs_dbg(FYI, "CIFS - CTIME changed\n");
Steve French388e57b2008-09-16 23:50:58 +00001237 info_buf.ChangeTime =
Arnd Bergmann95390202018-06-19 17:27:58 +02001238 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
Steve French388e57b2008-09-16 23:50:58 +00001239 } else
1240 info_buf.ChangeTime = 0;
1241
1242 info_buf.CreationTime = 0; /* don't change */
1243 info_buf.Attributes = cpu_to_le32(dosattr);
1244
Pavel Shilovsky6bdf6db2012-09-18 16:20:32 -07001245 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
Steve French388e57b2008-09-16 23:50:58 +00001246}
1247
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001248/*
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001249 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001250 * and rename it to a random name that hopefully won't conflict with
1251 * anything else.
1252 */
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001253int
1254cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1255 const unsigned int xid)
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001256{
1257 int oplock = 0;
1258 int rc;
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001259 struct cifs_fid fid;
1260 struct cifs_open_parms oparms;
David Howells2b0143b2015-03-17 22:25:59 +00001261 struct inode *inode = d_inode(dentry);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001262 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1263 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001264 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001265 struct cifs_tcon *tcon;
Steve French32709582008-10-20 00:44:19 +00001266 __u32 dosattr, origattr;
1267 FILE_BASIC_INFO *info_buf = NULL;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001268
Jeff Layton7ffec372010-09-29 19:51:11 -04001269 tlink = cifs_sb_tlink(cifs_sb);
1270 if (IS_ERR(tlink))
1271 return PTR_ERR(tlink);
1272 tcon = tlink_tcon(tlink);
1273
Sachin Prabhuc483a982013-03-05 19:25:56 +00001274 /*
1275 * We cannot rename the file if the server doesn't support
1276 * CAP_INFOLEVEL_PASSTHRU
1277 */
1278 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1279 rc = -EBUSY;
1280 goto out;
1281 }
1282
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001283 oparms.tcon = tcon;
1284 oparms.cifs_sb = cifs_sb;
1285 oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
Amir Goldstein0f060932020-02-03 21:46:43 +02001286 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001287 oparms.disposition = FILE_OPEN;
1288 oparms.path = full_path;
1289 oparms.fid = &fid;
1290 oparms.reconnect = false;
1291
1292 rc = CIFS_open(xid, &oparms, &oplock, NULL);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001293 if (rc != 0)
1294 goto out;
1295
Steve French32709582008-10-20 00:44:19 +00001296 origattr = cifsInode->cifsAttrs;
1297 if (origattr == 0)
1298 origattr |= ATTR_NORMAL;
1299
1300 dosattr = origattr & ~ATTR_READONLY;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001301 if (dosattr == 0)
1302 dosattr |= ATTR_NORMAL;
1303 dosattr |= ATTR_HIDDEN;
1304
Steve French32709582008-10-20 00:44:19 +00001305 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1306 if (dosattr != origattr) {
1307 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1308 if (info_buf == NULL) {
1309 rc = -ENOMEM;
1310 goto out_close;
1311 }
1312 info_buf->Attributes = cpu_to_le32(dosattr);
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001313 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
Steve French32709582008-10-20 00:44:19 +00001314 current->tgid);
1315 /* although we would like to mark the file hidden
1316 if that fails we will still try to rename it */
Sachin Prabhu72d282d2013-03-05 19:25:55 +00001317 if (!rc)
Steve French32709582008-10-20 00:44:19 +00001318 cifsInode->cifsAttrs = dosattr;
1319 else
1320 dosattr = origattr; /* since not able to change them */
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001321 }
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001322
Jeff Laytondd1db2d2008-10-16 19:27:12 -04001323 /* rename the file */
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001324 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1325 cifs_sb->local_nls,
Steve French2baa2682014-09-27 02:19:01 -05001326 cifs_remap(cifs_sb));
Steve French32709582008-10-20 00:44:19 +00001327 if (rc != 0) {
Sachin Prabhu47c78f42013-03-11 13:08:49 +00001328 rc = -EBUSY;
Steve French32709582008-10-20 00:44:19 +00001329 goto undo_setattr;
1330 }
Jeff Layton6d22f092008-09-23 11:48:35 -04001331
Steve French32709582008-10-20 00:44:19 +00001332 /* try to set DELETE_ON_CLOSE */
Jeff Laytonaff8d5c2014-04-30 09:31:45 -04001333 if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001334 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
Steve French32709582008-10-20 00:44:19 +00001335 current->tgid);
1336 /*
1337 * some samba versions return -ENOENT when we try to set the
1338 * file disposition here. Likely a samba bug, but work around
1339 * it for now. This means that some cifsXXX files may hang
1340 * around after they shouldn't.
1341 *
1342 * BB: remove this hack after more servers have the fix
1343 */
1344 if (rc == -ENOENT)
1345 rc = 0;
1346 else if (rc != 0) {
Sachin Prabhu47c78f42013-03-11 13:08:49 +00001347 rc = -EBUSY;
Steve French32709582008-10-20 00:44:19 +00001348 goto undo_rename;
1349 }
Jeff Laytonaff8d5c2014-04-30 09:31:45 -04001350 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
Steve French32709582008-10-20 00:44:19 +00001351 }
Jeff Layton7ce86d52008-09-24 11:32:59 -04001352
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001353out_close:
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001354 CIFSSMBClose(xid, tcon, fid.netfid);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001355out:
Steve French32709582008-10-20 00:44:19 +00001356 kfree(info_buf);
Jeff Layton7ffec372010-09-29 19:51:11 -04001357 cifs_put_tlink(tlink);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001358 return rc;
Steve French32709582008-10-20 00:44:19 +00001359
1360 /*
1361 * reset everything back to the original state. Don't bother
1362 * dealing with errors here since we can't do anything about
1363 * them anyway.
1364 */
1365undo_rename:
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001366 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
Steve French2baa2682014-09-27 02:19:01 -05001367 cifs_sb->local_nls, cifs_remap(cifs_sb));
Steve French32709582008-10-20 00:44:19 +00001368undo_setattr:
1369 if (dosattr != origattr) {
1370 info_buf->Attributes = cpu_to_le32(origattr);
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001371 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
Steve French32709582008-10-20 00:44:19 +00001372 current->tgid))
1373 cifsInode->cifsAttrs = origattr;
1374 }
1375
1376 goto out_close;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001377}
1378
Steve Frenchb7ca6922012-08-03 08:43:01 -05001379/* copied from fs/nfs/dir.c with small changes */
1380static void
1381cifs_drop_nlink(struct inode *inode)
1382{
1383 spin_lock(&inode->i_lock);
1384 if (inode->i_nlink > 0)
1385 drop_nlink(inode);
1386 spin_unlock(&inode->i_lock);
1387}
Steve Frenchff694522009-04-20 19:45:13 +00001388
1389/*
David Howells2b0143b2015-03-17 22:25:59 +00001390 * If d_inode(dentry) is null (usually meaning the cached dentry
Steve Frenchff694522009-04-20 19:45:13 +00001391 * is a negative dentry) then we would attempt a standard SMB delete, but
Colin Ian King413d6102018-10-26 19:07:21 +01001392 * if that fails we can not attempt the fall back mechanisms on EACCES
1393 * but will return the EACCES to the caller. Note that the VFS does not call
Steve Frenchff694522009-04-20 19:45:13 +00001394 * unlink on negative dentries currently.
1395 */
Jeff Layton5f0319a2008-09-16 14:05:16 -04001396int cifs_unlink(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397{
1398 int rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001399 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 char *full_path = NULL;
David Howells2b0143b2015-03-17 22:25:59 +00001401 struct inode *inode = d_inode(dentry);
Steve Frenchff694522009-04-20 19:45:13 +00001402 struct cifsInodeInfo *cifs_inode;
Jeff Layton5f0319a2008-09-16 14:05:16 -04001403 struct super_block *sb = dir->i_sb;
1404 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001405 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001406 struct cifs_tcon *tcon;
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001407 struct TCP_Server_Info *server;
Steve French60502472008-10-07 18:42:52 +00001408 struct iattr *attrs = NULL;
1409 __u32 dosattr = 0, origattr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410
Joe Perchesf96637b2013-05-04 22:12:25 -05001411 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412
Jeff Layton7ffec372010-09-29 19:51:11 -04001413 tlink = cifs_sb_tlink(cifs_sb);
1414 if (IS_ERR(tlink))
1415 return PTR_ERR(tlink);
1416 tcon = tlink_tcon(tlink);
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001417 server = tcon->ses->server;
Jeff Layton7ffec372010-09-29 19:51:11 -04001418
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001419 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420
Jeff Layton5f0319a2008-09-16 14:05:16 -04001421 /* Unlink can be called from rename so we can not take the
1422 * sb->s_vfs_rename_mutex here */
1423 full_path = build_path_from_dentry(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301425 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001426 goto unlink_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 }
Steve French2d785a52007-07-15 01:48:57 +00001428
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001429 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1430 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001431 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
Steve French2d785a52007-07-15 01:48:57 +00001432 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
Steve French2baa2682014-09-27 02:19:01 -05001433 cifs_remap(cifs_sb));
Joe Perchesf96637b2013-05-04 22:12:25 -05001434 cifs_dbg(FYI, "posix del rc %d\n", rc);
Steve French2d785a52007-07-15 01:48:57 +00001435 if ((rc == 0) || (rc == -ENOENT))
1436 goto psx_del_no_retry;
1437 }
1438
Steve French60502472008-10-07 18:42:52 +00001439retry_std_delete:
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001440 if (!server->ops->unlink) {
1441 rc = -ENOSYS;
1442 goto psx_del_no_retry;
1443 }
1444
1445 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
Steve French60502472008-10-07 18:42:52 +00001446
Steve French2d785a52007-07-15 01:48:57 +00001447psx_del_no_retry:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 if (!rc) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001449 if (inode)
Steve Frenchb7ca6922012-08-03 08:43:01 -05001450 cifs_drop_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451 } else if (rc == -ENOENT) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001452 d_drop(dentry);
Sachin Prabhu47c78f42013-03-11 13:08:49 +00001453 } else if (rc == -EBUSY) {
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001454 if (server->ops->rename_pending_delete) {
1455 rc = server->ops->rename_pending_delete(full_path,
1456 dentry, xid);
1457 if (rc == 0)
1458 cifs_drop_nlink(inode);
1459 }
Steve Frenchff694522009-04-20 19:45:13 +00001460 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
Steve French388e57b2008-09-16 23:50:58 +00001461 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1462 if (attrs == NULL) {
1463 rc = -ENOMEM;
1464 goto out_reval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465 }
Steve French388e57b2008-09-16 23:50:58 +00001466
1467 /* try to reset dos attributes */
Steve Frenchff694522009-04-20 19:45:13 +00001468 cifs_inode = CIFS_I(inode);
1469 origattr = cifs_inode->cifsAttrs;
Steve French60502472008-10-07 18:42:52 +00001470 if (origattr == 0)
1471 origattr |= ATTR_NORMAL;
1472 dosattr = origattr & ~ATTR_READONLY;
Steve French388e57b2008-09-16 23:50:58 +00001473 if (dosattr == 0)
1474 dosattr |= ATTR_NORMAL;
1475 dosattr |= ATTR_HIDDEN;
1476
1477 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
Steve French388e57b2008-09-16 23:50:58 +00001478 if (rc != 0)
1479 goto out_reval;
Steve French60502472008-10-07 18:42:52 +00001480
1481 goto retry_std_delete;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482 }
Steve French60502472008-10-07 18:42:52 +00001483
1484 /* undo the setattr if we errored out and it's needed */
1485 if (rc != 0 && dosattr != 0)
1486 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1487
Steve French388e57b2008-09-16 23:50:58 +00001488out_reval:
Jeff Layton5f0319a2008-09-16 14:05:16 -04001489 if (inode) {
Steve Frenchff694522009-04-20 19:45:13 +00001490 cifs_inode = CIFS_I(inode);
1491 cifs_inode->time = 0; /* will force revalidate to get info
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001492 when needed */
Deepa Dinamanie37fea52017-05-08 15:59:16 -07001493 inode->i_ctime = current_time(inode);
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001494 }
Deepa Dinamanie37fea52017-05-08 15:59:16 -07001495 dir->i_ctime = dir->i_mtime = current_time(dir);
Steve Frenchff694522009-04-20 19:45:13 +00001496 cifs_inode = CIFS_I(dir);
Steve French60502472008-10-07 18:42:52 +00001497 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
Jeff Layton7ffec372010-09-29 19:51:11 -04001498unlink_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499 kfree(full_path);
Steve French60502472008-10-07 18:42:52 +00001500 kfree(attrs);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001501 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001502 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503 return rc;
1504}
1505
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001506static int
Jeff Layton101b92d2012-09-19 06:22:45 -07001507cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001508 const char *full_path, struct cifs_sb_info *cifs_sb,
1509 struct cifs_tcon *tcon, const unsigned int xid)
1510{
1511 int rc = 0;
Jeff Layton101b92d2012-09-19 06:22:45 -07001512 struct inode *inode = NULL;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001513
1514 if (tcon->unix_ext)
Jeff Layton101b92d2012-09-19 06:22:45 -07001515 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001516 xid);
1517 else
Jeff Layton101b92d2012-09-19 06:22:45 -07001518 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1519 xid, NULL);
1520
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001521 if (rc)
1522 return rc;
1523
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001524 /*
1525 * setting nlink not necessary except in cases where we failed to get it
Jeff Layton101b92d2012-09-19 06:22:45 -07001526 * from the server or was set bogus. Also, since this is a brand new
1527 * inode, no need to grab the i_lock before setting the i_nlink.
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001528 */
Jeff Layton101b92d2012-09-19 06:22:45 -07001529 if (inode->i_nlink < 2)
1530 set_nlink(inode, 2);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001531 mode &= ~current_umask();
1532 /* must turn on setgid bit if parent dir has it */
Jeff Layton101b92d2012-09-19 06:22:45 -07001533 if (parent->i_mode & S_ISGID)
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001534 mode |= S_ISGID;
1535
1536 if (tcon->unix_ext) {
1537 struct cifs_unix_set_info_args args = {
1538 .mode = mode,
1539 .ctime = NO_CHANGE_64,
1540 .atime = NO_CHANGE_64,
1541 .mtime = NO_CHANGE_64,
1542 .device = 0,
1543 };
1544 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
Eric W. Biederman49418b22013-02-06 00:57:56 -08001545 args.uid = current_fsuid();
Jeff Layton101b92d2012-09-19 06:22:45 -07001546 if (parent->i_mode & S_ISGID)
Eric W. Biederman49418b22013-02-06 00:57:56 -08001547 args.gid = parent->i_gid;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001548 else
Eric W. Biederman49418b22013-02-06 00:57:56 -08001549 args.gid = current_fsgid();
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001550 } else {
Eric W. Biederman49418b22013-02-06 00:57:56 -08001551 args.uid = INVALID_UID; /* no change */
1552 args.gid = INVALID_GID; /* no change */
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001553 }
1554 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1555 cifs_sb->local_nls,
Steve French2baa2682014-09-27 02:19:01 -05001556 cifs_remap(cifs_sb));
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001557 } else {
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001558 struct TCP_Server_Info *server = tcon->ses->server;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001559 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001560 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
Jeff Layton101b92d2012-09-19 06:22:45 -07001561 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001562 tcon, xid);
Jeff Layton101b92d2012-09-19 06:22:45 -07001563 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1564 inode->i_mode = (mode | S_IFDIR);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001565
Jeff Layton101b92d2012-09-19 06:22:45 -07001566 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1567 inode->i_uid = current_fsuid();
1568 if (inode->i_mode & S_ISGID)
1569 inode->i_gid = parent->i_gid;
1570 else
1571 inode->i_gid = current_fsgid();
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001572 }
1573 }
Jeff Layton101b92d2012-09-19 06:22:45 -07001574 d_instantiate(dentry, inode);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001575 return rc;
1576}
1577
1578static int
1579cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1580 const char *full_path, struct cifs_sb_info *cifs_sb,
1581 struct cifs_tcon *tcon, const unsigned int xid)
1582{
1583 int rc = 0;
1584 u32 oplock = 0;
1585 FILE_UNIX_BASIC_INFO *info = NULL;
1586 struct inode *newinode = NULL;
1587 struct cifs_fattr fattr;
1588
1589 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1590 if (info == NULL) {
1591 rc = -ENOMEM;
1592 goto posix_mkdir_out;
1593 }
1594
1595 mode &= ~current_umask();
1596 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1597 NULL /* netfid */, info, &oplock, full_path,
Steve French2baa2682014-09-27 02:19:01 -05001598 cifs_sb->local_nls, cifs_remap(cifs_sb));
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001599 if (rc == -EOPNOTSUPP)
1600 goto posix_mkdir_out;
1601 else if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001602 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001603 d_drop(dentry);
1604 goto posix_mkdir_out;
1605 }
1606
1607 if (info->Type == cpu_to_le32(-1))
1608 /* no return info, go query for it */
1609 goto posix_mkdir_get_info;
1610 /*
1611 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1612 * need to set uid/gid.
1613 */
1614
1615 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1616 cifs_fill_uniqueid(inode->i_sb, &fattr);
1617 newinode = cifs_iget(inode->i_sb, &fattr);
1618 if (!newinode)
1619 goto posix_mkdir_get_info;
1620
1621 d_instantiate(dentry, newinode);
1622
1623#ifdef CONFIG_CIFS_DEBUG2
Al Viro35c265e2014-08-19 20:25:34 -04001624 cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1625 dentry, dentry, newinode);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001626
1627 if (newinode->i_nlink != 2)
Joe Perchesf96637b2013-05-04 22:12:25 -05001628 cifs_dbg(FYI, "unexpected number of links %d\n",
1629 newinode->i_nlink);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001630#endif
1631
1632posix_mkdir_out:
1633 kfree(info);
1634 return rc;
1635posix_mkdir_get_info:
1636 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1637 xid);
1638 goto posix_mkdir_out;
1639}
1640
Al Viro18bb1db2011-07-26 01:41:39 -04001641int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642{
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001643 int rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001644 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001646 struct tcon_link *tlink;
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001647 struct cifs_tcon *tcon;
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001648 struct TCP_Server_Info *server;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001649 char *full_path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650
Frank Sorensonf52aa792020-02-12 15:31:48 -06001651 cifs_dbg(FYI, "In cifs_mkdir, mode = %04ho inode = 0x%p\n",
Joe Perchesf96637b2013-05-04 22:12:25 -05001652 mode, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654 cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001655 tlink = cifs_sb_tlink(cifs_sb);
1656 if (IS_ERR(tlink))
1657 return PTR_ERR(tlink);
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001658 tcon = tlink_tcon(tlink);
Jeff Layton7ffec372010-09-29 19:51:11 -04001659
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001660 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661
Steve French7f573562005-08-30 11:32:14 -07001662 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301664 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001665 goto mkdir_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 }
Steve French50c2f752007-07-13 00:33:32 +00001667
Steve Frenchbea851b2018-06-14 21:56:32 -05001668 server = tcon->ses->server;
1669
Steve Frenchbea851b2018-06-14 21:56:32 -05001670 if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) {
1671 rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,
1672 cifs_sb);
1673 d_drop(direntry); /* for time being always refresh inode info */
1674 goto mkdir_out;
1675 }
Steve Frenchbea851b2018-06-14 21:56:32 -05001676
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001677 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1678 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001679 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1680 tcon, xid);
1681 if (rc != -EOPNOTSUPP)
Steve French2dd29d32007-04-23 22:07:35 +00001682 goto mkdir_out;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001683 }
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001684
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001685 if (!server->ops->mkdir) {
1686 rc = -ENOSYS;
1687 goto mkdir_out;
1688 }
1689
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690 /* BB add setting the equivalent of mode via CreateX w/ACLs */
Steve Frenchc3ca78e2019-09-25 00:32:13 -05001691 rc = server->ops->mkdir(xid, inode, mode, tcon, full_path, cifs_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001693 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694 d_drop(direntry);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001695 goto mkdir_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696 }
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001697
Steve Frenchc3ca78e2019-09-25 00:32:13 -05001698 /* TODO: skip this for smb2/smb3 */
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001699 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1700 xid);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001701mkdir_out:
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +03001702 /*
1703 * Force revalidate to get parent dir info when needed since cached
1704 * attributes are invalid now.
1705 */
1706 CIFS_I(inode)->time = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001708 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001709 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710 return rc;
1711}
1712
1713int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1714{
1715 int rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001716 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001718 struct tcon_link *tlink;
Pavel Shilovskyf958ca52012-07-10 16:14:18 +04001719 struct cifs_tcon *tcon;
1720 struct TCP_Server_Info *server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721 char *full_path = NULL;
1722 struct cifsInodeInfo *cifsInode;
1723
Joe Perchesf96637b2013-05-04 22:12:25 -05001724 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001726 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727
Steve French7f573562005-08-30 11:32:14 -07001728 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301730 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001731 goto rmdir_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 }
1733
Jeff Layton7ffec372010-09-29 19:51:11 -04001734 cifs_sb = CIFS_SB(inode->i_sb);
1735 tlink = cifs_sb_tlink(cifs_sb);
1736 if (IS_ERR(tlink)) {
1737 rc = PTR_ERR(tlink);
1738 goto rmdir_exit;
1739 }
Pavel Shilovskyf958ca52012-07-10 16:14:18 +04001740 tcon = tlink_tcon(tlink);
1741 server = tcon->ses->server;
Jeff Layton7ffec372010-09-29 19:51:11 -04001742
Pavel Shilovskyf958ca52012-07-10 16:14:18 +04001743 if (!server->ops->rmdir) {
1744 rc = -ENOSYS;
1745 cifs_put_tlink(tlink);
1746 goto rmdir_exit;
1747 }
1748
1749 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001750 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751
1752 if (!rc) {
David Howells2b0143b2015-03-17 22:25:59 +00001753 spin_lock(&d_inode(direntry)->i_lock);
1754 i_size_write(d_inode(direntry), 0);
1755 clear_nlink(d_inode(direntry));
1756 spin_unlock(&d_inode(direntry)->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 }
1758
David Howells2b0143b2015-03-17 22:25:59 +00001759 cifsInode = CIFS_I(d_inode(direntry));
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +03001760 /* force revalidate to go get info when needed */
1761 cifsInode->time = 0;
Steve French42c245442009-01-13 22:03:55 +00001762
1763 cifsInode = CIFS_I(inode);
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +03001764 /*
1765 * Force revalidate to get parent dir info when needed since cached
1766 * attributes are invalid now.
1767 */
1768 cifsInode->time = 0;
Steve French42c245442009-01-13 22:03:55 +00001769
David Howells2b0143b2015-03-17 22:25:59 +00001770 d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
Deepa Dinamanie37fea52017-05-08 15:59:16 -07001771 current_time(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772
Jeff Layton7ffec372010-09-29 19:51:11 -04001773rmdir_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001775 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776 return rc;
1777}
1778
Steve Frenchee2fd962008-09-23 18:23:33 +00001779static int
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001780cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1781 const char *from_path, struct dentry *to_dentry,
1782 const char *to_path)
Steve Frenchee2fd962008-09-23 18:23:33 +00001783{
1784 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001785 struct tcon_link *tlink;
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001786 struct cifs_tcon *tcon;
1787 struct TCP_Server_Info *server;
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001788 struct cifs_fid fid;
1789 struct cifs_open_parms oparms;
Steve Frenchee2fd962008-09-23 18:23:33 +00001790 int oplock, rc;
1791
Jeff Layton7ffec372010-09-29 19:51:11 -04001792 tlink = cifs_sb_tlink(cifs_sb);
1793 if (IS_ERR(tlink))
1794 return PTR_ERR(tlink);
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001795 tcon = tlink_tcon(tlink);
1796 server = tcon->ses->server;
1797
1798 if (!server->ops->rename)
1799 return -ENOSYS;
Jeff Layton7ffec372010-09-29 19:51:11 -04001800
Steve Frenchee2fd962008-09-23 18:23:33 +00001801 /* try path-based rename first */
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001802 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
Steve Frenchee2fd962008-09-23 18:23:33 +00001803
1804 /*
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001805 * Don't bother with rename by filehandle unless file is busy and
1806 * source. Note that cross directory moves do not work with
Steve Frenchee2fd962008-09-23 18:23:33 +00001807 * rename by filehandle to various Windows servers.
1808 */
Sachin Prabhu47c78f42013-03-11 13:08:49 +00001809 if (rc == 0 || rc != -EBUSY)
Jeff Layton7ffec372010-09-29 19:51:11 -04001810 goto do_rename_exit;
Steve Frenchee2fd962008-09-23 18:23:33 +00001811
Frank Sorenson652727b2019-04-16 08:37:27 -05001812 /* Don't fall back to using SMB on SMB 2+ mount */
1813 if (server->vals->protocol_id != 0)
1814 goto do_rename_exit;
1815
Jeff Laytoned0e3ac2010-06-01 16:21:01 -04001816 /* open-file renames don't work across directories */
1817 if (to_dentry->d_parent != from_dentry->d_parent)
Jeff Layton7ffec372010-09-29 19:51:11 -04001818 goto do_rename_exit;
Jeff Laytoned0e3ac2010-06-01 16:21:01 -04001819
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001820 oparms.tcon = tcon;
1821 oparms.cifs_sb = cifs_sb;
Steve Frenchee2fd962008-09-23 18:23:33 +00001822 /* open the file to be renamed -- we need DELETE perms */
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001823 oparms.desired_access = DELETE;
Amir Goldstein0f060932020-02-03 21:46:43 +02001824 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001825 oparms.disposition = FILE_OPEN;
1826 oparms.path = from_path;
1827 oparms.fid = &fid;
1828 oparms.reconnect = false;
1829
1830 rc = CIFS_open(xid, &oparms, &oplock, NULL);
Steve Frenchee2fd962008-09-23 18:23:33 +00001831 if (rc == 0) {
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001832 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
Steve Frenchee2fd962008-09-23 18:23:33 +00001833 (const char *) to_dentry->d_name.name,
Steve French2baa2682014-09-27 02:19:01 -05001834 cifs_sb->local_nls, cifs_remap(cifs_sb));
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001835 CIFSSMBClose(xid, tcon, fid.netfid);
Steve Frenchee2fd962008-09-23 18:23:33 +00001836 }
Jeff Layton7ffec372010-09-29 19:51:11 -04001837do_rename_exit:
1838 cifs_put_tlink(tlink);
Steve Frenchee2fd962008-09-23 18:23:33 +00001839 return rc;
1840}
1841
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001842int
Miklos Szeredi7c33d592014-07-23 15:15:36 +02001843cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
1844 struct inode *target_dir, struct dentry *target_dentry,
1845 unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846{
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001847 char *from_name = NULL;
1848 char *to_name = NULL;
Jeff Layton639e7a92010-09-03 11:50:09 -04001849 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001850 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001851 struct cifs_tcon *tcon;
Steve Frenchee2fd962008-09-23 18:23:33 +00001852 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1853 FILE_UNIX_BASIC_INFO *info_buf_target;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001854 unsigned int xid;
1855 int rc, tmprc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856
Miklos Szeredi7c33d592014-07-23 15:15:36 +02001857 if (flags & ~RENAME_NOREPLACE)
1858 return -EINVAL;
1859
Jeff Layton639e7a92010-09-03 11:50:09 -04001860 cifs_sb = CIFS_SB(source_dir->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001861 tlink = cifs_sb_tlink(cifs_sb);
1862 if (IS_ERR(tlink))
1863 return PTR_ERR(tlink);
1864 tcon = tlink_tcon(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001866 xid = get_xid();
Steve Frenchee2fd962008-09-23 18:23:33 +00001867
1868 /*
Steve Frenchee2fd962008-09-23 18:23:33 +00001869 * we already have the rename sem so we do not need to
1870 * grab it again here to protect the path integrity
1871 */
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001872 from_name = build_path_from_dentry(source_dentry);
1873 if (from_name == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874 rc = -ENOMEM;
1875 goto cifs_rename_exit;
1876 }
1877
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001878 to_name = build_path_from_dentry(target_dentry);
1879 if (to_name == NULL) {
Steve Frenchee2fd962008-09-23 18:23:33 +00001880 rc = -ENOMEM;
1881 goto cifs_rename_exit;
1882 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001884 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1885 to_name);
Steve Frenchee2fd962008-09-23 18:23:33 +00001886
Miklos Szeredi7c33d592014-07-23 15:15:36 +02001887 /*
1888 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1889 */
1890 if (flags & RENAME_NOREPLACE)
1891 goto cifs_rename_exit;
1892
Jeff Layton14121bd2008-10-20 14:45:22 -04001893 if (rc == -EEXIST && tcon->unix_ext) {
Steve Frenchee2fd962008-09-23 18:23:33 +00001894 /*
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001895 * Are src and dst hardlinks of same inode? We can only tell
1896 * with unix extensions enabled.
Steve Frenchee2fd962008-09-23 18:23:33 +00001897 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001898 info_buf_source =
Kees Cook6da2ec52018-06-12 13:55:00 -07001899 kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
Jeff Layton14121bd2008-10-20 14:45:22 -04001900 GFP_KERNEL);
1901 if (info_buf_source == NULL) {
1902 rc = -ENOMEM;
1903 goto cifs_rename_exit;
1904 }
1905
1906 info_buf_target = info_buf_source + 1;
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001907 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1908 info_buf_source,
1909 cifs_sb->local_nls,
Steve French2baa2682014-09-27 02:19:01 -05001910 cifs_remap(cifs_sb));
Jeff Layton8d281ef2008-10-22 13:57:01 -04001911 if (tmprc != 0)
Jeff Layton14121bd2008-10-20 14:45:22 -04001912 goto unlink_target;
1913
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001914 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1915 info_buf_target,
1916 cifs_sb->local_nls,
Steve French2baa2682014-09-27 02:19:01 -05001917 cifs_remap(cifs_sb));
Jeff Layton14121bd2008-10-20 14:45:22 -04001918
Jeff Layton8d281ef2008-10-22 13:57:01 -04001919 if (tmprc == 0 && (info_buf_source->UniqueId ==
Jeff Laytonae6884a2008-11-03 14:05:08 -05001920 info_buf_target->UniqueId)) {
Jeff Layton14121bd2008-10-20 14:45:22 -04001921 /* same file, POSIX says that this is a noop */
Jeff Laytonae6884a2008-11-03 14:05:08 -05001922 rc = 0;
Jeff Layton14121bd2008-10-20 14:45:22 -04001923 goto cifs_rename_exit;
Jeff Laytonae6884a2008-11-03 14:05:08 -05001924 }
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001925 }
1926 /*
1927 * else ... BB we could add the same check for Windows by
1928 * checking the UniqueId via FILE_INTERNAL_INFO
1929 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001930
Jeff Layton14121bd2008-10-20 14:45:22 -04001931unlink_target:
Jeff Laytonfc6f3942009-04-17 11:45:30 -04001932 /* Try unlinking the target dentry if it's not negative */
David Howells2b0143b2015-03-17 22:25:59 +00001933 if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
Pavel Shilovskya07d3222014-08-22 13:32:09 +04001934 if (d_is_dir(target_dentry))
1935 tmprc = cifs_rmdir(target_dir, target_dentry);
1936 else
1937 tmprc = cifs_unlink(target_dir, target_dentry);
Jeff Layton14121bd2008-10-20 14:45:22 -04001938 if (tmprc)
1939 goto cifs_rename_exit;
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001940 rc = cifs_do_rename(xid, source_dentry, from_name,
1941 target_dentry, to_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942 }
1943
Pavel Shilovskyb46799a2014-08-18 20:49:58 +04001944 /* force revalidate to go get info when needed */
1945 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
1946
1947 source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
Deepa Dinamanie37fea52017-05-08 15:59:16 -07001948 target_dir->i_mtime = current_time(source_dir);
Pavel Shilovskyb46799a2014-08-18 20:49:58 +04001949
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950cifs_rename_exit:
Steve Frenchee2fd962008-09-23 18:23:33 +00001951 kfree(info_buf_source);
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001952 kfree(from_name);
1953 kfree(to_name);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001954 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001955 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001956 return rc;
1957}
1958
Jeff Laytondf2cf172010-02-12 07:44:16 -05001959static bool
1960cifs_inode_needs_reval(struct inode *inode)
1961{
1962 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301963 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Laytondf2cf172010-02-12 07:44:16 -05001964
Ronnie Sahlberg57c55cd2018-05-24 06:54:27 +10001965 if (cifs_i->time == 0)
1966 return true;
1967
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001968 if (CIFS_CACHE_READ(cifs_i))
Jeff Laytondf2cf172010-02-12 07:44:16 -05001969 return false;
1970
1971 if (!lookupCacheEnabled)
1972 return true;
1973
Jeff Laytona87c9ad2014-03-26 07:24:23 -07001974 if (!cifs_sb->actimeo)
1975 return true;
1976
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301977 if (!time_in_range(jiffies, cifs_i->time,
1978 cifs_i->time + cifs_sb->actimeo))
Jeff Laytondf2cf172010-02-12 07:44:16 -05001979 return true;
1980
Jeff Laytondb192722010-05-17 14:51:49 -04001981 /* hardlinked files w/ noserverino get "special" treatment */
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301982 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
Jeff Laytondb192722010-05-17 14:51:49 -04001983 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1984 return true;
1985
Jeff Laytondf2cf172010-02-12 07:44:16 -05001986 return false;
1987}
1988
Suresh Jayaraman523fb8c2010-11-29 22:39:47 +05301989/*
1990 * Zap the cache. Called when invalid_mapping flag is set.
1991 */
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001992int
Jeff Laytondf2cf172010-02-12 07:44:16 -05001993cifs_invalidate_mapping(struct inode *inode)
1994{
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001995 int rc = 0;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001996
Jeff Laytondf2cf172010-02-12 07:44:16 -05001997 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
Pavel Shilovsky257fb1f2011-03-16 01:55:32 +03001998 rc = invalidate_inode_pages2(inode->i_mapping);
Jeff Layton4f73c7d2014-04-30 09:31:47 -04001999 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05002000 cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
2001 __func__, inode);
Jeff Laytondf2cf172010-02-12 07:44:16 -05002002 }
Pavel Shilovsky257fb1f2011-03-16 01:55:32 +03002003
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +05302004 cifs_fscache_reset_inode_cookie(inode);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002005 return rc;
Jeff Laytondf2cf172010-02-12 07:44:16 -05002006}
2007
Jeff Layton4f73c7d2014-04-30 09:31:47 -04002008/**
2009 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
2010 * @word: long word containing the bit lock
2011 */
2012static int
Peter Zijlstradfd01f02015-12-13 22:11:16 +01002013cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
Jeff Layton4f73c7d2014-04-30 09:31:47 -04002014{
Jeff Layton4f73c7d2014-04-30 09:31:47 -04002015 freezable_schedule_unsafe();
Peter Zijlstradfd01f02015-12-13 22:11:16 +01002016 if (signal_pending_state(mode, current))
2017 return -ERESTARTSYS;
Jeff Layton4f73c7d2014-04-30 09:31:47 -04002018 return 0;
2019}
2020
Jeff Laytone284e532014-04-30 09:31:46 -04002021int
2022cifs_revalidate_mapping(struct inode *inode)
2023{
Jeff Layton4f73c7d2014-04-30 09:31:47 -04002024 int rc;
2025 unsigned long *flags = &CIFS_I(inode)->flags;
2026
NeilBrown74316202014-07-07 15:16:04 +10002027 rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
2028 TASK_KILLABLE);
Jeff Layton4f73c7d2014-04-30 09:31:47 -04002029 if (rc)
2030 return rc;
2031
2032 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
2033 rc = cifs_invalidate_mapping(inode);
2034 if (rc)
2035 set_bit(CIFS_INO_INVALID_MAPPING, flags);
2036 }
2037
2038 clear_bit_unlock(CIFS_INO_LOCK, flags);
Linus Torvaldsb1cce802014-06-09 19:08:43 -07002039 smp_mb__after_atomic();
Jeff Layton4f73c7d2014-04-30 09:31:47 -04002040 wake_up_bit(flags, CIFS_INO_LOCK);
2041
2042 return rc;
2043}
2044
2045int
2046cifs_zap_mapping(struct inode *inode)
2047{
2048 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
2049 return cifs_revalidate_mapping(inode);
Jeff Laytone284e532014-04-30 09:31:46 -04002050}
2051
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002052int cifs_revalidate_file_attr(struct file *filp)
Jeff Laytonabab0952010-02-12 07:44:18 -05002053{
2054 int rc = 0;
Al Viro496ad9a2013-01-23 17:07:38 -05002055 struct inode *inode = file_inode(filp);
Jeff Laytonba00ba642010-09-20 16:01:31 -07002056 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
Jeff Laytonabab0952010-02-12 07:44:18 -05002057
2058 if (!cifs_inode_needs_reval(inode))
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002059 return rc;
Jeff Laytonabab0952010-02-12 07:44:18 -05002060
Jeff Layton13cfb732010-09-29 19:51:11 -04002061 if (tlink_tcon(cfile->tlink)->unix_ext)
Jeff Laytonabab0952010-02-12 07:44:18 -05002062 rc = cifs_get_file_info_unix(filp);
2063 else
2064 rc = cifs_get_file_info(filp);
2065
Jeff Laytonabab0952010-02-12 07:44:18 -05002066 return rc;
2067}
2068
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002069int cifs_revalidate_dentry_attr(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002071 unsigned int xid;
Jeff Laytondf2cf172010-02-12 07:44:16 -05002072 int rc = 0;
David Howells2b0143b2015-03-17 22:25:59 +00002073 struct inode *inode = d_inode(dentry);
Jeff Laytondf2cf172010-02-12 07:44:16 -05002074 struct super_block *sb = dentry->d_sb;
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002075 char *full_path = NULL;
Ronnie Sahlbergfc513fa2020-02-19 06:01:03 +10002076 int count = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077
Jeff Laytondf2cf172010-02-12 07:44:16 -05002078 if (inode == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002079 return -ENOENT;
2080
Jeff Laytondf2cf172010-02-12 07:44:16 -05002081 if (!cifs_inode_needs_reval(inode))
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002082 return rc;
2083
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002084 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085
2086 /* can not safely grab the rename sem here if rename calls revalidate
2087 since that would deadlock */
Jeff Laytondf2cf172010-02-12 07:44:16 -05002088 full_path = build_path_from_dentry(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302090 rc = -ENOMEM;
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002091 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002092 }
Jeff Laytondf2cf172010-02-12 07:44:16 -05002093
Joe Perchesf96637b2013-05-04 22:12:25 -05002094 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2095 full_path, inode, inode->i_count.counter,
Miklos Szeredia00be0e2016-09-16 12:44:21 +02002096 dentry, cifs_get_time(dentry), jiffies);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097
Ronnie Sahlbergfc513fa2020-02-19 06:01:03 +10002098again:
Jeff Layton0d424ad2010-09-20 16:01:35 -07002099 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
Jeff Laytondf2cf172010-02-12 07:44:16 -05002100 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2101 else
2102 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2103 xid, NULL);
Ronnie Sahlbergfc513fa2020-02-19 06:01:03 +10002104 if (rc == -EAGAIN && count++ < 10)
2105 goto again;
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002106out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002108 free_xid(xid);
Ronnie Sahlbergfc513fa2020-02-19 06:01:03 +10002109
Linus Torvalds1da177e2005-04-16 15:20:36 -07002110 return rc;
2111}
2112
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002113int cifs_revalidate_file(struct file *filp)
2114{
2115 int rc;
Al Viro496ad9a2013-01-23 17:07:38 -05002116 struct inode *inode = file_inode(filp);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002117
2118 rc = cifs_revalidate_file_attr(filp);
2119 if (rc)
2120 return rc;
2121
Jeff Laytone284e532014-04-30 09:31:46 -04002122 return cifs_revalidate_mapping(inode);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002123}
2124
2125/* revalidate a dentry's inode attributes */
2126int cifs_revalidate_dentry(struct dentry *dentry)
2127{
2128 int rc;
David Howells2b0143b2015-03-17 22:25:59 +00002129 struct inode *inode = d_inode(dentry);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002130
2131 rc = cifs_revalidate_dentry_attr(dentry);
2132 if (rc)
2133 return rc;
2134
Jeff Laytone284e532014-04-30 09:31:46 -04002135 return cifs_revalidate_mapping(inode);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002136}
2137
David Howellsa528d352017-01-31 16:46:22 +00002138int cifs_getattr(const struct path *path, struct kstat *stat,
2139 u32 request_mask, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140{
David Howellsa528d352017-01-31 16:46:22 +00002141 struct dentry *dentry = path->dentry;
Jeff Layton3aa1c8c2010-10-07 14:46:28 -04002142 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
Steve French96daf2b2011-05-27 04:34:02 +00002143 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
David Howells2b0143b2015-03-17 22:25:59 +00002144 struct inode *inode = d_inode(dentry);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002145 int rc;
Jeff Layton3aa1c8c2010-10-07 14:46:28 -04002146
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002147 /*
2148 * We need to be sure that all dirty pages are written and the server
2149 * has actual ctime, mtime and file length.
2150 */
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04002151 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002152 inode->i_mapping->nrpages != 0) {
2153 rc = filemap_fdatawait(inode->i_mapping);
Steve French156ecb22011-05-20 17:00:01 +00002154 if (rc) {
2155 mapping_set_error(inode->i_mapping, rc);
2156 return rc;
2157 }
Steve French5fe14c82006-11-07 19:26:33 +00002158 }
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002159
2160 rc = cifs_revalidate_dentry_attr(dentry);
2161 if (rc)
2162 return rc;
2163
2164 generic_fillattr(inode, stat);
Steve Frenche8506d22019-02-28 21:32:15 -06002165 stat->blksize = cifs_sb->bsize;
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002166 stat->ino = CIFS_I(inode)->uniqueid;
2167
Steve French6e70e262017-09-21 21:32:29 -05002168 /* old CIFS Unix Extensions doesn't return create time */
2169 if (CIFS_I(inode)->createtime) {
2170 stat->result_mask |= STATX_BTIME;
Arnd Bergmann95390202018-06-19 17:27:58 +02002171 stat->btime =
2172 cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
Steve French6e70e262017-09-21 21:32:29 -05002173 }
2174
2175 stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2176 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2177 stat->attributes |= STATX_ATTR_COMPRESSED;
2178 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2179 stat->attributes |= STATX_ATTR_ENCRYPTED;
2180
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002181 /*
Jeff Laytond3d1fce2012-11-25 08:00:40 -05002182 * If on a multiuser mount without unix extensions or cifsacl being
2183 * enabled, and the admin hasn't overridden them, set the ownership
2184 * to the fsuid/fsgid of the current process.
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002185 */
2186 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
Jeff Laytond3d1fce2012-11-25 08:00:40 -05002187 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002188 !tcon->unix_ext) {
2189 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2190 stat->uid = current_fsuid();
2191 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2192 stat->gid = current_fsgid();
2193 }
2194 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195}
2196
Ronnie Sahlberg2f3ebab2019-04-25 16:45:29 +10002197int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start,
2198 u64 len)
2199{
2200 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2201 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_i->vfs_inode.i_sb);
2202 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2203 struct TCP_Server_Info *server = tcon->ses->server;
2204 struct cifsFileInfo *cfile;
2205 int rc;
2206
2207 /*
2208 * We need to be sure that all dirty pages are written as they
2209 * might fill holes on the server.
2210 */
2211 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2212 inode->i_mapping->nrpages != 0) {
2213 rc = filemap_fdatawait(inode->i_mapping);
2214 if (rc) {
2215 mapping_set_error(inode->i_mapping, rc);
2216 return rc;
2217 }
2218 }
2219
2220 cfile = find_readable_file(cifs_i, false);
2221 if (cfile == NULL)
2222 return -EINVAL;
2223
2224 if (server->ops->fiemap) {
2225 rc = server->ops->fiemap(tcon, cfile, fei, start, len);
2226 cifsFileInfo_put(cfile);
2227 return rc;
2228 }
2229
2230 cifsFileInfo_put(cfile);
2231 return -ENOTSUPP;
2232}
2233
Ronnie Sahlberg8bd0d702020-01-17 11:45:02 +10002234int cifs_truncate_page(struct address_space *mapping, loff_t from)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235{
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002236 pgoff_t index = from >> PAGE_SHIFT;
2237 unsigned offset = from & (PAGE_SIZE - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238 struct page *page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002239 int rc = 0;
2240
2241 page = grab_cache_page(mapping, index);
2242 if (!page)
2243 return -ENOMEM;
2244
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002245 zero_user_segment(page, offset, PAGE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002246 unlock_page(page);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002247 put_page(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002248 return rc;
2249}
2250
Ronnie Sahlberg8bd0d702020-01-17 11:45:02 +10002251void cifs_setsize(struct inode *inode, loff_t offset)
Steve French3677db12007-02-26 16:46:11 +00002252{
Ronnie Sahlberg57c55cd2018-05-24 06:54:27 +10002253 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2254
Steve Frenchba6a46a2007-02-26 20:06:29 +00002255 spin_lock(&inode->i_lock);
Steve French3677db12007-02-26 16:46:11 +00002256 i_size_write(inode, offset);
Steve Frenchba6a46a2007-02-26 20:06:29 +00002257 spin_unlock(&inode->i_lock);
Christoph Hellwig1b947462010-07-18 17:51:21 -04002258
Ronnie Sahlberg57c55cd2018-05-24 06:54:27 +10002259 /* Cached inode must be refreshed on truncate */
2260 cifs_i->time = 0;
Kirill A. Shutemov7caef262013-09-12 15:13:56 -07002261 truncate_pagecache(inode, offset);
Steve French3677db12007-02-26 16:46:11 +00002262}
2263
Jeff Layton8efdbde2008-07-23 21:28:12 +00002264static int
2265cifs_set_file_size(struct inode *inode, struct iattr *attrs,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002266 unsigned int xid, char *full_path)
Jeff Layton8efdbde2008-07-23 21:28:12 +00002267{
2268 int rc;
2269 struct cifsFileInfo *open_file;
2270 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2271 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04002272 struct tcon_link *tlink = NULL;
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002273 struct cifs_tcon *tcon = NULL;
2274 struct TCP_Server_Info *server;
Jeff Layton8efdbde2008-07-23 21:28:12 +00002275
2276 /*
2277 * To avoid spurious oplock breaks from server, in the case of
2278 * inodes that we already have open, avoid doing path based
2279 * setting of file size if we can do it by handle.
2280 * This keeps our caching token (oplock) and avoids timeouts
2281 * when the local oplock break takes longer to flush
2282 * writebehind data than the SMB timeout for the SetPathInfo
2283 * request would allow
2284 */
Aurelien Aptel86f740f2020-02-21 11:19:06 +01002285 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
Jeff Layton8efdbde2008-07-23 21:28:12 +00002286 if (open_file) {
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002287 tcon = tlink_tcon(open_file->tlink);
2288 server = tcon->ses->server;
2289 if (server->ops->set_file_size)
2290 rc = server->ops->set_file_size(xid, tcon, open_file,
2291 attrs->ia_size, false);
2292 else
2293 rc = -ENOSYS;
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04002294 cifsFileInfo_put(open_file);
Joe Perchesf96637b2013-05-04 22:12:25 -05002295 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00002296 } else
2297 rc = -EINVAL;
2298
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002299 if (!rc)
2300 goto set_size_out;
Jeff Laytonba00ba642010-09-20 16:01:31 -07002301
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002302 if (tcon == NULL) {
2303 tlink = cifs_sb_tlink(cifs_sb);
2304 if (IS_ERR(tlink))
2305 return PTR_ERR(tlink);
2306 tcon = tlink_tcon(tlink);
2307 server = tcon->ses->server;
Jeff Layton8efdbde2008-07-23 21:28:12 +00002308 }
2309
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002310 /*
2311 * Set file size by pathname rather than by handle either because no
2312 * valid, writeable file handle for it was found or because there was
2313 * an error setting it by handle.
2314 */
2315 if (server->ops->set_path_size)
2316 rc = server->ops->set_path_size(xid, tcon, full_path,
2317 attrs->ia_size, cifs_sb, false);
2318 else
2319 rc = -ENOSYS;
Joe Perchesf96637b2013-05-04 22:12:25 -05002320 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002321
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002322 if (tlink)
2323 cifs_put_tlink(tlink);
2324
2325set_size_out:
Jeff Layton8efdbde2008-07-23 21:28:12 +00002326 if (rc == 0) {
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04002327 cifsInode->server_eof = attrs->ia_size;
Christoph Hellwig1b947462010-07-18 17:51:21 -04002328 cifs_setsize(inode, attrs->ia_size);
Jeff Layton8efdbde2008-07-23 21:28:12 +00002329 cifs_truncate_page(inode->i_mapping, inode->i_size);
2330 }
2331
2332 return rc;
2333}
2334
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002335static int
2336cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2337{
2338 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002339 unsigned int xid;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002340 char *full_path = NULL;
David Howells2b0143b2015-03-17 22:25:59 +00002341 struct inode *inode = d_inode(direntry);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002342 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2343 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04002344 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00002345 struct cifs_tcon *pTcon;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002346 struct cifs_unix_set_info_args *args = NULL;
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002347 struct cifsFileInfo *open_file;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002348
Al Viro35c265e2014-08-19 20:25:34 -04002349 cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2350 direntry, attrs->ia_valid);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002351
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002352 xid = get_xid();
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002353
Christoph Hellwigdb78b872010-06-04 11:30:03 +02002354 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2355 attrs->ia_valid |= ATTR_FORCE;
2356
Jan Kara31051c82016-05-26 16:55:18 +02002357 rc = setattr_prepare(direntry, attrs);
Christoph Hellwigdb78b872010-06-04 11:30:03 +02002358 if (rc < 0)
2359 goto out;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002360
2361 full_path = build_path_from_dentry(direntry);
2362 if (full_path == NULL) {
2363 rc = -ENOMEM;
2364 goto out;
2365 }
2366
Jeff Layton0f4d6342009-03-26 13:35:37 -04002367 /*
2368 * Attempt to flush data before changing attributes. We need to do
2369 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2370 * ownership or mode then we may also need to do this. Here, we take
2371 * the safe way out and just do the flush on all setattr requests. If
2372 * the flush returns error, store it to report later and continue.
2373 *
2374 * BB: This should be smarter. Why bother flushing pages that
2375 * will be truncated anyway? Also, should we error out here if
2376 * the flush returns error?
2377 */
2378 rc = filemap_write_and_wait(inode->i_mapping);
Pavel Shilovsky9a663962019-01-08 11:15:28 -08002379 if (is_interrupt_error(rc)) {
2380 rc = -ERESTARTSYS;
2381 goto out;
2382 }
2383
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002384 mapping_set_error(inode->i_mapping, rc);
2385 rc = 0;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002386
2387 if (attrs->ia_valid & ATTR_SIZE) {
2388 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2389 if (rc != 0)
2390 goto out;
2391 }
2392
2393 /* skip mode change if it's just for clearing setuid/setgid */
2394 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2395 attrs->ia_valid &= ~ATTR_MODE;
2396
2397 args = kmalloc(sizeof(*args), GFP_KERNEL);
2398 if (args == NULL) {
2399 rc = -ENOMEM;
2400 goto out;
2401 }
2402
2403 /* set up the struct */
2404 if (attrs->ia_valid & ATTR_MODE)
2405 args->mode = attrs->ia_mode;
2406 else
2407 args->mode = NO_CHANGE_64;
2408
2409 if (attrs->ia_valid & ATTR_UID)
2410 args->uid = attrs->ia_uid;
2411 else
Eric W. Biederman49418b22013-02-06 00:57:56 -08002412 args->uid = INVALID_UID; /* no change */
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002413
2414 if (attrs->ia_valid & ATTR_GID)
2415 args->gid = attrs->ia_gid;
2416 else
Eric W. Biederman49418b22013-02-06 00:57:56 -08002417 args->gid = INVALID_GID; /* no change */
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002418
2419 if (attrs->ia_valid & ATTR_ATIME)
Arnd Bergmann95390202018-06-19 17:27:58 +02002420 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002421 else
2422 args->atime = NO_CHANGE_64;
2423
2424 if (attrs->ia_valid & ATTR_MTIME)
Arnd Bergmann95390202018-06-19 17:27:58 +02002425 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002426 else
2427 args->mtime = NO_CHANGE_64;
2428
2429 if (attrs->ia_valid & ATTR_CTIME)
Arnd Bergmann95390202018-06-19 17:27:58 +02002430 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002431 else
2432 args->ctime = NO_CHANGE_64;
2433
2434 args->device = 0;
Aurelien Aptel86f740f2020-02-21 11:19:06 +01002435 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002436 if (open_file) {
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07002437 u16 nfid = open_file->fid.netfid;
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002438 u32 npid = open_file->pid;
Jeff Layton13cfb732010-09-29 19:51:11 -04002439 pTcon = tlink_tcon(open_file->tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002440 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04002441 cifsFileInfo_put(open_file);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002442 } else {
Jeff Layton7ffec372010-09-29 19:51:11 -04002443 tlink = cifs_sb_tlink(cifs_sb);
2444 if (IS_ERR(tlink)) {
2445 rc = PTR_ERR(tlink);
2446 goto out;
2447 }
2448 pTcon = tlink_tcon(tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002449 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
Jeff Layton01ea95e2009-07-09 20:02:49 -04002450 cifs_sb->local_nls,
Nakajima Akirabc8ebdc42015-02-13 15:35:58 +09002451 cifs_remap(cifs_sb));
Jeff Layton7ffec372010-09-29 19:51:11 -04002452 cifs_put_tlink(tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002453 }
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002454
Christoph Hellwig10257742010-06-04 11:30:02 +02002455 if (rc)
2456 goto out;
Steve Frenchccd4bb12010-02-08 17:39:58 +00002457
Christoph Hellwig10257742010-06-04 11:30:02 +02002458 if ((attrs->ia_valid & ATTR_SIZE) &&
Christoph Hellwig1b947462010-07-18 17:51:21 -04002459 attrs->ia_size != i_size_read(inode))
2460 truncate_setsize(inode, attrs->ia_size);
Christoph Hellwig10257742010-06-04 11:30:02 +02002461
2462 setattr_copy(inode, attrs);
2463 mark_inode_dirty(inode);
2464
2465 /* force revalidate when any of these times are set since some
2466 of the fs types (eg ext3, fat) do not have fine enough
2467 time granularity to match protocol, and we do not have a
2468 a way (yet) to query the server fs's time granularity (and
2469 whether it rounds times down).
2470 */
2471 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2472 cifsInode->time = 0;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002473out:
2474 kfree(args);
2475 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002476 free_xid(xid);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002477 return rc;
2478}
2479
Jeff Layton0510eeb2008-08-02 07:26:12 -04002480static int
2481cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002482{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002483 unsigned int xid;
Eric W. Biederman8abf2772013-02-06 00:33:17 -08002484 kuid_t uid = INVALID_UID;
2485 kgid_t gid = INVALID_GID;
David Howells2b0143b2015-03-17 22:25:59 +00002486 struct inode *inode = d_inode(direntry);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002487 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002488 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
Ronnie Sahlbergaa081852019-07-19 08:12:11 +10002489 struct cifsFileInfo *wfile;
2490 struct cifs_tcon *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002491 char *full_path = NULL;
2492 int rc = -EACCES;
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002493 __u32 dosattr = 0;
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04002494 __u64 mode = NO_CHANGE_64;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002495
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002496 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002497
Colin Ian King63d614a2019-06-24 17:39:43 +01002498 cifs_dbg(FYI, "setattr on file %pd attrs->ia_valid 0x%x\n",
Al Viro35c265e2014-08-19 20:25:34 -04002499 direntry, attrs->ia_valid);
Steve French6473a552005-11-29 20:20:10 -08002500
Christoph Hellwigdb78b872010-06-04 11:30:03 +02002501 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2502 attrs->ia_valid |= ATTR_FORCE;
2503
Jan Kara31051c82016-05-26 16:55:18 +02002504 rc = setattr_prepare(direntry, attrs);
Christoph Hellwigdb78b872010-06-04 11:30:03 +02002505 if (rc < 0) {
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002506 free_xid(xid);
Christoph Hellwigdb78b872010-06-04 11:30:03 +02002507 return rc;
Steve French6473a552005-11-29 20:20:10 -08002508 }
Steve French50c2f752007-07-13 00:33:32 +00002509
Steve French7f573562005-08-30 11:32:14 -07002510 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002511 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302512 rc = -ENOMEM;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002513 free_xid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302514 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002515 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002516
Jeff Layton0f4d6342009-03-26 13:35:37 -04002517 /*
2518 * Attempt to flush data before changing attributes. We need to do
2519 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2520 * ownership or mode then we may also need to do this. Here, we take
2521 * the safe way out and just do the flush on all setattr requests. If
2522 * the flush returns error, store it to report later and continue.
2523 *
2524 * BB: This should be smarter. Why bother flushing pages that
2525 * will be truncated anyway? Also, should we error out here if
2526 * the flush returns error?
2527 */
2528 rc = filemap_write_and_wait(inode->i_mapping);
Pavel Shilovsky9a663962019-01-08 11:15:28 -08002529 if (is_interrupt_error(rc)) {
2530 rc = -ERESTARTSYS;
2531 goto cifs_setattr_exit;
2532 }
2533
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002534 mapping_set_error(inode->i_mapping, rc);
2535 rc = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +00002536
Ronnie Sahlbergaa081852019-07-19 08:12:11 +10002537 if (attrs->ia_valid & ATTR_MTIME) {
Aurelien Aptel86f740f2020-02-21 11:19:06 +01002538 rc = cifs_get_writable_file(cifsInode, FIND_WR_ANY, &wfile);
Ronnie Sahlbergaa081852019-07-19 08:12:11 +10002539 if (!rc) {
2540 tcon = tlink_tcon(wfile->tlink);
2541 rc = tcon->ses->server->ops->flush(xid, tcon, &wfile->fid);
2542 cifsFileInfo_put(wfile);
2543 if (rc)
Chuhong Yuan783bf7b2019-10-14 15:15:31 +08002544 goto cifs_setattr_exit;
Ronnie Sahlbergaa081852019-07-19 08:12:11 +10002545 } else if (rc != -EBADF)
Chuhong Yuan783bf7b2019-10-14 15:15:31 +08002546 goto cifs_setattr_exit;
Ronnie Sahlbergaa081852019-07-19 08:12:11 +10002547 else
2548 rc = 0;
2549 }
2550
Steve French50531442008-03-14 19:21:31 +00002551 if (attrs->ia_valid & ATTR_SIZE) {
Jeff Layton8efdbde2008-07-23 21:28:12 +00002552 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2553 if (rc != 0)
Steve Frenche30dcf32005-09-20 20:49:16 -07002554 goto cifs_setattr_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555 }
Jeff Layton4ca691a2008-05-22 09:33:34 -04002556
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002557 if (attrs->ia_valid & ATTR_UID)
2558 uid = attrs->ia_uid;
2559
2560 if (attrs->ia_valid & ATTR_GID)
2561 gid = attrs->ia_gid;
2562
Steve French22442172019-07-19 08:15:55 +00002563 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2564 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
Eric W. Biederman8abf2772013-02-06 00:33:17 -08002565 if (uid_valid(uid) || gid_valid(gid)) {
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002566 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2567 uid, gid);
2568 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002569 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2570 __func__, rc);
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002571 goto cifs_setattr_exit;
2572 }
2573 }
2574 } else
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002575 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
Jeff Layton4ca691a2008-05-22 09:33:34 -04002576 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002577
Jeff Laytond32c4f22007-10-18 03:05:22 -07002578 /* skip mode change if it's just for clearing setuid/setgid */
2579 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2580 attrs->ia_valid &= ~ATTR_MODE;
2581
Linus Torvalds1da177e2005-04-16 15:20:36 -07002582 if (attrs->ia_valid & ATTR_MODE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002583 mode = attrs->ia_mode;
Steve Frenchcdbce9c82005-11-19 21:04:52 -08002584 rc = 0;
Steve French22442172019-07-19 08:15:55 +00002585 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2586 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002587 rc = id_mode_to_cifs_acl(inode, full_path, mode,
Eric W. Biederman8abf2772013-02-06 00:33:17 -08002588 INVALID_UID, INVALID_GID);
Shirish Pargaonkar78415d22010-11-27 11:37:26 -06002589 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002590 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2591 __func__, rc);
Shirish Pargaonkar78415d22010-11-27 11:37:26 -06002592 goto cifs_setattr_exit;
2593 }
2594 } else
Jeff Layton51328612008-05-22 09:33:34 -04002595 if (((mode & S_IWUGO) == 0) &&
2596 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002597
2598 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2599
Jeff Layton51328612008-05-22 09:33:34 -04002600 /* fix up mode if we're not using dynperm */
2601 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2602 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2603 } else if ((mode & S_IWUGO) &&
2604 (cifsInode->cifsAttrs & ATTR_READONLY)) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002605
2606 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2607 /* Attributes of 0 are ignored */
2608 if (dosattr == 0)
2609 dosattr |= ATTR_NORMAL;
Jeff Layton51328612008-05-22 09:33:34 -04002610
2611 /* reset local inode permissions to normal */
2612 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2613 attrs->ia_mode &= ~(S_IALLUGO);
2614 if (S_ISDIR(inode->i_mode))
2615 attrs->ia_mode |=
2616 cifs_sb->mnt_dir_mode;
2617 else
2618 attrs->ia_mode |=
2619 cifs_sb->mnt_file_mode;
2620 }
2621 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2622 /* ignore mode change - ATTR_READONLY hasn't changed */
2623 attrs->ia_valid &= ~ATTR_MODE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002624 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002625 }
2626
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002627 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2628 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2629 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2630 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002631
Steve Frenche30dcf32005-09-20 20:49:16 -07002632 /* Even if error on time set, no sense failing the call if
2633 the server would set the time to a reasonable value anyway,
2634 and this check ensures that we are not being called from
2635 sys_utimes in which case we ought to fail the call back to
2636 the user when the server rejects the call */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002637 if ((rc) && (attrs->ia_valid &
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002638 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
Steve Frenche30dcf32005-09-20 20:49:16 -07002639 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002640 }
2641
2642 /* do not need local check to inode_check_ok since the server does
2643 that */
Christoph Hellwig10257742010-06-04 11:30:02 +02002644 if (rc)
2645 goto cifs_setattr_exit;
2646
2647 if ((attrs->ia_valid & ATTR_SIZE) &&
Christoph Hellwig1b947462010-07-18 17:51:21 -04002648 attrs->ia_size != i_size_read(inode))
2649 truncate_setsize(inode, attrs->ia_size);
Christoph Hellwig10257742010-06-04 11:30:02 +02002650
2651 setattr_copy(inode, attrs);
2652 mark_inode_dirty(inode);
Christoph Hellwig10257742010-06-04 11:30:02 +02002653
Steve Frenche30dcf32005-09-20 20:49:16 -07002654cifs_setattr_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002655 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002656 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002657 return rc;
2658}
2659
Jeff Layton0510eeb2008-08-02 07:26:12 -04002660int
2661cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2662{
Al Virofc640052016-04-10 01:33:30 -04002663 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
Steve French96daf2b2011-05-27 04:34:02 +00002664 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
Jeff Layton0510eeb2008-08-02 07:26:12 -04002665
2666 if (pTcon->unix_ext)
2667 return cifs_setattr_unix(direntry, attrs);
2668
2669 return cifs_setattr_nounix(direntry, attrs);
2670
2671 /* BB: add cifs_setattr_legacy for really old servers */
2672}
2673
Steve French99ee4db2007-02-27 05:35:17 +00002674#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07002675void cifs_delete_inode(struct inode *inode)
2676{
Joe Perchesf96637b2013-05-04 22:12:25 -05002677 cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002678 /* may have to add back in if and when safe distributed caching of
2679 directories added e.g. via FindNotify */
2680}
Steve French99ee4db2007-02-27 05:35:17 +00002681#endif