blob: 6b66dd5d15408676ab6510f7ce415164fe5c0571 [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 <
Christoph Hellwig70eff552008-02-15 20:55:05 +000062 PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
63 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);
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500817 } else
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400818 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
Steve Frenchb9a32602008-05-20 21:52:32 +0000819
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400820 /* query for SFU type info if supported and needed */
821 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
822 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
823 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
824 if (tmprc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500825 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
Steve Frenchb9a32602008-05-20 21:52:32 +0000826 }
Steve Frenchb9a32602008-05-20 21:52:32 +0000827
Jeff Layton79df1ba2010-12-06 12:52:08 -0500828#ifdef CONFIG_CIFS_ACL
Steve Frenchb9a32602008-05-20 21:52:32 +0000829 /* fill in 0777 bits from ACL */
830 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400831 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, full_path, fid);
Shirish Pargaonkar78415d22010-11-27 11:37:26 -0600832 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500833 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
834 __func__, rc);
Shirish Pargaonkar78415d22010-11-27 11:37:26 -0600835 goto cgii_exit;
836 }
Steve Frenchb9a32602008-05-20 21:52:32 +0000837 }
Jeff Layton79df1ba2010-12-06 12:52:08 -0500838#endif /* CONFIG_CIFS_ACL */
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400839
840 /* fill in remaining high mode bits e.g. SUID, VTX */
841 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
842 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
843
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200844 /* check for Minshall+French symlinks */
845 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
Sachin Prabhucb084b12013-11-25 17:09:50 +0000846 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
847 full_path);
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200848 if (tmprc)
Sachin Prabhucb084b12013-11-25 17:09:50 +0000849 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200850 }
851
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400852 if (!*inode) {
853 *inode = cifs_iget(sb, &fattr);
854 if (!*inode)
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400855 rc = -ENOMEM;
856 } else {
Nakajima Akira7196ac12015-04-22 15:24:44 +0900857 /* we already have inode, update it */
858
859 /* if filetype is different, return error */
860 if (unlikely(((*inode)->i_mode & S_IFMT) !=
861 (fattr.cf_mode & S_IFMT))) {
862 rc = -ESTALE;
863 goto cgii_exit;
864 }
865
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400866 cifs_fattr_to_inode(*inode, &fattr);
Steve Frenchb9a32602008-05-20 21:52:32 +0000867 }
868
Igor Mammedov79626702008-03-09 03:44:18 +0000869cgii_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 kfree(buf);
Jeff Layton7ffec372010-09-29 19:51:11 -0400871 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 return rc;
873}
874
Steve French7f8ed422007-09-28 22:28:55 +0000875static const struct inode_operations cifs_ipc_inode_ops = {
876 .lookup = cifs_lookup,
877};
878
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400879static int
880cifs_find_inode(struct inode *inode, void *opaque)
881{
882 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
883
Jeff Laytonf30b9c12010-07-19 18:00:17 -0400884 /* don't match inode with different uniqueid */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400885 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
886 return 0;
887
Jeff Layton20054bd2011-01-07 11:30:27 -0500888 /* use createtime like an i_generation field */
889 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
890 return 0;
891
Jeff Laytonf30b9c12010-07-19 18:00:17 -0400892 /* don't match inode of different type */
893 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
894 return 0;
895
Jeff Layton5acfec22010-08-02 17:43:54 -0400896 /* if it's not a directory or has no dentries, then flag it */
Al Virob3d9b7a2012-06-09 13:51:19 -0400897 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
Jeff Layton3d694382010-05-11 14:59:55 -0400898 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
Jeff Layton3d694382010-05-11 14:59:55 -0400899
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400900 return 1;
901}
902
903static int
904cifs_init_inode(struct inode *inode, void *opaque)
905{
906 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
907
908 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
Jeff Layton20054bd2011-01-07 11:30:27 -0500909 CIFS_I(inode)->createtime = fattr->cf_createtime;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400910 return 0;
911}
912
Jeff Layton5acfec22010-08-02 17:43:54 -0400913/*
914 * walk dentry list for an inode and report whether it has aliases that
915 * are hashed. We use this to determine if a directory inode can actually
916 * be used.
917 */
918static bool
919inode_has_hashed_dentries(struct inode *inode)
920{
921 struct dentry *dentry;
922
Nick Piggin873feea2011-01-07 17:50:06 +1100923 spin_lock(&inode->i_lock);
Al Viro946e51f2014-10-26 19:19:16 -0400924 hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
Jeff Layton5acfec22010-08-02 17:43:54 -0400925 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
Nick Piggin873feea2011-01-07 17:50:06 +1100926 spin_unlock(&inode->i_lock);
Jeff Layton5acfec22010-08-02 17:43:54 -0400927 return true;
928 }
929 }
Nick Piggin873feea2011-01-07 17:50:06 +1100930 spin_unlock(&inode->i_lock);
Jeff Layton5acfec22010-08-02 17:43:54 -0400931 return false;
932}
933
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400934/* Given fattrs, get a corresponding inode */
935struct inode *
936cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
937{
938 unsigned long hash;
939 struct inode *inode;
940
Jeff Layton3d694382010-05-11 14:59:55 -0400941retry_iget5_locked:
Joe Perchesf96637b2013-05-04 22:12:25 -0500942 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400943
944 /* hash down to 32-bits on 32-bit arch */
945 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
946
947 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400948 if (inode) {
Jeff Layton5acfec22010-08-02 17:43:54 -0400949 /* was there a potentially problematic inode collision? */
Jeff Layton3d694382010-05-11 14:59:55 -0400950 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
Jeff Layton3d694382010-05-11 14:59:55 -0400951 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
Jeff Layton5acfec22010-08-02 17:43:54 -0400952
953 if (inode_has_hashed_dentries(inode)) {
954 cifs_autodisable_serverino(CIFS_SB(sb));
955 iput(inode);
956 fattr->cf_uniqueid = iunique(sb, ROOT_I);
957 goto retry_iget5_locked;
958 }
Jeff Layton3d694382010-05-11 14:59:55 -0400959 }
960
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400961 cifs_fattr_to_inode(inode, fattr);
962 if (sb->s_flags & MS_NOATIME)
963 inode->i_flags |= S_NOATIME | S_NOCMTIME;
964 if (inode->i_state & I_NEW) {
965 inode->i_ino = hash;
Steve French0ccd4802010-07-16 04:31:02 +0000966#ifdef CONFIG_CIFS_FSCACHE
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530967 /* initialize per-inode cache cookie pointer */
968 CIFS_I(inode)->fscache = NULL;
Steve French0ccd4802010-07-16 04:31:02 +0000969#endif
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400970 unlock_new_inode(inode);
971 }
972 }
973
974 return inode;
975}
976
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977/* gets root inode */
Shirish Pargaonkar9b6763e2011-02-21 23:56:59 -0600978struct inode *cifs_root_iget(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400980 unsigned int xid;
Jeff Layton0d424ad2010-09-20 16:01:35 -0700981 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400982 struct inode *inode = NULL;
David Howellsce634ab2008-02-07 00:15:33 -0800983 long rc;
Steve French96daf2b2011-05-27 04:34:02 +0000984 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
David Howellsce634ab2008-02-07 00:15:33 -0800985
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400986 xid = get_xid();
Steve Frenchb5b374ea2014-10-06 01:01:03 -0500987 if (tcon->unix_ext) {
Steve Frenchf87d39d2011-05-27 03:50:55 +0000988 rc = cifs_get_inode_info_unix(&inode, "", sb, xid);
Steve Frenchb5b374ea2014-10-06 01:01:03 -0500989 /* some servers mistakenly claim POSIX support */
990 if (rc != -EOPNOTSUPP)
991 goto iget_no_retry;
992 cifs_dbg(VFS, "server does not support POSIX extensions");
993 tcon->unix_ext = false;
994 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400995
Steve Frenchb5b374ea2014-10-06 01:01:03 -0500996 rc = cifs_get_inode_info(&inode, "", NULL, sb, xid, NULL);
997
998iget_no_retry:
Oskar Schirmera7851ce2010-11-10 21:06:13 +0000999 if (!inode) {
1000 inode = ERR_PTR(rc);
1001 goto out;
1002 }
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001003
Steve French0ccd4802010-07-16 04:31:02 +00001004#ifdef CONFIG_CIFS_FSCACHE
Suresh Jayaramand03382c2010-07-05 18:12:27 +05301005 /* populate tcon->resource_id */
Jeff Layton0d424ad2010-09-20 16:01:35 -07001006 tcon->resource_id = CIFS_I(inode)->uniqueid;
Steve French0ccd4802010-07-16 04:31:02 +00001007#endif
Suresh Jayaramand03382c2010-07-05 18:12:27 +05301008
Jeff Layton0d424ad2010-09-20 16:01:35 -07001009 if (rc && tcon->ipc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001010 cifs_dbg(FYI, "ipc connection - fake read inode\n");
Steve Frenchb7ca6922012-08-03 08:43:01 -05001011 spin_lock(&inode->i_lock);
Steve French7f8ed422007-09-28 22:28:55 +00001012 inode->i_mode |= S_IFDIR;
Miklos Szeredibfe86842011-10-28 14:13:29 +02001013 set_nlink(inode, 2);
Steve French7f8ed422007-09-28 22:28:55 +00001014 inode->i_op = &cifs_ipc_inode_ops;
1015 inode->i_fop = &simple_dir_operations;
1016 inode->i_uid = cifs_sb->mnt_uid;
1017 inode->i_gid = cifs_sb->mnt_gid;
Steve Frenchb7ca6922012-08-03 08:43:01 -05001018 spin_unlock(&inode->i_lock);
Steve Frenchad661332008-08-12 14:14:40 +00001019 } else if (rc) {
David Howellsce634ab2008-02-07 00:15:33 -08001020 iget_failed(inode);
Oskar Schirmera7851ce2010-11-10 21:06:13 +00001021 inode = ERR_PTR(rc);
Steve French7f8ed422007-09-28 22:28:55 +00001022 }
1023
Oskar Schirmera7851ce2010-11-10 21:06:13 +00001024out:
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001025 /* can not call macro free_xid here since in a void func
David Howellsce634ab2008-02-07 00:15:33 -08001026 * TODO: This is no longer true
1027 */
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001028 _free_xid(xid);
David Howellsce634ab2008-02-07 00:15:33 -08001029 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030}
1031
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001032int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001033cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001034 char *full_path, __u32 dosattr)
Steve French388e57b2008-09-16 23:50:58 +00001035{
Steve French388e57b2008-09-16 23:50:58 +00001036 bool set_time = false;
Steve French388e57b2008-09-16 23:50:58 +00001037 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Pavel Shilovsky6bdf6db2012-09-18 16:20:32 -07001038 struct TCP_Server_Info *server;
Steve French388e57b2008-09-16 23:50:58 +00001039 FILE_BASIC_INFO info_buf;
1040
Steve French1adcb712009-02-25 14:19:56 +00001041 if (attrs == NULL)
1042 return -EINVAL;
1043
Pavel Shilovsky6bdf6db2012-09-18 16:20:32 -07001044 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1045 if (!server->ops->set_file_info)
1046 return -ENOSYS;
1047
Steve French388e57b2008-09-16 23:50:58 +00001048 if (attrs->ia_valid & ATTR_ATIME) {
1049 set_time = true;
1050 info_buf.LastAccessTime =
1051 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1052 } else
1053 info_buf.LastAccessTime = 0;
1054
1055 if (attrs->ia_valid & ATTR_MTIME) {
1056 set_time = true;
1057 info_buf.LastWriteTime =
1058 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1059 } else
1060 info_buf.LastWriteTime = 0;
1061
1062 /*
1063 * Samba throws this field away, but windows may actually use it.
1064 * Do not set ctime unless other time stamps are changed explicitly
1065 * (i.e. by utimes()) since we would then have a mix of client and
1066 * server times.
1067 */
1068 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001069 cifs_dbg(FYI, "CIFS - CTIME changed\n");
Steve French388e57b2008-09-16 23:50:58 +00001070 info_buf.ChangeTime =
1071 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1072 } else
1073 info_buf.ChangeTime = 0;
1074
1075 info_buf.CreationTime = 0; /* don't change */
1076 info_buf.Attributes = cpu_to_le32(dosattr);
1077
Pavel Shilovsky6bdf6db2012-09-18 16:20:32 -07001078 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
Steve French388e57b2008-09-16 23:50:58 +00001079}
1080
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001081/*
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001082 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001083 * and rename it to a random name that hopefully won't conflict with
1084 * anything else.
1085 */
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001086int
1087cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1088 const unsigned int xid)
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001089{
1090 int oplock = 0;
1091 int rc;
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001092 struct cifs_fid fid;
1093 struct cifs_open_parms oparms;
David Howells2b0143b2015-03-17 22:25:59 +00001094 struct inode *inode = d_inode(dentry);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001095 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1096 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001097 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001098 struct cifs_tcon *tcon;
Steve French32709582008-10-20 00:44:19 +00001099 __u32 dosattr, origattr;
1100 FILE_BASIC_INFO *info_buf = NULL;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001101
Jeff Layton7ffec372010-09-29 19:51:11 -04001102 tlink = cifs_sb_tlink(cifs_sb);
1103 if (IS_ERR(tlink))
1104 return PTR_ERR(tlink);
1105 tcon = tlink_tcon(tlink);
1106
Sachin Prabhuc483a982013-03-05 19:25:56 +00001107 /*
1108 * We cannot rename the file if the server doesn't support
1109 * CAP_INFOLEVEL_PASSTHRU
1110 */
1111 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1112 rc = -EBUSY;
1113 goto out;
1114 }
1115
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001116 oparms.tcon = tcon;
1117 oparms.cifs_sb = cifs_sb;
1118 oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1119 oparms.create_options = CREATE_NOT_DIR;
1120 oparms.disposition = FILE_OPEN;
1121 oparms.path = full_path;
1122 oparms.fid = &fid;
1123 oparms.reconnect = false;
1124
1125 rc = CIFS_open(xid, &oparms, &oplock, NULL);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001126 if (rc != 0)
1127 goto out;
1128
Steve French32709582008-10-20 00:44:19 +00001129 origattr = cifsInode->cifsAttrs;
1130 if (origattr == 0)
1131 origattr |= ATTR_NORMAL;
1132
1133 dosattr = origattr & ~ATTR_READONLY;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001134 if (dosattr == 0)
1135 dosattr |= ATTR_NORMAL;
1136 dosattr |= ATTR_HIDDEN;
1137
Steve French32709582008-10-20 00:44:19 +00001138 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1139 if (dosattr != origattr) {
1140 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1141 if (info_buf == NULL) {
1142 rc = -ENOMEM;
1143 goto out_close;
1144 }
1145 info_buf->Attributes = cpu_to_le32(dosattr);
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001146 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
Steve French32709582008-10-20 00:44:19 +00001147 current->tgid);
1148 /* although we would like to mark the file hidden
1149 if that fails we will still try to rename it */
Sachin Prabhu72d282d2013-03-05 19:25:55 +00001150 if (!rc)
Steve French32709582008-10-20 00:44:19 +00001151 cifsInode->cifsAttrs = dosattr;
1152 else
1153 dosattr = origattr; /* since not able to change them */
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001154 }
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001155
Jeff Laytondd1db2d2008-10-16 19:27:12 -04001156 /* rename the file */
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001157 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1158 cifs_sb->local_nls,
Steve French2baa2682014-09-27 02:19:01 -05001159 cifs_remap(cifs_sb));
Steve French32709582008-10-20 00:44:19 +00001160 if (rc != 0) {
Sachin Prabhu47c78f42013-03-11 13:08:49 +00001161 rc = -EBUSY;
Steve French32709582008-10-20 00:44:19 +00001162 goto undo_setattr;
1163 }
Jeff Layton6d22f092008-09-23 11:48:35 -04001164
Steve French32709582008-10-20 00:44:19 +00001165 /* try to set DELETE_ON_CLOSE */
Jeff Laytonaff8d5c2014-04-30 09:31:45 -04001166 if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001167 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
Steve French32709582008-10-20 00:44:19 +00001168 current->tgid);
1169 /*
1170 * some samba versions return -ENOENT when we try to set the
1171 * file disposition here. Likely a samba bug, but work around
1172 * it for now. This means that some cifsXXX files may hang
1173 * around after they shouldn't.
1174 *
1175 * BB: remove this hack after more servers have the fix
1176 */
1177 if (rc == -ENOENT)
1178 rc = 0;
1179 else if (rc != 0) {
Sachin Prabhu47c78f42013-03-11 13:08:49 +00001180 rc = -EBUSY;
Steve French32709582008-10-20 00:44:19 +00001181 goto undo_rename;
1182 }
Jeff Laytonaff8d5c2014-04-30 09:31:45 -04001183 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
Steve French32709582008-10-20 00:44:19 +00001184 }
Jeff Layton7ce86d52008-09-24 11:32:59 -04001185
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001186out_close:
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001187 CIFSSMBClose(xid, tcon, fid.netfid);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001188out:
Steve French32709582008-10-20 00:44:19 +00001189 kfree(info_buf);
Jeff Layton7ffec372010-09-29 19:51:11 -04001190 cifs_put_tlink(tlink);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001191 return rc;
Steve French32709582008-10-20 00:44:19 +00001192
1193 /*
1194 * reset everything back to the original state. Don't bother
1195 * dealing with errors here since we can't do anything about
1196 * them anyway.
1197 */
1198undo_rename:
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001199 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
Steve French2baa2682014-09-27 02:19:01 -05001200 cifs_sb->local_nls, cifs_remap(cifs_sb));
Steve French32709582008-10-20 00:44:19 +00001201undo_setattr:
1202 if (dosattr != origattr) {
1203 info_buf->Attributes = cpu_to_le32(origattr);
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001204 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
Steve French32709582008-10-20 00:44:19 +00001205 current->tgid))
1206 cifsInode->cifsAttrs = origattr;
1207 }
1208
1209 goto out_close;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001210}
1211
Steve Frenchb7ca6922012-08-03 08:43:01 -05001212/* copied from fs/nfs/dir.c with small changes */
1213static void
1214cifs_drop_nlink(struct inode *inode)
1215{
1216 spin_lock(&inode->i_lock);
1217 if (inode->i_nlink > 0)
1218 drop_nlink(inode);
1219 spin_unlock(&inode->i_lock);
1220}
Steve Frenchff694522009-04-20 19:45:13 +00001221
1222/*
David Howells2b0143b2015-03-17 22:25:59 +00001223 * If d_inode(dentry) is null (usually meaning the cached dentry
Steve Frenchff694522009-04-20 19:45:13 +00001224 * is a negative dentry) then we would attempt a standard SMB delete, but
André Goddard Rosaaf901ca2009-11-14 13:09:05 -02001225 * if that fails we can not attempt the fall back mechanisms on EACCESS
1226 * but will return the EACCESS to the caller. Note that the VFS does not call
Steve Frenchff694522009-04-20 19:45:13 +00001227 * unlink on negative dentries currently.
1228 */
Jeff Layton5f0319a2008-09-16 14:05:16 -04001229int cifs_unlink(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230{
1231 int rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001232 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 char *full_path = NULL;
David Howells2b0143b2015-03-17 22:25:59 +00001234 struct inode *inode = d_inode(dentry);
Steve Frenchff694522009-04-20 19:45:13 +00001235 struct cifsInodeInfo *cifs_inode;
Jeff Layton5f0319a2008-09-16 14:05:16 -04001236 struct super_block *sb = dir->i_sb;
1237 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001238 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001239 struct cifs_tcon *tcon;
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001240 struct TCP_Server_Info *server;
Steve French60502472008-10-07 18:42:52 +00001241 struct iattr *attrs = NULL;
1242 __u32 dosattr = 0, origattr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243
Joe Perchesf96637b2013-05-04 22:12:25 -05001244 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245
Jeff Layton7ffec372010-09-29 19:51:11 -04001246 tlink = cifs_sb_tlink(cifs_sb);
1247 if (IS_ERR(tlink))
1248 return PTR_ERR(tlink);
1249 tcon = tlink_tcon(tlink);
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001250 server = tcon->ses->server;
Jeff Layton7ffec372010-09-29 19:51:11 -04001251
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001252 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253
Jeff Layton5f0319a2008-09-16 14:05:16 -04001254 /* Unlink can be called from rename so we can not take the
1255 * sb->s_vfs_rename_mutex here */
1256 full_path = build_path_from_dentry(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301258 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001259 goto unlink_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 }
Steve French2d785a52007-07-15 01:48:57 +00001261
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001262 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1263 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001264 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
Steve French2d785a52007-07-15 01:48:57 +00001265 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
Steve French2baa2682014-09-27 02:19:01 -05001266 cifs_remap(cifs_sb));
Joe Perchesf96637b2013-05-04 22:12:25 -05001267 cifs_dbg(FYI, "posix del rc %d\n", rc);
Steve French2d785a52007-07-15 01:48:57 +00001268 if ((rc == 0) || (rc == -ENOENT))
1269 goto psx_del_no_retry;
1270 }
1271
Steve French60502472008-10-07 18:42:52 +00001272retry_std_delete:
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001273 if (!server->ops->unlink) {
1274 rc = -ENOSYS;
1275 goto psx_del_no_retry;
1276 }
1277
1278 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
Steve French60502472008-10-07 18:42:52 +00001279
Steve French2d785a52007-07-15 01:48:57 +00001280psx_del_no_retry:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 if (!rc) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001282 if (inode)
Steve Frenchb7ca6922012-08-03 08:43:01 -05001283 cifs_drop_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 } else if (rc == -ENOENT) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001285 d_drop(dentry);
Sachin Prabhu47c78f42013-03-11 13:08:49 +00001286 } else if (rc == -EBUSY) {
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001287 if (server->ops->rename_pending_delete) {
1288 rc = server->ops->rename_pending_delete(full_path,
1289 dentry, xid);
1290 if (rc == 0)
1291 cifs_drop_nlink(inode);
1292 }
Steve Frenchff694522009-04-20 19:45:13 +00001293 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
Steve French388e57b2008-09-16 23:50:58 +00001294 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1295 if (attrs == NULL) {
1296 rc = -ENOMEM;
1297 goto out_reval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 }
Steve French388e57b2008-09-16 23:50:58 +00001299
1300 /* try to reset dos attributes */
Steve Frenchff694522009-04-20 19:45:13 +00001301 cifs_inode = CIFS_I(inode);
1302 origattr = cifs_inode->cifsAttrs;
Steve French60502472008-10-07 18:42:52 +00001303 if (origattr == 0)
1304 origattr |= ATTR_NORMAL;
1305 dosattr = origattr & ~ATTR_READONLY;
Steve French388e57b2008-09-16 23:50:58 +00001306 if (dosattr == 0)
1307 dosattr |= ATTR_NORMAL;
1308 dosattr |= ATTR_HIDDEN;
1309
1310 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
Steve French388e57b2008-09-16 23:50:58 +00001311 if (rc != 0)
1312 goto out_reval;
Steve French60502472008-10-07 18:42:52 +00001313
1314 goto retry_std_delete;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 }
Steve French60502472008-10-07 18:42:52 +00001316
1317 /* undo the setattr if we errored out and it's needed */
1318 if (rc != 0 && dosattr != 0)
1319 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1320
Steve French388e57b2008-09-16 23:50:58 +00001321out_reval:
Jeff Layton5f0319a2008-09-16 14:05:16 -04001322 if (inode) {
Steve Frenchff694522009-04-20 19:45:13 +00001323 cifs_inode = CIFS_I(inode);
1324 cifs_inode->time = 0; /* will force revalidate to get info
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001325 when needed */
Jeff Layton5f0319a2008-09-16 14:05:16 -04001326 inode->i_ctime = current_fs_time(sb);
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001327 }
Jeff Layton5f0319a2008-09-16 14:05:16 -04001328 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
Steve Frenchff694522009-04-20 19:45:13 +00001329 cifs_inode = CIFS_I(dir);
Steve French60502472008-10-07 18:42:52 +00001330 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
Jeff Layton7ffec372010-09-29 19:51:11 -04001331unlink_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 kfree(full_path);
Steve French60502472008-10-07 18:42:52 +00001333 kfree(attrs);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001334 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001335 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 return rc;
1337}
1338
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001339static int
Jeff Layton101b92d2012-09-19 06:22:45 -07001340cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001341 const char *full_path, struct cifs_sb_info *cifs_sb,
1342 struct cifs_tcon *tcon, const unsigned int xid)
1343{
1344 int rc = 0;
Jeff Layton101b92d2012-09-19 06:22:45 -07001345 struct inode *inode = NULL;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001346
1347 if (tcon->unix_ext)
Jeff Layton101b92d2012-09-19 06:22:45 -07001348 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001349 xid);
1350 else
Jeff Layton101b92d2012-09-19 06:22:45 -07001351 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1352 xid, NULL);
1353
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001354 if (rc)
1355 return rc;
1356
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001357 /*
1358 * setting nlink not necessary except in cases where we failed to get it
Jeff Layton101b92d2012-09-19 06:22:45 -07001359 * from the server or was set bogus. Also, since this is a brand new
1360 * inode, no need to grab the i_lock before setting the i_nlink.
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001361 */
Jeff Layton101b92d2012-09-19 06:22:45 -07001362 if (inode->i_nlink < 2)
1363 set_nlink(inode, 2);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001364 mode &= ~current_umask();
1365 /* must turn on setgid bit if parent dir has it */
Jeff Layton101b92d2012-09-19 06:22:45 -07001366 if (parent->i_mode & S_ISGID)
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001367 mode |= S_ISGID;
1368
1369 if (tcon->unix_ext) {
1370 struct cifs_unix_set_info_args args = {
1371 .mode = mode,
1372 .ctime = NO_CHANGE_64,
1373 .atime = NO_CHANGE_64,
1374 .mtime = NO_CHANGE_64,
1375 .device = 0,
1376 };
1377 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
Eric W. Biederman49418b22013-02-06 00:57:56 -08001378 args.uid = current_fsuid();
Jeff Layton101b92d2012-09-19 06:22:45 -07001379 if (parent->i_mode & S_ISGID)
Eric W. Biederman49418b22013-02-06 00:57:56 -08001380 args.gid = parent->i_gid;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001381 else
Eric W. Biederman49418b22013-02-06 00:57:56 -08001382 args.gid = current_fsgid();
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001383 } else {
Eric W. Biederman49418b22013-02-06 00:57:56 -08001384 args.uid = INVALID_UID; /* no change */
1385 args.gid = INVALID_GID; /* no change */
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001386 }
1387 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1388 cifs_sb->local_nls,
Steve French2baa2682014-09-27 02:19:01 -05001389 cifs_remap(cifs_sb));
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001390 } else {
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001391 struct TCP_Server_Info *server = tcon->ses->server;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001392 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001393 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
Jeff Layton101b92d2012-09-19 06:22:45 -07001394 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001395 tcon, xid);
Jeff Layton101b92d2012-09-19 06:22:45 -07001396 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1397 inode->i_mode = (mode | S_IFDIR);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001398
Jeff Layton101b92d2012-09-19 06:22:45 -07001399 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1400 inode->i_uid = current_fsuid();
1401 if (inode->i_mode & S_ISGID)
1402 inode->i_gid = parent->i_gid;
1403 else
1404 inode->i_gid = current_fsgid();
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001405 }
1406 }
Jeff Layton101b92d2012-09-19 06:22:45 -07001407 d_instantiate(dentry, inode);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001408 return rc;
1409}
1410
1411static int
1412cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1413 const char *full_path, struct cifs_sb_info *cifs_sb,
1414 struct cifs_tcon *tcon, const unsigned int xid)
1415{
1416 int rc = 0;
1417 u32 oplock = 0;
1418 FILE_UNIX_BASIC_INFO *info = NULL;
1419 struct inode *newinode = NULL;
1420 struct cifs_fattr fattr;
1421
1422 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1423 if (info == NULL) {
1424 rc = -ENOMEM;
1425 goto posix_mkdir_out;
1426 }
1427
1428 mode &= ~current_umask();
1429 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1430 NULL /* netfid */, info, &oplock, full_path,
Steve French2baa2682014-09-27 02:19:01 -05001431 cifs_sb->local_nls, cifs_remap(cifs_sb));
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001432 if (rc == -EOPNOTSUPP)
1433 goto posix_mkdir_out;
1434 else if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001435 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001436 d_drop(dentry);
1437 goto posix_mkdir_out;
1438 }
1439
1440 if (info->Type == cpu_to_le32(-1))
1441 /* no return info, go query for it */
1442 goto posix_mkdir_get_info;
1443 /*
1444 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1445 * need to set uid/gid.
1446 */
1447
1448 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1449 cifs_fill_uniqueid(inode->i_sb, &fattr);
1450 newinode = cifs_iget(inode->i_sb, &fattr);
1451 if (!newinode)
1452 goto posix_mkdir_get_info;
1453
1454 d_instantiate(dentry, newinode);
1455
1456#ifdef CONFIG_CIFS_DEBUG2
Al Viro35c265e2014-08-19 20:25:34 -04001457 cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1458 dentry, dentry, newinode);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001459
1460 if (newinode->i_nlink != 2)
Joe Perchesf96637b2013-05-04 22:12:25 -05001461 cifs_dbg(FYI, "unexpected number of links %d\n",
1462 newinode->i_nlink);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001463#endif
1464
1465posix_mkdir_out:
1466 kfree(info);
1467 return rc;
1468posix_mkdir_get_info:
1469 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1470 xid);
1471 goto posix_mkdir_out;
1472}
1473
Al Viro18bb1db2011-07-26 01:41:39 -04001474int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475{
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001476 int rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001477 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001479 struct tcon_link *tlink;
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001480 struct cifs_tcon *tcon;
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001481 struct TCP_Server_Info *server;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001482 char *full_path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483
Joe Perchesf96637b2013-05-04 22:12:25 -05001484 cifs_dbg(FYI, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1485 mode, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001488 tlink = cifs_sb_tlink(cifs_sb);
1489 if (IS_ERR(tlink))
1490 return PTR_ERR(tlink);
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001491 tcon = tlink_tcon(tlink);
Jeff Layton7ffec372010-09-29 19:51:11 -04001492
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001493 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494
Steve French7f573562005-08-30 11:32:14 -07001495 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301497 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001498 goto mkdir_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499 }
Steve French50c2f752007-07-13 00:33:32 +00001500
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001501 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1502 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001503 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1504 tcon, xid);
1505 if (rc != -EOPNOTSUPP)
Steve French2dd29d32007-04-23 22:07:35 +00001506 goto mkdir_out;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001507 }
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001508
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001509 server = tcon->ses->server;
1510
1511 if (!server->ops->mkdir) {
1512 rc = -ENOSYS;
1513 goto mkdir_out;
1514 }
1515
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 /* BB add setting the equivalent of mode via CreateX w/ACLs */
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001517 rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001519 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520 d_drop(direntry);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001521 goto mkdir_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 }
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001523
1524 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1525 xid);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001526mkdir_out:
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +03001527 /*
1528 * Force revalidate to get parent dir info when needed since cached
1529 * attributes are invalid now.
1530 */
1531 CIFS_I(inode)->time = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001533 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001534 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535 return rc;
1536}
1537
1538int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1539{
1540 int rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001541 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001543 struct tcon_link *tlink;
Pavel Shilovskyf958ca52012-07-10 16:14:18 +04001544 struct cifs_tcon *tcon;
1545 struct TCP_Server_Info *server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546 char *full_path = NULL;
1547 struct cifsInodeInfo *cifsInode;
1548
Joe Perchesf96637b2013-05-04 22:12:25 -05001549 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001551 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552
Steve French7f573562005-08-30 11:32:14 -07001553 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301555 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001556 goto rmdir_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557 }
1558
Jeff Layton7ffec372010-09-29 19:51:11 -04001559 cifs_sb = CIFS_SB(inode->i_sb);
1560 tlink = cifs_sb_tlink(cifs_sb);
1561 if (IS_ERR(tlink)) {
1562 rc = PTR_ERR(tlink);
1563 goto rmdir_exit;
1564 }
Pavel Shilovskyf958ca52012-07-10 16:14:18 +04001565 tcon = tlink_tcon(tlink);
1566 server = tcon->ses->server;
Jeff Layton7ffec372010-09-29 19:51:11 -04001567
Pavel Shilovskyf958ca52012-07-10 16:14:18 +04001568 if (!server->ops->rmdir) {
1569 rc = -ENOSYS;
1570 cifs_put_tlink(tlink);
1571 goto rmdir_exit;
1572 }
1573
1574 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001575 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576
1577 if (!rc) {
David Howells2b0143b2015-03-17 22:25:59 +00001578 spin_lock(&d_inode(direntry)->i_lock);
1579 i_size_write(d_inode(direntry), 0);
1580 clear_nlink(d_inode(direntry));
1581 spin_unlock(&d_inode(direntry)->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 }
1583
David Howells2b0143b2015-03-17 22:25:59 +00001584 cifsInode = CIFS_I(d_inode(direntry));
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +03001585 /* force revalidate to go get info when needed */
1586 cifsInode->time = 0;
Steve French42c24542009-01-13 22:03:55 +00001587
1588 cifsInode = CIFS_I(inode);
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +03001589 /*
1590 * Force revalidate to get parent dir info when needed since cached
1591 * attributes are invalid now.
1592 */
1593 cifsInode->time = 0;
Steve French42c24542009-01-13 22:03:55 +00001594
David Howells2b0143b2015-03-17 22:25:59 +00001595 d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596 current_fs_time(inode->i_sb);
1597
Jeff Layton7ffec372010-09-29 19:51:11 -04001598rmdir_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001600 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601 return rc;
1602}
1603
Steve Frenchee2fd962008-09-23 18:23:33 +00001604static int
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001605cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1606 const char *from_path, struct dentry *to_dentry,
1607 const char *to_path)
Steve Frenchee2fd962008-09-23 18:23:33 +00001608{
1609 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001610 struct tcon_link *tlink;
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001611 struct cifs_tcon *tcon;
1612 struct TCP_Server_Info *server;
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001613 struct cifs_fid fid;
1614 struct cifs_open_parms oparms;
Steve Frenchee2fd962008-09-23 18:23:33 +00001615 int oplock, rc;
1616
Jeff Layton7ffec372010-09-29 19:51:11 -04001617 tlink = cifs_sb_tlink(cifs_sb);
1618 if (IS_ERR(tlink))
1619 return PTR_ERR(tlink);
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001620 tcon = tlink_tcon(tlink);
1621 server = tcon->ses->server;
1622
1623 if (!server->ops->rename)
1624 return -ENOSYS;
Jeff Layton7ffec372010-09-29 19:51:11 -04001625
Steve Frenchee2fd962008-09-23 18:23:33 +00001626 /* try path-based rename first */
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001627 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
Steve Frenchee2fd962008-09-23 18:23:33 +00001628
1629 /*
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001630 * Don't bother with rename by filehandle unless file is busy and
1631 * source. Note that cross directory moves do not work with
Steve Frenchee2fd962008-09-23 18:23:33 +00001632 * rename by filehandle to various Windows servers.
1633 */
Sachin Prabhu47c78f42013-03-11 13:08:49 +00001634 if (rc == 0 || rc != -EBUSY)
Jeff Layton7ffec372010-09-29 19:51:11 -04001635 goto do_rename_exit;
Steve Frenchee2fd962008-09-23 18:23:33 +00001636
Jeff Laytoned0e3ac2010-06-01 16:21:01 -04001637 /* open-file renames don't work across directories */
1638 if (to_dentry->d_parent != from_dentry->d_parent)
Jeff Layton7ffec372010-09-29 19:51:11 -04001639 goto do_rename_exit;
Jeff Laytoned0e3ac2010-06-01 16:21:01 -04001640
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001641 oparms.tcon = tcon;
1642 oparms.cifs_sb = cifs_sb;
Steve Frenchee2fd962008-09-23 18:23:33 +00001643 /* open the file to be renamed -- we need DELETE perms */
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001644 oparms.desired_access = DELETE;
1645 oparms.create_options = CREATE_NOT_DIR;
1646 oparms.disposition = FILE_OPEN;
1647 oparms.path = from_path;
1648 oparms.fid = &fid;
1649 oparms.reconnect = false;
1650
1651 rc = CIFS_open(xid, &oparms, &oplock, NULL);
Steve Frenchee2fd962008-09-23 18:23:33 +00001652 if (rc == 0) {
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001653 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
Steve Frenchee2fd962008-09-23 18:23:33 +00001654 (const char *) to_dentry->d_name.name,
Steve French2baa2682014-09-27 02:19:01 -05001655 cifs_sb->local_nls, cifs_remap(cifs_sb));
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001656 CIFSSMBClose(xid, tcon, fid.netfid);
Steve Frenchee2fd962008-09-23 18:23:33 +00001657 }
Jeff Layton7ffec372010-09-29 19:51:11 -04001658do_rename_exit:
1659 cifs_put_tlink(tlink);
Steve Frenchee2fd962008-09-23 18:23:33 +00001660 return rc;
1661}
1662
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001663int
Miklos Szeredi7c33d592014-07-23 15:15:36 +02001664cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
1665 struct inode *target_dir, struct dentry *target_dentry,
1666 unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667{
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001668 char *from_name = NULL;
1669 char *to_name = NULL;
Jeff Layton639e7a92010-09-03 11:50:09 -04001670 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001671 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001672 struct cifs_tcon *tcon;
Steve Frenchee2fd962008-09-23 18:23:33 +00001673 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1674 FILE_UNIX_BASIC_INFO *info_buf_target;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001675 unsigned int xid;
1676 int rc, tmprc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677
Miklos Szeredi7c33d592014-07-23 15:15:36 +02001678 if (flags & ~RENAME_NOREPLACE)
1679 return -EINVAL;
1680
Jeff Layton639e7a92010-09-03 11:50:09 -04001681 cifs_sb = CIFS_SB(source_dir->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001682 tlink = cifs_sb_tlink(cifs_sb);
1683 if (IS_ERR(tlink))
1684 return PTR_ERR(tlink);
1685 tcon = tlink_tcon(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001687 xid = get_xid();
Steve Frenchee2fd962008-09-23 18:23:33 +00001688
1689 /*
Steve Frenchee2fd962008-09-23 18:23:33 +00001690 * we already have the rename sem so we do not need to
1691 * grab it again here to protect the path integrity
1692 */
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001693 from_name = build_path_from_dentry(source_dentry);
1694 if (from_name == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 rc = -ENOMEM;
1696 goto cifs_rename_exit;
1697 }
1698
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001699 to_name = build_path_from_dentry(target_dentry);
1700 if (to_name == NULL) {
Steve Frenchee2fd962008-09-23 18:23:33 +00001701 rc = -ENOMEM;
1702 goto cifs_rename_exit;
1703 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001705 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1706 to_name);
Steve Frenchee2fd962008-09-23 18:23:33 +00001707
Miklos Szeredi7c33d592014-07-23 15:15:36 +02001708 /*
1709 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1710 */
1711 if (flags & RENAME_NOREPLACE)
1712 goto cifs_rename_exit;
1713
Jeff Layton14121bd2008-10-20 14:45:22 -04001714 if (rc == -EEXIST && tcon->unix_ext) {
Steve Frenchee2fd962008-09-23 18:23:33 +00001715 /*
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001716 * Are src and dst hardlinks of same inode? We can only tell
1717 * with unix extensions enabled.
Steve Frenchee2fd962008-09-23 18:23:33 +00001718 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001719 info_buf_source =
1720 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1721 GFP_KERNEL);
1722 if (info_buf_source == NULL) {
1723 rc = -ENOMEM;
1724 goto cifs_rename_exit;
1725 }
1726
1727 info_buf_target = info_buf_source + 1;
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001728 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1729 info_buf_source,
1730 cifs_sb->local_nls,
Steve French2baa2682014-09-27 02:19:01 -05001731 cifs_remap(cifs_sb));
Jeff Layton8d281ef2008-10-22 13:57:01 -04001732 if (tmprc != 0)
Jeff Layton14121bd2008-10-20 14:45:22 -04001733 goto unlink_target;
1734
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001735 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1736 info_buf_target,
1737 cifs_sb->local_nls,
Steve French2baa2682014-09-27 02:19:01 -05001738 cifs_remap(cifs_sb));
Jeff Layton14121bd2008-10-20 14:45:22 -04001739
Jeff Layton8d281ef2008-10-22 13:57:01 -04001740 if (tmprc == 0 && (info_buf_source->UniqueId ==
Jeff Laytonae6884a2008-11-03 14:05:08 -05001741 info_buf_target->UniqueId)) {
Jeff Layton14121bd2008-10-20 14:45:22 -04001742 /* same file, POSIX says that this is a noop */
Jeff Laytonae6884a2008-11-03 14:05:08 -05001743 rc = 0;
Jeff Layton14121bd2008-10-20 14:45:22 -04001744 goto cifs_rename_exit;
Jeff Laytonae6884a2008-11-03 14:05:08 -05001745 }
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001746 }
1747 /*
1748 * else ... BB we could add the same check for Windows by
1749 * checking the UniqueId via FILE_INTERNAL_INFO
1750 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001751
Jeff Layton14121bd2008-10-20 14:45:22 -04001752unlink_target:
Jeff Laytonfc6f3942009-04-17 11:45:30 -04001753 /* Try unlinking the target dentry if it's not negative */
David Howells2b0143b2015-03-17 22:25:59 +00001754 if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
Pavel Shilovskya07d3222014-08-22 13:32:09 +04001755 if (d_is_dir(target_dentry))
1756 tmprc = cifs_rmdir(target_dir, target_dentry);
1757 else
1758 tmprc = cifs_unlink(target_dir, target_dentry);
Jeff Layton14121bd2008-10-20 14:45:22 -04001759 if (tmprc)
1760 goto cifs_rename_exit;
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001761 rc = cifs_do_rename(xid, source_dentry, from_name,
1762 target_dentry, to_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001763 }
1764
Pavel Shilovskyb46799a2014-08-18 20:49:58 +04001765 /* force revalidate to go get info when needed */
1766 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
1767
1768 source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
1769 target_dir->i_mtime = current_fs_time(source_dir->i_sb);
1770
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771cifs_rename_exit:
Steve Frenchee2fd962008-09-23 18:23:33 +00001772 kfree(info_buf_source);
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001773 kfree(from_name);
1774 kfree(to_name);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001775 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001776 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777 return rc;
1778}
1779
Jeff Laytondf2cf172010-02-12 07:44:16 -05001780static bool
1781cifs_inode_needs_reval(struct inode *inode)
1782{
1783 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301784 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Laytondf2cf172010-02-12 07:44:16 -05001785
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001786 if (CIFS_CACHE_READ(cifs_i))
Jeff Laytondf2cf172010-02-12 07:44:16 -05001787 return false;
1788
1789 if (!lookupCacheEnabled)
1790 return true;
1791
1792 if (cifs_i->time == 0)
1793 return true;
1794
Jeff Laytona87c9ad2014-03-26 07:24:23 -07001795 if (!cifs_sb->actimeo)
1796 return true;
1797
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301798 if (!time_in_range(jiffies, cifs_i->time,
1799 cifs_i->time + cifs_sb->actimeo))
Jeff Laytondf2cf172010-02-12 07:44:16 -05001800 return true;
1801
Jeff Laytondb192722010-05-17 14:51:49 -04001802 /* hardlinked files w/ noserverino get "special" treatment */
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301803 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
Jeff Laytondb192722010-05-17 14:51:49 -04001804 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1805 return true;
1806
Jeff Laytondf2cf172010-02-12 07:44:16 -05001807 return false;
1808}
1809
Suresh Jayaraman523fb8c2010-11-29 22:39:47 +05301810/*
1811 * Zap the cache. Called when invalid_mapping flag is set.
1812 */
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001813int
Jeff Laytondf2cf172010-02-12 07:44:16 -05001814cifs_invalidate_mapping(struct inode *inode)
1815{
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001816 int rc = 0;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001817
Jeff Laytondf2cf172010-02-12 07:44:16 -05001818 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
Pavel Shilovsky257fb1f2011-03-16 01:55:32 +03001819 rc = invalidate_inode_pages2(inode->i_mapping);
Jeff Layton4f73c7d2014-04-30 09:31:47 -04001820 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05001821 cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1822 __func__, inode);
Jeff Laytondf2cf172010-02-12 07:44:16 -05001823 }
Pavel Shilovsky257fb1f2011-03-16 01:55:32 +03001824
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +05301825 cifs_fscache_reset_inode_cookie(inode);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001826 return rc;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001827}
1828
Jeff Layton4f73c7d2014-04-30 09:31:47 -04001829/**
1830 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
1831 * @word: long word containing the bit lock
1832 */
1833static int
NeilBrownc1221322014-07-07 15:16:04 +10001834cifs_wait_bit_killable(struct wait_bit_key *key)
Jeff Layton4f73c7d2014-04-30 09:31:47 -04001835{
1836 if (fatal_signal_pending(current))
1837 return -ERESTARTSYS;
1838 freezable_schedule_unsafe();
1839 return 0;
1840}
1841
Jeff Laytone284e532014-04-30 09:31:46 -04001842int
1843cifs_revalidate_mapping(struct inode *inode)
1844{
Jeff Layton4f73c7d2014-04-30 09:31:47 -04001845 int rc;
1846 unsigned long *flags = &CIFS_I(inode)->flags;
1847
NeilBrown74316202014-07-07 15:16:04 +10001848 rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
1849 TASK_KILLABLE);
Jeff Layton4f73c7d2014-04-30 09:31:47 -04001850 if (rc)
1851 return rc;
1852
1853 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
1854 rc = cifs_invalidate_mapping(inode);
1855 if (rc)
1856 set_bit(CIFS_INO_INVALID_MAPPING, flags);
1857 }
1858
1859 clear_bit_unlock(CIFS_INO_LOCK, flags);
Linus Torvaldsb1cce802014-06-09 19:08:43 -07001860 smp_mb__after_atomic();
Jeff Layton4f73c7d2014-04-30 09:31:47 -04001861 wake_up_bit(flags, CIFS_INO_LOCK);
1862
1863 return rc;
1864}
1865
1866int
1867cifs_zap_mapping(struct inode *inode)
1868{
1869 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
1870 return cifs_revalidate_mapping(inode);
Jeff Laytone284e532014-04-30 09:31:46 -04001871}
1872
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001873int cifs_revalidate_file_attr(struct file *filp)
Jeff Laytonabab0952010-02-12 07:44:18 -05001874{
1875 int rc = 0;
Al Viro496ad9a2013-01-23 17:07:38 -05001876 struct inode *inode = file_inode(filp);
Jeff Laytonba00ba62010-09-20 16:01:31 -07001877 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
Jeff Laytonabab0952010-02-12 07:44:18 -05001878
1879 if (!cifs_inode_needs_reval(inode))
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001880 return rc;
Jeff Laytonabab0952010-02-12 07:44:18 -05001881
Jeff Layton13cfb732010-09-29 19:51:11 -04001882 if (tlink_tcon(cfile->tlink)->unix_ext)
Jeff Laytonabab0952010-02-12 07:44:18 -05001883 rc = cifs_get_file_info_unix(filp);
1884 else
1885 rc = cifs_get_file_info(filp);
1886
Jeff Laytonabab0952010-02-12 07:44:18 -05001887 return rc;
1888}
1889
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001890int cifs_revalidate_dentry_attr(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001892 unsigned int xid;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001893 int rc = 0;
David Howells2b0143b2015-03-17 22:25:59 +00001894 struct inode *inode = d_inode(dentry);
Jeff Laytondf2cf172010-02-12 07:44:16 -05001895 struct super_block *sb = dentry->d_sb;
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001896 char *full_path = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897
Jeff Laytondf2cf172010-02-12 07:44:16 -05001898 if (inode == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899 return -ENOENT;
1900
Jeff Laytondf2cf172010-02-12 07:44:16 -05001901 if (!cifs_inode_needs_reval(inode))
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001902 return rc;
1903
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001904 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905
1906 /* can not safely grab the rename sem here if rename calls revalidate
1907 since that would deadlock */
Jeff Laytondf2cf172010-02-12 07:44:16 -05001908 full_path = build_path_from_dentry(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301910 rc = -ENOMEM;
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001911 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912 }
Jeff Laytondf2cf172010-02-12 07:44:16 -05001913
Joe Perchesf96637b2013-05-04 22:12:25 -05001914 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1915 full_path, inode, inode->i_count.counter,
Steve Frenchf19159d2010-04-21 04:12:10 +00001916 dentry, dentry->d_time, jiffies);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917
Jeff Layton0d424ad2010-09-20 16:01:35 -07001918 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
Jeff Laytondf2cf172010-02-12 07:44:16 -05001919 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1920 else
1921 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1922 xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001924out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001926 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927 return rc;
1928}
1929
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001930int cifs_revalidate_file(struct file *filp)
1931{
1932 int rc;
Al Viro496ad9a2013-01-23 17:07:38 -05001933 struct inode *inode = file_inode(filp);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001934
1935 rc = cifs_revalidate_file_attr(filp);
1936 if (rc)
1937 return rc;
1938
Jeff Laytone284e532014-04-30 09:31:46 -04001939 return cifs_revalidate_mapping(inode);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001940}
1941
1942/* revalidate a dentry's inode attributes */
1943int cifs_revalidate_dentry(struct dentry *dentry)
1944{
1945 int rc;
David Howells2b0143b2015-03-17 22:25:59 +00001946 struct inode *inode = d_inode(dentry);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001947
1948 rc = cifs_revalidate_dentry_attr(dentry);
1949 if (rc)
1950 return rc;
1951
Jeff Laytone284e532014-04-30 09:31:46 -04001952 return cifs_revalidate_mapping(inode);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001953}
1954
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
Jeff Layton1c456012010-10-12 11:32:42 -04001956 struct kstat *stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957{
Jeff Layton3aa1c8c2010-10-07 14:46:28 -04001958 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
Steve French96daf2b2011-05-27 04:34:02 +00001959 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
David Howells2b0143b2015-03-17 22:25:59 +00001960 struct inode *inode = d_inode(dentry);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001961 int rc;
Jeff Layton3aa1c8c2010-10-07 14:46:28 -04001962
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001963 /*
1964 * We need to be sure that all dirty pages are written and the server
1965 * has actual ctime, mtime and file length.
1966 */
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001967 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001968 inode->i_mapping->nrpages != 0) {
1969 rc = filemap_fdatawait(inode->i_mapping);
Steve French156ecb22011-05-20 17:00:01 +00001970 if (rc) {
1971 mapping_set_error(inode->i_mapping, rc);
1972 return rc;
1973 }
Steve French5fe14c82006-11-07 19:26:33 +00001974 }
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001975
1976 rc = cifs_revalidate_dentry_attr(dentry);
1977 if (rc)
1978 return rc;
1979
1980 generic_fillattr(inode, stat);
1981 stat->blksize = CIFS_MAX_MSGSIZE;
1982 stat->ino = CIFS_I(inode)->uniqueid;
1983
1984 /*
Jeff Laytond3d1fce2012-11-25 08:00:40 -05001985 * If on a multiuser mount without unix extensions or cifsacl being
1986 * enabled, and the admin hasn't overridden them, set the ownership
1987 * to the fsuid/fsgid of the current process.
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001988 */
1989 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
Jeff Laytond3d1fce2012-11-25 08:00:40 -05001990 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001991 !tcon->unix_ext) {
1992 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1993 stat->uid = current_fsuid();
1994 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1995 stat->gid = current_fsgid();
1996 }
1997 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998}
1999
2000static int cifs_truncate_page(struct address_space *mapping, loff_t from)
2001{
2002 pgoff_t index = from >> PAGE_CACHE_SHIFT;
2003 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
2004 struct page *page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005 int rc = 0;
2006
2007 page = grab_cache_page(mapping, index);
2008 if (!page)
2009 return -ENOMEM;
2010
Christoph Lametereebd2aa2008-02-04 22:28:29 -08002011 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012 unlock_page(page);
2013 page_cache_release(page);
2014 return rc;
2015}
2016
Christoph Hellwig1b947462010-07-18 17:51:21 -04002017static void cifs_setsize(struct inode *inode, loff_t offset)
Steve French3677db12007-02-26 16:46:11 +00002018{
Steve Frenchba6a46a2007-02-26 20:06:29 +00002019 spin_lock(&inode->i_lock);
Steve French3677db12007-02-26 16:46:11 +00002020 i_size_write(inode, offset);
Steve Frenchba6a46a2007-02-26 20:06:29 +00002021 spin_unlock(&inode->i_lock);
Christoph Hellwig1b947462010-07-18 17:51:21 -04002022
Kirill A. Shutemov7caef262013-09-12 15:13:56 -07002023 truncate_pagecache(inode, offset);
Steve French3677db12007-02-26 16:46:11 +00002024}
2025
Jeff Layton8efdbde2008-07-23 21:28:12 +00002026static int
2027cifs_set_file_size(struct inode *inode, struct iattr *attrs,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002028 unsigned int xid, char *full_path)
Jeff Layton8efdbde2008-07-23 21:28:12 +00002029{
2030 int rc;
2031 struct cifsFileInfo *open_file;
2032 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2033 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04002034 struct tcon_link *tlink = NULL;
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002035 struct cifs_tcon *tcon = NULL;
2036 struct TCP_Server_Info *server;
Jeff Layton8efdbde2008-07-23 21:28:12 +00002037
2038 /*
2039 * To avoid spurious oplock breaks from server, in the case of
2040 * inodes that we already have open, avoid doing path based
2041 * setting of file size if we can do it by handle.
2042 * This keeps our caching token (oplock) and avoids timeouts
2043 * when the local oplock break takes longer to flush
2044 * writebehind data than the SMB timeout for the SetPathInfo
2045 * request would allow
2046 */
Jeff Layton6508d902010-09-29 19:51:11 -04002047 open_file = find_writable_file(cifsInode, true);
Jeff Layton8efdbde2008-07-23 21:28:12 +00002048 if (open_file) {
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002049 tcon = tlink_tcon(open_file->tlink);
2050 server = tcon->ses->server;
2051 if (server->ops->set_file_size)
2052 rc = server->ops->set_file_size(xid, tcon, open_file,
2053 attrs->ia_size, false);
2054 else
2055 rc = -ENOSYS;
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04002056 cifsFileInfo_put(open_file);
Joe Perchesf96637b2013-05-04 22:12:25 -05002057 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00002058 } else
2059 rc = -EINVAL;
2060
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002061 if (!rc)
2062 goto set_size_out;
Jeff Laytonba00ba62010-09-20 16:01:31 -07002063
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002064 if (tcon == NULL) {
2065 tlink = cifs_sb_tlink(cifs_sb);
2066 if (IS_ERR(tlink))
2067 return PTR_ERR(tlink);
2068 tcon = tlink_tcon(tlink);
2069 server = tcon->ses->server;
Jeff Layton8efdbde2008-07-23 21:28:12 +00002070 }
2071
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002072 /*
2073 * Set file size by pathname rather than by handle either because no
2074 * valid, writeable file handle for it was found or because there was
2075 * an error setting it by handle.
2076 */
2077 if (server->ops->set_path_size)
2078 rc = server->ops->set_path_size(xid, tcon, full_path,
2079 attrs->ia_size, cifs_sb, false);
2080 else
2081 rc = -ENOSYS;
Joe Perchesf96637b2013-05-04 22:12:25 -05002082 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002083
Pavel Shilovskyd1433412012-09-18 16:20:31 -07002084 if (tlink)
2085 cifs_put_tlink(tlink);
2086
2087set_size_out:
Jeff Layton8efdbde2008-07-23 21:28:12 +00002088 if (rc == 0) {
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04002089 cifsInode->server_eof = attrs->ia_size;
Christoph Hellwig1b947462010-07-18 17:51:21 -04002090 cifs_setsize(inode, attrs->ia_size);
Jeff Layton8efdbde2008-07-23 21:28:12 +00002091 cifs_truncate_page(inode->i_mapping, inode->i_size);
2092 }
2093
2094 return rc;
2095}
2096
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002097static int
2098cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2099{
2100 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002101 unsigned int xid;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002102 char *full_path = NULL;
David Howells2b0143b2015-03-17 22:25:59 +00002103 struct inode *inode = d_inode(direntry);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002104 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2105 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04002106 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00002107 struct cifs_tcon *pTcon;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002108 struct cifs_unix_set_info_args *args = NULL;
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002109 struct cifsFileInfo *open_file;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002110
Al Viro35c265e2014-08-19 20:25:34 -04002111 cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2112 direntry, attrs->ia_valid);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002113
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002114 xid = get_xid();
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002115
Christoph Hellwigdb78b872010-06-04 11:30:03 +02002116 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2117 attrs->ia_valid |= ATTR_FORCE;
2118
2119 rc = inode_change_ok(inode, attrs);
2120 if (rc < 0)
2121 goto out;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002122
2123 full_path = build_path_from_dentry(direntry);
2124 if (full_path == NULL) {
2125 rc = -ENOMEM;
2126 goto out;
2127 }
2128
Jeff Layton0f4d6342009-03-26 13:35:37 -04002129 /*
2130 * Attempt to flush data before changing attributes. We need to do
2131 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2132 * ownership or mode then we may also need to do this. Here, we take
2133 * the safe way out and just do the flush on all setattr requests. If
2134 * the flush returns error, store it to report later and continue.
2135 *
2136 * BB: This should be smarter. Why bother flushing pages that
2137 * will be truncated anyway? Also, should we error out here if
2138 * the flush returns error?
2139 */
2140 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002141 mapping_set_error(inode->i_mapping, rc);
2142 rc = 0;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002143
2144 if (attrs->ia_valid & ATTR_SIZE) {
2145 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2146 if (rc != 0)
2147 goto out;
2148 }
2149
2150 /* skip mode change if it's just for clearing setuid/setgid */
2151 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2152 attrs->ia_valid &= ~ATTR_MODE;
2153
2154 args = kmalloc(sizeof(*args), GFP_KERNEL);
2155 if (args == NULL) {
2156 rc = -ENOMEM;
2157 goto out;
2158 }
2159
2160 /* set up the struct */
2161 if (attrs->ia_valid & ATTR_MODE)
2162 args->mode = attrs->ia_mode;
2163 else
2164 args->mode = NO_CHANGE_64;
2165
2166 if (attrs->ia_valid & ATTR_UID)
2167 args->uid = attrs->ia_uid;
2168 else
Eric W. Biederman49418b22013-02-06 00:57:56 -08002169 args->uid = INVALID_UID; /* no change */
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002170
2171 if (attrs->ia_valid & ATTR_GID)
2172 args->gid = attrs->ia_gid;
2173 else
Eric W. Biederman49418b22013-02-06 00:57:56 -08002174 args->gid = INVALID_GID; /* no change */
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002175
2176 if (attrs->ia_valid & ATTR_ATIME)
2177 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2178 else
2179 args->atime = NO_CHANGE_64;
2180
2181 if (attrs->ia_valid & ATTR_MTIME)
2182 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2183 else
2184 args->mtime = NO_CHANGE_64;
2185
2186 if (attrs->ia_valid & ATTR_CTIME)
2187 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2188 else
2189 args->ctime = NO_CHANGE_64;
2190
2191 args->device = 0;
Jeff Layton6508d902010-09-29 19:51:11 -04002192 open_file = find_writable_file(cifsInode, true);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002193 if (open_file) {
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07002194 u16 nfid = open_file->fid.netfid;
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002195 u32 npid = open_file->pid;
Jeff Layton13cfb732010-09-29 19:51:11 -04002196 pTcon = tlink_tcon(open_file->tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002197 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04002198 cifsFileInfo_put(open_file);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002199 } else {
Jeff Layton7ffec372010-09-29 19:51:11 -04002200 tlink = cifs_sb_tlink(cifs_sb);
2201 if (IS_ERR(tlink)) {
2202 rc = PTR_ERR(tlink);
2203 goto out;
2204 }
2205 pTcon = tlink_tcon(tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002206 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
Jeff Layton01ea95e2009-07-09 20:02:49 -04002207 cifs_sb->local_nls,
Nakajima Akirabc8ebdc42015-02-13 15:35:58 +09002208 cifs_remap(cifs_sb));
Jeff Layton7ffec372010-09-29 19:51:11 -04002209 cifs_put_tlink(tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002210 }
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002211
Christoph Hellwig10257742010-06-04 11:30:02 +02002212 if (rc)
2213 goto out;
Steve Frenchccd4bb12010-02-08 17:39:58 +00002214
Christoph Hellwig10257742010-06-04 11:30:02 +02002215 if ((attrs->ia_valid & ATTR_SIZE) &&
Christoph Hellwig1b947462010-07-18 17:51:21 -04002216 attrs->ia_size != i_size_read(inode))
2217 truncate_setsize(inode, attrs->ia_size);
Christoph Hellwig10257742010-06-04 11:30:02 +02002218
2219 setattr_copy(inode, attrs);
2220 mark_inode_dirty(inode);
2221
2222 /* force revalidate when any of these times are set since some
2223 of the fs types (eg ext3, fat) do not have fine enough
2224 time granularity to match protocol, and we do not have a
2225 a way (yet) to query the server fs's time granularity (and
2226 whether it rounds times down).
2227 */
2228 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2229 cifsInode->time = 0;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002230out:
2231 kfree(args);
2232 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002233 free_xid(xid);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002234 return rc;
2235}
2236
Jeff Layton0510eeb2008-08-02 07:26:12 -04002237static int
2238cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002239{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002240 unsigned int xid;
Eric W. Biederman8abf2772013-02-06 00:33:17 -08002241 kuid_t uid = INVALID_UID;
2242 kgid_t gid = INVALID_GID;
David Howells2b0143b2015-03-17 22:25:59 +00002243 struct inode *inode = d_inode(direntry);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002244 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002245 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002246 char *full_path = NULL;
2247 int rc = -EACCES;
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002248 __u32 dosattr = 0;
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04002249 __u64 mode = NO_CHANGE_64;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002250
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002251 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002252
Al Viro35c265e2014-08-19 20:25:34 -04002253 cifs_dbg(FYI, "setattr on file %pd attrs->iavalid 0x%x\n",
2254 direntry, attrs->ia_valid);
Steve French6473a552005-11-29 20:20:10 -08002255
Christoph Hellwigdb78b872010-06-04 11:30:03 +02002256 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2257 attrs->ia_valid |= ATTR_FORCE;
2258
2259 rc = inode_change_ok(inode, attrs);
2260 if (rc < 0) {
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002261 free_xid(xid);
Christoph Hellwigdb78b872010-06-04 11:30:03 +02002262 return rc;
Steve French6473a552005-11-29 20:20:10 -08002263 }
Steve French50c2f752007-07-13 00:33:32 +00002264
Steve French7f573562005-08-30 11:32:14 -07002265 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302267 rc = -ENOMEM;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002268 free_xid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302269 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002270 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002271
Jeff Layton0f4d6342009-03-26 13:35:37 -04002272 /*
2273 * Attempt to flush data before changing attributes. We need to do
2274 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2275 * ownership or mode then we may also need to do this. Here, we take
2276 * the safe way out and just do the flush on all setattr requests. If
2277 * the flush returns error, store it to report later and continue.
2278 *
2279 * BB: This should be smarter. Why bother flushing pages that
2280 * will be truncated anyway? Also, should we error out here if
2281 * the flush returns error?
2282 */
2283 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002284 mapping_set_error(inode->i_mapping, rc);
2285 rc = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +00002286
Steve French50531442008-03-14 19:21:31 +00002287 if (attrs->ia_valid & ATTR_SIZE) {
Jeff Layton8efdbde2008-07-23 21:28:12 +00002288 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2289 if (rc != 0)
Steve Frenche30dcf32005-09-20 20:49:16 -07002290 goto cifs_setattr_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002291 }
Jeff Layton4ca691a2008-05-22 09:33:34 -04002292
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002293 if (attrs->ia_valid & ATTR_UID)
2294 uid = attrs->ia_uid;
2295
2296 if (attrs->ia_valid & ATTR_GID)
2297 gid = attrs->ia_gid;
2298
2299#ifdef CONFIG_CIFS_ACL
2300 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
Eric W. Biederman8abf2772013-02-06 00:33:17 -08002301 if (uid_valid(uid) || gid_valid(gid)) {
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002302 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2303 uid, gid);
2304 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002305 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2306 __func__, rc);
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002307 goto cifs_setattr_exit;
2308 }
2309 }
2310 } else
2311#endif /* CONFIG_CIFS_ACL */
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002312 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
Jeff Layton4ca691a2008-05-22 09:33:34 -04002313 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314
Jeff Laytond32c4f22007-10-18 03:05:22 -07002315 /* skip mode change if it's just for clearing setuid/setgid */
2316 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2317 attrs->ia_valid &= ~ATTR_MODE;
2318
Linus Torvalds1da177e2005-04-16 15:20:36 -07002319 if (attrs->ia_valid & ATTR_MODE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002320 mode = attrs->ia_mode;
Steve Frenchcdbce9c2005-11-19 21:04:52 -08002321 rc = 0;
Jeff Layton79df1ba2010-12-06 12:52:08 -05002322#ifdef CONFIG_CIFS_ACL
Shirish Pargaonkar78415d22010-11-27 11:37:26 -06002323 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002324 rc = id_mode_to_cifs_acl(inode, full_path, mode,
Eric W. Biederman8abf2772013-02-06 00:33:17 -08002325 INVALID_UID, INVALID_GID);
Shirish Pargaonkar78415d22010-11-27 11:37:26 -06002326 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002327 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2328 __func__, rc);
Shirish Pargaonkar78415d22010-11-27 11:37:26 -06002329 goto cifs_setattr_exit;
2330 }
2331 } else
Jeff Layton79df1ba2010-12-06 12:52:08 -05002332#endif /* CONFIG_CIFS_ACL */
Jeff Layton51328612008-05-22 09:33:34 -04002333 if (((mode & S_IWUGO) == 0) &&
2334 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002335
2336 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2337
Jeff Layton51328612008-05-22 09:33:34 -04002338 /* fix up mode if we're not using dynperm */
2339 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2340 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2341 } else if ((mode & S_IWUGO) &&
2342 (cifsInode->cifsAttrs & ATTR_READONLY)) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002343
2344 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2345 /* Attributes of 0 are ignored */
2346 if (dosattr == 0)
2347 dosattr |= ATTR_NORMAL;
Jeff Layton51328612008-05-22 09:33:34 -04002348
2349 /* reset local inode permissions to normal */
2350 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2351 attrs->ia_mode &= ~(S_IALLUGO);
2352 if (S_ISDIR(inode->i_mode))
2353 attrs->ia_mode |=
2354 cifs_sb->mnt_dir_mode;
2355 else
2356 attrs->ia_mode |=
2357 cifs_sb->mnt_file_mode;
2358 }
2359 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2360 /* ignore mode change - ATTR_READONLY hasn't changed */
2361 attrs->ia_valid &= ~ATTR_MODE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002362 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002363 }
2364
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002365 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2366 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2367 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2368 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002369
Steve Frenche30dcf32005-09-20 20:49:16 -07002370 /* Even if error on time set, no sense failing the call if
2371 the server would set the time to a reasonable value anyway,
2372 and this check ensures that we are not being called from
2373 sys_utimes in which case we ought to fail the call back to
2374 the user when the server rejects the call */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002375 if ((rc) && (attrs->ia_valid &
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002376 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
Steve Frenche30dcf32005-09-20 20:49:16 -07002377 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002378 }
2379
2380 /* do not need local check to inode_check_ok since the server does
2381 that */
Christoph Hellwig10257742010-06-04 11:30:02 +02002382 if (rc)
2383 goto cifs_setattr_exit;
2384
2385 if ((attrs->ia_valid & ATTR_SIZE) &&
Christoph Hellwig1b947462010-07-18 17:51:21 -04002386 attrs->ia_size != i_size_read(inode))
2387 truncate_setsize(inode, attrs->ia_size);
Christoph Hellwig10257742010-06-04 11:30:02 +02002388
2389 setattr_copy(inode, attrs);
2390 mark_inode_dirty(inode);
Christoph Hellwig10257742010-06-04 11:30:02 +02002391
Steve Frenche30dcf32005-09-20 20:49:16 -07002392cifs_setattr_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002393 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002394 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002395 return rc;
2396}
2397
Jeff Layton0510eeb2008-08-02 07:26:12 -04002398int
2399cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2400{
David Howells2b0143b2015-03-17 22:25:59 +00002401 struct inode *inode = d_inode(direntry);
Jeff Layton0510eeb2008-08-02 07:26:12 -04002402 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Steve French96daf2b2011-05-27 04:34:02 +00002403 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
Jeff Layton0510eeb2008-08-02 07:26:12 -04002404
2405 if (pTcon->unix_ext)
2406 return cifs_setattr_unix(direntry, attrs);
2407
2408 return cifs_setattr_nounix(direntry, attrs);
2409
2410 /* BB: add cifs_setattr_legacy for really old servers */
2411}
2412
Steve French99ee4db2007-02-27 05:35:17 +00002413#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07002414void cifs_delete_inode(struct inode *inode)
2415{
Joe Perchesf96637b2013-05-04 22:12:25 -05002416 cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002417 /* may have to add back in if and when safe distributed caching of
2418 directories added e.g. via FindNotify */
2419}
Steve French99ee4db2007-02-27 05:35:17 +00002420#endif