blob: 7ab5be7944aa8436f35e1e6d1ac6f277a07e14af [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <asm/div64.h>
27#include "cifsfs.h"
28#include "cifspdu.h"
29#include "cifsglob.h"
30#include "cifsproto.h"
31#include "cifs_debug.h"
32#include "cifs_fs_sb.h"
Steve French2baa2682014-09-27 02:19:01 -050033#include "cifs_unicode.h"
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +053034#include "fscache.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
Christoph Hellwig70eff552008-02-15 20:55:05 +000036
David Howells01c64fe2011-01-14 18:45:47 +000037static void cifs_set_ops(struct inode *inode)
Christoph Hellwig70eff552008-02-15 20:55:05 +000038{
39 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
40
41 switch (inode->i_mode & S_IFMT) {
42 case S_IFREG:
43 inode->i_op = &cifs_file_inode_ops;
44 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
45 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
46 inode->i_fop = &cifs_file_direct_nobrl_ops;
47 else
48 inode->i_fop = &cifs_file_direct_ops;
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +030049 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
50 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
51 inode->i_fop = &cifs_file_strict_nobrl_ops;
52 else
53 inode->i_fop = &cifs_file_strict_ops;
Christoph Hellwig70eff552008-02-15 20:55:05 +000054 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
55 inode->i_fop = &cifs_file_nobrl_ops;
56 else { /* not direct, send byte range locks */
57 inode->i_fop = &cifs_file_ops;
58 }
59
Christoph Hellwig70eff552008-02-15 20:55:05 +000060 /* check if server can support readpages */
Jeff Layton0d424ad2010-09-20 16:01:35 -070061 if (cifs_sb_master_tcon(cifs_sb)->ses->server->maxBuf <
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +030062 PAGE_SIZE + MAX_CIFS_HDR_SIZE)
Christoph Hellwig70eff552008-02-15 20:55:05 +000063 inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
64 else
65 inode->i_data.a_ops = &cifs_addr_ops;
66 break;
67 case S_IFDIR:
Steve Frenchbc5b6e22008-03-11 21:07:48 +000068#ifdef CONFIG_CIFS_DFS_UPCALL
David Howells01c64fe2011-01-14 18:45:47 +000069 if (IS_AUTOMOUNT(inode)) {
Igor Mammedov79626702008-03-09 03:44:18 +000070 inode->i_op = &cifs_dfs_referral_inode_operations;
71 } else {
Steve Frenchbc5b6e22008-03-11 21:07:48 +000072#else /* NO DFS support, treat as a directory */
73 {
74#endif
Igor Mammedov79626702008-03-09 03:44:18 +000075 inode->i_op = &cifs_dir_inode_ops;
76 inode->i_fop = &cifs_dir_ops;
77 }
Christoph Hellwig70eff552008-02-15 20:55:05 +000078 break;
79 case S_IFLNK:
80 inode->i_op = &cifs_symlink_inode_ops;
81 break;
82 default:
83 init_special_inode(inode, inode->i_mode, inode->i_rdev);
84 break;
85 }
86}
87
Jeff Laytondf2cf172010-02-12 07:44:16 -050088/* check inode attributes against fattr. If they don't match, tag the
89 * inode for cache invalidation
90 */
91static void
92cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
93{
94 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
95
Joe Perchesf96637b2013-05-04 22:12:25 -050096 cifs_dbg(FYI, "%s: revalidating inode %llu\n",
97 __func__, cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -050098
99 if (inode->i_state & I_NEW) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500100 cifs_dbg(FYI, "%s: inode %llu is new\n",
101 __func__, cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -0500102 return;
103 }
104
105 /* don't bother with revalidation if we have an oplock */
Pavel Shilovsky18cceb62013-09-05 13:01:06 +0400106 if (CIFS_CACHE_READ(cifs_i)) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500107 cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
108 __func__, cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -0500109 return;
110 }
111
112 /* revalidate if mtime or size have changed */
113 if (timespec_equal(&inode->i_mtime, &fattr->cf_mtime) &&
114 cifs_i->server_eof == fattr->cf_eof) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500115 cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
116 __func__, cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -0500117 return;
118 }
119
Joe Perchesf96637b2013-05-04 22:12:25 -0500120 cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
121 __func__, cifs_i->uniqueid);
Jeff Laytonaff8d5c2014-04-30 09:31:45 -0400122 set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags);
Jeff Laytondf2cf172010-02-12 07:44:16 -0500123}
124
Jim McDonough74d290d2013-09-21 10:36:10 -0500125/*
126 * copy nlink to the inode, unless it wasn't provided. Provide
127 * sane values if we don't have an existing one and none was provided
128 */
129static void
130cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
131{
132 /*
133 * if we're in a situation where we can't trust what we
134 * got from the server (readdir, some non-unix cases)
135 * fake reasonable values
136 */
137 if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
138 /* only provide fake values on a new inode */
139 if (inode->i_state & I_NEW) {
140 if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
141 set_nlink(inode, 2);
142 else
143 set_nlink(inode, 1);
144 }
145 return;
146 }
147
148 /* we trust the server, so update it */
149 set_nlink(inode, fattr->cf_nlink);
150}
151
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400152/* populate an inode with info from a cifs_fattr struct */
153void
154cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
Christoph Hellwig75f12982008-02-25 20:25:21 +0000155{
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400156 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400157 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Christoph Hellwig75f12982008-02-25 20:25:21 +0000158
Jeff Laytondf2cf172010-02-12 07:44:16 -0500159 cifs_revalidate_cache(inode, fattr);
160
Steve Frenchb7ca6922012-08-03 08:43:01 -0500161 spin_lock(&inode->i_lock);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400162 inode->i_atime = fattr->cf_atime;
163 inode->i_mtime = fattr->cf_mtime;
164 inode->i_ctime = fattr->cf_ctime;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400165 inode->i_rdev = fattr->cf_rdev;
Jim McDonough74d290d2013-09-21 10:36:10 -0500166 cifs_nlink_fattr_to_inode(inode, fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400167 inode->i_uid = fattr->cf_uid;
168 inode->i_gid = fattr->cf_gid;
169
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400170 /* if dynperm is set, don't clobber existing mode */
171 if (inode->i_state & I_NEW ||
172 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
173 inode->i_mode = fattr->cf_mode;
174
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400175 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400176
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400177 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
178 cifs_i->time = 0;
179 else
180 cifs_i->time = jiffies;
181
Jeff Laytonaff8d5c2014-04-30 09:31:45 -0400182 if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING)
183 set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
184 else
185 clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
Christoph Hellwig75f12982008-02-25 20:25:21 +0000186
Jeff Layton835a36c2010-02-10 16:21:33 -0500187 cifs_i->server_eof = fattr->cf_eof;
Christoph Hellwig75f12982008-02-25 20:25:21 +0000188 /*
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400189 * Can't safely change the file size here if the client is writing to
190 * it due to potential races.
Christoph Hellwig75f12982008-02-25 20:25:21 +0000191 */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400192 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
193 i_size_write(inode, fattr->cf_eof);
Christoph Hellwig75f12982008-02-25 20:25:21 +0000194
195 /*
196 * i_blocks is not related to (i_size / i_blksize),
197 * but instead 512 byte (2**9) size is required for
198 * calculating num blocks.
199 */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400200 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
Christoph Hellwig75f12982008-02-25 20:25:21 +0000201 }
202 spin_unlock(&inode->i_lock);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400203
David Howells01c64fe2011-01-14 18:45:47 +0000204 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
205 inode->i_flags |= S_AUTOMOUNT;
Jeff Laytonc2b93e02013-05-07 11:28:31 -0400206 if (inode->i_state & I_NEW)
207 cifs_set_ops(inode);
Christoph Hellwig75f12982008-02-25 20:25:21 +0000208}
209
Jeff Layton4065c802010-05-17 07:18:58 -0400210void
211cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
212{
213 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
214
215 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
216 return;
217
218 fattr->cf_uniqueid = iunique(sb, ROOT_I);
219}
220
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400221/* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
222void
223cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
224 struct cifs_sb_info *cifs_sb)
225{
226 memset(fattr, 0, sizeof(*fattr));
227 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
228 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
229 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
230
231 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
232 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
233 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
234 fattr->cf_mode = le64_to_cpu(info->Permissions);
235
236 /*
237 * Since we set the inode type below we need to mask off
238 * to avoid strange results if bits set above.
239 */
240 fattr->cf_mode &= ~S_IFMT;
241 switch (le32_to_cpu(info->Type)) {
242 case UNIX_FILE:
243 fattr->cf_mode |= S_IFREG;
244 fattr->cf_dtype = DT_REG;
245 break;
246 case UNIX_SYMLINK:
247 fattr->cf_mode |= S_IFLNK;
248 fattr->cf_dtype = DT_LNK;
249 break;
250 case UNIX_DIR:
251 fattr->cf_mode |= S_IFDIR;
252 fattr->cf_dtype = DT_DIR;
253 break;
254 case UNIX_CHARDEV:
255 fattr->cf_mode |= S_IFCHR;
256 fattr->cf_dtype = DT_CHR;
257 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
258 le64_to_cpu(info->DevMinor) & MINORMASK);
259 break;
260 case UNIX_BLOCKDEV:
261 fattr->cf_mode |= S_IFBLK;
262 fattr->cf_dtype = DT_BLK;
263 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
264 le64_to_cpu(info->DevMinor) & MINORMASK);
265 break;
266 case UNIX_FIFO:
267 fattr->cf_mode |= S_IFIFO;
268 fattr->cf_dtype = DT_FIFO;
269 break;
270 case UNIX_SOCKET:
271 fattr->cf_mode |= S_IFSOCK;
272 fattr->cf_dtype = DT_SOCK;
273 break;
274 default:
275 /* safest to call it a file if we do not know */
276 fattr->cf_mode |= S_IFREG;
277 fattr->cf_dtype = DT_REG;
Joe Perchesf96637b2013-05-04 22:12:25 -0500278 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400279 break;
280 }
281
Eric W. Biederman46bbc252013-02-05 23:55:44 -0800282 fattr->cf_uid = cifs_sb->mnt_uid;
283 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
284 u64 id = le64_to_cpu(info->Uid);
Eric W. Biederman4a2c8cf2013-02-06 01:53:25 -0800285 if (id < ((uid_t)-1)) {
286 kuid_t uid = make_kuid(&init_user_ns, id);
287 if (uid_valid(uid))
288 fattr->cf_uid = uid;
289 }
Eric W. Biederman46bbc252013-02-05 23:55:44 -0800290 }
291
292 fattr->cf_gid = cifs_sb->mnt_gid;
293 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
294 u64 id = le64_to_cpu(info->Gid);
Eric W. Biederman4a2c8cf2013-02-06 01:53:25 -0800295 if (id < ((gid_t)-1)) {
296 kgid_t gid = make_kgid(&init_user_ns, id);
297 if (gid_valid(gid))
298 fattr->cf_gid = gid;
299 }
Eric W. Biederman46bbc252013-02-05 23:55:44 -0800300 }
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400301
302 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
303}
Steve Frenchb9a32602008-05-20 21:52:32 +0000304
305/*
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400306 * Fill a cifs_fattr struct with fake inode info.
307 *
308 * Needed to setup cifs_fattr data for the directory which is the
309 * junction to the new submount (ie to setup the fake directory
310 * which represents a DFS referral).
Steve Frenchb9a32602008-05-20 21:52:32 +0000311 */
Steve Frenchf1230c92009-07-22 23:13:01 +0000312static void
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400313cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
Steve French0e4bbde2008-05-20 19:50:46 +0000314{
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400315 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Steve French0e4bbde2008-05-20 19:50:46 +0000316
Joe Perchesf96637b2013-05-04 22:12:25 -0500317 cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
Steve French0e4bbde2008-05-20 19:50:46 +0000318
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400319 memset(fattr, 0, sizeof(*fattr));
320 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
321 fattr->cf_uid = cifs_sb->mnt_uid;
322 fattr->cf_gid = cifs_sb->mnt_gid;
323 fattr->cf_atime = CURRENT_TIME;
324 fattr->cf_ctime = CURRENT_TIME;
325 fattr->cf_mtime = CURRENT_TIME;
326 fattr->cf_nlink = 2;
327 fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
Steve French0e4bbde2008-05-20 19:50:46 +0000328}
329
Pavel Shilovsky4ad65042012-09-18 16:20:26 -0700330static int
331cifs_get_file_info_unix(struct file *filp)
Jeff Laytonabab0952010-02-12 07:44:18 -0500332{
333 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400334 unsigned int xid;
Jeff Laytonabab0952010-02-12 07:44:18 -0500335 FILE_UNIX_BASIC_INFO find_data;
336 struct cifs_fattr fattr;
Al Viro496ad9a2013-01-23 17:07:38 -0500337 struct inode *inode = file_inode(filp);
Jeff Laytonabab0952010-02-12 07:44:18 -0500338 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Joe Perchesc21dfb62010-07-12 13:50:14 -0700339 struct cifsFileInfo *cfile = filp->private_data;
Steve French96daf2b2011-05-27 04:34:02 +0000340 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Jeff Laytonabab0952010-02-12 07:44:18 -0500341
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400342 xid = get_xid();
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700343 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
Jeff Laytonabab0952010-02-12 07:44:18 -0500344 if (!rc) {
345 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
346 } else if (rc == -EREMOTE) {
347 cifs_create_dfs_fattr(&fattr, inode->i_sb);
348 rc = 0;
349 }
350
351 cifs_fattr_to_inode(inode, &fattr);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400352 free_xid(xid);
Jeff Laytonabab0952010-02-12 07:44:18 -0500353 return rc;
354}
355
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356int cifs_get_inode_info_unix(struct inode **pinode,
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400357 const unsigned char *full_path,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400358 struct super_block *sb, unsigned int xid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359{
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400360 int rc;
Steve French0e4bbde2008-05-20 19:50:46 +0000361 FILE_UNIX_BASIC_INFO find_data;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400362 struct cifs_fattr fattr;
Steve French96daf2b2011-05-27 04:34:02 +0000363 struct cifs_tcon *tcon;
Jeff Layton7ffec372010-09-29 19:51:11 -0400364 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366
Joe Perchesf96637b2013-05-04 22:12:25 -0500367 cifs_dbg(FYI, "Getting info on %s\n", full_path);
Igor Mammedov79626702008-03-09 03:44:18 +0000368
Jeff Layton7ffec372010-09-29 19:51:11 -0400369 tlink = cifs_sb_tlink(cifs_sb);
370 if (IS_ERR(tlink))
371 return PTR_ERR(tlink);
372 tcon = tlink_tcon(tlink);
373
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 /* could have done a find first instead but this returns more info */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400375 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
Nakajima Akirabc8ebdc42015-02-13 15:35:58 +0900376 cifs_sb->local_nls, cifs_remap(cifs_sb));
Jeff Layton7ffec372010-09-29 19:51:11 -0400377 cifs_put_tlink(tlink);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400378
379 if (!rc) {
380 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
381 } else if (rc == -EREMOTE) {
382 cifs_create_dfs_fattr(&fattr, sb);
Jeff Laytone911d0c2008-07-12 13:47:59 -0700383 rc = 0;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400384 } else {
385 return rc;
Steve French0e4bbde2008-05-20 19:50:46 +0000386 }
387
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200388 /* check for Minshall+French symlinks */
389 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
Sachin Prabhucb084b12013-11-25 17:09:50 +0000390 int tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
391 full_path);
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200392 if (tmprc)
Sachin Prabhucb084b12013-11-25 17:09:50 +0000393 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200394 }
395
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400396 if (*pinode == NULL) {
397 /* get new inode */
Jeff Layton4065c802010-05-17 07:18:58 -0400398 cifs_fill_uniqueid(sb, &fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400399 *pinode = cifs_iget(sb, &fattr);
400 if (!*pinode)
401 rc = -ENOMEM;
402 } else {
403 /* we already have inode, update it */
Nakajima Akira7196ac12015-04-22 15:24:44 +0900404
405 /* if uniqueid is different, return error */
406 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
407 CIFS_I(*pinode)->uniqueid != fattr.cf_uniqueid)) {
408 rc = -ESTALE;
409 goto cgiiu_exit;
410 }
411
412 /* if filetype is different, return error */
413 if (unlikely(((*pinode)->i_mode & S_IFMT) !=
414 (fattr.cf_mode & S_IFMT))) {
415 rc = -ESTALE;
416 goto cgiiu_exit;
417 }
418
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400419 cifs_fattr_to_inode(*pinode, &fattr);
420 }
Steve French0e4bbde2008-05-20 19:50:46 +0000421
Nakajima Akira7196ac12015-04-22 15:24:44 +0900422cgiiu_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 return rc;
424}
425
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400426static int
Pavel Shilovsky0360d602014-01-16 15:53:35 +0400427cifs_sfu_type(struct cifs_fattr *fattr, const char *path,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400428 struct cifs_sb_info *cifs_sb, unsigned int xid)
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800429{
430 int rc;
Steve Frenchdb8b6312014-09-22 05:13:55 -0500431 __u32 oplock;
Jeff Layton7ffec372010-09-29 19:51:11 -0400432 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +0000433 struct cifs_tcon *tcon;
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +0400434 struct cifs_fid fid;
435 struct cifs_open_parms oparms;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000436 struct cifs_io_parms io_parms;
Steve French86c96b42005-11-18 20:25:31 -0800437 char buf[24];
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800438 unsigned int bytes_read;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000439 char *pbuf;
Pavel Shilovsky0360d602014-01-16 15:53:35 +0400440 int buf_type = CIFS_NO_BUFFER;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800441
442 pbuf = buf;
443
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400444 fattr->cf_mode &= ~S_IFMT;
445
446 if (fattr->cf_eof == 0) {
447 fattr->cf_mode |= S_IFIFO;
448 fattr->cf_dtype = DT_FIFO;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800449 return 0;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400450 } else if (fattr->cf_eof < 8) {
451 fattr->cf_mode |= S_IFREG;
452 fattr->cf_dtype = DT_REG;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800453 return -EINVAL; /* EOPNOTSUPP? */
454 }
Steve French50c2f752007-07-13 00:33:32 +0000455
Jeff Layton7ffec372010-09-29 19:51:11 -0400456 tlink = cifs_sb_tlink(cifs_sb);
457 if (IS_ERR(tlink))
458 return PTR_ERR(tlink);
459 tcon = tlink_tcon(tlink);
460
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +0400461 oparms.tcon = tcon;
462 oparms.cifs_sb = cifs_sb;
463 oparms.desired_access = GENERIC_READ;
464 oparms.create_options = CREATE_NOT_DIR;
465 oparms.disposition = FILE_OPEN;
466 oparms.path = path;
467 oparms.fid = &fid;
468 oparms.reconnect = false;
469
Steve Frenchdb8b6312014-09-22 05:13:55 -0500470 if (tcon->ses->server->oplocks)
471 oplock = REQ_OPLOCK;
472 else
473 oplock = 0;
474 rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);
Pavel Shilovsky0360d602014-01-16 15:53:35 +0400475 if (rc) {
Steve Frenchdb8b6312014-09-22 05:13:55 -0500476 cifs_dbg(FYI, "check sfu type of %s, open rc = %d\n", path, rc);
Pavel Shilovsky0360d602014-01-16 15:53:35 +0400477 cifs_put_tlink(tlink);
478 return rc;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800479 }
Pavel Shilovsky0360d602014-01-16 15:53:35 +0400480
481 /* Read header */
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +0400482 io_parms.netfid = fid.netfid;
Pavel Shilovsky0360d602014-01-16 15:53:35 +0400483 io_parms.pid = current->tgid;
484 io_parms.tcon = tcon;
485 io_parms.offset = 0;
486 io_parms.length = 24;
487
Steve Frenchdb8b6312014-09-22 05:13:55 -0500488 rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,
489 &bytes_read, &pbuf, &buf_type);
Pavel Shilovsky0360d602014-01-16 15:53:35 +0400490 if ((rc == 0) && (bytes_read >= 8)) {
491 if (memcmp("IntxBLK", pbuf, 8) == 0) {
492 cifs_dbg(FYI, "Block device\n");
493 fattr->cf_mode |= S_IFBLK;
494 fattr->cf_dtype = DT_BLK;
495 if (bytes_read == 24) {
496 /* we have enough to decode dev num */
497 __u64 mjr; /* major */
498 __u64 mnr; /* minor */
499 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
500 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
501 fattr->cf_rdev = MKDEV(mjr, mnr);
502 }
503 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
504 cifs_dbg(FYI, "Char device\n");
505 fattr->cf_mode |= S_IFCHR;
506 fattr->cf_dtype = DT_CHR;
507 if (bytes_read == 24) {
508 /* we have enough to decode dev num */
509 __u64 mjr; /* major */
510 __u64 mnr; /* minor */
511 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
512 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
513 fattr->cf_rdev = MKDEV(mjr, mnr);
514 }
515 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
516 cifs_dbg(FYI, "Symlink\n");
517 fattr->cf_mode |= S_IFLNK;
518 fattr->cf_dtype = DT_LNK;
519 } else {
520 fattr->cf_mode |= S_IFREG; /* file? */
521 fattr->cf_dtype = DT_REG;
522 rc = -EOPNOTSUPP;
523 }
524 } else {
525 fattr->cf_mode |= S_IFREG; /* then it is a file */
526 fattr->cf_dtype = DT_REG;
527 rc = -EOPNOTSUPP; /* or some unknown SFU type */
528 }
Steve Frenchdb8b6312014-09-22 05:13:55 -0500529
530 tcon->ses->server->ops->close(xid, tcon, &fid);
Jeff Layton7ffec372010-09-29 19:51:11 -0400531 cifs_put_tlink(tlink);
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800532 return rc;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800533}
534
Steve French9e294f12005-11-17 16:59:21 -0800535#define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
536
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400537/*
538 * Fetch mode bits as provided by SFU.
539 *
540 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
541 */
542static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400543 struct cifs_sb_info *cifs_sb, unsigned int xid)
Steve French9e294f12005-11-17 16:59:21 -0800544{
Steve French3020a1f2005-11-18 11:31:10 -0800545#ifdef CONFIG_CIFS_XATTR
Steve French9e294f12005-11-17 16:59:21 -0800546 ssize_t rc;
547 char ea_value[4];
548 __u32 mode;
Jeff Layton7ffec372010-09-29 19:51:11 -0400549 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +0000550 struct cifs_tcon *tcon;
Steve French9e294f12005-11-17 16:59:21 -0800551
Jeff Layton7ffec372010-09-29 19:51:11 -0400552 tlink = cifs_sb_tlink(cifs_sb);
553 if (IS_ERR(tlink))
554 return PTR_ERR(tlink);
555 tcon = tlink_tcon(tlink);
556
Steve Frenchd979f3b2014-02-01 23:27:18 -0600557 if (tcon->ses->server->ops->query_all_EAs == NULL) {
558 cifs_put_tlink(tlink);
559 return -EOPNOTSUPP;
560 }
561
562 rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
563 "SETFILEBITS", ea_value, 4 /* size of buf */,
564 cifs_sb->local_nls,
Steve French2baa2682014-09-27 02:19:01 -0500565 cifs_remap(cifs_sb));
Jeff Layton7ffec372010-09-29 19:51:11 -0400566 cifs_put_tlink(tlink);
Steve French4523cc32007-04-30 20:13:06 +0000567 if (rc < 0)
Steve French9e294f12005-11-17 16:59:21 -0800568 return (int)rc;
569 else if (rc > 3) {
570 mode = le32_to_cpu(*((__le32 *)ea_value));
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400571 fattr->cf_mode &= ~SFBITS_MASK;
Joe Perchesf96637b2013-05-04 22:12:25 -0500572 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
573 mode, fattr->cf_mode);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400574 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
Joe Perchesf96637b2013-05-04 22:12:25 -0500575 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
Steve French9e294f12005-11-17 16:59:21 -0800576 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400577
578 return 0;
Steve French3020a1f2005-11-18 11:31:10 -0800579#else
580 return -EOPNOTSUPP;
581#endif
Steve French9e294f12005-11-17 16:59:21 -0800582}
583
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400584/* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
Steve Frenchf1230c92009-07-22 23:13:01 +0000585static void
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400586cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
Pavel Shilovskyeb85d94b2013-10-23 17:49:47 +0400587 struct cifs_sb_info *cifs_sb, bool adjust_tz,
588 bool symlink)
Steve Frenchb9a32602008-05-20 21:52:32 +0000589{
Steve French96daf2b2011-05-27 04:34:02 +0000590 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Jeff Layton0d424ad2010-09-20 16:01:35 -0700591
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400592 memset(fattr, 0, sizeof(*fattr));
593 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
594 if (info->DeletePending)
595 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
Steve Frenchb9a32602008-05-20 21:52:32 +0000596
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400597 if (info->LastAccessTime)
598 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
599 else
600 fattr->cf_atime = CURRENT_TIME;
601
602 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
603 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
604
605 if (adjust_tz) {
Jeff Layton0d424ad2010-09-20 16:01:35 -0700606 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
607 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400608 }
609
610 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
611 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
Jeff Layton20054bd2011-01-07 11:30:27 -0500612 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400613
Jim McDonough74d290d2013-09-21 10:36:10 -0500614 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
Pavel Shilovskyeb85d94b2013-10-23 17:49:47 +0400615
616 if (symlink) {
617 fattr->cf_mode = S_IFLNK;
618 fattr->cf_dtype = DT_LNK;
619 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400620 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
621 fattr->cf_dtype = DT_DIR;
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +0300622 /*
623 * Server can return wrong NumberOfLinks value for directories
624 * when Unix extensions are disabled - fake it.
625 */
Jim McDonough74d290d2013-09-21 10:36:10 -0500626 if (!tcon->unix_ext)
627 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400628 } else {
629 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
630 fattr->cf_dtype = DT_REG;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400631
Jeff Laytond0c280d2009-07-09 01:46:44 -0400632 /* clear write bits if ATTR_READONLY is set */
633 if (fattr->cf_cifsattrs & ATTR_READONLY)
634 fattr->cf_mode &= ~(S_IWUGO);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400635
Jim McDonough74d290d2013-09-21 10:36:10 -0500636 /*
637 * Don't accept zero nlink from non-unix servers unless
638 * delete is pending. Instead mark it as unknown.
639 */
640 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
641 !info->DeletePending) {
642 cifs_dbg(1, "bogus file nlink value %u\n",
Steve French6658b9f2013-07-04 14:38:48 -0500643 fattr->cf_nlink);
Jim McDonough74d290d2013-09-21 10:36:10 -0500644 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
Steve French6658b9f2013-07-04 14:38:48 -0500645 }
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +0300646 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400647
648 fattr->cf_uid = cifs_sb->mnt_uid;
649 fattr->cf_gid = cifs_sb->mnt_gid;
Steve Frenchb9a32602008-05-20 21:52:32 +0000650}
651
Pavel Shilovsky4ad65042012-09-18 16:20:26 -0700652static int
653cifs_get_file_info(struct file *filp)
Jeff Laytonabab0952010-02-12 07:44:18 -0500654{
655 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400656 unsigned int xid;
Jeff Laytonabab0952010-02-12 07:44:18 -0500657 FILE_ALL_INFO find_data;
658 struct cifs_fattr fattr;
Al Viro496ad9a2013-01-23 17:07:38 -0500659 struct inode *inode = file_inode(filp);
Jeff Laytonabab0952010-02-12 07:44:18 -0500660 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Joe Perchesc21dfb62010-07-12 13:50:14 -0700661 struct cifsFileInfo *cfile = filp->private_data;
Steve French96daf2b2011-05-27 04:34:02 +0000662 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky4ad65042012-09-18 16:20:26 -0700663 struct TCP_Server_Info *server = tcon->ses->server;
664
665 if (!server->ops->query_file_info)
666 return -ENOSYS;
Jeff Laytonabab0952010-02-12 07:44:18 -0500667
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400668 xid = get_xid();
Pavel Shilovsky4ad65042012-09-18 16:20:26 -0700669 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400670 switch (rc) {
671 case 0:
Pavel Shilovskyeb85d94b2013-10-23 17:49:47 +0400672 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false,
673 false);
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400674 break;
675 case -EREMOTE:
676 cifs_create_dfs_fattr(&fattr, inode->i_sb);
677 rc = 0;
678 break;
679 case -EOPNOTSUPP:
680 case -EINVAL:
Jeff Laytonabab0952010-02-12 07:44:18 -0500681 /*
682 * FIXME: legacy server -- fall back to path-based call?
Steve Frenchff2157132010-03-09 20:30:42 +0000683 * for now, just skip revalidating and mark inode for
684 * immediate reval.
685 */
Jeff Laytonabab0952010-02-12 07:44:18 -0500686 rc = 0;
687 CIFS_I(inode)->time = 0;
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400688 default:
Jeff Laytonabab0952010-02-12 07:44:18 -0500689 goto cgfi_exit;
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400690 }
Jeff Laytonabab0952010-02-12 07:44:18 -0500691
692 /*
693 * don't bother with SFU junk here -- just mark inode as needing
694 * revalidation.
695 */
Jeff Laytonabab0952010-02-12 07:44:18 -0500696 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
697 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
698 cifs_fattr_to_inode(inode, &fattr);
699cgfi_exit:
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400700 free_xid(xid);
Jeff Laytonabab0952010-02-12 07:44:18 -0500701 return rc;
702}
703
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400704int
705cifs_get_inode_info(struct inode **inode, const char *full_path,
706 FILE_ALL_INFO *data, struct super_block *sb, int xid,
Steve French42eacf92014-02-10 14:08:16 -0600707 const struct cifs_fid *fid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708{
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500709 bool validinum = false;
710 __u16 srchflgs;
711 int rc = 0, tmprc = ENOSYS;
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400712 struct cifs_tcon *tcon;
713 struct TCP_Server_Info *server;
Jeff Layton7ffec372010-09-29 19:51:11 -0400714 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 char *buf = NULL;
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400717 bool adjust_tz = false;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400718 struct cifs_fattr fattr;
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500719 struct cifs_search_info *srchinf = NULL;
Pavel Shilovskyeb85d94b2013-10-23 17:49:47 +0400720 bool symlink = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721
Jeff Layton7ffec372010-09-29 19:51:11 -0400722 tlink = cifs_sb_tlink(cifs_sb);
723 if (IS_ERR(tlink))
724 return PTR_ERR(tlink);
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400725 tcon = tlink_tcon(tlink);
726 server = tcon->ses->server;
Jeff Layton7ffec372010-09-29 19:51:11 -0400727
Joe Perchesf96637b2013-05-04 22:12:25 -0500728 cifs_dbg(FYI, "Getting info on %s\n", full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400730 if ((data == NULL) && (*inode != NULL)) {
Pavel Shilovsky18cceb62013-09-05 13:01:06 +0400731 if (CIFS_CACHE_READ(CIFS_I(*inode))) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500732 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
Jeff Layton7ffec372010-09-29 19:51:11 -0400733 goto cgii_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 }
735 }
736
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400737 /* if inode info is not passed, get it from server */
738 if (data == NULL) {
739 if (!server->ops->query_path_info) {
740 rc = -ENOSYS;
741 goto cgii_exit;
742 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
Jeff Layton7ffec372010-09-29 19:51:11 -0400744 if (buf == NULL) {
745 rc = -ENOMEM;
746 goto cgii_exit;
747 }
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400748 data = (FILE_ALL_INFO *)buf;
749 rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path,
Pavel Shilovskyeb85d94b2013-10-23 17:49:47 +0400750 data, &adjust_tz, &symlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400752
753 if (!rc) {
Pavel Shilovskyeb85d94b2013-10-23 17:49:47 +0400754 cifs_all_info_to_fattr(&fattr, data, cifs_sb, adjust_tz,
755 symlink);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400756 } else if (rc == -EREMOTE) {
757 cifs_create_dfs_fattr(&fattr, sb);
Steve Frenchb9a32602008-05-20 21:52:32 +0000758 rc = 0;
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500759 } else if (rc == -EACCES && backup_cred(cifs_sb)) {
760 srchinf = kzalloc(sizeof(struct cifs_search_info),
761 GFP_KERNEL);
762 if (srchinf == NULL) {
763 rc = -ENOMEM;
764 goto cgii_exit;
765 }
766
767 srchinf->endOfSearch = false;
768 srchinf->info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
769
770 srchflgs = CIFS_SEARCH_CLOSE_ALWAYS |
771 CIFS_SEARCH_CLOSE_AT_END |
772 CIFS_SEARCH_BACKUP_SEARCH;
773
774 rc = CIFSFindFirst(xid, tcon, full_path,
775 cifs_sb, NULL, srchflgs, srchinf, false);
776 if (!rc) {
777 data =
778 (FILE_ALL_INFO *)srchinf->srch_entries_start;
779
780 cifs_dir_info_to_fattr(&fattr,
781 (FILE_DIRECTORY_INFO *)data, cifs_sb);
782 fattr.cf_uniqueid = le64_to_cpu(
783 ((SEARCH_ID_FULL_DIR_INFO *)data)->UniqueId);
784 validinum = true;
785
786 cifs_buf_release(srchinf->ntwrk_buf_start);
787 }
788 kfree(srchinf);
Steve French4c5930e2015-03-30 22:03:06 -0500789 if (rc)
790 goto cgii_exit;
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500791 } else
Igor Mammedov79626702008-03-09 03:44:18 +0000792 goto cgii_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400794 /*
795 * If an inode wasn't passed in, then get the inode number
796 *
797 * Is an i_ino of zero legal? Can we use that to check if the server
798 * supports returning inode numbers? Are there other sanity checks we
799 * can use to ensure that the server is really filling in that field?
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400800 */
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400801 if (*inode == NULL) {
Steve Frenchb9a32602008-05-20 21:52:32 +0000802 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500803 if (validinum == false) {
804 if (server->ops->get_srv_inum)
805 tmprc = server->ops->get_srv_inum(xid,
806 tcon, cifs_sb, full_path,
807 &fattr.cf_uniqueid, data);
808 if (tmprc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500809 cifs_dbg(FYI, "GetSrvInodeNum rc %d\n",
810 tmprc);
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500811 fattr.cf_uniqueid = iunique(sb, ROOT_I);
812 cifs_autodisable_serverino(cifs_sb);
813 }
Jeff Layton132ac7b2009-02-10 07:33:57 -0500814 }
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500815 } else
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400816 fattr.cf_uniqueid = iunique(sb, ROOT_I);
Ross Lagerwalla108471b2015-12-02 14:46:08 +0000817 } else {
818 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
819 validinum == false && server->ops->get_srv_inum) {
820 /*
821 * Pass a NULL tcon to ensure we don't make a round
822 * trip to the server. This only works for SMB2+.
823 */
824 tmprc = server->ops->get_srv_inum(xid,
825 NULL, cifs_sb, full_path,
826 &fattr.cf_uniqueid, data);
827 if (tmprc)
828 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
829 } else
830 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
831 }
Steve Frenchb9a32602008-05-20 21:52:32 +0000832
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400833 /* query for SFU type info if supported and needed */
834 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
835 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
836 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
837 if (tmprc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500838 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
Steve Frenchb9a32602008-05-20 21:52:32 +0000839 }
Steve Frenchb9a32602008-05-20 21:52:32 +0000840
Jeff Layton79df1ba2010-12-06 12:52:08 -0500841#ifdef CONFIG_CIFS_ACL
Steve Frenchb9a32602008-05-20 21:52:32 +0000842 /* fill in 0777 bits from ACL */
843 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400844 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, full_path, fid);
Shirish Pargaonkar78415d22010-11-27 11:37:26 -0600845 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500846 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
847 __func__, rc);
Shirish Pargaonkar78415d22010-11-27 11:37:26 -0600848 goto cgii_exit;
849 }
Steve Frenchb9a32602008-05-20 21:52:32 +0000850 }
Jeff Layton79df1ba2010-12-06 12:52:08 -0500851#endif /* CONFIG_CIFS_ACL */
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400852
853 /* fill in remaining high mode bits e.g. SUID, VTX */
854 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
855 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
856
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200857 /* check for Minshall+French symlinks */
858 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
Sachin Prabhucb084b12013-11-25 17:09:50 +0000859 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
860 full_path);
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200861 if (tmprc)
Sachin Prabhucb084b12013-11-25 17:09:50 +0000862 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200863 }
864
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400865 if (!*inode) {
866 *inode = cifs_iget(sb, &fattr);
867 if (!*inode)
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400868 rc = -ENOMEM;
869 } else {
Nakajima Akira7196ac12015-04-22 15:24:44 +0900870 /* we already have inode, update it */
871
Ross Lagerwalla108471b2015-12-02 14:46:08 +0000872 /* if uniqueid is different, return error */
873 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
874 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
875 rc = -ESTALE;
876 goto cgii_exit;
877 }
878
Nakajima Akira7196ac12015-04-22 15:24:44 +0900879 /* if filetype is different, return error */
880 if (unlikely(((*inode)->i_mode & S_IFMT) !=
881 (fattr.cf_mode & S_IFMT))) {
882 rc = -ESTALE;
883 goto cgii_exit;
884 }
885
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400886 cifs_fattr_to_inode(*inode, &fattr);
Steve Frenchb9a32602008-05-20 21:52:32 +0000887 }
888
Igor Mammedov79626702008-03-09 03:44:18 +0000889cgii_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 kfree(buf);
Jeff Layton7ffec372010-09-29 19:51:11 -0400891 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 return rc;
893}
894
Steve French7f8ed422007-09-28 22:28:55 +0000895static const struct inode_operations cifs_ipc_inode_ops = {
896 .lookup = cifs_lookup,
897};
898
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400899static int
900cifs_find_inode(struct inode *inode, void *opaque)
901{
902 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
903
Jeff Laytonf30b9c12010-07-19 18:00:17 -0400904 /* don't match inode with different uniqueid */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400905 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
906 return 0;
907
Jeff Layton20054bd2011-01-07 11:30:27 -0500908 /* use createtime like an i_generation field */
909 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
910 return 0;
911
Jeff Laytonf30b9c12010-07-19 18:00:17 -0400912 /* don't match inode of different type */
913 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
914 return 0;
915
Jeff Layton5acfec22010-08-02 17:43:54 -0400916 /* if it's not a directory or has no dentries, then flag it */
Al Virob3d9b7a2012-06-09 13:51:19 -0400917 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
Jeff Layton3d694382010-05-11 14:59:55 -0400918 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
Jeff Layton3d694382010-05-11 14:59:55 -0400919
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400920 return 1;
921}
922
923static int
924cifs_init_inode(struct inode *inode, void *opaque)
925{
926 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
927
928 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
Jeff Layton20054bd2011-01-07 11:30:27 -0500929 CIFS_I(inode)->createtime = fattr->cf_createtime;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400930 return 0;
931}
932
Jeff Layton5acfec22010-08-02 17:43:54 -0400933/*
934 * walk dentry list for an inode and report whether it has aliases that
935 * are hashed. We use this to determine if a directory inode can actually
936 * be used.
937 */
938static bool
939inode_has_hashed_dentries(struct inode *inode)
940{
941 struct dentry *dentry;
942
Nick Piggin873feea2011-01-07 17:50:06 +1100943 spin_lock(&inode->i_lock);
Al Viro946e51f2014-10-26 19:19:16 -0400944 hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
Jeff Layton5acfec22010-08-02 17:43:54 -0400945 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
Nick Piggin873feea2011-01-07 17:50:06 +1100946 spin_unlock(&inode->i_lock);
Jeff Layton5acfec22010-08-02 17:43:54 -0400947 return true;
948 }
949 }
Nick Piggin873feea2011-01-07 17:50:06 +1100950 spin_unlock(&inode->i_lock);
Jeff Layton5acfec22010-08-02 17:43:54 -0400951 return false;
952}
953
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400954/* Given fattrs, get a corresponding inode */
955struct inode *
956cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
957{
958 unsigned long hash;
959 struct inode *inode;
960
Jeff Layton3d694382010-05-11 14:59:55 -0400961retry_iget5_locked:
Joe Perchesf96637b2013-05-04 22:12:25 -0500962 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400963
964 /* hash down to 32-bits on 32-bit arch */
965 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
966
967 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400968 if (inode) {
Jeff Layton5acfec22010-08-02 17:43:54 -0400969 /* was there a potentially problematic inode collision? */
Jeff Layton3d694382010-05-11 14:59:55 -0400970 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
Jeff Layton3d694382010-05-11 14:59:55 -0400971 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
Jeff Layton5acfec22010-08-02 17:43:54 -0400972
973 if (inode_has_hashed_dentries(inode)) {
974 cifs_autodisable_serverino(CIFS_SB(sb));
975 iput(inode);
976 fattr->cf_uniqueid = iunique(sb, ROOT_I);
977 goto retry_iget5_locked;
978 }
Jeff Layton3d694382010-05-11 14:59:55 -0400979 }
980
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400981 cifs_fattr_to_inode(inode, fattr);
982 if (sb->s_flags & MS_NOATIME)
983 inode->i_flags |= S_NOATIME | S_NOCMTIME;
984 if (inode->i_state & I_NEW) {
985 inode->i_ino = hash;
Steve French0ccd4802010-07-16 04:31:02 +0000986#ifdef CONFIG_CIFS_FSCACHE
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530987 /* initialize per-inode cache cookie pointer */
988 CIFS_I(inode)->fscache = NULL;
Steve French0ccd4802010-07-16 04:31:02 +0000989#endif
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400990 unlock_new_inode(inode);
991 }
992 }
993
994 return inode;
995}
996
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997/* gets root inode */
Shirish Pargaonkar9b6763e2011-02-21 23:56:59 -0600998struct inode *cifs_root_iget(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001000 unsigned int xid;
Jeff Layton0d424ad2010-09-20 16:01:35 -07001001 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001002 struct inode *inode = NULL;
David Howellsce634ab2008-02-07 00:15:33 -08001003 long rc;
Steve French96daf2b2011-05-27 04:34:02 +00001004 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Aurelien Aptela6b50582016-05-25 19:59:09 +02001005 char *path = NULL;
1006 int len;
1007
1008 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
1009 && cifs_sb->prepath) {
1010 len = strlen(cifs_sb->prepath);
1011 path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
1012 if (path == NULL)
1013 return ERR_PTR(-ENOMEM);
1014 path[0] = '/';
1015 memcpy(path+1, cifs_sb->prepath, len);
1016 } else {
1017 path = kstrdup("", GFP_KERNEL);
1018 if (path == NULL)
1019 return ERR_PTR(-ENOMEM);
1020 }
David Howellsce634ab2008-02-07 00:15:33 -08001021
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001022 xid = get_xid();
Steve Frenchb5b374ea2014-10-06 01:01:03 -05001023 if (tcon->unix_ext) {
Aurelien Aptela6b50582016-05-25 19:59:09 +02001024 rc = cifs_get_inode_info_unix(&inode, path, sb, xid);
Steve Frenchb5b374ea2014-10-06 01:01:03 -05001025 /* some servers mistakenly claim POSIX support */
1026 if (rc != -EOPNOTSUPP)
1027 goto iget_no_retry;
1028 cifs_dbg(VFS, "server does not support POSIX extensions");
1029 tcon->unix_ext = false;
1030 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -04001031
Aurelien Aptela6b50582016-05-25 19:59:09 +02001032 convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
1033 rc = cifs_get_inode_info(&inode, path, NULL, sb, xid, NULL);
Steve Frenchb5b374ea2014-10-06 01:01:03 -05001034
1035iget_no_retry:
Oskar Schirmera7851ce2010-11-10 21:06:13 +00001036 if (!inode) {
1037 inode = ERR_PTR(rc);
1038 goto out;
1039 }
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001040
Steve French0ccd4802010-07-16 04:31:02 +00001041#ifdef CONFIG_CIFS_FSCACHE
Suresh Jayaramand03382c2010-07-05 18:12:27 +05301042 /* populate tcon->resource_id */
Jeff Layton0d424ad2010-09-20 16:01:35 -07001043 tcon->resource_id = CIFS_I(inode)->uniqueid;
Steve French0ccd4802010-07-16 04:31:02 +00001044#endif
Suresh Jayaramand03382c2010-07-05 18:12:27 +05301045
Jeff Layton0d424ad2010-09-20 16:01:35 -07001046 if (rc && tcon->ipc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001047 cifs_dbg(FYI, "ipc connection - fake read inode\n");
Steve Frenchb7ca6922012-08-03 08:43:01 -05001048 spin_lock(&inode->i_lock);
Steve French7f8ed422007-09-28 22:28:55 +00001049 inode->i_mode |= S_IFDIR;
Miklos Szeredibfe86842011-10-28 14:13:29 +02001050 set_nlink(inode, 2);
Steve French7f8ed422007-09-28 22:28:55 +00001051 inode->i_op = &cifs_ipc_inode_ops;
1052 inode->i_fop = &simple_dir_operations;
1053 inode->i_uid = cifs_sb->mnt_uid;
1054 inode->i_gid = cifs_sb->mnt_gid;
Steve Frenchb7ca6922012-08-03 08:43:01 -05001055 spin_unlock(&inode->i_lock);
Steve Frenchad661332008-08-12 14:14:40 +00001056 } else if (rc) {
David Howellsce634ab2008-02-07 00:15:33 -08001057 iget_failed(inode);
Oskar Schirmera7851ce2010-11-10 21:06:13 +00001058 inode = ERR_PTR(rc);
Steve French7f8ed422007-09-28 22:28:55 +00001059 }
1060
Oskar Schirmera7851ce2010-11-10 21:06:13 +00001061out:
Aurelien Aptela6b50582016-05-25 19:59:09 +02001062 kfree(path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001063 /* can not call macro free_xid here since in a void func
David Howellsce634ab2008-02-07 00:15:33 -08001064 * TODO: This is no longer true
1065 */
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001066 _free_xid(xid);
David Howellsce634ab2008-02-07 00:15:33 -08001067 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068}
1069
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001070int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001071cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001072 char *full_path, __u32 dosattr)
Steve French388e57b2008-09-16 23:50:58 +00001073{
Steve French388e57b2008-09-16 23:50:58 +00001074 bool set_time = false;
Steve French388e57b2008-09-16 23:50:58 +00001075 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Pavel Shilovsky6bdf6db2012-09-18 16:20:32 -07001076 struct TCP_Server_Info *server;
Steve French388e57b2008-09-16 23:50:58 +00001077 FILE_BASIC_INFO info_buf;
1078
Steve French1adcb712009-02-25 14:19:56 +00001079 if (attrs == NULL)
1080 return -EINVAL;
1081
Pavel Shilovsky6bdf6db2012-09-18 16:20:32 -07001082 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1083 if (!server->ops->set_file_info)
1084 return -ENOSYS;
1085
Steve French388e57b2008-09-16 23:50:58 +00001086 if (attrs->ia_valid & ATTR_ATIME) {
1087 set_time = true;
1088 info_buf.LastAccessTime =
1089 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1090 } else
1091 info_buf.LastAccessTime = 0;
1092
1093 if (attrs->ia_valid & ATTR_MTIME) {
1094 set_time = true;
1095 info_buf.LastWriteTime =
1096 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1097 } else
1098 info_buf.LastWriteTime = 0;
1099
1100 /*
1101 * Samba throws this field away, but windows may actually use it.
1102 * Do not set ctime unless other time stamps are changed explicitly
1103 * (i.e. by utimes()) since we would then have a mix of client and
1104 * server times.
1105 */
1106 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001107 cifs_dbg(FYI, "CIFS - CTIME changed\n");
Steve French388e57b2008-09-16 23:50:58 +00001108 info_buf.ChangeTime =
1109 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1110 } else
1111 info_buf.ChangeTime = 0;
1112
1113 info_buf.CreationTime = 0; /* don't change */
1114 info_buf.Attributes = cpu_to_le32(dosattr);
1115
Pavel Shilovsky6bdf6db2012-09-18 16:20:32 -07001116 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
Steve French388e57b2008-09-16 23:50:58 +00001117}
1118
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001119/*
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001120 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001121 * and rename it to a random name that hopefully won't conflict with
1122 * anything else.
1123 */
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001124int
1125cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1126 const unsigned int xid)
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001127{
1128 int oplock = 0;
1129 int rc;
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001130 struct cifs_fid fid;
1131 struct cifs_open_parms oparms;
David Howells2b0143b2015-03-17 22:25:59 +00001132 struct inode *inode = d_inode(dentry);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001133 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1134 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001135 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001136 struct cifs_tcon *tcon;
Steve French32709582008-10-20 00:44:19 +00001137 __u32 dosattr, origattr;
1138 FILE_BASIC_INFO *info_buf = NULL;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001139
Jeff Layton7ffec372010-09-29 19:51:11 -04001140 tlink = cifs_sb_tlink(cifs_sb);
1141 if (IS_ERR(tlink))
1142 return PTR_ERR(tlink);
1143 tcon = tlink_tcon(tlink);
1144
Sachin Prabhuc483a982013-03-05 19:25:56 +00001145 /*
1146 * We cannot rename the file if the server doesn't support
1147 * CAP_INFOLEVEL_PASSTHRU
1148 */
1149 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1150 rc = -EBUSY;
1151 goto out;
1152 }
1153
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001154 oparms.tcon = tcon;
1155 oparms.cifs_sb = cifs_sb;
1156 oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1157 oparms.create_options = CREATE_NOT_DIR;
1158 oparms.disposition = FILE_OPEN;
1159 oparms.path = full_path;
1160 oparms.fid = &fid;
1161 oparms.reconnect = false;
1162
1163 rc = CIFS_open(xid, &oparms, &oplock, NULL);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001164 if (rc != 0)
1165 goto out;
1166
Steve French32709582008-10-20 00:44:19 +00001167 origattr = cifsInode->cifsAttrs;
1168 if (origattr == 0)
1169 origattr |= ATTR_NORMAL;
1170
1171 dosattr = origattr & ~ATTR_READONLY;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001172 if (dosattr == 0)
1173 dosattr |= ATTR_NORMAL;
1174 dosattr |= ATTR_HIDDEN;
1175
Steve French32709582008-10-20 00:44:19 +00001176 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1177 if (dosattr != origattr) {
1178 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1179 if (info_buf == NULL) {
1180 rc = -ENOMEM;
1181 goto out_close;
1182 }
1183 info_buf->Attributes = cpu_to_le32(dosattr);
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001184 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
Steve French32709582008-10-20 00:44:19 +00001185 current->tgid);
1186 /* although we would like to mark the file hidden
1187 if that fails we will still try to rename it */
Sachin Prabhu72d282d2013-03-05 19:25:55 +00001188 if (!rc)
Steve French32709582008-10-20 00:44:19 +00001189 cifsInode->cifsAttrs = dosattr;
1190 else
1191 dosattr = origattr; /* since not able to change them */
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001192 }
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001193
Jeff Laytondd1db2d2008-10-16 19:27:12 -04001194 /* rename the file */
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001195 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1196 cifs_sb->local_nls,
Steve French2baa2682014-09-27 02:19:01 -05001197 cifs_remap(cifs_sb));
Steve French32709582008-10-20 00:44:19 +00001198 if (rc != 0) {
Sachin Prabhu47c78f42013-03-11 13:08:49 +00001199 rc = -EBUSY;
Steve French32709582008-10-20 00:44:19 +00001200 goto undo_setattr;
1201 }
Jeff Layton6d22f092008-09-23 11:48:35 -04001202
Steve French32709582008-10-20 00:44:19 +00001203 /* try to set DELETE_ON_CLOSE */
Jeff Laytonaff8d5c2014-04-30 09:31:45 -04001204 if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001205 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
Steve French32709582008-10-20 00:44:19 +00001206 current->tgid);
1207 /*
1208 * some samba versions return -ENOENT when we try to set the
1209 * file disposition here. Likely a samba bug, but work around
1210 * it for now. This means that some cifsXXX files may hang
1211 * around after they shouldn't.
1212 *
1213 * BB: remove this hack after more servers have the fix
1214 */
1215 if (rc == -ENOENT)
1216 rc = 0;
1217 else if (rc != 0) {
Sachin Prabhu47c78f42013-03-11 13:08:49 +00001218 rc = -EBUSY;
Steve French32709582008-10-20 00:44:19 +00001219 goto undo_rename;
1220 }
Jeff Laytonaff8d5c2014-04-30 09:31:45 -04001221 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
Steve French32709582008-10-20 00:44:19 +00001222 }
Jeff Layton7ce86d52008-09-24 11:32:59 -04001223
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001224out_close:
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001225 CIFSSMBClose(xid, tcon, fid.netfid);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001226out:
Steve French32709582008-10-20 00:44:19 +00001227 kfree(info_buf);
Jeff Layton7ffec372010-09-29 19:51:11 -04001228 cifs_put_tlink(tlink);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001229 return rc;
Steve French32709582008-10-20 00:44:19 +00001230
1231 /*
1232 * reset everything back to the original state. Don't bother
1233 * dealing with errors here since we can't do anything about
1234 * them anyway.
1235 */
1236undo_rename:
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001237 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
Steve French2baa2682014-09-27 02:19:01 -05001238 cifs_sb->local_nls, cifs_remap(cifs_sb));
Steve French32709582008-10-20 00:44:19 +00001239undo_setattr:
1240 if (dosattr != origattr) {
1241 info_buf->Attributes = cpu_to_le32(origattr);
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001242 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
Steve French32709582008-10-20 00:44:19 +00001243 current->tgid))
1244 cifsInode->cifsAttrs = origattr;
1245 }
1246
1247 goto out_close;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001248}
1249
Steve Frenchb7ca6922012-08-03 08:43:01 -05001250/* copied from fs/nfs/dir.c with small changes */
1251static void
1252cifs_drop_nlink(struct inode *inode)
1253{
1254 spin_lock(&inode->i_lock);
1255 if (inode->i_nlink > 0)
1256 drop_nlink(inode);
1257 spin_unlock(&inode->i_lock);
1258}
Steve Frenchff694522009-04-20 19:45:13 +00001259
1260/*
David Howells2b0143b2015-03-17 22:25:59 +00001261 * If d_inode(dentry) is null (usually meaning the cached dentry
Steve Frenchff694522009-04-20 19:45:13 +00001262 * is a negative dentry) then we would attempt a standard SMB delete, but
André Goddard Rosaaf901ca2009-11-14 13:09:05 -02001263 * if that fails we can not attempt the fall back mechanisms on EACCESS
1264 * but will return the EACCESS to the caller. Note that the VFS does not call
Steve Frenchff694522009-04-20 19:45:13 +00001265 * unlink on negative dentries currently.
1266 */
Jeff Layton5f0319a2008-09-16 14:05:16 -04001267int cifs_unlink(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268{
1269 int rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001270 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271 char *full_path = NULL;
David Howells2b0143b2015-03-17 22:25:59 +00001272 struct inode *inode = d_inode(dentry);
Steve Frenchff694522009-04-20 19:45:13 +00001273 struct cifsInodeInfo *cifs_inode;
Jeff Layton5f0319a2008-09-16 14:05:16 -04001274 struct super_block *sb = dir->i_sb;
1275 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001276 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001277 struct cifs_tcon *tcon;
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001278 struct TCP_Server_Info *server;
Steve French60502472008-10-07 18:42:52 +00001279 struct iattr *attrs = NULL;
1280 __u32 dosattr = 0, origattr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281
Joe Perchesf96637b2013-05-04 22:12:25 -05001282 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283
Jeff Layton7ffec372010-09-29 19:51:11 -04001284 tlink = cifs_sb_tlink(cifs_sb);
1285 if (IS_ERR(tlink))
1286 return PTR_ERR(tlink);
1287 tcon = tlink_tcon(tlink);
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001288 server = tcon->ses->server;
Jeff Layton7ffec372010-09-29 19:51:11 -04001289
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001290 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291
Jeff Layton5f0319a2008-09-16 14:05:16 -04001292 /* Unlink can be called from rename so we can not take the
1293 * sb->s_vfs_rename_mutex here */
1294 full_path = build_path_from_dentry(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301296 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001297 goto unlink_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 }
Steve French2d785a52007-07-15 01:48:57 +00001299
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001300 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1301 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001302 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
Steve French2d785a52007-07-15 01:48:57 +00001303 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
Steve French2baa2682014-09-27 02:19:01 -05001304 cifs_remap(cifs_sb));
Joe Perchesf96637b2013-05-04 22:12:25 -05001305 cifs_dbg(FYI, "posix del rc %d\n", rc);
Steve French2d785a52007-07-15 01:48:57 +00001306 if ((rc == 0) || (rc == -ENOENT))
1307 goto psx_del_no_retry;
1308 }
1309
Steve French60502472008-10-07 18:42:52 +00001310retry_std_delete:
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001311 if (!server->ops->unlink) {
1312 rc = -ENOSYS;
1313 goto psx_del_no_retry;
1314 }
1315
1316 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
Steve French60502472008-10-07 18:42:52 +00001317
Steve French2d785a52007-07-15 01:48:57 +00001318psx_del_no_retry:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319 if (!rc) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001320 if (inode)
Steve Frenchb7ca6922012-08-03 08:43:01 -05001321 cifs_drop_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 } else if (rc == -ENOENT) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001323 d_drop(dentry);
Sachin Prabhu47c78f42013-03-11 13:08:49 +00001324 } else if (rc == -EBUSY) {
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001325 if (server->ops->rename_pending_delete) {
1326 rc = server->ops->rename_pending_delete(full_path,
1327 dentry, xid);
1328 if (rc == 0)
1329 cifs_drop_nlink(inode);
1330 }
Steve Frenchff694522009-04-20 19:45:13 +00001331 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
Steve French388e57b2008-09-16 23:50:58 +00001332 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1333 if (attrs == NULL) {
1334 rc = -ENOMEM;
1335 goto out_reval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 }
Steve French388e57b2008-09-16 23:50:58 +00001337
1338 /* try to reset dos attributes */
Steve Frenchff694522009-04-20 19:45:13 +00001339 cifs_inode = CIFS_I(inode);
1340 origattr = cifs_inode->cifsAttrs;
Steve French60502472008-10-07 18:42:52 +00001341 if (origattr == 0)
1342 origattr |= ATTR_NORMAL;
1343 dosattr = origattr & ~ATTR_READONLY;
Steve French388e57b2008-09-16 23:50:58 +00001344 if (dosattr == 0)
1345 dosattr |= ATTR_NORMAL;
1346 dosattr |= ATTR_HIDDEN;
1347
1348 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
Steve French388e57b2008-09-16 23:50:58 +00001349 if (rc != 0)
1350 goto out_reval;
Steve French60502472008-10-07 18:42:52 +00001351
1352 goto retry_std_delete;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 }
Steve French60502472008-10-07 18:42:52 +00001354
1355 /* undo the setattr if we errored out and it's needed */
1356 if (rc != 0 && dosattr != 0)
1357 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1358
Steve French388e57b2008-09-16 23:50:58 +00001359out_reval:
Jeff Layton5f0319a2008-09-16 14:05:16 -04001360 if (inode) {
Steve Frenchff694522009-04-20 19:45:13 +00001361 cifs_inode = CIFS_I(inode);
1362 cifs_inode->time = 0; /* will force revalidate to get info
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001363 when needed */
Jeff Layton5f0319a2008-09-16 14:05:16 -04001364 inode->i_ctime = current_fs_time(sb);
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001365 }
Jeff Layton5f0319a2008-09-16 14:05:16 -04001366 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
Steve Frenchff694522009-04-20 19:45:13 +00001367 cifs_inode = CIFS_I(dir);
Steve French60502472008-10-07 18:42:52 +00001368 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
Jeff Layton7ffec372010-09-29 19:51:11 -04001369unlink_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 kfree(full_path);
Steve French60502472008-10-07 18:42:52 +00001371 kfree(attrs);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001372 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001373 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374 return rc;
1375}
1376
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001377static int
Jeff Layton101b92d2012-09-19 06:22:45 -07001378cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001379 const char *full_path, struct cifs_sb_info *cifs_sb,
1380 struct cifs_tcon *tcon, const unsigned int xid)
1381{
1382 int rc = 0;
Jeff Layton101b92d2012-09-19 06:22:45 -07001383 struct inode *inode = NULL;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001384
1385 if (tcon->unix_ext)
Jeff Layton101b92d2012-09-19 06:22:45 -07001386 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001387 xid);
1388 else
Jeff Layton101b92d2012-09-19 06:22:45 -07001389 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1390 xid, NULL);
1391
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001392 if (rc)
1393 return rc;
1394
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001395 /*
1396 * setting nlink not necessary except in cases where we failed to get it
Jeff Layton101b92d2012-09-19 06:22:45 -07001397 * from the server or was set bogus. Also, since this is a brand new
1398 * inode, no need to grab the i_lock before setting the i_nlink.
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001399 */
Jeff Layton101b92d2012-09-19 06:22:45 -07001400 if (inode->i_nlink < 2)
1401 set_nlink(inode, 2);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001402 mode &= ~current_umask();
1403 /* must turn on setgid bit if parent dir has it */
Jeff Layton101b92d2012-09-19 06:22:45 -07001404 if (parent->i_mode & S_ISGID)
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001405 mode |= S_ISGID;
1406
1407 if (tcon->unix_ext) {
1408 struct cifs_unix_set_info_args args = {
1409 .mode = mode,
1410 .ctime = NO_CHANGE_64,
1411 .atime = NO_CHANGE_64,
1412 .mtime = NO_CHANGE_64,
1413 .device = 0,
1414 };
1415 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
Eric W. Biederman49418b22013-02-06 00:57:56 -08001416 args.uid = current_fsuid();
Jeff Layton101b92d2012-09-19 06:22:45 -07001417 if (parent->i_mode & S_ISGID)
Eric W. Biederman49418b22013-02-06 00:57:56 -08001418 args.gid = parent->i_gid;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001419 else
Eric W. Biederman49418b22013-02-06 00:57:56 -08001420 args.gid = current_fsgid();
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001421 } else {
Eric W. Biederman49418b22013-02-06 00:57:56 -08001422 args.uid = INVALID_UID; /* no change */
1423 args.gid = INVALID_GID; /* no change */
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001424 }
1425 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1426 cifs_sb->local_nls,
Steve French2baa2682014-09-27 02:19:01 -05001427 cifs_remap(cifs_sb));
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001428 } else {
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001429 struct TCP_Server_Info *server = tcon->ses->server;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001430 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001431 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
Jeff Layton101b92d2012-09-19 06:22:45 -07001432 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001433 tcon, xid);
Jeff Layton101b92d2012-09-19 06:22:45 -07001434 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1435 inode->i_mode = (mode | S_IFDIR);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001436
Jeff Layton101b92d2012-09-19 06:22:45 -07001437 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1438 inode->i_uid = current_fsuid();
1439 if (inode->i_mode & S_ISGID)
1440 inode->i_gid = parent->i_gid;
1441 else
1442 inode->i_gid = current_fsgid();
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001443 }
1444 }
Jeff Layton101b92d2012-09-19 06:22:45 -07001445 d_instantiate(dentry, inode);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001446 return rc;
1447}
1448
1449static int
1450cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1451 const char *full_path, struct cifs_sb_info *cifs_sb,
1452 struct cifs_tcon *tcon, const unsigned int xid)
1453{
1454 int rc = 0;
1455 u32 oplock = 0;
1456 FILE_UNIX_BASIC_INFO *info = NULL;
1457 struct inode *newinode = NULL;
1458 struct cifs_fattr fattr;
1459
1460 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1461 if (info == NULL) {
1462 rc = -ENOMEM;
1463 goto posix_mkdir_out;
1464 }
1465
1466 mode &= ~current_umask();
1467 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1468 NULL /* netfid */, info, &oplock, full_path,
Steve French2baa2682014-09-27 02:19:01 -05001469 cifs_sb->local_nls, cifs_remap(cifs_sb));
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001470 if (rc == -EOPNOTSUPP)
1471 goto posix_mkdir_out;
1472 else if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001473 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001474 d_drop(dentry);
1475 goto posix_mkdir_out;
1476 }
1477
1478 if (info->Type == cpu_to_le32(-1))
1479 /* no return info, go query for it */
1480 goto posix_mkdir_get_info;
1481 /*
1482 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1483 * need to set uid/gid.
1484 */
1485
1486 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1487 cifs_fill_uniqueid(inode->i_sb, &fattr);
1488 newinode = cifs_iget(inode->i_sb, &fattr);
1489 if (!newinode)
1490 goto posix_mkdir_get_info;
1491
1492 d_instantiate(dentry, newinode);
1493
1494#ifdef CONFIG_CIFS_DEBUG2
Al Viro35c265e2014-08-19 20:25:34 -04001495 cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1496 dentry, dentry, newinode);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001497
1498 if (newinode->i_nlink != 2)
Joe Perchesf96637b2013-05-04 22:12:25 -05001499 cifs_dbg(FYI, "unexpected number of links %d\n",
1500 newinode->i_nlink);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001501#endif
1502
1503posix_mkdir_out:
1504 kfree(info);
1505 return rc;
1506posix_mkdir_get_info:
1507 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1508 xid);
1509 goto posix_mkdir_out;
1510}
1511
Al Viro18bb1db2011-07-26 01:41:39 -04001512int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513{
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001514 int rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001515 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001517 struct tcon_link *tlink;
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001518 struct cifs_tcon *tcon;
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001519 struct TCP_Server_Info *server;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001520 char *full_path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521
Joe Perchesf96637b2013-05-04 22:12:25 -05001522 cifs_dbg(FYI, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1523 mode, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525 cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001526 tlink = cifs_sb_tlink(cifs_sb);
1527 if (IS_ERR(tlink))
1528 return PTR_ERR(tlink);
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001529 tcon = tlink_tcon(tlink);
Jeff Layton7ffec372010-09-29 19:51:11 -04001530
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001531 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532
Steve French7f573562005-08-30 11:32:14 -07001533 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301535 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001536 goto mkdir_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537 }
Steve French50c2f752007-07-13 00:33:32 +00001538
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001539 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1540 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001541 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1542 tcon, xid);
1543 if (rc != -EOPNOTSUPP)
Steve French2dd29d32007-04-23 22:07:35 +00001544 goto mkdir_out;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001545 }
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001546
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001547 server = tcon->ses->server;
1548
1549 if (!server->ops->mkdir) {
1550 rc = -ENOSYS;
1551 goto mkdir_out;
1552 }
1553
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554 /* BB add setting the equivalent of mode via CreateX w/ACLs */
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001555 rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001557 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558 d_drop(direntry);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001559 goto mkdir_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560 }
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001561
1562 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1563 xid);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001564mkdir_out:
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +03001565 /*
1566 * Force revalidate to get parent dir info when needed since cached
1567 * attributes are invalid now.
1568 */
1569 CIFS_I(inode)->time = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001571 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001572 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573 return rc;
1574}
1575
1576int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1577{
1578 int rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001579 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001581 struct tcon_link *tlink;
Pavel Shilovskyf958ca52012-07-10 16:14:18 +04001582 struct cifs_tcon *tcon;
1583 struct TCP_Server_Info *server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 char *full_path = NULL;
1585 struct cifsInodeInfo *cifsInode;
1586
Joe Perchesf96637b2013-05-04 22:12:25 -05001587 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001589 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590
Steve French7f573562005-08-30 11:32:14 -07001591 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301593 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001594 goto rmdir_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595 }
1596
Jeff Layton7ffec372010-09-29 19:51:11 -04001597 cifs_sb = CIFS_SB(inode->i_sb);
1598 tlink = cifs_sb_tlink(cifs_sb);
1599 if (IS_ERR(tlink)) {
1600 rc = PTR_ERR(tlink);
1601 goto rmdir_exit;
1602 }
Pavel Shilovskyf958ca52012-07-10 16:14:18 +04001603 tcon = tlink_tcon(tlink);
1604 server = tcon->ses->server;
Jeff Layton7ffec372010-09-29 19:51:11 -04001605
Pavel Shilovskyf958ca52012-07-10 16:14:18 +04001606 if (!server->ops->rmdir) {
1607 rc = -ENOSYS;
1608 cifs_put_tlink(tlink);
1609 goto rmdir_exit;
1610 }
1611
1612 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001613 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614
1615 if (!rc) {
David Howells2b0143b2015-03-17 22:25:59 +00001616 spin_lock(&d_inode(direntry)->i_lock);
1617 i_size_write(d_inode(direntry), 0);
1618 clear_nlink(d_inode(direntry));
1619 spin_unlock(&d_inode(direntry)->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620 }
1621
David Howells2b0143b2015-03-17 22:25:59 +00001622 cifsInode = CIFS_I(d_inode(direntry));
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +03001623 /* force revalidate to go get info when needed */
1624 cifsInode->time = 0;
Steve French42c24542009-01-13 22:03:55 +00001625
1626 cifsInode = CIFS_I(inode);
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +03001627 /*
1628 * Force revalidate to get parent dir info when needed since cached
1629 * attributes are invalid now.
1630 */
1631 cifsInode->time = 0;
Steve French42c24542009-01-13 22:03:55 +00001632
David Howells2b0143b2015-03-17 22:25:59 +00001633 d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634 current_fs_time(inode->i_sb);
1635
Jeff Layton7ffec372010-09-29 19:51:11 -04001636rmdir_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001638 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639 return rc;
1640}
1641
Steve Frenchee2fd962008-09-23 18:23:33 +00001642static int
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001643cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1644 const char *from_path, struct dentry *to_dentry,
1645 const char *to_path)
Steve Frenchee2fd962008-09-23 18:23:33 +00001646{
1647 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001648 struct tcon_link *tlink;
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001649 struct cifs_tcon *tcon;
1650 struct TCP_Server_Info *server;
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001651 struct cifs_fid fid;
1652 struct cifs_open_parms oparms;
Steve Frenchee2fd962008-09-23 18:23:33 +00001653 int oplock, rc;
1654
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 Shilovsky8ceb9842012-09-18 16:20:30 -07001658 tcon = tlink_tcon(tlink);
1659 server = tcon->ses->server;
1660
1661 if (!server->ops->rename)
1662 return -ENOSYS;
Jeff Layton7ffec372010-09-29 19:51:11 -04001663
Steve Frenchee2fd962008-09-23 18:23:33 +00001664 /* try path-based rename first */
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001665 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
Steve Frenchee2fd962008-09-23 18:23:33 +00001666
1667 /*
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001668 * Don't bother with rename by filehandle unless file is busy and
1669 * source. Note that cross directory moves do not work with
Steve Frenchee2fd962008-09-23 18:23:33 +00001670 * rename by filehandle to various Windows servers.
1671 */
Sachin Prabhu47c78f42013-03-11 13:08:49 +00001672 if (rc == 0 || rc != -EBUSY)
Jeff Layton7ffec372010-09-29 19:51:11 -04001673 goto do_rename_exit;
Steve Frenchee2fd962008-09-23 18:23:33 +00001674
Jeff Laytoned0e3ac2010-06-01 16:21:01 -04001675 /* open-file renames don't work across directories */
1676 if (to_dentry->d_parent != from_dentry->d_parent)
Jeff Layton7ffec372010-09-29 19:51:11 -04001677 goto do_rename_exit;
Jeff Laytoned0e3ac2010-06-01 16:21:01 -04001678
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001679 oparms.tcon = tcon;
1680 oparms.cifs_sb = cifs_sb;
Steve Frenchee2fd962008-09-23 18:23:33 +00001681 /* open the file to be renamed -- we need DELETE perms */
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001682 oparms.desired_access = DELETE;
1683 oparms.create_options = CREATE_NOT_DIR;
1684 oparms.disposition = FILE_OPEN;
1685 oparms.path = from_path;
1686 oparms.fid = &fid;
1687 oparms.reconnect = false;
1688
1689 rc = CIFS_open(xid, &oparms, &oplock, NULL);
Steve Frenchee2fd962008-09-23 18:23:33 +00001690 if (rc == 0) {
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001691 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
Steve Frenchee2fd962008-09-23 18:23:33 +00001692 (const char *) to_dentry->d_name.name,
Steve French2baa2682014-09-27 02:19:01 -05001693 cifs_sb->local_nls, cifs_remap(cifs_sb));
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001694 CIFSSMBClose(xid, tcon, fid.netfid);
Steve Frenchee2fd962008-09-23 18:23:33 +00001695 }
Jeff Layton7ffec372010-09-29 19:51:11 -04001696do_rename_exit:
1697 cifs_put_tlink(tlink);
Steve Frenchee2fd962008-09-23 18:23:33 +00001698 return rc;
1699}
1700
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001701int
Miklos Szeredi7c33d592014-07-23 15:15:36 +02001702cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
1703 struct inode *target_dir, struct dentry *target_dentry,
1704 unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705{
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001706 char *from_name = NULL;
1707 char *to_name = NULL;
Jeff Layton639e7a92010-09-03 11:50:09 -04001708 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001709 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001710 struct cifs_tcon *tcon;
Steve Frenchee2fd962008-09-23 18:23:33 +00001711 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1712 FILE_UNIX_BASIC_INFO *info_buf_target;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001713 unsigned int xid;
1714 int rc, tmprc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715
Miklos Szeredi7c33d592014-07-23 15:15:36 +02001716 if (flags & ~RENAME_NOREPLACE)
1717 return -EINVAL;
1718
Jeff Layton639e7a92010-09-03 11:50:09 -04001719 cifs_sb = CIFS_SB(source_dir->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001720 tlink = cifs_sb_tlink(cifs_sb);
1721 if (IS_ERR(tlink))
1722 return PTR_ERR(tlink);
1723 tcon = tlink_tcon(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001725 xid = get_xid();
Steve Frenchee2fd962008-09-23 18:23:33 +00001726
1727 /*
Steve Frenchee2fd962008-09-23 18:23:33 +00001728 * we already have the rename sem so we do not need to
1729 * grab it again here to protect the path integrity
1730 */
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001731 from_name = build_path_from_dentry(source_dentry);
1732 if (from_name == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733 rc = -ENOMEM;
1734 goto cifs_rename_exit;
1735 }
1736
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001737 to_name = build_path_from_dentry(target_dentry);
1738 if (to_name == NULL) {
Steve Frenchee2fd962008-09-23 18:23:33 +00001739 rc = -ENOMEM;
1740 goto cifs_rename_exit;
1741 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001743 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1744 to_name);
Steve Frenchee2fd962008-09-23 18:23:33 +00001745
Miklos Szeredi7c33d592014-07-23 15:15:36 +02001746 /*
1747 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1748 */
1749 if (flags & RENAME_NOREPLACE)
1750 goto cifs_rename_exit;
1751
Jeff Layton14121bd2008-10-20 14:45:22 -04001752 if (rc == -EEXIST && tcon->unix_ext) {
Steve Frenchee2fd962008-09-23 18:23:33 +00001753 /*
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001754 * Are src and dst hardlinks of same inode? We can only tell
1755 * with unix extensions enabled.
Steve Frenchee2fd962008-09-23 18:23:33 +00001756 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001757 info_buf_source =
1758 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1759 GFP_KERNEL);
1760 if (info_buf_source == NULL) {
1761 rc = -ENOMEM;
1762 goto cifs_rename_exit;
1763 }
1764
1765 info_buf_target = info_buf_source + 1;
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001766 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1767 info_buf_source,
1768 cifs_sb->local_nls,
Steve French2baa2682014-09-27 02:19:01 -05001769 cifs_remap(cifs_sb));
Jeff Layton8d281ef2008-10-22 13:57:01 -04001770 if (tmprc != 0)
Jeff Layton14121bd2008-10-20 14:45:22 -04001771 goto unlink_target;
1772
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001773 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1774 info_buf_target,
1775 cifs_sb->local_nls,
Steve French2baa2682014-09-27 02:19:01 -05001776 cifs_remap(cifs_sb));
Jeff Layton14121bd2008-10-20 14:45:22 -04001777
Jeff Layton8d281ef2008-10-22 13:57:01 -04001778 if (tmprc == 0 && (info_buf_source->UniqueId ==
Jeff Laytonae6884a2008-11-03 14:05:08 -05001779 info_buf_target->UniqueId)) {
Jeff Layton14121bd2008-10-20 14:45:22 -04001780 /* same file, POSIX says that this is a noop */
Jeff Laytonae6884a2008-11-03 14:05:08 -05001781 rc = 0;
Jeff Layton14121bd2008-10-20 14:45:22 -04001782 goto cifs_rename_exit;
Jeff Laytonae6884a2008-11-03 14:05:08 -05001783 }
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001784 }
1785 /*
1786 * else ... BB we could add the same check for Windows by
1787 * checking the UniqueId via FILE_INTERNAL_INFO
1788 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001789
Jeff Layton14121bd2008-10-20 14:45:22 -04001790unlink_target:
Jeff Laytonfc6f3942009-04-17 11:45:30 -04001791 /* Try unlinking the target dentry if it's not negative */
David Howells2b0143b2015-03-17 22:25:59 +00001792 if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
Pavel Shilovskya07d3222014-08-22 13:32:09 +04001793 if (d_is_dir(target_dentry))
1794 tmprc = cifs_rmdir(target_dir, target_dentry);
1795 else
1796 tmprc = cifs_unlink(target_dir, target_dentry);
Jeff Layton14121bd2008-10-20 14:45:22 -04001797 if (tmprc)
1798 goto cifs_rename_exit;
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001799 rc = cifs_do_rename(xid, source_dentry, from_name,
1800 target_dentry, to_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801 }
1802
Pavel Shilovskyb46799a2014-08-18 20:49:58 +04001803 /* force revalidate to go get info when needed */
1804 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
1805
1806 source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
1807 target_dir->i_mtime = current_fs_time(source_dir->i_sb);
1808
Linus Torvalds1da177e2005-04-16 15:20:36 -07001809cifs_rename_exit:
Steve Frenchee2fd962008-09-23 18:23:33 +00001810 kfree(info_buf_source);
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001811 kfree(from_name);
1812 kfree(to_name);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001813 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001814 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815 return rc;
1816}
1817
Jeff Laytondf2cf172010-02-12 07:44:16 -05001818static bool
1819cifs_inode_needs_reval(struct inode *inode)
1820{
1821 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301822 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Laytondf2cf172010-02-12 07:44:16 -05001823
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001824 if (CIFS_CACHE_READ(cifs_i))
Jeff Laytondf2cf172010-02-12 07:44:16 -05001825 return false;
1826
1827 if (!lookupCacheEnabled)
1828 return true;
1829
1830 if (cifs_i->time == 0)
1831 return true;
1832
Jeff Laytona87c9ad2014-03-26 07:24:23 -07001833 if (!cifs_sb->actimeo)
1834 return true;
1835
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301836 if (!time_in_range(jiffies, cifs_i->time,
1837 cifs_i->time + cifs_sb->actimeo))
Jeff Laytondf2cf172010-02-12 07:44:16 -05001838 return true;
1839
Jeff Laytondb192722010-05-17 14:51:49 -04001840 /* hardlinked files w/ noserverino get "special" treatment */
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301841 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
Jeff Laytondb192722010-05-17 14:51:49 -04001842 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1843 return true;
1844
Jeff Laytondf2cf172010-02-12 07:44:16 -05001845 return false;
1846}
1847
Suresh Jayaraman523fb8c2010-11-29 22:39:47 +05301848/*
1849 * Zap the cache. Called when invalid_mapping flag is set.
1850 */
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001851int
Jeff Laytondf2cf172010-02-12 07:44:16 -05001852cifs_invalidate_mapping(struct inode *inode)
1853{
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001854 int rc = 0;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001855
Jeff Laytondf2cf172010-02-12 07:44:16 -05001856 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
Pavel Shilovsky257fb1f2011-03-16 01:55:32 +03001857 rc = invalidate_inode_pages2(inode->i_mapping);
Jeff Layton4f73c7d2014-04-30 09:31:47 -04001858 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05001859 cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1860 __func__, inode);
Jeff Laytondf2cf172010-02-12 07:44:16 -05001861 }
Pavel Shilovsky257fb1f2011-03-16 01:55:32 +03001862
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +05301863 cifs_fscache_reset_inode_cookie(inode);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001864 return rc;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001865}
1866
Jeff Layton4f73c7d2014-04-30 09:31:47 -04001867/**
1868 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
1869 * @word: long word containing the bit lock
1870 */
1871static int
Peter Zijlstradfd01f02015-12-13 22:11:16 +01001872cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
Jeff Layton4f73c7d2014-04-30 09:31:47 -04001873{
Jeff Layton4f73c7d2014-04-30 09:31:47 -04001874 freezable_schedule_unsafe();
Peter Zijlstradfd01f02015-12-13 22:11:16 +01001875 if (signal_pending_state(mode, current))
1876 return -ERESTARTSYS;
Jeff Layton4f73c7d2014-04-30 09:31:47 -04001877 return 0;
1878}
1879
Jeff Laytone284e532014-04-30 09:31:46 -04001880int
1881cifs_revalidate_mapping(struct inode *inode)
1882{
Jeff Layton4f73c7d2014-04-30 09:31:47 -04001883 int rc;
1884 unsigned long *flags = &CIFS_I(inode)->flags;
1885
NeilBrown74316202014-07-07 15:16:04 +10001886 rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
1887 TASK_KILLABLE);
Jeff Layton4f73c7d2014-04-30 09:31:47 -04001888 if (rc)
1889 return rc;
1890
1891 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
1892 rc = cifs_invalidate_mapping(inode);
1893 if (rc)
1894 set_bit(CIFS_INO_INVALID_MAPPING, flags);
1895 }
1896
1897 clear_bit_unlock(CIFS_INO_LOCK, flags);
Linus Torvaldsb1cce802014-06-09 19:08:43 -07001898 smp_mb__after_atomic();
Jeff Layton4f73c7d2014-04-30 09:31:47 -04001899 wake_up_bit(flags, CIFS_INO_LOCK);
1900
1901 return rc;
1902}
1903
1904int
1905cifs_zap_mapping(struct inode *inode)
1906{
1907 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
1908 return cifs_revalidate_mapping(inode);
Jeff Laytone284e532014-04-30 09:31:46 -04001909}
1910
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001911int cifs_revalidate_file_attr(struct file *filp)
Jeff Laytonabab0952010-02-12 07:44:18 -05001912{
1913 int rc = 0;
Al Viro496ad9a2013-01-23 17:07:38 -05001914 struct inode *inode = file_inode(filp);
Jeff Laytonba00ba62010-09-20 16:01:31 -07001915 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
Jeff Laytonabab0952010-02-12 07:44:18 -05001916
1917 if (!cifs_inode_needs_reval(inode))
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001918 return rc;
Jeff Laytonabab0952010-02-12 07:44:18 -05001919
Jeff Layton13cfb732010-09-29 19:51:11 -04001920 if (tlink_tcon(cfile->tlink)->unix_ext)
Jeff Laytonabab0952010-02-12 07:44:18 -05001921 rc = cifs_get_file_info_unix(filp);
1922 else
1923 rc = cifs_get_file_info(filp);
1924
Jeff Laytonabab0952010-02-12 07:44:18 -05001925 return rc;
1926}
1927
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001928int cifs_revalidate_dentry_attr(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001930 unsigned int xid;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001931 int rc = 0;
David Howells2b0143b2015-03-17 22:25:59 +00001932 struct inode *inode = d_inode(dentry);
Jeff Laytondf2cf172010-02-12 07:44:16 -05001933 struct super_block *sb = dentry->d_sb;
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001934 char *full_path = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935
Jeff Laytondf2cf172010-02-12 07:44:16 -05001936 if (inode == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 return -ENOENT;
1938
Jeff Laytondf2cf172010-02-12 07:44:16 -05001939 if (!cifs_inode_needs_reval(inode))
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001940 return rc;
1941
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001942 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943
1944 /* can not safely grab the rename sem here if rename calls revalidate
1945 since that would deadlock */
Jeff Laytondf2cf172010-02-12 07:44:16 -05001946 full_path = build_path_from_dentry(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301948 rc = -ENOMEM;
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001949 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950 }
Jeff Laytondf2cf172010-02-12 07:44:16 -05001951
Joe Perchesf96637b2013-05-04 22:12:25 -05001952 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1953 full_path, inode, inode->i_count.counter,
Miklos Szeredia00be0e2016-09-16 12:44:21 +02001954 dentry, cifs_get_time(dentry), jiffies);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955
Jeff Layton0d424ad2010-09-20 16:01:35 -07001956 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
Jeff Laytondf2cf172010-02-12 07:44:16 -05001957 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1958 else
1959 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1960 xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001962out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001964 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965 return rc;
1966}
1967
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001968int cifs_revalidate_file(struct file *filp)
1969{
1970 int rc;
Al Viro496ad9a2013-01-23 17:07:38 -05001971 struct inode *inode = file_inode(filp);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001972
1973 rc = cifs_revalidate_file_attr(filp);
1974 if (rc)
1975 return rc;
1976
Jeff Laytone284e532014-04-30 09:31:46 -04001977 return cifs_revalidate_mapping(inode);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001978}
1979
1980/* revalidate a dentry's inode attributes */
1981int cifs_revalidate_dentry(struct dentry *dentry)
1982{
1983 int rc;
David Howells2b0143b2015-03-17 22:25:59 +00001984 struct inode *inode = d_inode(dentry);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001985
1986 rc = cifs_revalidate_dentry_attr(dentry);
1987 if (rc)
1988 return rc;
1989
Jeff Laytone284e532014-04-30 09:31:46 -04001990 return cifs_revalidate_mapping(inode);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001991}
1992
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
Jeff Layton1c456012010-10-12 11:32:42 -04001994 struct kstat *stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995{
Jeff Layton3aa1c8c2010-10-07 14:46:28 -04001996 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
Steve French96daf2b2011-05-27 04:34:02 +00001997 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
David Howells2b0143b2015-03-17 22:25:59 +00001998 struct inode *inode = d_inode(dentry);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001999 int rc;
Jeff Layton3aa1c8c2010-10-07 14:46:28 -04002000
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002001 /*
2002 * We need to be sure that all dirty pages are written and the server
2003 * has actual ctime, mtime and file length.
2004 */
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04002005 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002006 inode->i_mapping->nrpages != 0) {
2007 rc = filemap_fdatawait(inode->i_mapping);
Steve French156ecb22011-05-20 17:00:01 +00002008 if (rc) {
2009 mapping_set_error(inode->i_mapping, rc);
2010 return rc;
2011 }
Steve French5fe14c82006-11-07 19:26:33 +00002012 }
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002013
2014 rc = cifs_revalidate_dentry_attr(dentry);
2015 if (rc)
2016 return rc;
2017
2018 generic_fillattr(inode, stat);
2019 stat->blksize = CIFS_MAX_MSGSIZE;
2020 stat->ino = CIFS_I(inode)->uniqueid;
2021
2022 /*
Jeff Laytond3d1fce2012-11-25 08:00:40 -05002023 * If on a multiuser mount without unix extensions or cifsacl being
2024 * enabled, and the admin hasn't overridden them, set the ownership
2025 * to the fsuid/fsgid of the current process.
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002026 */
2027 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
Jeff Laytond3d1fce2012-11-25 08:00:40 -05002028 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002029 !tcon->unix_ext) {
2030 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2031 stat->uid = current_fsuid();
2032 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2033 stat->gid = current_fsgid();
2034 }
2035 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036}
2037
2038static int cifs_truncate_page(struct address_space *mapping, loff_t from)
2039{
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002040 pgoff_t index = from >> PAGE_SHIFT;
2041 unsigned offset = from & (PAGE_SIZE - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042 struct page *page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002043 int rc = 0;
2044
2045 page = grab_cache_page(mapping, index);
2046 if (!page)
2047 return -ENOMEM;
2048
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002049 zero_user_segment(page, offset, PAGE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050 unlock_page(page);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002051 put_page(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002052 return rc;
2053}
2054
Christoph Hellwig1b947462010-07-18 17:51:21 -04002055static void cifs_setsize(struct inode *inode, loff_t offset)
Steve French3677db12007-02-26 16:46:11 +00002056{
Steve Frenchba6a46a2007-02-26 20:06:29 +00002057 spin_lock(&inode->i_lock);
Steve French3677db12007-02-26 16:46:11 +00002058 i_size_write(inode, offset);
Steve Frenchba6a46a2007-02-26 20:06:29 +00002059 spin_unlock(&inode->i_lock);
Christoph Hellwig1b947462010-07-18 17:51:21 -04002060
Kirill A. Shutemov7caef262013-09-12 15:13:56 -07002061 truncate_pagecache(inode, offset);
Steve French3677db12007-02-26 16:46:11 +00002062}
2063
Jeff Layton8efdbde2008-07-23 21:28:12 +00002064static int
2065cifs_set_file_size(struct inode *inode, struct iattr *attrs,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002066 unsigned int xid, char *full_path)
Jeff Layton8efdbde2008-07-23 21:28:12 +00002067{
2068 int rc;
2069 struct cifsFileInfo *open_file;
2070 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2071 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04002072 struct tcon_link *tlink = NULL;
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002073 struct cifs_tcon *tcon = NULL;
2074 struct TCP_Server_Info *server;
Jeff Layton8efdbde2008-07-23 21:28:12 +00002075
2076 /*
2077 * To avoid spurious oplock breaks from server, in the case of
2078 * inodes that we already have open, avoid doing path based
2079 * setting of file size if we can do it by handle.
2080 * This keeps our caching token (oplock) and avoids timeouts
2081 * when the local oplock break takes longer to flush
2082 * writebehind data than the SMB timeout for the SetPathInfo
2083 * request would allow
2084 */
Jeff Layton6508d902010-09-29 19:51:11 -04002085 open_file = find_writable_file(cifsInode, true);
Jeff Layton8efdbde2008-07-23 21:28:12 +00002086 if (open_file) {
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002087 tcon = tlink_tcon(open_file->tlink);
2088 server = tcon->ses->server;
2089 if (server->ops->set_file_size)
2090 rc = server->ops->set_file_size(xid, tcon, open_file,
2091 attrs->ia_size, false);
2092 else
2093 rc = -ENOSYS;
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04002094 cifsFileInfo_put(open_file);
Joe Perchesf96637b2013-05-04 22:12:25 -05002095 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00002096 } else
2097 rc = -EINVAL;
2098
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002099 if (!rc)
2100 goto set_size_out;
Jeff Laytonba00ba62010-09-20 16:01:31 -07002101
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002102 if (tcon == NULL) {
2103 tlink = cifs_sb_tlink(cifs_sb);
2104 if (IS_ERR(tlink))
2105 return PTR_ERR(tlink);
2106 tcon = tlink_tcon(tlink);
2107 server = tcon->ses->server;
Jeff Layton8efdbde2008-07-23 21:28:12 +00002108 }
2109
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002110 /*
2111 * Set file size by pathname rather than by handle either because no
2112 * valid, writeable file handle for it was found or because there was
2113 * an error setting it by handle.
2114 */
2115 if (server->ops->set_path_size)
2116 rc = server->ops->set_path_size(xid, tcon, full_path,
2117 attrs->ia_size, cifs_sb, false);
2118 else
2119 rc = -ENOSYS;
Joe Perchesf96637b2013-05-04 22:12:25 -05002120 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002121
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002122 if (tlink)
2123 cifs_put_tlink(tlink);
2124
2125set_size_out:
Jeff Layton8efdbde2008-07-23 21:28:12 +00002126 if (rc == 0) {
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04002127 cifsInode->server_eof = attrs->ia_size;
Christoph Hellwig1b947462010-07-18 17:51:21 -04002128 cifs_setsize(inode, attrs->ia_size);
Jeff Layton8efdbde2008-07-23 21:28:12 +00002129 cifs_truncate_page(inode->i_mapping, inode->i_size);
2130 }
2131
2132 return rc;
2133}
2134
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002135static int
2136cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2137{
2138 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002139 unsigned int xid;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002140 char *full_path = NULL;
David Howells2b0143b2015-03-17 22:25:59 +00002141 struct inode *inode = d_inode(direntry);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002142 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2143 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04002144 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00002145 struct cifs_tcon *pTcon;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002146 struct cifs_unix_set_info_args *args = NULL;
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002147 struct cifsFileInfo *open_file;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002148
Al Viro35c265e2014-08-19 20:25:34 -04002149 cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2150 direntry, attrs->ia_valid);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002151
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002152 xid = get_xid();
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002153
Christoph Hellwigdb78b872010-06-04 11:30:03 +02002154 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2155 attrs->ia_valid |= ATTR_FORCE;
2156
Jan Kara31051c82016-05-26 16:55:18 +02002157 rc = setattr_prepare(direntry, attrs);
Christoph Hellwigdb78b872010-06-04 11:30:03 +02002158 if (rc < 0)
2159 goto out;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002160
2161 full_path = build_path_from_dentry(direntry);
2162 if (full_path == NULL) {
2163 rc = -ENOMEM;
2164 goto out;
2165 }
2166
Jeff Layton0f4d6342009-03-26 13:35:37 -04002167 /*
2168 * Attempt to flush data before changing attributes. We need to do
2169 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2170 * ownership or mode then we may also need to do this. Here, we take
2171 * the safe way out and just do the flush on all setattr requests. If
2172 * the flush returns error, store it to report later and continue.
2173 *
2174 * BB: This should be smarter. Why bother flushing pages that
2175 * will be truncated anyway? Also, should we error out here if
2176 * the flush returns error?
2177 */
2178 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002179 mapping_set_error(inode->i_mapping, rc);
2180 rc = 0;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002181
2182 if (attrs->ia_valid & ATTR_SIZE) {
2183 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2184 if (rc != 0)
2185 goto out;
2186 }
2187
2188 /* skip mode change if it's just for clearing setuid/setgid */
2189 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2190 attrs->ia_valid &= ~ATTR_MODE;
2191
2192 args = kmalloc(sizeof(*args), GFP_KERNEL);
2193 if (args == NULL) {
2194 rc = -ENOMEM;
2195 goto out;
2196 }
2197
2198 /* set up the struct */
2199 if (attrs->ia_valid & ATTR_MODE)
2200 args->mode = attrs->ia_mode;
2201 else
2202 args->mode = NO_CHANGE_64;
2203
2204 if (attrs->ia_valid & ATTR_UID)
2205 args->uid = attrs->ia_uid;
2206 else
Eric W. Biederman49418b22013-02-06 00:57:56 -08002207 args->uid = INVALID_UID; /* no change */
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002208
2209 if (attrs->ia_valid & ATTR_GID)
2210 args->gid = attrs->ia_gid;
2211 else
Eric W. Biederman49418b22013-02-06 00:57:56 -08002212 args->gid = INVALID_GID; /* no change */
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002213
2214 if (attrs->ia_valid & ATTR_ATIME)
2215 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2216 else
2217 args->atime = NO_CHANGE_64;
2218
2219 if (attrs->ia_valid & ATTR_MTIME)
2220 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2221 else
2222 args->mtime = NO_CHANGE_64;
2223
2224 if (attrs->ia_valid & ATTR_CTIME)
2225 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2226 else
2227 args->ctime = NO_CHANGE_64;
2228
2229 args->device = 0;
Jeff Layton6508d902010-09-29 19:51:11 -04002230 open_file = find_writable_file(cifsInode, true);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002231 if (open_file) {
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07002232 u16 nfid = open_file->fid.netfid;
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002233 u32 npid = open_file->pid;
Jeff Layton13cfb732010-09-29 19:51:11 -04002234 pTcon = tlink_tcon(open_file->tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002235 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04002236 cifsFileInfo_put(open_file);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002237 } else {
Jeff Layton7ffec372010-09-29 19:51:11 -04002238 tlink = cifs_sb_tlink(cifs_sb);
2239 if (IS_ERR(tlink)) {
2240 rc = PTR_ERR(tlink);
2241 goto out;
2242 }
2243 pTcon = tlink_tcon(tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002244 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
Jeff Layton01ea95e2009-07-09 20:02:49 -04002245 cifs_sb->local_nls,
Nakajima Akirabc8ebdc42015-02-13 15:35:58 +09002246 cifs_remap(cifs_sb));
Jeff Layton7ffec372010-09-29 19:51:11 -04002247 cifs_put_tlink(tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002248 }
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002249
Christoph Hellwig10257742010-06-04 11:30:02 +02002250 if (rc)
2251 goto out;
Steve Frenchccd4bb12010-02-08 17:39:58 +00002252
Christoph Hellwig10257742010-06-04 11:30:02 +02002253 if ((attrs->ia_valid & ATTR_SIZE) &&
Christoph Hellwig1b947462010-07-18 17:51:21 -04002254 attrs->ia_size != i_size_read(inode))
2255 truncate_setsize(inode, attrs->ia_size);
Christoph Hellwig10257742010-06-04 11:30:02 +02002256
2257 setattr_copy(inode, attrs);
2258 mark_inode_dirty(inode);
2259
2260 /* force revalidate when any of these times are set since some
2261 of the fs types (eg ext3, fat) do not have fine enough
2262 time granularity to match protocol, and we do not have a
2263 a way (yet) to query the server fs's time granularity (and
2264 whether it rounds times down).
2265 */
2266 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2267 cifsInode->time = 0;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002268out:
2269 kfree(args);
2270 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002271 free_xid(xid);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002272 return rc;
2273}
2274
Jeff Layton0510eeb2008-08-02 07:26:12 -04002275static int
2276cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002277{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002278 unsigned int xid;
Eric W. Biederman8abf2772013-02-06 00:33:17 -08002279 kuid_t uid = INVALID_UID;
2280 kgid_t gid = INVALID_GID;
David Howells2b0143b2015-03-17 22:25:59 +00002281 struct inode *inode = d_inode(direntry);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002282 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002283 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002284 char *full_path = NULL;
2285 int rc = -EACCES;
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002286 __u32 dosattr = 0;
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04002287 __u64 mode = NO_CHANGE_64;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002288
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002289 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002290
Al Viro35c265e2014-08-19 20:25:34 -04002291 cifs_dbg(FYI, "setattr on file %pd attrs->iavalid 0x%x\n",
2292 direntry, attrs->ia_valid);
Steve French6473a552005-11-29 20:20:10 -08002293
Christoph Hellwigdb78b872010-06-04 11:30:03 +02002294 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2295 attrs->ia_valid |= ATTR_FORCE;
2296
Jan Kara31051c82016-05-26 16:55:18 +02002297 rc = setattr_prepare(direntry, attrs);
Christoph Hellwigdb78b872010-06-04 11:30:03 +02002298 if (rc < 0) {
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002299 free_xid(xid);
Christoph Hellwigdb78b872010-06-04 11:30:03 +02002300 return rc;
Steve French6473a552005-11-29 20:20:10 -08002301 }
Steve French50c2f752007-07-13 00:33:32 +00002302
Steve French7f573562005-08-30 11:32:14 -07002303 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002304 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302305 rc = -ENOMEM;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002306 free_xid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302307 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002308 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309
Jeff Layton0f4d6342009-03-26 13:35:37 -04002310 /*
2311 * Attempt to flush data before changing attributes. We need to do
2312 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2313 * ownership or mode then we may also need to do this. Here, we take
2314 * the safe way out and just do the flush on all setattr requests. If
2315 * the flush returns error, store it to report later and continue.
2316 *
2317 * BB: This should be smarter. Why bother flushing pages that
2318 * will be truncated anyway? Also, should we error out here if
2319 * the flush returns error?
2320 */
2321 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002322 mapping_set_error(inode->i_mapping, rc);
2323 rc = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +00002324
Steve French50531442008-03-14 19:21:31 +00002325 if (attrs->ia_valid & ATTR_SIZE) {
Jeff Layton8efdbde2008-07-23 21:28:12 +00002326 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2327 if (rc != 0)
Steve Frenche30dcf32005-09-20 20:49:16 -07002328 goto cifs_setattr_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329 }
Jeff Layton4ca691a2008-05-22 09:33:34 -04002330
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002331 if (attrs->ia_valid & ATTR_UID)
2332 uid = attrs->ia_uid;
2333
2334 if (attrs->ia_valid & ATTR_GID)
2335 gid = attrs->ia_gid;
2336
2337#ifdef CONFIG_CIFS_ACL
2338 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
Eric W. Biederman8abf2772013-02-06 00:33:17 -08002339 if (uid_valid(uid) || gid_valid(gid)) {
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002340 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2341 uid, gid);
2342 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002343 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2344 __func__, rc);
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002345 goto cifs_setattr_exit;
2346 }
2347 }
2348 } else
2349#endif /* CONFIG_CIFS_ACL */
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002350 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
Jeff Layton4ca691a2008-05-22 09:33:34 -04002351 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002352
Jeff Laytond32c4f22007-10-18 03:05:22 -07002353 /* skip mode change if it's just for clearing setuid/setgid */
2354 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2355 attrs->ia_valid &= ~ATTR_MODE;
2356
Linus Torvalds1da177e2005-04-16 15:20:36 -07002357 if (attrs->ia_valid & ATTR_MODE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002358 mode = attrs->ia_mode;
Steve Frenchcdbce9c2005-11-19 21:04:52 -08002359 rc = 0;
Jeff Layton79df1ba2010-12-06 12:52:08 -05002360#ifdef CONFIG_CIFS_ACL
Shirish Pargaonkar78415d22010-11-27 11:37:26 -06002361 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002362 rc = id_mode_to_cifs_acl(inode, full_path, mode,
Eric W. Biederman8abf2772013-02-06 00:33:17 -08002363 INVALID_UID, INVALID_GID);
Shirish Pargaonkar78415d22010-11-27 11:37:26 -06002364 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002365 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2366 __func__, rc);
Shirish Pargaonkar78415d22010-11-27 11:37:26 -06002367 goto cifs_setattr_exit;
2368 }
2369 } else
Jeff Layton79df1ba2010-12-06 12:52:08 -05002370#endif /* CONFIG_CIFS_ACL */
Jeff Layton51328612008-05-22 09:33:34 -04002371 if (((mode & S_IWUGO) == 0) &&
2372 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002373
2374 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2375
Jeff Layton51328612008-05-22 09:33:34 -04002376 /* fix up mode if we're not using dynperm */
2377 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2378 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2379 } else if ((mode & S_IWUGO) &&
2380 (cifsInode->cifsAttrs & ATTR_READONLY)) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002381
2382 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2383 /* Attributes of 0 are ignored */
2384 if (dosattr == 0)
2385 dosattr |= ATTR_NORMAL;
Jeff Layton51328612008-05-22 09:33:34 -04002386
2387 /* reset local inode permissions to normal */
2388 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2389 attrs->ia_mode &= ~(S_IALLUGO);
2390 if (S_ISDIR(inode->i_mode))
2391 attrs->ia_mode |=
2392 cifs_sb->mnt_dir_mode;
2393 else
2394 attrs->ia_mode |=
2395 cifs_sb->mnt_file_mode;
2396 }
2397 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2398 /* ignore mode change - ATTR_READONLY hasn't changed */
2399 attrs->ia_valid &= ~ATTR_MODE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002400 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002401 }
2402
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002403 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2404 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2405 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2406 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002407
Steve Frenche30dcf32005-09-20 20:49:16 -07002408 /* Even if error on time set, no sense failing the call if
2409 the server would set the time to a reasonable value anyway,
2410 and this check ensures that we are not being called from
2411 sys_utimes in which case we ought to fail the call back to
2412 the user when the server rejects the call */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002413 if ((rc) && (attrs->ia_valid &
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002414 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
Steve Frenche30dcf32005-09-20 20:49:16 -07002415 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002416 }
2417
2418 /* do not need local check to inode_check_ok since the server does
2419 that */
Christoph Hellwig10257742010-06-04 11:30:02 +02002420 if (rc)
2421 goto cifs_setattr_exit;
2422
2423 if ((attrs->ia_valid & ATTR_SIZE) &&
Christoph Hellwig1b947462010-07-18 17:51:21 -04002424 attrs->ia_size != i_size_read(inode))
2425 truncate_setsize(inode, attrs->ia_size);
Christoph Hellwig10257742010-06-04 11:30:02 +02002426
2427 setattr_copy(inode, attrs);
2428 mark_inode_dirty(inode);
Christoph Hellwig10257742010-06-04 11:30:02 +02002429
Steve Frenche30dcf32005-09-20 20:49:16 -07002430cifs_setattr_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002431 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002432 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002433 return rc;
2434}
2435
Jeff Layton0510eeb2008-08-02 07:26:12 -04002436int
2437cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2438{
Al Virofc640052016-04-10 01:33:30 -04002439 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
Steve French96daf2b2011-05-27 04:34:02 +00002440 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
Jeff Layton0510eeb2008-08-02 07:26:12 -04002441
2442 if (pTcon->unix_ext)
2443 return cifs_setattr_unix(direntry, attrs);
2444
2445 return cifs_setattr_nounix(direntry, attrs);
2446
2447 /* BB: add cifs_setattr_legacy for really old servers */
2448}
2449
Steve French99ee4db2007-02-27 05:35:17 +00002450#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07002451void cifs_delete_inode(struct inode *inode)
2452{
Joe Perchesf96637b2013-05-04 22:12:25 -05002453 cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002454 /* may have to add back in if and when safe distributed caching of
2455 directories added e.g. via FindNotify */
2456}
Steve French99ee4db2007-02-27 05:35:17 +00002457#endif