blob: 36f9ebb93ceba676c363cdf7b973f3936a9dde8f [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>
25#include <asm/div64.h>
26#include "cifsfs.h"
27#include "cifspdu.h"
28#include "cifsglob.h"
29#include "cifsproto.h"
30#include "cifs_debug.h"
31#include "cifs_fs_sb.h"
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +053032#include "fscache.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070033
Christoph Hellwig70eff552008-02-15 20:55:05 +000034
David Howells01c64fe2011-01-14 18:45:47 +000035static void cifs_set_ops(struct inode *inode)
Christoph Hellwig70eff552008-02-15 20:55:05 +000036{
37 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
38
39 switch (inode->i_mode & S_IFMT) {
40 case S_IFREG:
41 inode->i_op = &cifs_file_inode_ops;
42 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
43 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
44 inode->i_fop = &cifs_file_direct_nobrl_ops;
45 else
46 inode->i_fop = &cifs_file_direct_ops;
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +030047 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
48 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
49 inode->i_fop = &cifs_file_strict_nobrl_ops;
50 else
51 inode->i_fop = &cifs_file_strict_ops;
Christoph Hellwig70eff552008-02-15 20:55:05 +000052 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
53 inode->i_fop = &cifs_file_nobrl_ops;
54 else { /* not direct, send byte range locks */
55 inode->i_fop = &cifs_file_ops;
56 }
57
Christoph Hellwig70eff552008-02-15 20:55:05 +000058 /* check if server can support readpages */
Jeff Layton0d424ad2010-09-20 16:01:35 -070059 if (cifs_sb_master_tcon(cifs_sb)->ses->server->maxBuf <
Christoph Hellwig70eff552008-02-15 20:55:05 +000060 PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
61 inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
62 else
63 inode->i_data.a_ops = &cifs_addr_ops;
64 break;
65 case S_IFDIR:
Steve Frenchbc5b6e22008-03-11 21:07:48 +000066#ifdef CONFIG_CIFS_DFS_UPCALL
David Howells01c64fe2011-01-14 18:45:47 +000067 if (IS_AUTOMOUNT(inode)) {
Igor Mammedov79626702008-03-09 03:44:18 +000068 inode->i_op = &cifs_dfs_referral_inode_operations;
69 } else {
Steve Frenchbc5b6e22008-03-11 21:07:48 +000070#else /* NO DFS support, treat as a directory */
71 {
72#endif
Igor Mammedov79626702008-03-09 03:44:18 +000073 inode->i_op = &cifs_dir_inode_ops;
74 inode->i_fop = &cifs_dir_ops;
75 }
Christoph Hellwig70eff552008-02-15 20:55:05 +000076 break;
77 case S_IFLNK:
78 inode->i_op = &cifs_symlink_inode_ops;
79 break;
80 default:
81 init_special_inode(inode, inode->i_mode, inode->i_rdev);
82 break;
83 }
84}
85
Jeff Laytondf2cf172010-02-12 07:44:16 -050086/* check inode attributes against fattr. If they don't match, tag the
87 * inode for cache invalidation
88 */
89static void
90cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
91{
92 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
93
Joe Perchesf96637b2013-05-04 22:12:25 -050094 cifs_dbg(FYI, "%s: revalidating inode %llu\n",
95 __func__, cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -050096
97 if (inode->i_state & I_NEW) {
Joe Perchesf96637b2013-05-04 22:12:25 -050098 cifs_dbg(FYI, "%s: inode %llu is new\n",
99 __func__, cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -0500100 return;
101 }
102
103 /* don't bother with revalidation if we have an oplock */
Pavel Shilovsky18cceb62013-09-05 13:01:06 +0400104 if (CIFS_CACHE_READ(cifs_i)) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500105 cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
106 __func__, cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -0500107 return;
108 }
109
110 /* revalidate if mtime or size have changed */
111 if (timespec_equal(&inode->i_mtime, &fattr->cf_mtime) &&
112 cifs_i->server_eof == fattr->cf_eof) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500113 cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
114 __func__, cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -0500115 return;
116 }
117
Joe Perchesf96637b2013-05-04 22:12:25 -0500118 cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
119 __func__, cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -0500120 cifs_i->invalid_mapping = true;
121}
122
Jim McDonough74d290d2013-09-21 10:36:10 -0500123/*
124 * copy nlink to the inode, unless it wasn't provided. Provide
125 * sane values if we don't have an existing one and none was provided
126 */
127static void
128cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
129{
130 /*
131 * if we're in a situation where we can't trust what we
132 * got from the server (readdir, some non-unix cases)
133 * fake reasonable values
134 */
135 if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
136 /* only provide fake values on a new inode */
137 if (inode->i_state & I_NEW) {
138 if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
139 set_nlink(inode, 2);
140 else
141 set_nlink(inode, 1);
142 }
143 return;
144 }
145
146 /* we trust the server, so update it */
147 set_nlink(inode, fattr->cf_nlink);
148}
149
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400150/* populate an inode with info from a cifs_fattr struct */
151void
152cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
Christoph Hellwig75f12982008-02-25 20:25:21 +0000153{
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400154 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400155 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Christoph Hellwig75f12982008-02-25 20:25:21 +0000156
Jeff Laytondf2cf172010-02-12 07:44:16 -0500157 cifs_revalidate_cache(inode, fattr);
158
Steve Frenchb7ca6922012-08-03 08:43:01 -0500159 spin_lock(&inode->i_lock);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400160 inode->i_atime = fattr->cf_atime;
161 inode->i_mtime = fattr->cf_mtime;
162 inode->i_ctime = fattr->cf_ctime;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400163 inode->i_rdev = fattr->cf_rdev;
Jim McDonough74d290d2013-09-21 10:36:10 -0500164 cifs_nlink_fattr_to_inode(inode, fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400165 inode->i_uid = fattr->cf_uid;
166 inode->i_gid = fattr->cf_gid;
167
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400168 /* if dynperm is set, don't clobber existing mode */
169 if (inode->i_state & I_NEW ||
170 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
171 inode->i_mode = fattr->cf_mode;
172
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400173 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400174
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400175 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
176 cifs_i->time = 0;
177 else
178 cifs_i->time = jiffies;
179
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400180 cifs_i->delete_pending = fattr->cf_flags & CIFS_FATTR_DELETE_PENDING;
Christoph Hellwig75f12982008-02-25 20:25:21 +0000181
Jeff Layton835a36c2010-02-10 16:21:33 -0500182 cifs_i->server_eof = fattr->cf_eof;
Christoph Hellwig75f12982008-02-25 20:25:21 +0000183 /*
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400184 * Can't safely change the file size here if the client is writing to
185 * it due to potential races.
Christoph Hellwig75f12982008-02-25 20:25:21 +0000186 */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400187 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
188 i_size_write(inode, fattr->cf_eof);
Christoph Hellwig75f12982008-02-25 20:25:21 +0000189
190 /*
191 * i_blocks is not related to (i_size / i_blksize),
192 * but instead 512 byte (2**9) size is required for
193 * calculating num blocks.
194 */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400195 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
Christoph Hellwig75f12982008-02-25 20:25:21 +0000196 }
197 spin_unlock(&inode->i_lock);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400198
David Howells01c64fe2011-01-14 18:45:47 +0000199 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
200 inode->i_flags |= S_AUTOMOUNT;
Jeff Laytonc2b93e02013-05-07 11:28:31 -0400201 if (inode->i_state & I_NEW)
202 cifs_set_ops(inode);
Christoph Hellwig75f12982008-02-25 20:25:21 +0000203}
204
Jeff Layton4065c802010-05-17 07:18:58 -0400205void
206cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
207{
208 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
209
210 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
211 return;
212
213 fattr->cf_uniqueid = iunique(sb, ROOT_I);
214}
215
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400216/* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
217void
218cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
219 struct cifs_sb_info *cifs_sb)
220{
221 memset(fattr, 0, sizeof(*fattr));
222 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
223 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
224 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
225
226 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
227 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
228 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
229 fattr->cf_mode = le64_to_cpu(info->Permissions);
230
231 /*
232 * Since we set the inode type below we need to mask off
233 * to avoid strange results if bits set above.
234 */
235 fattr->cf_mode &= ~S_IFMT;
236 switch (le32_to_cpu(info->Type)) {
237 case UNIX_FILE:
238 fattr->cf_mode |= S_IFREG;
239 fattr->cf_dtype = DT_REG;
240 break;
241 case UNIX_SYMLINK:
242 fattr->cf_mode |= S_IFLNK;
243 fattr->cf_dtype = DT_LNK;
244 break;
245 case UNIX_DIR:
246 fattr->cf_mode |= S_IFDIR;
247 fattr->cf_dtype = DT_DIR;
248 break;
249 case UNIX_CHARDEV:
250 fattr->cf_mode |= S_IFCHR;
251 fattr->cf_dtype = DT_CHR;
252 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
253 le64_to_cpu(info->DevMinor) & MINORMASK);
254 break;
255 case UNIX_BLOCKDEV:
256 fattr->cf_mode |= S_IFBLK;
257 fattr->cf_dtype = DT_BLK;
258 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
259 le64_to_cpu(info->DevMinor) & MINORMASK);
260 break;
261 case UNIX_FIFO:
262 fattr->cf_mode |= S_IFIFO;
263 fattr->cf_dtype = DT_FIFO;
264 break;
265 case UNIX_SOCKET:
266 fattr->cf_mode |= S_IFSOCK;
267 fattr->cf_dtype = DT_SOCK;
268 break;
269 default:
270 /* safest to call it a file if we do not know */
271 fattr->cf_mode |= S_IFREG;
272 fattr->cf_dtype = DT_REG;
Joe Perchesf96637b2013-05-04 22:12:25 -0500273 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400274 break;
275 }
276
Eric W. Biederman46bbc252013-02-05 23:55:44 -0800277 fattr->cf_uid = cifs_sb->mnt_uid;
278 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
279 u64 id = le64_to_cpu(info->Uid);
Eric W. Biederman4a2c8cf2013-02-06 01:53:25 -0800280 if (id < ((uid_t)-1)) {
281 kuid_t uid = make_kuid(&init_user_ns, id);
282 if (uid_valid(uid))
283 fattr->cf_uid = uid;
284 }
Eric W. Biederman46bbc252013-02-05 23:55:44 -0800285 }
286
287 fattr->cf_gid = cifs_sb->mnt_gid;
288 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
289 u64 id = le64_to_cpu(info->Gid);
Eric W. Biederman4a2c8cf2013-02-06 01:53:25 -0800290 if (id < ((gid_t)-1)) {
291 kgid_t gid = make_kgid(&init_user_ns, id);
292 if (gid_valid(gid))
293 fattr->cf_gid = gid;
294 }
Eric W. Biederman46bbc252013-02-05 23:55:44 -0800295 }
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400296
297 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
298}
Steve Frenchb9a32602008-05-20 21:52:32 +0000299
300/*
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400301 * Fill a cifs_fattr struct with fake inode info.
302 *
303 * Needed to setup cifs_fattr data for the directory which is the
304 * junction to the new submount (ie to setup the fake directory
305 * which represents a DFS referral).
Steve Frenchb9a32602008-05-20 21:52:32 +0000306 */
Steve Frenchf1230c92009-07-22 23:13:01 +0000307static void
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400308cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
Steve French0e4bbde2008-05-20 19:50:46 +0000309{
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400310 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Steve French0e4bbde2008-05-20 19:50:46 +0000311
Joe Perchesf96637b2013-05-04 22:12:25 -0500312 cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
Steve French0e4bbde2008-05-20 19:50:46 +0000313
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400314 memset(fattr, 0, sizeof(*fattr));
315 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
316 fattr->cf_uid = cifs_sb->mnt_uid;
317 fattr->cf_gid = cifs_sb->mnt_gid;
318 fattr->cf_atime = CURRENT_TIME;
319 fattr->cf_ctime = CURRENT_TIME;
320 fattr->cf_mtime = CURRENT_TIME;
321 fattr->cf_nlink = 2;
322 fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
Steve French0e4bbde2008-05-20 19:50:46 +0000323}
324
Pavel Shilovsky4ad65042012-09-18 16:20:26 -0700325static int
326cifs_get_file_info_unix(struct file *filp)
Jeff Laytonabab0952010-02-12 07:44:18 -0500327{
328 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400329 unsigned int xid;
Jeff Laytonabab0952010-02-12 07:44:18 -0500330 FILE_UNIX_BASIC_INFO find_data;
331 struct cifs_fattr fattr;
Al Viro496ad9a2013-01-23 17:07:38 -0500332 struct inode *inode = file_inode(filp);
Jeff Laytonabab0952010-02-12 07:44:18 -0500333 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Joe Perchesc21dfb62010-07-12 13:50:14 -0700334 struct cifsFileInfo *cfile = filp->private_data;
Steve French96daf2b2011-05-27 04:34:02 +0000335 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Jeff Laytonabab0952010-02-12 07:44:18 -0500336
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400337 xid = get_xid();
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700338 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
Jeff Laytonabab0952010-02-12 07:44:18 -0500339 if (!rc) {
340 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
341 } else if (rc == -EREMOTE) {
342 cifs_create_dfs_fattr(&fattr, inode->i_sb);
343 rc = 0;
344 }
345
346 cifs_fattr_to_inode(inode, &fattr);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400347 free_xid(xid);
Jeff Laytonabab0952010-02-12 07:44:18 -0500348 return rc;
349}
350
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351int cifs_get_inode_info_unix(struct inode **pinode,
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400352 const unsigned char *full_path,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400353 struct super_block *sb, unsigned int xid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354{
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400355 int rc;
Steve French0e4bbde2008-05-20 19:50:46 +0000356 FILE_UNIX_BASIC_INFO find_data;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400357 struct cifs_fattr fattr;
Steve French96daf2b2011-05-27 04:34:02 +0000358 struct cifs_tcon *tcon;
Jeff Layton7ffec372010-09-29 19:51:11 -0400359 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361
Joe Perchesf96637b2013-05-04 22:12:25 -0500362 cifs_dbg(FYI, "Getting info on %s\n", full_path);
Igor Mammedov79626702008-03-09 03:44:18 +0000363
Jeff Layton7ffec372010-09-29 19:51:11 -0400364 tlink = cifs_sb_tlink(cifs_sb);
365 if (IS_ERR(tlink))
366 return PTR_ERR(tlink);
367 tcon = tlink_tcon(tlink);
368
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 /* could have done a find first instead but this returns more info */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400370 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
Steve French737b7582005-04-28 22:41:06 -0700371 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
372 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton7ffec372010-09-29 19:51:11 -0400373 cifs_put_tlink(tlink);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400374
375 if (!rc) {
376 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
377 } else if (rc == -EREMOTE) {
378 cifs_create_dfs_fattr(&fattr, sb);
Jeff Laytone911d0c2008-07-12 13:47:59 -0700379 rc = 0;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400380 } else {
381 return rc;
Steve French0e4bbde2008-05-20 19:50:46 +0000382 }
383
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200384 /* check for Minshall+French symlinks */
385 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
386 int tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
387 if (tmprc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500388 cifs_dbg(FYI, "CIFSCheckMFSymlink: %d\n", tmprc);
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200389 }
390
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400391 if (*pinode == NULL) {
392 /* get new inode */
Jeff Layton4065c802010-05-17 07:18:58 -0400393 cifs_fill_uniqueid(sb, &fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400394 *pinode = cifs_iget(sb, &fattr);
395 if (!*pinode)
396 rc = -ENOMEM;
397 } else {
398 /* we already have inode, update it */
399 cifs_fattr_to_inode(*pinode, &fattr);
400 }
Steve French0e4bbde2008-05-20 19:50:46 +0000401
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 return rc;
403}
404
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400405static int
406cifs_sfu_type(struct cifs_fattr *fattr, const unsigned char *path,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400407 struct cifs_sb_info *cifs_sb, unsigned int xid)
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800408{
409 int rc;
Steve French4b18f2a2008-04-29 00:06:05 +0000410 int oplock = 0;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800411 __u16 netfid;
Jeff Layton7ffec372010-09-29 19:51:11 -0400412 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +0000413 struct cifs_tcon *tcon;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000414 struct cifs_io_parms io_parms;
Steve French86c96b42005-11-18 20:25:31 -0800415 char buf[24];
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800416 unsigned int bytes_read;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000417 char *pbuf;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800418
419 pbuf = buf;
420
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400421 fattr->cf_mode &= ~S_IFMT;
422
423 if (fattr->cf_eof == 0) {
424 fattr->cf_mode |= S_IFIFO;
425 fattr->cf_dtype = DT_FIFO;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800426 return 0;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400427 } else if (fattr->cf_eof < 8) {
428 fattr->cf_mode |= S_IFREG;
429 fattr->cf_dtype = DT_REG;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800430 return -EINVAL; /* EOPNOTSUPP? */
431 }
Steve French50c2f752007-07-13 00:33:32 +0000432
Jeff Layton7ffec372010-09-29 19:51:11 -0400433 tlink = cifs_sb_tlink(cifs_sb);
434 if (IS_ERR(tlink))
435 return PTR_ERR(tlink);
436 tcon = tlink_tcon(tlink);
437
438 rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, GENERIC_READ,
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800439 CREATE_NOT_DIR, &netfid, &oplock, NULL,
440 cifs_sb->local_nls,
441 cifs_sb->mnt_cifs_flags &
442 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000443 if (rc == 0) {
Steve Frenchec637e32005-12-12 20:53:18 -0800444 int buf_type = CIFS_NO_BUFFER;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800445 /* Read header */
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000446 io_parms.netfid = netfid;
447 io_parms.pid = current->tgid;
448 io_parms.tcon = tcon;
449 io_parms.offset = 0;
450 io_parms.length = 24;
451 rc = CIFSSMBRead(xid, &io_parms, &bytes_read, &pbuf,
452 &buf_type);
Steve French4523cc32007-04-30 20:13:06 +0000453 if ((rc == 0) && (bytes_read >= 8)) {
454 if (memcmp("IntxBLK", pbuf, 8) == 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500455 cifs_dbg(FYI, "Block device\n");
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400456 fattr->cf_mode |= S_IFBLK;
457 fattr->cf_dtype = DT_BLK;
Steve French4523cc32007-04-30 20:13:06 +0000458 if (bytes_read == 24) {
Steve French86c96b42005-11-18 20:25:31 -0800459 /* we have enough to decode dev num */
460 __u64 mjr; /* major */
461 __u64 mnr; /* minor */
462 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
463 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400464 fattr->cf_rdev = MKDEV(mjr, mnr);
Steve French86c96b42005-11-18 20:25:31 -0800465 }
Steve French4523cc32007-04-30 20:13:06 +0000466 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500467 cifs_dbg(FYI, "Char device\n");
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400468 fattr->cf_mode |= S_IFCHR;
469 fattr->cf_dtype = DT_CHR;
Steve French4523cc32007-04-30 20:13:06 +0000470 if (bytes_read == 24) {
Steve French86c96b42005-11-18 20:25:31 -0800471 /* we have enough to decode dev num */
472 __u64 mjr; /* major */
473 __u64 mnr; /* minor */
474 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
475 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400476 fattr->cf_rdev = MKDEV(mjr, mnr);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000477 }
Steve French4523cc32007-04-30 20:13:06 +0000478 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500479 cifs_dbg(FYI, "Symlink\n");
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400480 fattr->cf_mode |= S_IFLNK;
481 fattr->cf_dtype = DT_LNK;
Steve French86c96b42005-11-18 20:25:31 -0800482 } else {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400483 fattr->cf_mode |= S_IFREG; /* file? */
484 fattr->cf_dtype = DT_REG;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000485 rc = -EOPNOTSUPP;
Steve French86c96b42005-11-18 20:25:31 -0800486 }
Steve French3020a1f2005-11-18 11:31:10 -0800487 } else {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400488 fattr->cf_mode |= S_IFREG; /* then it is a file */
489 fattr->cf_dtype = DT_REG;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000490 rc = -EOPNOTSUPP; /* or some unknown SFU type */
491 }
Jeff Layton7ffec372010-09-29 19:51:11 -0400492 CIFSSMBClose(xid, tcon, netfid);
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800493 }
Jeff Layton7ffec372010-09-29 19:51:11 -0400494 cifs_put_tlink(tlink);
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800495 return rc;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800496}
497
Steve French9e294f12005-11-17 16:59:21 -0800498#define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
499
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400500/*
501 * Fetch mode bits as provided by SFU.
502 *
503 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
504 */
505static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400506 struct cifs_sb_info *cifs_sb, unsigned int xid)
Steve French9e294f12005-11-17 16:59:21 -0800507{
Steve French3020a1f2005-11-18 11:31:10 -0800508#ifdef CONFIG_CIFS_XATTR
Steve French9e294f12005-11-17 16:59:21 -0800509 ssize_t rc;
510 char ea_value[4];
511 __u32 mode;
Jeff Layton7ffec372010-09-29 19:51:11 -0400512 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +0000513 struct cifs_tcon *tcon;
Steve French9e294f12005-11-17 16:59:21 -0800514
Jeff Layton7ffec372010-09-29 19:51:11 -0400515 tlink = cifs_sb_tlink(cifs_sb);
516 if (IS_ERR(tlink))
517 return PTR_ERR(tlink);
518 tcon = tlink_tcon(tlink);
519
520 rc = CIFSSMBQAllEAs(xid, tcon, path, "SETFILEBITS",
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400521 ea_value, 4 /* size of buf */, cifs_sb->local_nls,
522 cifs_sb->mnt_cifs_flags &
523 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton7ffec372010-09-29 19:51:11 -0400524 cifs_put_tlink(tlink);
Steve French4523cc32007-04-30 20:13:06 +0000525 if (rc < 0)
Steve French9e294f12005-11-17 16:59:21 -0800526 return (int)rc;
527 else if (rc > 3) {
528 mode = le32_to_cpu(*((__le32 *)ea_value));
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400529 fattr->cf_mode &= ~SFBITS_MASK;
Joe Perchesf96637b2013-05-04 22:12:25 -0500530 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
531 mode, fattr->cf_mode);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400532 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
Joe Perchesf96637b2013-05-04 22:12:25 -0500533 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
Steve French9e294f12005-11-17 16:59:21 -0800534 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400535
536 return 0;
Steve French3020a1f2005-11-18 11:31:10 -0800537#else
538 return -EOPNOTSUPP;
539#endif
Steve French9e294f12005-11-17 16:59:21 -0800540}
541
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400542/* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
Steve Frenchf1230c92009-07-22 23:13:01 +0000543static void
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400544cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
Pavel Shilovskyeb85d94b2013-10-23 17:49:47 +0400545 struct cifs_sb_info *cifs_sb, bool adjust_tz,
546 bool symlink)
Steve Frenchb9a32602008-05-20 21:52:32 +0000547{
Steve French96daf2b2011-05-27 04:34:02 +0000548 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Jeff Layton0d424ad2010-09-20 16:01:35 -0700549
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400550 memset(fattr, 0, sizeof(*fattr));
551 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
552 if (info->DeletePending)
553 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
Steve Frenchb9a32602008-05-20 21:52:32 +0000554
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400555 if (info->LastAccessTime)
556 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
557 else
558 fattr->cf_atime = CURRENT_TIME;
559
560 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
561 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
562
563 if (adjust_tz) {
Jeff Layton0d424ad2010-09-20 16:01:35 -0700564 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
565 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400566 }
567
568 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
569 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
Jeff Layton20054bd2011-01-07 11:30:27 -0500570 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400571
Jim McDonough74d290d2013-09-21 10:36:10 -0500572 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
Pavel Shilovskyeb85d94b2013-10-23 17:49:47 +0400573
574 if (symlink) {
575 fattr->cf_mode = S_IFLNK;
576 fattr->cf_dtype = DT_LNK;
577 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400578 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
579 fattr->cf_dtype = DT_DIR;
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +0300580 /*
581 * Server can return wrong NumberOfLinks value for directories
582 * when Unix extensions are disabled - fake it.
583 */
Jim McDonough74d290d2013-09-21 10:36:10 -0500584 if (!tcon->unix_ext)
585 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400586 } else {
587 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
588 fattr->cf_dtype = DT_REG;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400589
Jeff Laytond0c280d2009-07-09 01:46:44 -0400590 /* clear write bits if ATTR_READONLY is set */
591 if (fattr->cf_cifsattrs & ATTR_READONLY)
592 fattr->cf_mode &= ~(S_IWUGO);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400593
Jim McDonough74d290d2013-09-21 10:36:10 -0500594 /*
595 * Don't accept zero nlink from non-unix servers unless
596 * delete is pending. Instead mark it as unknown.
597 */
598 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
599 !info->DeletePending) {
600 cifs_dbg(1, "bogus file nlink value %u\n",
Steve French6658b9f2013-07-04 14:38:48 -0500601 fattr->cf_nlink);
Jim McDonough74d290d2013-09-21 10:36:10 -0500602 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
Steve French6658b9f2013-07-04 14:38:48 -0500603 }
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +0300604 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400605
606 fattr->cf_uid = cifs_sb->mnt_uid;
607 fattr->cf_gid = cifs_sb->mnt_gid;
Steve Frenchb9a32602008-05-20 21:52:32 +0000608}
609
Pavel Shilovsky4ad65042012-09-18 16:20:26 -0700610static int
611cifs_get_file_info(struct file *filp)
Jeff Laytonabab0952010-02-12 07:44:18 -0500612{
613 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400614 unsigned int xid;
Jeff Laytonabab0952010-02-12 07:44:18 -0500615 FILE_ALL_INFO find_data;
616 struct cifs_fattr fattr;
Al Viro496ad9a2013-01-23 17:07:38 -0500617 struct inode *inode = file_inode(filp);
Jeff Laytonabab0952010-02-12 07:44:18 -0500618 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Joe Perchesc21dfb62010-07-12 13:50:14 -0700619 struct cifsFileInfo *cfile = filp->private_data;
Steve French96daf2b2011-05-27 04:34:02 +0000620 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky4ad65042012-09-18 16:20:26 -0700621 struct TCP_Server_Info *server = tcon->ses->server;
622
623 if (!server->ops->query_file_info)
624 return -ENOSYS;
Jeff Laytonabab0952010-02-12 07:44:18 -0500625
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400626 xid = get_xid();
Pavel Shilovsky4ad65042012-09-18 16:20:26 -0700627 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400628 switch (rc) {
629 case 0:
Pavel Shilovskyeb85d94b2013-10-23 17:49:47 +0400630 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false,
631 false);
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400632 break;
633 case -EREMOTE:
634 cifs_create_dfs_fattr(&fattr, inode->i_sb);
635 rc = 0;
636 break;
637 case -EOPNOTSUPP:
638 case -EINVAL:
Jeff Laytonabab0952010-02-12 07:44:18 -0500639 /*
640 * FIXME: legacy server -- fall back to path-based call?
Steve Frenchff2157132010-03-09 20:30:42 +0000641 * for now, just skip revalidating and mark inode for
642 * immediate reval.
643 */
Jeff Laytonabab0952010-02-12 07:44:18 -0500644 rc = 0;
645 CIFS_I(inode)->time = 0;
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400646 default:
Jeff Laytonabab0952010-02-12 07:44:18 -0500647 goto cgfi_exit;
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400648 }
Jeff Laytonabab0952010-02-12 07:44:18 -0500649
650 /*
651 * don't bother with SFU junk here -- just mark inode as needing
652 * revalidation.
653 */
Jeff Laytonabab0952010-02-12 07:44:18 -0500654 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
655 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
656 cifs_fattr_to_inode(inode, &fattr);
657cgfi_exit:
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400658 free_xid(xid);
Jeff Laytonabab0952010-02-12 07:44:18 -0500659 return rc;
660}
661
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400662int
663cifs_get_inode_info(struct inode **inode, const char *full_path,
664 FILE_ALL_INFO *data, struct super_block *sb, int xid,
665 const __u16 *fid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666{
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500667 bool validinum = false;
668 __u16 srchflgs;
669 int rc = 0, tmprc = ENOSYS;
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400670 struct cifs_tcon *tcon;
671 struct TCP_Server_Info *server;
Jeff Layton7ffec372010-09-29 19:51:11 -0400672 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 char *buf = NULL;
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400675 bool adjust_tz = false;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400676 struct cifs_fattr fattr;
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500677 struct cifs_search_info *srchinf = NULL;
Pavel Shilovskyeb85d94b2013-10-23 17:49:47 +0400678 bool symlink = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679
Jeff Layton7ffec372010-09-29 19:51:11 -0400680 tlink = cifs_sb_tlink(cifs_sb);
681 if (IS_ERR(tlink))
682 return PTR_ERR(tlink);
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400683 tcon = tlink_tcon(tlink);
684 server = tcon->ses->server;
Jeff Layton7ffec372010-09-29 19:51:11 -0400685
Joe Perchesf96637b2013-05-04 22:12:25 -0500686 cifs_dbg(FYI, "Getting info on %s\n", full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400688 if ((data == NULL) && (*inode != NULL)) {
Pavel Shilovsky18cceb62013-09-05 13:01:06 +0400689 if (CIFS_CACHE_READ(CIFS_I(*inode))) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500690 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
Jeff Layton7ffec372010-09-29 19:51:11 -0400691 goto cgii_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 }
693 }
694
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400695 /* if inode info is not passed, get it from server */
696 if (data == NULL) {
697 if (!server->ops->query_path_info) {
698 rc = -ENOSYS;
699 goto cgii_exit;
700 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
Jeff Layton7ffec372010-09-29 19:51:11 -0400702 if (buf == NULL) {
703 rc = -ENOMEM;
704 goto cgii_exit;
705 }
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400706 data = (FILE_ALL_INFO *)buf;
707 rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path,
Pavel Shilovskyeb85d94b2013-10-23 17:49:47 +0400708 data, &adjust_tz, &symlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400710
711 if (!rc) {
Pavel Shilovskyeb85d94b2013-10-23 17:49:47 +0400712 cifs_all_info_to_fattr(&fattr, data, cifs_sb, adjust_tz,
713 symlink);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400714 } else if (rc == -EREMOTE) {
715 cifs_create_dfs_fattr(&fattr, sb);
Steve Frenchb9a32602008-05-20 21:52:32 +0000716 rc = 0;
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500717 } else if (rc == -EACCES && backup_cred(cifs_sb)) {
718 srchinf = kzalloc(sizeof(struct cifs_search_info),
719 GFP_KERNEL);
720 if (srchinf == NULL) {
721 rc = -ENOMEM;
722 goto cgii_exit;
723 }
724
725 srchinf->endOfSearch = false;
726 srchinf->info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
727
728 srchflgs = CIFS_SEARCH_CLOSE_ALWAYS |
729 CIFS_SEARCH_CLOSE_AT_END |
730 CIFS_SEARCH_BACKUP_SEARCH;
731
732 rc = CIFSFindFirst(xid, tcon, full_path,
733 cifs_sb, NULL, srchflgs, srchinf, false);
734 if (!rc) {
735 data =
736 (FILE_ALL_INFO *)srchinf->srch_entries_start;
737
738 cifs_dir_info_to_fattr(&fattr,
739 (FILE_DIRECTORY_INFO *)data, cifs_sb);
740 fattr.cf_uniqueid = le64_to_cpu(
741 ((SEARCH_ID_FULL_DIR_INFO *)data)->UniqueId);
742 validinum = true;
743
744 cifs_buf_release(srchinf->ntwrk_buf_start);
745 }
746 kfree(srchinf);
747 } else
Igor Mammedov79626702008-03-09 03:44:18 +0000748 goto cgii_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400750 /*
751 * If an inode wasn't passed in, then get the inode number
752 *
753 * Is an i_ino of zero legal? Can we use that to check if the server
754 * supports returning inode numbers? Are there other sanity checks we
755 * can use to ensure that the server is really filling in that field?
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400756 */
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400757 if (*inode == NULL) {
Steve Frenchb9a32602008-05-20 21:52:32 +0000758 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500759 if (validinum == false) {
760 if (server->ops->get_srv_inum)
761 tmprc = server->ops->get_srv_inum(xid,
762 tcon, cifs_sb, full_path,
763 &fattr.cf_uniqueid, data);
764 if (tmprc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500765 cifs_dbg(FYI, "GetSrvInodeNum rc %d\n",
766 tmprc);
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500767 fattr.cf_uniqueid = iunique(sb, ROOT_I);
768 cifs_autodisable_serverino(cifs_sb);
769 }
Jeff Layton132ac7b2009-02-10 07:33:57 -0500770 }
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500771 } else
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400772 fattr.cf_uniqueid = iunique(sb, ROOT_I);
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500773 } else
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400774 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
Steve Frenchb9a32602008-05-20 21:52:32 +0000775
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400776 /* query for SFU type info if supported and needed */
777 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
778 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
779 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
780 if (tmprc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500781 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
Steve Frenchb9a32602008-05-20 21:52:32 +0000782 }
Steve Frenchb9a32602008-05-20 21:52:32 +0000783
Jeff Layton79df1ba2010-12-06 12:52:08 -0500784#ifdef CONFIG_CIFS_ACL
Steve Frenchb9a32602008-05-20 21:52:32 +0000785 /* fill in 0777 bits from ACL */
786 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400787 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, full_path, fid);
Shirish Pargaonkar78415d22010-11-27 11:37:26 -0600788 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500789 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
790 __func__, rc);
Shirish Pargaonkar78415d22010-11-27 11:37:26 -0600791 goto cgii_exit;
792 }
Steve Frenchb9a32602008-05-20 21:52:32 +0000793 }
Jeff Layton79df1ba2010-12-06 12:52:08 -0500794#endif /* CONFIG_CIFS_ACL */
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400795
796 /* fill in remaining high mode bits e.g. SUID, VTX */
797 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
798 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
799
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200800 /* check for Minshall+French symlinks */
801 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
802 tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
803 if (tmprc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500804 cifs_dbg(FYI, "CIFSCheckMFSymlink: %d\n", tmprc);
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200805 }
806
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400807 if (!*inode) {
808 *inode = cifs_iget(sb, &fattr);
809 if (!*inode)
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400810 rc = -ENOMEM;
811 } else {
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400812 cifs_fattr_to_inode(*inode, &fattr);
Steve Frenchb9a32602008-05-20 21:52:32 +0000813 }
814
Igor Mammedov79626702008-03-09 03:44:18 +0000815cgii_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 kfree(buf);
Jeff Layton7ffec372010-09-29 19:51:11 -0400817 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 return rc;
819}
820
Steve French7f8ed422007-09-28 22:28:55 +0000821static const struct inode_operations cifs_ipc_inode_ops = {
822 .lookup = cifs_lookup,
823};
824
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400825static int
826cifs_find_inode(struct inode *inode, void *opaque)
827{
828 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
829
Jeff Laytonf30b9c12010-07-19 18:00:17 -0400830 /* don't match inode with different uniqueid */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400831 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
832 return 0;
833
Jeff Layton20054bd2011-01-07 11:30:27 -0500834 /* use createtime like an i_generation field */
835 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
836 return 0;
837
Jeff Laytonf30b9c12010-07-19 18:00:17 -0400838 /* don't match inode of different type */
839 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
840 return 0;
841
Jeff Layton5acfec22010-08-02 17:43:54 -0400842 /* if it's not a directory or has no dentries, then flag it */
Al Virob3d9b7a2012-06-09 13:51:19 -0400843 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
Jeff Layton3d694382010-05-11 14:59:55 -0400844 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
Jeff Layton3d694382010-05-11 14:59:55 -0400845
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400846 return 1;
847}
848
849static int
850cifs_init_inode(struct inode *inode, void *opaque)
851{
852 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
853
854 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
Jeff Layton20054bd2011-01-07 11:30:27 -0500855 CIFS_I(inode)->createtime = fattr->cf_createtime;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400856 return 0;
857}
858
Jeff Layton5acfec22010-08-02 17:43:54 -0400859/*
860 * walk dentry list for an inode and report whether it has aliases that
861 * are hashed. We use this to determine if a directory inode can actually
862 * be used.
863 */
864static bool
865inode_has_hashed_dentries(struct inode *inode)
866{
867 struct dentry *dentry;
868
Nick Piggin873feea2011-01-07 17:50:06 +1100869 spin_lock(&inode->i_lock);
Sasha Levinb67bfe02013-02-27 17:06:00 -0800870 hlist_for_each_entry(dentry, &inode->i_dentry, d_alias) {
Jeff Layton5acfec22010-08-02 17:43:54 -0400871 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
Nick Piggin873feea2011-01-07 17:50:06 +1100872 spin_unlock(&inode->i_lock);
Jeff Layton5acfec22010-08-02 17:43:54 -0400873 return true;
874 }
875 }
Nick Piggin873feea2011-01-07 17:50:06 +1100876 spin_unlock(&inode->i_lock);
Jeff Layton5acfec22010-08-02 17:43:54 -0400877 return false;
878}
879
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400880/* Given fattrs, get a corresponding inode */
881struct inode *
882cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
883{
884 unsigned long hash;
885 struct inode *inode;
886
Jeff Layton3d694382010-05-11 14:59:55 -0400887retry_iget5_locked:
Joe Perchesf96637b2013-05-04 22:12:25 -0500888 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400889
890 /* hash down to 32-bits on 32-bit arch */
891 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
892
893 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400894 if (inode) {
Jeff Layton5acfec22010-08-02 17:43:54 -0400895 /* was there a potentially problematic inode collision? */
Jeff Layton3d694382010-05-11 14:59:55 -0400896 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
Jeff Layton3d694382010-05-11 14:59:55 -0400897 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
Jeff Layton5acfec22010-08-02 17:43:54 -0400898
899 if (inode_has_hashed_dentries(inode)) {
900 cifs_autodisable_serverino(CIFS_SB(sb));
901 iput(inode);
902 fattr->cf_uniqueid = iunique(sb, ROOT_I);
903 goto retry_iget5_locked;
904 }
Jeff Layton3d694382010-05-11 14:59:55 -0400905 }
906
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400907 cifs_fattr_to_inode(inode, fattr);
908 if (sb->s_flags & MS_NOATIME)
909 inode->i_flags |= S_NOATIME | S_NOCMTIME;
910 if (inode->i_state & I_NEW) {
911 inode->i_ino = hash;
Jeff Layton522440e2010-09-29 09:49:54 -0400912 if (S_ISREG(inode->i_mode))
913 inode->i_data.backing_dev_info = sb->s_bdi;
Steve French0ccd4802010-07-16 04:31:02 +0000914#ifdef CONFIG_CIFS_FSCACHE
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530915 /* initialize per-inode cache cookie pointer */
916 CIFS_I(inode)->fscache = NULL;
Steve French0ccd4802010-07-16 04:31:02 +0000917#endif
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400918 unlock_new_inode(inode);
919 }
920 }
921
922 return inode;
923}
924
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925/* gets root inode */
Shirish Pargaonkar9b6763e2011-02-21 23:56:59 -0600926struct inode *cifs_root_iget(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400928 unsigned int xid;
Jeff Layton0d424ad2010-09-20 16:01:35 -0700929 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400930 struct inode *inode = NULL;
David Howellsce634ab2008-02-07 00:15:33 -0800931 long rc;
Steve French96daf2b2011-05-27 04:34:02 +0000932 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
David Howellsce634ab2008-02-07 00:15:33 -0800933
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400934 xid = get_xid();
Jeff Layton0d424ad2010-09-20 16:01:35 -0700935 if (tcon->unix_ext)
Steve Frenchf87d39d2011-05-27 03:50:55 +0000936 rc = cifs_get_inode_info_unix(&inode, "", sb, xid);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400937 else
Steve Frenchf87d39d2011-05-27 03:50:55 +0000938 rc = cifs_get_inode_info(&inode, "", NULL, sb, xid, NULL);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400939
Oskar Schirmera7851ce2010-11-10 21:06:13 +0000940 if (!inode) {
941 inode = ERR_PTR(rc);
942 goto out;
943 }
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400944
Steve French0ccd4802010-07-16 04:31:02 +0000945#ifdef CONFIG_CIFS_FSCACHE
Suresh Jayaramand03382c2010-07-05 18:12:27 +0530946 /* populate tcon->resource_id */
Jeff Layton0d424ad2010-09-20 16:01:35 -0700947 tcon->resource_id = CIFS_I(inode)->uniqueid;
Steve French0ccd4802010-07-16 04:31:02 +0000948#endif
Suresh Jayaramand03382c2010-07-05 18:12:27 +0530949
Jeff Layton0d424ad2010-09-20 16:01:35 -0700950 if (rc && tcon->ipc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500951 cifs_dbg(FYI, "ipc connection - fake read inode\n");
Steve Frenchb7ca6922012-08-03 08:43:01 -0500952 spin_lock(&inode->i_lock);
Steve French7f8ed422007-09-28 22:28:55 +0000953 inode->i_mode |= S_IFDIR;
Miklos Szeredibfe86842011-10-28 14:13:29 +0200954 set_nlink(inode, 2);
Steve French7f8ed422007-09-28 22:28:55 +0000955 inode->i_op = &cifs_ipc_inode_ops;
956 inode->i_fop = &simple_dir_operations;
957 inode->i_uid = cifs_sb->mnt_uid;
958 inode->i_gid = cifs_sb->mnt_gid;
Steve Frenchb7ca6922012-08-03 08:43:01 -0500959 spin_unlock(&inode->i_lock);
Steve Frenchad661332008-08-12 14:14:40 +0000960 } else if (rc) {
David Howellsce634ab2008-02-07 00:15:33 -0800961 iget_failed(inode);
Oskar Schirmera7851ce2010-11-10 21:06:13 +0000962 inode = ERR_PTR(rc);
Steve French7f8ed422007-09-28 22:28:55 +0000963 }
964
Oskar Schirmera7851ce2010-11-10 21:06:13 +0000965out:
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400966 /* can not call macro free_xid here since in a void func
David Howellsce634ab2008-02-07 00:15:33 -0800967 * TODO: This is no longer true
968 */
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400969 _free_xid(xid);
David Howellsce634ab2008-02-07 00:15:33 -0800970 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971}
972
Pavel Shilovskyed6875e2012-09-18 16:20:25 -0700973int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400974cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
Pavel Shilovskyed6875e2012-09-18 16:20:25 -0700975 char *full_path, __u32 dosattr)
Steve French388e57b2008-09-16 23:50:58 +0000976{
Steve French388e57b2008-09-16 23:50:58 +0000977 bool set_time = false;
Steve French388e57b2008-09-16 23:50:58 +0000978 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Pavel Shilovsky6bdf6db2012-09-18 16:20:32 -0700979 struct TCP_Server_Info *server;
Steve French388e57b2008-09-16 23:50:58 +0000980 FILE_BASIC_INFO info_buf;
981
Steve French1adcb712009-02-25 14:19:56 +0000982 if (attrs == NULL)
983 return -EINVAL;
984
Pavel Shilovsky6bdf6db2012-09-18 16:20:32 -0700985 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
986 if (!server->ops->set_file_info)
987 return -ENOSYS;
988
Steve French388e57b2008-09-16 23:50:58 +0000989 if (attrs->ia_valid & ATTR_ATIME) {
990 set_time = true;
991 info_buf.LastAccessTime =
992 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
993 } else
994 info_buf.LastAccessTime = 0;
995
996 if (attrs->ia_valid & ATTR_MTIME) {
997 set_time = true;
998 info_buf.LastWriteTime =
999 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1000 } else
1001 info_buf.LastWriteTime = 0;
1002
1003 /*
1004 * Samba throws this field away, but windows may actually use it.
1005 * Do not set ctime unless other time stamps are changed explicitly
1006 * (i.e. by utimes()) since we would then have a mix of client and
1007 * server times.
1008 */
1009 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001010 cifs_dbg(FYI, "CIFS - CTIME changed\n");
Steve French388e57b2008-09-16 23:50:58 +00001011 info_buf.ChangeTime =
1012 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1013 } else
1014 info_buf.ChangeTime = 0;
1015
1016 info_buf.CreationTime = 0; /* don't change */
1017 info_buf.Attributes = cpu_to_le32(dosattr);
1018
Pavel Shilovsky6bdf6db2012-09-18 16:20:32 -07001019 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
Steve French388e57b2008-09-16 23:50:58 +00001020}
1021
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001022/*
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001023 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001024 * and rename it to a random name that hopefully won't conflict with
1025 * anything else.
1026 */
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001027int
1028cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1029 const unsigned int xid)
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001030{
1031 int oplock = 0;
1032 int rc;
1033 __u16 netfid;
Steve French32709582008-10-20 00:44:19 +00001034 struct inode *inode = dentry->d_inode;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001035 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1036 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001037 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001038 struct cifs_tcon *tcon;
Steve French32709582008-10-20 00:44:19 +00001039 __u32 dosattr, origattr;
1040 FILE_BASIC_INFO *info_buf = NULL;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001041
Jeff Layton7ffec372010-09-29 19:51:11 -04001042 tlink = cifs_sb_tlink(cifs_sb);
1043 if (IS_ERR(tlink))
1044 return PTR_ERR(tlink);
1045 tcon = tlink_tcon(tlink);
1046
Sachin Prabhuc483a982013-03-05 19:25:56 +00001047 /*
1048 * We cannot rename the file if the server doesn't support
1049 * CAP_INFOLEVEL_PASSTHRU
1050 */
1051 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1052 rc = -EBUSY;
1053 goto out;
1054 }
1055
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001056 rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
Jeff Laytondd1db2d2008-10-16 19:27:12 -04001057 DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001058 &netfid, &oplock, NULL, cifs_sb->local_nls,
1059 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1060 if (rc != 0)
1061 goto out;
1062
Steve French32709582008-10-20 00:44:19 +00001063 origattr = cifsInode->cifsAttrs;
1064 if (origattr == 0)
1065 origattr |= ATTR_NORMAL;
1066
1067 dosattr = origattr & ~ATTR_READONLY;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001068 if (dosattr == 0)
1069 dosattr |= ATTR_NORMAL;
1070 dosattr |= ATTR_HIDDEN;
1071
Steve French32709582008-10-20 00:44:19 +00001072 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1073 if (dosattr != origattr) {
1074 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1075 if (info_buf == NULL) {
1076 rc = -ENOMEM;
1077 goto out_close;
1078 }
1079 info_buf->Attributes = cpu_to_le32(dosattr);
1080 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1081 current->tgid);
1082 /* although we would like to mark the file hidden
1083 if that fails we will still try to rename it */
Sachin Prabhu72d282d2013-03-05 19:25:55 +00001084 if (!rc)
Steve French32709582008-10-20 00:44:19 +00001085 cifsInode->cifsAttrs = dosattr;
1086 else
1087 dosattr = origattr; /* since not able to change them */
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001088 }
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001089
Jeff Laytondd1db2d2008-10-16 19:27:12 -04001090 /* rename the file */
1091 rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001092 cifs_sb->mnt_cifs_flags &
1093 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French32709582008-10-20 00:44:19 +00001094 if (rc != 0) {
Sachin Prabhu47c78f42013-03-11 13:08:49 +00001095 rc = -EBUSY;
Steve French32709582008-10-20 00:44:19 +00001096 goto undo_setattr;
1097 }
Jeff Layton6d22f092008-09-23 11:48:35 -04001098
Steve French32709582008-10-20 00:44:19 +00001099 /* try to set DELETE_ON_CLOSE */
1100 if (!cifsInode->delete_pending) {
1101 rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
1102 current->tgid);
1103 /*
1104 * some samba versions return -ENOENT when we try to set the
1105 * file disposition here. Likely a samba bug, but work around
1106 * it for now. This means that some cifsXXX files may hang
1107 * around after they shouldn't.
1108 *
1109 * BB: remove this hack after more servers have the fix
1110 */
1111 if (rc == -ENOENT)
1112 rc = 0;
1113 else if (rc != 0) {
Sachin Prabhu47c78f42013-03-11 13:08:49 +00001114 rc = -EBUSY;
Steve French32709582008-10-20 00:44:19 +00001115 goto undo_rename;
1116 }
1117 cifsInode->delete_pending = true;
1118 }
Jeff Layton7ce86d52008-09-24 11:32:59 -04001119
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001120out_close:
1121 CIFSSMBClose(xid, tcon, netfid);
1122out:
Steve French32709582008-10-20 00:44:19 +00001123 kfree(info_buf);
Jeff Layton7ffec372010-09-29 19:51:11 -04001124 cifs_put_tlink(tlink);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001125 return rc;
Steve French32709582008-10-20 00:44:19 +00001126
1127 /*
1128 * reset everything back to the original state. Don't bother
1129 * dealing with errors here since we can't do anything about
1130 * them anyway.
1131 */
1132undo_rename:
1133 CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
1134 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1135 CIFS_MOUNT_MAP_SPECIAL_CHR);
1136undo_setattr:
1137 if (dosattr != origattr) {
1138 info_buf->Attributes = cpu_to_le32(origattr);
1139 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1140 current->tgid))
1141 cifsInode->cifsAttrs = origattr;
1142 }
1143
1144 goto out_close;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001145}
1146
Steve Frenchb7ca6922012-08-03 08:43:01 -05001147/* copied from fs/nfs/dir.c with small changes */
1148static void
1149cifs_drop_nlink(struct inode *inode)
1150{
1151 spin_lock(&inode->i_lock);
1152 if (inode->i_nlink > 0)
1153 drop_nlink(inode);
1154 spin_unlock(&inode->i_lock);
1155}
Steve Frenchff694522009-04-20 19:45:13 +00001156
1157/*
1158 * If dentry->d_inode is null (usually meaning the cached dentry
1159 * is a negative dentry) then we would attempt a standard SMB delete, but
André Goddard Rosaaf901ca2009-11-14 13:09:05 -02001160 * if that fails we can not attempt the fall back mechanisms on EACCESS
1161 * but will return the EACCESS to the caller. Note that the VFS does not call
Steve Frenchff694522009-04-20 19:45:13 +00001162 * unlink on negative dentries currently.
1163 */
Jeff Layton5f0319a2008-09-16 14:05:16 -04001164int cifs_unlink(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165{
1166 int rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001167 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168 char *full_path = NULL;
Jeff Layton5f0319a2008-09-16 14:05:16 -04001169 struct inode *inode = dentry->d_inode;
Steve Frenchff694522009-04-20 19:45:13 +00001170 struct cifsInodeInfo *cifs_inode;
Jeff Layton5f0319a2008-09-16 14:05:16 -04001171 struct super_block *sb = dir->i_sb;
1172 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001173 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001174 struct cifs_tcon *tcon;
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001175 struct TCP_Server_Info *server;
Steve French60502472008-10-07 18:42:52 +00001176 struct iattr *attrs = NULL;
1177 __u32 dosattr = 0, origattr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178
Joe Perchesf96637b2013-05-04 22:12:25 -05001179 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180
Jeff Layton7ffec372010-09-29 19:51:11 -04001181 tlink = cifs_sb_tlink(cifs_sb);
1182 if (IS_ERR(tlink))
1183 return PTR_ERR(tlink);
1184 tcon = tlink_tcon(tlink);
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001185 server = tcon->ses->server;
Jeff Layton7ffec372010-09-29 19:51:11 -04001186
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001187 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188
Jeff Layton5f0319a2008-09-16 14:05:16 -04001189 /* Unlink can be called from rename so we can not take the
1190 * sb->s_vfs_rename_mutex here */
1191 full_path = build_path_from_dentry(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301193 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001194 goto unlink_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 }
Steve French2d785a52007-07-15 01:48:57 +00001196
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001197 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1198 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001199 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
Steve French2d785a52007-07-15 01:48:57 +00001200 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1201 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Joe Perchesf96637b2013-05-04 22:12:25 -05001202 cifs_dbg(FYI, "posix del rc %d\n", rc);
Steve French2d785a52007-07-15 01:48:57 +00001203 if ((rc == 0) || (rc == -ENOENT))
1204 goto psx_del_no_retry;
1205 }
1206
Steve French60502472008-10-07 18:42:52 +00001207retry_std_delete:
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001208 if (!server->ops->unlink) {
1209 rc = -ENOSYS;
1210 goto psx_del_no_retry;
1211 }
1212
1213 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
Steve French60502472008-10-07 18:42:52 +00001214
Steve French2d785a52007-07-15 01:48:57 +00001215psx_del_no_retry:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216 if (!rc) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001217 if (inode)
Steve Frenchb7ca6922012-08-03 08:43:01 -05001218 cifs_drop_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 } else if (rc == -ENOENT) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001220 d_drop(dentry);
Sachin Prabhu47c78f42013-03-11 13:08:49 +00001221 } else if (rc == -EBUSY) {
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001222 if (server->ops->rename_pending_delete) {
1223 rc = server->ops->rename_pending_delete(full_path,
1224 dentry, xid);
1225 if (rc == 0)
1226 cifs_drop_nlink(inode);
1227 }
Steve Frenchff694522009-04-20 19:45:13 +00001228 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
Steve French388e57b2008-09-16 23:50:58 +00001229 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1230 if (attrs == NULL) {
1231 rc = -ENOMEM;
1232 goto out_reval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 }
Steve French388e57b2008-09-16 23:50:58 +00001234
1235 /* try to reset dos attributes */
Steve Frenchff694522009-04-20 19:45:13 +00001236 cifs_inode = CIFS_I(inode);
1237 origattr = cifs_inode->cifsAttrs;
Steve French60502472008-10-07 18:42:52 +00001238 if (origattr == 0)
1239 origattr |= ATTR_NORMAL;
1240 dosattr = origattr & ~ATTR_READONLY;
Steve French388e57b2008-09-16 23:50:58 +00001241 if (dosattr == 0)
1242 dosattr |= ATTR_NORMAL;
1243 dosattr |= ATTR_HIDDEN;
1244
1245 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
Steve French388e57b2008-09-16 23:50:58 +00001246 if (rc != 0)
1247 goto out_reval;
Steve French60502472008-10-07 18:42:52 +00001248
1249 goto retry_std_delete;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 }
Steve French60502472008-10-07 18:42:52 +00001251
1252 /* undo the setattr if we errored out and it's needed */
1253 if (rc != 0 && dosattr != 0)
1254 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1255
Steve French388e57b2008-09-16 23:50:58 +00001256out_reval:
Jeff Layton5f0319a2008-09-16 14:05:16 -04001257 if (inode) {
Steve Frenchff694522009-04-20 19:45:13 +00001258 cifs_inode = CIFS_I(inode);
1259 cifs_inode->time = 0; /* will force revalidate to get info
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001260 when needed */
Jeff Layton5f0319a2008-09-16 14:05:16 -04001261 inode->i_ctime = current_fs_time(sb);
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001262 }
Jeff Layton5f0319a2008-09-16 14:05:16 -04001263 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
Steve Frenchff694522009-04-20 19:45:13 +00001264 cifs_inode = CIFS_I(dir);
Steve French60502472008-10-07 18:42:52 +00001265 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
Jeff Layton7ffec372010-09-29 19:51:11 -04001266unlink_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 kfree(full_path);
Steve French60502472008-10-07 18:42:52 +00001268 kfree(attrs);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001269 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001270 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271 return rc;
1272}
1273
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001274static int
Jeff Layton101b92d2012-09-19 06:22:45 -07001275cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001276 const char *full_path, struct cifs_sb_info *cifs_sb,
1277 struct cifs_tcon *tcon, const unsigned int xid)
1278{
1279 int rc = 0;
Jeff Layton101b92d2012-09-19 06:22:45 -07001280 struct inode *inode = NULL;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001281
1282 if (tcon->unix_ext)
Jeff Layton101b92d2012-09-19 06:22:45 -07001283 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001284 xid);
1285 else
Jeff Layton101b92d2012-09-19 06:22:45 -07001286 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1287 xid, NULL);
1288
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001289 if (rc)
1290 return rc;
1291
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001292 /*
1293 * setting nlink not necessary except in cases where we failed to get it
Jeff Layton101b92d2012-09-19 06:22:45 -07001294 * from the server or was set bogus. Also, since this is a brand new
1295 * inode, no need to grab the i_lock before setting the i_nlink.
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001296 */
Jeff Layton101b92d2012-09-19 06:22:45 -07001297 if (inode->i_nlink < 2)
1298 set_nlink(inode, 2);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001299 mode &= ~current_umask();
1300 /* must turn on setgid bit if parent dir has it */
Jeff Layton101b92d2012-09-19 06:22:45 -07001301 if (parent->i_mode & S_ISGID)
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001302 mode |= S_ISGID;
1303
1304 if (tcon->unix_ext) {
1305 struct cifs_unix_set_info_args args = {
1306 .mode = mode,
1307 .ctime = NO_CHANGE_64,
1308 .atime = NO_CHANGE_64,
1309 .mtime = NO_CHANGE_64,
1310 .device = 0,
1311 };
1312 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
Eric W. Biederman49418b22013-02-06 00:57:56 -08001313 args.uid = current_fsuid();
Jeff Layton101b92d2012-09-19 06:22:45 -07001314 if (parent->i_mode & S_ISGID)
Eric W. Biederman49418b22013-02-06 00:57:56 -08001315 args.gid = parent->i_gid;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001316 else
Eric W. Biederman49418b22013-02-06 00:57:56 -08001317 args.gid = current_fsgid();
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001318 } else {
Eric W. Biederman49418b22013-02-06 00:57:56 -08001319 args.uid = INVALID_UID; /* no change */
1320 args.gid = INVALID_GID; /* no change */
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001321 }
1322 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1323 cifs_sb->local_nls,
1324 cifs_sb->mnt_cifs_flags &
1325 CIFS_MOUNT_MAP_SPECIAL_CHR);
1326 } else {
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001327 struct TCP_Server_Info *server = tcon->ses->server;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001328 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001329 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
Jeff Layton101b92d2012-09-19 06:22:45 -07001330 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001331 tcon, xid);
Jeff Layton101b92d2012-09-19 06:22:45 -07001332 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1333 inode->i_mode = (mode | S_IFDIR);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001334
Jeff Layton101b92d2012-09-19 06:22:45 -07001335 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1336 inode->i_uid = current_fsuid();
1337 if (inode->i_mode & S_ISGID)
1338 inode->i_gid = parent->i_gid;
1339 else
1340 inode->i_gid = current_fsgid();
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001341 }
1342 }
Jeff Layton101b92d2012-09-19 06:22:45 -07001343 d_instantiate(dentry, inode);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001344 return rc;
1345}
1346
1347static int
1348cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1349 const char *full_path, struct cifs_sb_info *cifs_sb,
1350 struct cifs_tcon *tcon, const unsigned int xid)
1351{
1352 int rc = 0;
1353 u32 oplock = 0;
1354 FILE_UNIX_BASIC_INFO *info = NULL;
1355 struct inode *newinode = NULL;
1356 struct cifs_fattr fattr;
1357
1358 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1359 if (info == NULL) {
1360 rc = -ENOMEM;
1361 goto posix_mkdir_out;
1362 }
1363
1364 mode &= ~current_umask();
1365 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1366 NULL /* netfid */, info, &oplock, full_path,
1367 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1368 CIFS_MOUNT_MAP_SPECIAL_CHR);
1369 if (rc == -EOPNOTSUPP)
1370 goto posix_mkdir_out;
1371 else if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001372 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001373 d_drop(dentry);
1374 goto posix_mkdir_out;
1375 }
1376
1377 if (info->Type == cpu_to_le32(-1))
1378 /* no return info, go query for it */
1379 goto posix_mkdir_get_info;
1380 /*
1381 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1382 * need to set uid/gid.
1383 */
1384
1385 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1386 cifs_fill_uniqueid(inode->i_sb, &fattr);
1387 newinode = cifs_iget(inode->i_sb, &fattr);
1388 if (!newinode)
1389 goto posix_mkdir_get_info;
1390
1391 d_instantiate(dentry, newinode);
1392
1393#ifdef CONFIG_CIFS_DEBUG2
Joe Perchesf96637b2013-05-04 22:12:25 -05001394 cifs_dbg(FYI, "instantiated dentry %p %s to inode %p\n",
1395 dentry, dentry->d_name.name, newinode);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001396
1397 if (newinode->i_nlink != 2)
Joe Perchesf96637b2013-05-04 22:12:25 -05001398 cifs_dbg(FYI, "unexpected number of links %d\n",
1399 newinode->i_nlink);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001400#endif
1401
1402posix_mkdir_out:
1403 kfree(info);
1404 return rc;
1405posix_mkdir_get_info:
1406 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1407 xid);
1408 goto posix_mkdir_out;
1409}
1410
Al Viro18bb1db2011-07-26 01:41:39 -04001411int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412{
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001413 int rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001414 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001416 struct tcon_link *tlink;
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001417 struct cifs_tcon *tcon;
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001418 struct TCP_Server_Info *server;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001419 char *full_path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420
Joe Perchesf96637b2013-05-04 22:12:25 -05001421 cifs_dbg(FYI, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1422 mode, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424 cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001425 tlink = cifs_sb_tlink(cifs_sb);
1426 if (IS_ERR(tlink))
1427 return PTR_ERR(tlink);
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001428 tcon = tlink_tcon(tlink);
Jeff Layton7ffec372010-09-29 19:51:11 -04001429
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001430 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431
Steve French7f573562005-08-30 11:32:14 -07001432 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301434 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001435 goto mkdir_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 }
Steve French50c2f752007-07-13 00:33:32 +00001437
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001438 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1439 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001440 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1441 tcon, xid);
1442 if (rc != -EOPNOTSUPP)
Steve French2dd29d32007-04-23 22:07:35 +00001443 goto mkdir_out;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001444 }
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001445
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001446 server = tcon->ses->server;
1447
1448 if (!server->ops->mkdir) {
1449 rc = -ENOSYS;
1450 goto mkdir_out;
1451 }
1452
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453 /* BB add setting the equivalent of mode via CreateX w/ACLs */
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001454 rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001456 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 d_drop(direntry);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001458 goto mkdir_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 }
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001460
1461 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1462 xid);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001463mkdir_out:
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +03001464 /*
1465 * Force revalidate to get parent dir info when needed since cached
1466 * attributes are invalid now.
1467 */
1468 CIFS_I(inode)->time = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001470 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001471 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472 return rc;
1473}
1474
1475int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1476{
1477 int rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001478 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001480 struct tcon_link *tlink;
Pavel Shilovskyf958ca52012-07-10 16:14:18 +04001481 struct cifs_tcon *tcon;
1482 struct TCP_Server_Info *server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483 char *full_path = NULL;
1484 struct cifsInodeInfo *cifsInode;
1485
Joe Perchesf96637b2013-05-04 22:12:25 -05001486 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001488 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489
Steve French7f573562005-08-30 11:32:14 -07001490 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301492 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001493 goto rmdir_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494 }
1495
Jeff Layton7ffec372010-09-29 19:51:11 -04001496 cifs_sb = CIFS_SB(inode->i_sb);
1497 tlink = cifs_sb_tlink(cifs_sb);
1498 if (IS_ERR(tlink)) {
1499 rc = PTR_ERR(tlink);
1500 goto rmdir_exit;
1501 }
Pavel Shilovskyf958ca52012-07-10 16:14:18 +04001502 tcon = tlink_tcon(tlink);
1503 server = tcon->ses->server;
Jeff Layton7ffec372010-09-29 19:51:11 -04001504
Pavel Shilovskyf958ca52012-07-10 16:14:18 +04001505 if (!server->ops->rmdir) {
1506 rc = -ENOSYS;
1507 cifs_put_tlink(tlink);
1508 goto rmdir_exit;
1509 }
1510
1511 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001512 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513
1514 if (!rc) {
Steve French3677db12007-02-26 16:46:11 +00001515 spin_lock(&direntry->d_inode->i_lock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001516 i_size_write(direntry->d_inode, 0);
Dave Hansence71ec32006-09-30 23:29:06 -07001517 clear_nlink(direntry->d_inode);
Steve French3677db12007-02-26 16:46:11 +00001518 spin_unlock(&direntry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519 }
1520
1521 cifsInode = CIFS_I(direntry->d_inode);
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +03001522 /* force revalidate to go get info when needed */
1523 cifsInode->time = 0;
Steve French42c24542009-01-13 22:03:55 +00001524
1525 cifsInode = CIFS_I(inode);
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +03001526 /*
1527 * Force revalidate to get parent dir info when needed since cached
1528 * attributes are invalid now.
1529 */
1530 cifsInode->time = 0;
Steve French42c24542009-01-13 22:03:55 +00001531
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1533 current_fs_time(inode->i_sb);
1534
Jeff Layton7ffec372010-09-29 19:51:11 -04001535rmdir_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001537 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 return rc;
1539}
1540
Steve Frenchee2fd962008-09-23 18:23:33 +00001541static int
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001542cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1543 const char *from_path, struct dentry *to_dentry,
1544 const char *to_path)
Steve Frenchee2fd962008-09-23 18:23:33 +00001545{
1546 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001547 struct tcon_link *tlink;
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001548 struct cifs_tcon *tcon;
1549 struct TCP_Server_Info *server;
Steve Frenchee2fd962008-09-23 18:23:33 +00001550 __u16 srcfid;
1551 int oplock, rc;
1552
Jeff Layton7ffec372010-09-29 19:51:11 -04001553 tlink = cifs_sb_tlink(cifs_sb);
1554 if (IS_ERR(tlink))
1555 return PTR_ERR(tlink);
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001556 tcon = tlink_tcon(tlink);
1557 server = tcon->ses->server;
1558
1559 if (!server->ops->rename)
1560 return -ENOSYS;
Jeff Layton7ffec372010-09-29 19:51:11 -04001561
Steve Frenchee2fd962008-09-23 18:23:33 +00001562 /* try path-based rename first */
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001563 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
Steve Frenchee2fd962008-09-23 18:23:33 +00001564
1565 /*
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001566 * Don't bother with rename by filehandle unless file is busy and
1567 * source. Note that cross directory moves do not work with
Steve Frenchee2fd962008-09-23 18:23:33 +00001568 * rename by filehandle to various Windows servers.
1569 */
Sachin Prabhu47c78f42013-03-11 13:08:49 +00001570 if (rc == 0 || rc != -EBUSY)
Jeff Layton7ffec372010-09-29 19:51:11 -04001571 goto do_rename_exit;
Steve Frenchee2fd962008-09-23 18:23:33 +00001572
Jeff Laytoned0e3ac2010-06-01 16:21:01 -04001573 /* open-file renames don't work across directories */
1574 if (to_dentry->d_parent != from_dentry->d_parent)
Jeff Layton7ffec372010-09-29 19:51:11 -04001575 goto do_rename_exit;
Jeff Laytoned0e3ac2010-06-01 16:21:01 -04001576
Steve Frenchee2fd962008-09-23 18:23:33 +00001577 /* open the file to be renamed -- we need DELETE perms */
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001578 rc = CIFSSMBOpen(xid, tcon, from_path, FILE_OPEN, DELETE,
Steve Frenchee2fd962008-09-23 18:23:33 +00001579 CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1580 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1581 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve Frenchee2fd962008-09-23 18:23:33 +00001582 if (rc == 0) {
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001583 rc = CIFSSMBRenameOpenFile(xid, tcon, srcfid,
Steve Frenchee2fd962008-09-23 18:23:33 +00001584 (const char *) to_dentry->d_name.name,
1585 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1586 CIFS_MOUNT_MAP_SPECIAL_CHR);
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001587 CIFSSMBClose(xid, tcon, srcfid);
Steve Frenchee2fd962008-09-23 18:23:33 +00001588 }
Jeff Layton7ffec372010-09-29 19:51:11 -04001589do_rename_exit:
1590 cifs_put_tlink(tlink);
Steve Frenchee2fd962008-09-23 18:23:33 +00001591 return rc;
1592}
1593
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001594int
1595cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1596 struct inode *target_dir, struct dentry *target_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597{
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001598 char *from_name = NULL;
1599 char *to_name = NULL;
Jeff Layton639e7a92010-09-03 11:50:09 -04001600 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001601 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001602 struct cifs_tcon *tcon;
Steve Frenchee2fd962008-09-23 18:23:33 +00001603 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1604 FILE_UNIX_BASIC_INFO *info_buf_target;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001605 unsigned int xid;
1606 int rc, tmprc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607
Jeff Layton639e7a92010-09-03 11:50:09 -04001608 cifs_sb = CIFS_SB(source_dir->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001609 tlink = cifs_sb_tlink(cifs_sb);
1610 if (IS_ERR(tlink))
1611 return PTR_ERR(tlink);
1612 tcon = tlink_tcon(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001614 xid = get_xid();
Steve Frenchee2fd962008-09-23 18:23:33 +00001615
1616 /*
Steve Frenchee2fd962008-09-23 18:23:33 +00001617 * we already have the rename sem so we do not need to
1618 * grab it again here to protect the path integrity
1619 */
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001620 from_name = build_path_from_dentry(source_dentry);
1621 if (from_name == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622 rc = -ENOMEM;
1623 goto cifs_rename_exit;
1624 }
1625
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001626 to_name = build_path_from_dentry(target_dentry);
1627 if (to_name == NULL) {
Steve Frenchee2fd962008-09-23 18:23:33 +00001628 rc = -ENOMEM;
1629 goto cifs_rename_exit;
1630 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001632 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1633 to_name);
Steve Frenchee2fd962008-09-23 18:23:33 +00001634
Jeff Layton14121bd2008-10-20 14:45:22 -04001635 if (rc == -EEXIST && tcon->unix_ext) {
Steve Frenchee2fd962008-09-23 18:23:33 +00001636 /*
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001637 * Are src and dst hardlinks of same inode? We can only tell
1638 * with unix extensions enabled.
Steve Frenchee2fd962008-09-23 18:23:33 +00001639 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001640 info_buf_source =
1641 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1642 GFP_KERNEL);
1643 if (info_buf_source == NULL) {
1644 rc = -ENOMEM;
1645 goto cifs_rename_exit;
1646 }
1647
1648 info_buf_target = info_buf_source + 1;
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001649 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1650 info_buf_source,
1651 cifs_sb->local_nls,
1652 cifs_sb->mnt_cifs_flags &
1653 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton8d281ef2008-10-22 13:57:01 -04001654 if (tmprc != 0)
Jeff Layton14121bd2008-10-20 14:45:22 -04001655 goto unlink_target;
1656
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001657 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1658 info_buf_target,
1659 cifs_sb->local_nls,
1660 cifs_sb->mnt_cifs_flags &
1661 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton14121bd2008-10-20 14:45:22 -04001662
Jeff Layton8d281ef2008-10-22 13:57:01 -04001663 if (tmprc == 0 && (info_buf_source->UniqueId ==
Jeff Laytonae6884a2008-11-03 14:05:08 -05001664 info_buf_target->UniqueId)) {
Jeff Layton14121bd2008-10-20 14:45:22 -04001665 /* same file, POSIX says that this is a noop */
Jeff Laytonae6884a2008-11-03 14:05:08 -05001666 rc = 0;
Jeff Layton14121bd2008-10-20 14:45:22 -04001667 goto cifs_rename_exit;
Jeff Laytonae6884a2008-11-03 14:05:08 -05001668 }
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001669 }
1670 /*
1671 * else ... BB we could add the same check for Windows by
1672 * checking the UniqueId via FILE_INTERNAL_INFO
1673 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001674
Jeff Layton14121bd2008-10-20 14:45:22 -04001675unlink_target:
Jeff Laytonfc6f3942009-04-17 11:45:30 -04001676 /* Try unlinking the target dentry if it's not negative */
1677 if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
Jeff Layton8d281ef2008-10-22 13:57:01 -04001678 tmprc = cifs_unlink(target_dir, target_dentry);
Jeff Layton14121bd2008-10-20 14:45:22 -04001679 if (tmprc)
1680 goto cifs_rename_exit;
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001681 rc = cifs_do_rename(xid, source_dentry, from_name,
1682 target_dentry, to_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 }
1684
1685cifs_rename_exit:
Steve Frenchee2fd962008-09-23 18:23:33 +00001686 kfree(info_buf_source);
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001687 kfree(from_name);
1688 kfree(to_name);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001689 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001690 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691 return rc;
1692}
1693
Jeff Laytondf2cf172010-02-12 07:44:16 -05001694static bool
1695cifs_inode_needs_reval(struct inode *inode)
1696{
1697 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301698 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Laytondf2cf172010-02-12 07:44:16 -05001699
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001700 if (CIFS_CACHE_READ(cifs_i))
Jeff Laytondf2cf172010-02-12 07:44:16 -05001701 return false;
1702
1703 if (!lookupCacheEnabled)
1704 return true;
1705
1706 if (cifs_i->time == 0)
1707 return true;
1708
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301709 if (!time_in_range(jiffies, cifs_i->time,
1710 cifs_i->time + cifs_sb->actimeo))
Jeff Laytondf2cf172010-02-12 07:44:16 -05001711 return true;
1712
Jeff Laytondb192722010-05-17 14:51:49 -04001713 /* hardlinked files w/ noserverino get "special" treatment */
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301714 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
Jeff Laytondb192722010-05-17 14:51:49 -04001715 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1716 return true;
1717
Jeff Laytondf2cf172010-02-12 07:44:16 -05001718 return false;
1719}
1720
Suresh Jayaraman523fb8c2010-11-29 22:39:47 +05301721/*
1722 * Zap the cache. Called when invalid_mapping flag is set.
1723 */
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001724int
Jeff Laytondf2cf172010-02-12 07:44:16 -05001725cifs_invalidate_mapping(struct inode *inode)
1726{
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001727 int rc = 0;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001728 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1729
1730 cifs_i->invalid_mapping = false;
1731
Jeff Laytondf2cf172010-02-12 07:44:16 -05001732 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
Pavel Shilovsky257fb1f2011-03-16 01:55:32 +03001733 rc = invalidate_inode_pages2(inode->i_mapping);
1734 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001735 cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1736 __func__, inode);
Pavel Shilovsky257fb1f2011-03-16 01:55:32 +03001737 cifs_i->invalid_mapping = true;
1738 }
Jeff Laytondf2cf172010-02-12 07:44:16 -05001739 }
Pavel Shilovsky257fb1f2011-03-16 01:55:32 +03001740
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +05301741 cifs_fscache_reset_inode_cookie(inode);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001742 return rc;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001743}
1744
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001745int cifs_revalidate_file_attr(struct file *filp)
Jeff Laytonabab0952010-02-12 07:44:18 -05001746{
1747 int rc = 0;
Al Viro496ad9a2013-01-23 17:07:38 -05001748 struct inode *inode = file_inode(filp);
Jeff Laytonba00ba62010-09-20 16:01:31 -07001749 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
Jeff Laytonabab0952010-02-12 07:44:18 -05001750
1751 if (!cifs_inode_needs_reval(inode))
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001752 return rc;
Jeff Laytonabab0952010-02-12 07:44:18 -05001753
Jeff Layton13cfb732010-09-29 19:51:11 -04001754 if (tlink_tcon(cfile->tlink)->unix_ext)
Jeff Laytonabab0952010-02-12 07:44:18 -05001755 rc = cifs_get_file_info_unix(filp);
1756 else
1757 rc = cifs_get_file_info(filp);
1758
Jeff Laytonabab0952010-02-12 07:44:18 -05001759 return rc;
1760}
1761
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001762int cifs_revalidate_dentry_attr(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001763{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001764 unsigned int xid;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001765 int rc = 0;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001766 struct inode *inode = dentry->d_inode;
1767 struct super_block *sb = dentry->d_sb;
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001768 char *full_path = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769
Jeff Laytondf2cf172010-02-12 07:44:16 -05001770 if (inode == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771 return -ENOENT;
1772
Jeff Laytondf2cf172010-02-12 07:44:16 -05001773 if (!cifs_inode_needs_reval(inode))
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001774 return rc;
1775
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001776 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777
1778 /* can not safely grab the rename sem here if rename calls revalidate
1779 since that would deadlock */
Jeff Laytondf2cf172010-02-12 07:44:16 -05001780 full_path = build_path_from_dentry(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301782 rc = -ENOMEM;
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001783 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784 }
Jeff Laytondf2cf172010-02-12 07:44:16 -05001785
Joe Perchesf96637b2013-05-04 22:12:25 -05001786 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1787 full_path, inode, inode->i_count.counter,
Steve Frenchf19159d2010-04-21 04:12:10 +00001788 dentry, dentry->d_time, jiffies);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789
Jeff Layton0d424ad2010-09-20 16:01:35 -07001790 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
Jeff Laytondf2cf172010-02-12 07:44:16 -05001791 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1792 else
1793 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1794 xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001795
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001796out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001798 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799 return rc;
1800}
1801
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001802int cifs_revalidate_file(struct file *filp)
1803{
1804 int rc;
Al Viro496ad9a2013-01-23 17:07:38 -05001805 struct inode *inode = file_inode(filp);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001806
1807 rc = cifs_revalidate_file_attr(filp);
1808 if (rc)
1809 return rc;
1810
1811 if (CIFS_I(inode)->invalid_mapping)
1812 rc = cifs_invalidate_mapping(inode);
1813 return rc;
1814}
1815
1816/* revalidate a dentry's inode attributes */
1817int cifs_revalidate_dentry(struct dentry *dentry)
1818{
1819 int rc;
1820 struct inode *inode = dentry->d_inode;
1821
1822 rc = cifs_revalidate_dentry_attr(dentry);
1823 if (rc)
1824 return rc;
1825
1826 if (CIFS_I(inode)->invalid_mapping)
1827 rc = cifs_invalidate_mapping(inode);
1828 return rc;
1829}
1830
Linus Torvalds1da177e2005-04-16 15:20:36 -07001831int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
Jeff Layton1c456012010-10-12 11:32:42 -04001832 struct kstat *stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833{
Jeff Layton3aa1c8c2010-10-07 14:46:28 -04001834 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
Steve French96daf2b2011-05-27 04:34:02 +00001835 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001836 struct inode *inode = dentry->d_inode;
1837 int rc;
Jeff Layton3aa1c8c2010-10-07 14:46:28 -04001838
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001839 /*
1840 * We need to be sure that all dirty pages are written and the server
1841 * has actual ctime, mtime and file length.
1842 */
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001843 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001844 inode->i_mapping->nrpages != 0) {
1845 rc = filemap_fdatawait(inode->i_mapping);
Steve French156ecb22011-05-20 17:00:01 +00001846 if (rc) {
1847 mapping_set_error(inode->i_mapping, rc);
1848 return rc;
1849 }
Steve French5fe14c82006-11-07 19:26:33 +00001850 }
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001851
1852 rc = cifs_revalidate_dentry_attr(dentry);
1853 if (rc)
1854 return rc;
1855
1856 generic_fillattr(inode, stat);
1857 stat->blksize = CIFS_MAX_MSGSIZE;
1858 stat->ino = CIFS_I(inode)->uniqueid;
1859
1860 /*
Jeff Laytond3d1fce2012-11-25 08:00:40 -05001861 * If on a multiuser mount without unix extensions or cifsacl being
1862 * enabled, and the admin hasn't overridden them, set the ownership
1863 * to the fsuid/fsgid of the current process.
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001864 */
1865 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
Jeff Laytond3d1fce2012-11-25 08:00:40 -05001866 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001867 !tcon->unix_ext) {
1868 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1869 stat->uid = current_fsuid();
1870 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1871 stat->gid = current_fsgid();
1872 }
1873 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874}
1875
1876static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1877{
1878 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1879 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1880 struct page *page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881 int rc = 0;
1882
1883 page = grab_cache_page(mapping, index);
1884 if (!page)
1885 return -ENOMEM;
1886
Christoph Lametereebd2aa2008-02-04 22:28:29 -08001887 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888 unlock_page(page);
1889 page_cache_release(page);
1890 return rc;
1891}
1892
Christoph Hellwig1b947462010-07-18 17:51:21 -04001893static void cifs_setsize(struct inode *inode, loff_t offset)
Steve French3677db12007-02-26 16:46:11 +00001894{
Steve Frenchba6a46a2007-02-26 20:06:29 +00001895 spin_lock(&inode->i_lock);
Steve French3677db12007-02-26 16:46:11 +00001896 i_size_write(inode, offset);
Steve Frenchba6a46a2007-02-26 20:06:29 +00001897 spin_unlock(&inode->i_lock);
Christoph Hellwig1b947462010-07-18 17:51:21 -04001898
Kirill A. Shutemov7caef262013-09-12 15:13:56 -07001899 truncate_pagecache(inode, offset);
Steve French3677db12007-02-26 16:46:11 +00001900}
1901
Jeff Layton8efdbde2008-07-23 21:28:12 +00001902static int
1903cifs_set_file_size(struct inode *inode, struct iattr *attrs,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001904 unsigned int xid, char *full_path)
Jeff Layton8efdbde2008-07-23 21:28:12 +00001905{
1906 int rc;
1907 struct cifsFileInfo *open_file;
1908 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1909 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001910 struct tcon_link *tlink = NULL;
Pavel Shilovskyd1433412012-09-18 16:20:31 -07001911 struct cifs_tcon *tcon = NULL;
1912 struct TCP_Server_Info *server;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001913 struct cifs_io_parms io_parms;
Jeff Layton8efdbde2008-07-23 21:28:12 +00001914
1915 /*
1916 * To avoid spurious oplock breaks from server, in the case of
1917 * inodes that we already have open, avoid doing path based
1918 * setting of file size if we can do it by handle.
1919 * This keeps our caching token (oplock) and avoids timeouts
1920 * when the local oplock break takes longer to flush
1921 * writebehind data than the SMB timeout for the SetPathInfo
1922 * request would allow
1923 */
Jeff Layton6508d902010-09-29 19:51:11 -04001924 open_file = find_writable_file(cifsInode, true);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001925 if (open_file) {
Pavel Shilovskyd1433412012-09-18 16:20:31 -07001926 tcon = tlink_tcon(open_file->tlink);
1927 server = tcon->ses->server;
1928 if (server->ops->set_file_size)
1929 rc = server->ops->set_file_size(xid, tcon, open_file,
1930 attrs->ia_size, false);
1931 else
1932 rc = -ENOSYS;
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001933 cifsFileInfo_put(open_file);
Joe Perchesf96637b2013-05-04 22:12:25 -05001934 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001935 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1936 unsigned int bytes_written;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001937
Pavel Shilovskyd1433412012-09-18 16:20:31 -07001938 io_parms.netfid = open_file->fid.netfid;
1939 io_parms.pid = open_file->pid;
1940 io_parms.tcon = tcon;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001941 io_parms.offset = 0;
1942 io_parms.length = attrs->ia_size;
1943 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written,
1944 NULL, NULL, 1);
Joe Perchesf96637b2013-05-04 22:12:25 -05001945 cifs_dbg(FYI, "Wrt seteof rc %d\n", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001946 }
1947 } else
1948 rc = -EINVAL;
1949
Pavel Shilovskyd1433412012-09-18 16:20:31 -07001950 if (!rc)
1951 goto set_size_out;
Jeff Laytonba00ba62010-09-20 16:01:31 -07001952
Pavel Shilovskyd1433412012-09-18 16:20:31 -07001953 if (tcon == NULL) {
1954 tlink = cifs_sb_tlink(cifs_sb);
1955 if (IS_ERR(tlink))
1956 return PTR_ERR(tlink);
1957 tcon = tlink_tcon(tlink);
1958 server = tcon->ses->server;
Jeff Layton8efdbde2008-07-23 21:28:12 +00001959 }
1960
Pavel Shilovskyd1433412012-09-18 16:20:31 -07001961 /*
1962 * Set file size by pathname rather than by handle either because no
1963 * valid, writeable file handle for it was found or because there was
1964 * an error setting it by handle.
1965 */
1966 if (server->ops->set_path_size)
1967 rc = server->ops->set_path_size(xid, tcon, full_path,
1968 attrs->ia_size, cifs_sb, false);
1969 else
1970 rc = -ENOSYS;
Joe Perchesf96637b2013-05-04 22:12:25 -05001971 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
Pavel Shilovskyd1433412012-09-18 16:20:31 -07001972 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1973 __u16 netfid;
1974 int oplock = 0;
1975
1976 rc = SMBLegacyOpen(xid, tcon, full_path, FILE_OPEN,
1977 GENERIC_WRITE, CREATE_NOT_DIR, &netfid,
1978 &oplock, NULL, cifs_sb->local_nls,
1979 cifs_sb->mnt_cifs_flags &
1980 CIFS_MOUNT_MAP_SPECIAL_CHR);
1981 if (rc == 0) {
1982 unsigned int bytes_written;
1983
1984 io_parms.netfid = netfid;
1985 io_parms.pid = current->tgid;
1986 io_parms.tcon = tcon;
1987 io_parms.offset = 0;
1988 io_parms.length = attrs->ia_size;
1989 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written, NULL,
1990 NULL, 1);
Joe Perchesf96637b2013-05-04 22:12:25 -05001991 cifs_dbg(FYI, "wrt seteof rc %d\n", rc);
Pavel Shilovskyd1433412012-09-18 16:20:31 -07001992 CIFSSMBClose(xid, tcon, netfid);
1993 }
1994 }
1995 if (tlink)
1996 cifs_put_tlink(tlink);
1997
1998set_size_out:
Jeff Layton8efdbde2008-07-23 21:28:12 +00001999 if (rc == 0) {
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04002000 cifsInode->server_eof = attrs->ia_size;
Christoph Hellwig1b947462010-07-18 17:51:21 -04002001 cifs_setsize(inode, attrs->ia_size);
Jeff Layton8efdbde2008-07-23 21:28:12 +00002002 cifs_truncate_page(inode->i_mapping, inode->i_size);
2003 }
2004
2005 return rc;
2006}
2007
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002008static int
2009cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2010{
2011 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002012 unsigned int xid;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002013 char *full_path = NULL;
2014 struct inode *inode = direntry->d_inode;
2015 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2016 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04002017 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00002018 struct cifs_tcon *pTcon;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002019 struct cifs_unix_set_info_args *args = NULL;
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002020 struct cifsFileInfo *open_file;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002021
Joe Perchesf96637b2013-05-04 22:12:25 -05002022 cifs_dbg(FYI, "setattr_unix on file %s attrs->ia_valid=0x%x\n",
Joe Perchesb6b38f72010-04-21 03:50:45 +00002023 direntry->d_name.name, attrs->ia_valid);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002024
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002025 xid = get_xid();
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002026
Christoph Hellwigdb78b872010-06-04 11:30:03 +02002027 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2028 attrs->ia_valid |= ATTR_FORCE;
2029
2030 rc = inode_change_ok(inode, attrs);
2031 if (rc < 0)
2032 goto out;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002033
2034 full_path = build_path_from_dentry(direntry);
2035 if (full_path == NULL) {
2036 rc = -ENOMEM;
2037 goto out;
2038 }
2039
Jeff Layton0f4d6342009-03-26 13:35:37 -04002040 /*
2041 * Attempt to flush data before changing attributes. We need to do
2042 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2043 * ownership or mode then we may also need to do this. Here, we take
2044 * the safe way out and just do the flush on all setattr requests. If
2045 * the flush returns error, store it to report later and continue.
2046 *
2047 * BB: This should be smarter. Why bother flushing pages that
2048 * will be truncated anyway? Also, should we error out here if
2049 * the flush returns error?
2050 */
2051 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002052 mapping_set_error(inode->i_mapping, rc);
2053 rc = 0;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002054
2055 if (attrs->ia_valid & ATTR_SIZE) {
2056 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2057 if (rc != 0)
2058 goto out;
2059 }
2060
2061 /* skip mode change if it's just for clearing setuid/setgid */
2062 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2063 attrs->ia_valid &= ~ATTR_MODE;
2064
2065 args = kmalloc(sizeof(*args), GFP_KERNEL);
2066 if (args == NULL) {
2067 rc = -ENOMEM;
2068 goto out;
2069 }
2070
2071 /* set up the struct */
2072 if (attrs->ia_valid & ATTR_MODE)
2073 args->mode = attrs->ia_mode;
2074 else
2075 args->mode = NO_CHANGE_64;
2076
2077 if (attrs->ia_valid & ATTR_UID)
2078 args->uid = attrs->ia_uid;
2079 else
Eric W. Biederman49418b22013-02-06 00:57:56 -08002080 args->uid = INVALID_UID; /* no change */
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002081
2082 if (attrs->ia_valid & ATTR_GID)
2083 args->gid = attrs->ia_gid;
2084 else
Eric W. Biederman49418b22013-02-06 00:57:56 -08002085 args->gid = INVALID_GID; /* no change */
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002086
2087 if (attrs->ia_valid & ATTR_ATIME)
2088 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2089 else
2090 args->atime = NO_CHANGE_64;
2091
2092 if (attrs->ia_valid & ATTR_MTIME)
2093 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2094 else
2095 args->mtime = NO_CHANGE_64;
2096
2097 if (attrs->ia_valid & ATTR_CTIME)
2098 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2099 else
2100 args->ctime = NO_CHANGE_64;
2101
2102 args->device = 0;
Jeff Layton6508d902010-09-29 19:51:11 -04002103 open_file = find_writable_file(cifsInode, true);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002104 if (open_file) {
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07002105 u16 nfid = open_file->fid.netfid;
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002106 u32 npid = open_file->pid;
Jeff Layton13cfb732010-09-29 19:51:11 -04002107 pTcon = tlink_tcon(open_file->tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002108 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04002109 cifsFileInfo_put(open_file);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002110 } else {
Jeff Layton7ffec372010-09-29 19:51:11 -04002111 tlink = cifs_sb_tlink(cifs_sb);
2112 if (IS_ERR(tlink)) {
2113 rc = PTR_ERR(tlink);
2114 goto out;
2115 }
2116 pTcon = tlink_tcon(tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002117 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
Jeff Layton01ea95e2009-07-09 20:02:49 -04002118 cifs_sb->local_nls,
2119 cifs_sb->mnt_cifs_flags &
2120 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton7ffec372010-09-29 19:51:11 -04002121 cifs_put_tlink(tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002122 }
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002123
Christoph Hellwig10257742010-06-04 11:30:02 +02002124 if (rc)
2125 goto out;
Steve Frenchccd4bb12010-02-08 17:39:58 +00002126
Christoph Hellwig10257742010-06-04 11:30:02 +02002127 if ((attrs->ia_valid & ATTR_SIZE) &&
Christoph Hellwig1b947462010-07-18 17:51:21 -04002128 attrs->ia_size != i_size_read(inode))
2129 truncate_setsize(inode, attrs->ia_size);
Christoph Hellwig10257742010-06-04 11:30:02 +02002130
2131 setattr_copy(inode, attrs);
2132 mark_inode_dirty(inode);
2133
2134 /* force revalidate when any of these times are set since some
2135 of the fs types (eg ext3, fat) do not have fine enough
2136 time granularity to match protocol, and we do not have a
2137 a way (yet) to query the server fs's time granularity (and
2138 whether it rounds times down).
2139 */
2140 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2141 cifsInode->time = 0;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002142out:
2143 kfree(args);
2144 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002145 free_xid(xid);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002146 return rc;
2147}
2148
Jeff Layton0510eeb2008-08-02 07:26:12 -04002149static int
2150cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002152 unsigned int xid;
Eric W. Biederman8abf2772013-02-06 00:33:17 -08002153 kuid_t uid = INVALID_UID;
2154 kgid_t gid = INVALID_GID;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002155 struct inode *inode = direntry->d_inode;
2156 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002157 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158 char *full_path = NULL;
2159 int rc = -EACCES;
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002160 __u32 dosattr = 0;
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04002161 __u64 mode = NO_CHANGE_64;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002162
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002163 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002164
Joe Perchesf96637b2013-05-04 22:12:25 -05002165 cifs_dbg(FYI, "setattr on file %s attrs->iavalid 0x%x\n",
Joe Perchesb6b38f72010-04-21 03:50:45 +00002166 direntry->d_name.name, attrs->ia_valid);
Steve French6473a552005-11-29 20:20:10 -08002167
Christoph Hellwigdb78b872010-06-04 11:30:03 +02002168 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2169 attrs->ia_valid |= ATTR_FORCE;
2170
2171 rc = inode_change_ok(inode, attrs);
2172 if (rc < 0) {
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002173 free_xid(xid);
Christoph Hellwigdb78b872010-06-04 11:30:03 +02002174 return rc;
Steve French6473a552005-11-29 20:20:10 -08002175 }
Steve French50c2f752007-07-13 00:33:32 +00002176
Steve French7f573562005-08-30 11:32:14 -07002177 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002178 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302179 rc = -ENOMEM;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002180 free_xid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302181 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183
Jeff Layton0f4d6342009-03-26 13:35:37 -04002184 /*
2185 * Attempt to flush data before changing attributes. We need to do
2186 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2187 * ownership or mode then we may also need to do this. Here, we take
2188 * the safe way out and just do the flush on all setattr requests. If
2189 * the flush returns error, store it to report later and continue.
2190 *
2191 * BB: This should be smarter. Why bother flushing pages that
2192 * will be truncated anyway? Also, should we error out here if
2193 * the flush returns error?
2194 */
2195 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002196 mapping_set_error(inode->i_mapping, rc);
2197 rc = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +00002198
Steve French50531442008-03-14 19:21:31 +00002199 if (attrs->ia_valid & ATTR_SIZE) {
Jeff Layton8efdbde2008-07-23 21:28:12 +00002200 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2201 if (rc != 0)
Steve Frenche30dcf32005-09-20 20:49:16 -07002202 goto cifs_setattr_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002203 }
Jeff Layton4ca691a2008-05-22 09:33:34 -04002204
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002205 if (attrs->ia_valid & ATTR_UID)
2206 uid = attrs->ia_uid;
2207
2208 if (attrs->ia_valid & ATTR_GID)
2209 gid = attrs->ia_gid;
2210
2211#ifdef CONFIG_CIFS_ACL
2212 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
Eric W. Biederman8abf2772013-02-06 00:33:17 -08002213 if (uid_valid(uid) || gid_valid(gid)) {
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002214 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2215 uid, gid);
2216 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002217 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2218 __func__, rc);
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002219 goto cifs_setattr_exit;
2220 }
2221 }
2222 } else
2223#endif /* CONFIG_CIFS_ACL */
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002224 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
Jeff Layton4ca691a2008-05-22 09:33:34 -04002225 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226
Jeff Laytond32c4f22007-10-18 03:05:22 -07002227 /* skip mode change if it's just for clearing setuid/setgid */
2228 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2229 attrs->ia_valid &= ~ATTR_MODE;
2230
Linus Torvalds1da177e2005-04-16 15:20:36 -07002231 if (attrs->ia_valid & ATTR_MODE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232 mode = attrs->ia_mode;
Steve Frenchcdbce9c2005-11-19 21:04:52 -08002233 rc = 0;
Jeff Layton79df1ba2010-12-06 12:52:08 -05002234#ifdef CONFIG_CIFS_ACL
Shirish Pargaonkar78415d22010-11-27 11:37:26 -06002235 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002236 rc = id_mode_to_cifs_acl(inode, full_path, mode,
Eric W. Biederman8abf2772013-02-06 00:33:17 -08002237 INVALID_UID, INVALID_GID);
Shirish Pargaonkar78415d22010-11-27 11:37:26 -06002238 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002239 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2240 __func__, rc);
Shirish Pargaonkar78415d22010-11-27 11:37:26 -06002241 goto cifs_setattr_exit;
2242 }
2243 } else
Jeff Layton79df1ba2010-12-06 12:52:08 -05002244#endif /* CONFIG_CIFS_ACL */
Jeff Layton51328612008-05-22 09:33:34 -04002245 if (((mode & S_IWUGO) == 0) &&
2246 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002247
2248 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2249
Jeff Layton51328612008-05-22 09:33:34 -04002250 /* fix up mode if we're not using dynperm */
2251 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2252 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2253 } else if ((mode & S_IWUGO) &&
2254 (cifsInode->cifsAttrs & ATTR_READONLY)) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002255
2256 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2257 /* Attributes of 0 are ignored */
2258 if (dosattr == 0)
2259 dosattr |= ATTR_NORMAL;
Jeff Layton51328612008-05-22 09:33:34 -04002260
2261 /* reset local inode permissions to normal */
2262 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2263 attrs->ia_mode &= ~(S_IALLUGO);
2264 if (S_ISDIR(inode->i_mode))
2265 attrs->ia_mode |=
2266 cifs_sb->mnt_dir_mode;
2267 else
2268 attrs->ia_mode |=
2269 cifs_sb->mnt_file_mode;
2270 }
2271 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2272 /* ignore mode change - ATTR_READONLY hasn't changed */
2273 attrs->ia_valid &= ~ATTR_MODE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002274 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002275 }
2276
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002277 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2278 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2279 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2280 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002281
Steve Frenche30dcf32005-09-20 20:49:16 -07002282 /* Even if error on time set, no sense failing the call if
2283 the server would set the time to a reasonable value anyway,
2284 and this check ensures that we are not being called from
2285 sys_utimes in which case we ought to fail the call back to
2286 the user when the server rejects the call */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002287 if ((rc) && (attrs->ia_valid &
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002288 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
Steve Frenche30dcf32005-09-20 20:49:16 -07002289 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002290 }
2291
2292 /* do not need local check to inode_check_ok since the server does
2293 that */
Christoph Hellwig10257742010-06-04 11:30:02 +02002294 if (rc)
2295 goto cifs_setattr_exit;
2296
2297 if ((attrs->ia_valid & ATTR_SIZE) &&
Christoph Hellwig1b947462010-07-18 17:51:21 -04002298 attrs->ia_size != i_size_read(inode))
2299 truncate_setsize(inode, attrs->ia_size);
Christoph Hellwig10257742010-06-04 11:30:02 +02002300
2301 setattr_copy(inode, attrs);
2302 mark_inode_dirty(inode);
Christoph Hellwig10257742010-06-04 11:30:02 +02002303
Steve Frenche30dcf32005-09-20 20:49:16 -07002304cifs_setattr_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002305 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002306 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307 return rc;
2308}
2309
Jeff Layton0510eeb2008-08-02 07:26:12 -04002310int
2311cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2312{
2313 struct inode *inode = direntry->d_inode;
2314 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Steve French96daf2b2011-05-27 04:34:02 +00002315 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
Jeff Layton0510eeb2008-08-02 07:26:12 -04002316
2317 if (pTcon->unix_ext)
2318 return cifs_setattr_unix(direntry, attrs);
2319
2320 return cifs_setattr_nounix(direntry, attrs);
2321
2322 /* BB: add cifs_setattr_legacy for really old servers */
2323}
2324
Steve French99ee4db2007-02-27 05:35:17 +00002325#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07002326void cifs_delete_inode(struct inode *inode)
2327{
Joe Perchesf96637b2013-05-04 22:12:25 -05002328 cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329 /* may have to add back in if and when safe distributed caching of
2330 directories added e.g. via FindNotify */
2331}
Steve French99ee4db2007-02-27 05:35:17 +00002332#endif