blob: 49719b8228e58bd44b373fd4b39d844be9e2043b [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) {
Sachin Prabhu750b8de2013-11-25 17:09:48 +0000386 int tmprc = CIFSCheckMFSymlink(xid, tcon, cifs_sb, &fattr,
387 full_path);
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200388 if (tmprc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500389 cifs_dbg(FYI, "CIFSCheckMFSymlink: %d\n", tmprc);
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200390 }
391
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400392 if (*pinode == NULL) {
393 /* get new inode */
Jeff Layton4065c802010-05-17 07:18:58 -0400394 cifs_fill_uniqueid(sb, &fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400395 *pinode = cifs_iget(sb, &fattr);
396 if (!*pinode)
397 rc = -ENOMEM;
398 } else {
399 /* we already have inode, update it */
400 cifs_fattr_to_inode(*pinode, &fattr);
401 }
Steve French0e4bbde2008-05-20 19:50:46 +0000402
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 return rc;
404}
405
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400406static int
407cifs_sfu_type(struct cifs_fattr *fattr, const unsigned char *path,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400408 struct cifs_sb_info *cifs_sb, unsigned int xid)
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800409{
410 int rc;
Steve French4b18f2a2008-04-29 00:06:05 +0000411 int oplock = 0;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800412 __u16 netfid;
Jeff Layton7ffec372010-09-29 19:51:11 -0400413 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +0000414 struct cifs_tcon *tcon;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000415 struct cifs_io_parms io_parms;
Steve French86c96b42005-11-18 20:25:31 -0800416 char buf[24];
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800417 unsigned int bytes_read;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000418 char *pbuf;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800419
420 pbuf = buf;
421
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400422 fattr->cf_mode &= ~S_IFMT;
423
424 if (fattr->cf_eof == 0) {
425 fattr->cf_mode |= S_IFIFO;
426 fattr->cf_dtype = DT_FIFO;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800427 return 0;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400428 } else if (fattr->cf_eof < 8) {
429 fattr->cf_mode |= S_IFREG;
430 fattr->cf_dtype = DT_REG;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800431 return -EINVAL; /* EOPNOTSUPP? */
432 }
Steve French50c2f752007-07-13 00:33:32 +0000433
Jeff Layton7ffec372010-09-29 19:51:11 -0400434 tlink = cifs_sb_tlink(cifs_sb);
435 if (IS_ERR(tlink))
436 return PTR_ERR(tlink);
437 tcon = tlink_tcon(tlink);
438
439 rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, GENERIC_READ,
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800440 CREATE_NOT_DIR, &netfid, &oplock, NULL,
441 cifs_sb->local_nls,
442 cifs_sb->mnt_cifs_flags &
443 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000444 if (rc == 0) {
Steve Frenchec637e32005-12-12 20:53:18 -0800445 int buf_type = CIFS_NO_BUFFER;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800446 /* Read header */
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000447 io_parms.netfid = netfid;
448 io_parms.pid = current->tgid;
449 io_parms.tcon = tcon;
450 io_parms.offset = 0;
451 io_parms.length = 24;
452 rc = CIFSSMBRead(xid, &io_parms, &bytes_read, &pbuf,
453 &buf_type);
Steve French4523cc32007-04-30 20:13:06 +0000454 if ((rc == 0) && (bytes_read >= 8)) {
455 if (memcmp("IntxBLK", pbuf, 8) == 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500456 cifs_dbg(FYI, "Block device\n");
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400457 fattr->cf_mode |= S_IFBLK;
458 fattr->cf_dtype = DT_BLK;
Steve French4523cc32007-04-30 20:13:06 +0000459 if (bytes_read == 24) {
Steve French86c96b42005-11-18 20:25:31 -0800460 /* we have enough to decode dev num */
461 __u64 mjr; /* major */
462 __u64 mnr; /* minor */
463 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
464 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400465 fattr->cf_rdev = MKDEV(mjr, mnr);
Steve French86c96b42005-11-18 20:25:31 -0800466 }
Steve French4523cc32007-04-30 20:13:06 +0000467 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500468 cifs_dbg(FYI, "Char device\n");
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400469 fattr->cf_mode |= S_IFCHR;
470 fattr->cf_dtype = DT_CHR;
Steve French4523cc32007-04-30 20:13:06 +0000471 if (bytes_read == 24) {
Steve French86c96b42005-11-18 20:25:31 -0800472 /* we have enough to decode dev num */
473 __u64 mjr; /* major */
474 __u64 mnr; /* minor */
475 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
476 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400477 fattr->cf_rdev = MKDEV(mjr, mnr);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000478 }
Steve French4523cc32007-04-30 20:13:06 +0000479 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500480 cifs_dbg(FYI, "Symlink\n");
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400481 fattr->cf_mode |= S_IFLNK;
482 fattr->cf_dtype = DT_LNK;
Steve French86c96b42005-11-18 20:25:31 -0800483 } else {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400484 fattr->cf_mode |= S_IFREG; /* file? */
485 fattr->cf_dtype = DT_REG;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000486 rc = -EOPNOTSUPP;
Steve French86c96b42005-11-18 20:25:31 -0800487 }
Steve French3020a1f2005-11-18 11:31:10 -0800488 } else {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400489 fattr->cf_mode |= S_IFREG; /* then it is a file */
490 fattr->cf_dtype = DT_REG;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000491 rc = -EOPNOTSUPP; /* or some unknown SFU type */
492 }
Jeff Layton7ffec372010-09-29 19:51:11 -0400493 CIFSSMBClose(xid, tcon, netfid);
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800494 }
Jeff Layton7ffec372010-09-29 19:51:11 -0400495 cifs_put_tlink(tlink);
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800496 return rc;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800497}
498
Steve French9e294f12005-11-17 16:59:21 -0800499#define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
500
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400501/*
502 * Fetch mode bits as provided by SFU.
503 *
504 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
505 */
506static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400507 struct cifs_sb_info *cifs_sb, unsigned int xid)
Steve French9e294f12005-11-17 16:59:21 -0800508{
Steve French3020a1f2005-11-18 11:31:10 -0800509#ifdef CONFIG_CIFS_XATTR
Steve French9e294f12005-11-17 16:59:21 -0800510 ssize_t rc;
511 char ea_value[4];
512 __u32 mode;
Jeff Layton7ffec372010-09-29 19:51:11 -0400513 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +0000514 struct cifs_tcon *tcon;
Steve French9e294f12005-11-17 16:59:21 -0800515
Jeff Layton7ffec372010-09-29 19:51:11 -0400516 tlink = cifs_sb_tlink(cifs_sb);
517 if (IS_ERR(tlink))
518 return PTR_ERR(tlink);
519 tcon = tlink_tcon(tlink);
520
521 rc = CIFSSMBQAllEAs(xid, tcon, path, "SETFILEBITS",
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400522 ea_value, 4 /* size of buf */, cifs_sb->local_nls,
523 cifs_sb->mnt_cifs_flags &
524 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton7ffec372010-09-29 19:51:11 -0400525 cifs_put_tlink(tlink);
Steve French4523cc32007-04-30 20:13:06 +0000526 if (rc < 0)
Steve French9e294f12005-11-17 16:59:21 -0800527 return (int)rc;
528 else if (rc > 3) {
529 mode = le32_to_cpu(*((__le32 *)ea_value));
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400530 fattr->cf_mode &= ~SFBITS_MASK;
Joe Perchesf96637b2013-05-04 22:12:25 -0500531 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
532 mode, fattr->cf_mode);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400533 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
Joe Perchesf96637b2013-05-04 22:12:25 -0500534 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
Steve French9e294f12005-11-17 16:59:21 -0800535 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400536
537 return 0;
Steve French3020a1f2005-11-18 11:31:10 -0800538#else
539 return -EOPNOTSUPP;
540#endif
Steve French9e294f12005-11-17 16:59:21 -0800541}
542
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400543/* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
Steve Frenchf1230c92009-07-22 23:13:01 +0000544static void
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400545cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
Pavel Shilovskyeb85d94b2013-10-23 17:49:47 +0400546 struct cifs_sb_info *cifs_sb, bool adjust_tz,
547 bool symlink)
Steve Frenchb9a32602008-05-20 21:52:32 +0000548{
Steve French96daf2b2011-05-27 04:34:02 +0000549 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Jeff Layton0d424ad2010-09-20 16:01:35 -0700550
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400551 memset(fattr, 0, sizeof(*fattr));
552 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
553 if (info->DeletePending)
554 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
Steve Frenchb9a32602008-05-20 21:52:32 +0000555
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400556 if (info->LastAccessTime)
557 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
558 else
559 fattr->cf_atime = CURRENT_TIME;
560
561 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
562 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
563
564 if (adjust_tz) {
Jeff Layton0d424ad2010-09-20 16:01:35 -0700565 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
566 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400567 }
568
569 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
570 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
Jeff Layton20054bd2011-01-07 11:30:27 -0500571 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400572
Jim McDonough74d290d2013-09-21 10:36:10 -0500573 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
Pavel Shilovskyeb85d94b2013-10-23 17:49:47 +0400574
575 if (symlink) {
576 fattr->cf_mode = S_IFLNK;
577 fattr->cf_dtype = DT_LNK;
578 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400579 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
580 fattr->cf_dtype = DT_DIR;
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +0300581 /*
582 * Server can return wrong NumberOfLinks value for directories
583 * when Unix extensions are disabled - fake it.
584 */
Jim McDonough74d290d2013-09-21 10:36:10 -0500585 if (!tcon->unix_ext)
586 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400587 } else {
588 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
589 fattr->cf_dtype = DT_REG;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400590
Jeff Laytond0c280d2009-07-09 01:46:44 -0400591 /* clear write bits if ATTR_READONLY is set */
592 if (fattr->cf_cifsattrs & ATTR_READONLY)
593 fattr->cf_mode &= ~(S_IWUGO);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400594
Jim McDonough74d290d2013-09-21 10:36:10 -0500595 /*
596 * Don't accept zero nlink from non-unix servers unless
597 * delete is pending. Instead mark it as unknown.
598 */
599 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
600 !info->DeletePending) {
601 cifs_dbg(1, "bogus file nlink value %u\n",
Steve French6658b9f2013-07-04 14:38:48 -0500602 fattr->cf_nlink);
Jim McDonough74d290d2013-09-21 10:36:10 -0500603 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
Steve French6658b9f2013-07-04 14:38:48 -0500604 }
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +0300605 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400606
607 fattr->cf_uid = cifs_sb->mnt_uid;
608 fattr->cf_gid = cifs_sb->mnt_gid;
Steve Frenchb9a32602008-05-20 21:52:32 +0000609}
610
Pavel Shilovsky4ad65042012-09-18 16:20:26 -0700611static int
612cifs_get_file_info(struct file *filp)
Jeff Laytonabab0952010-02-12 07:44:18 -0500613{
614 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400615 unsigned int xid;
Jeff Laytonabab0952010-02-12 07:44:18 -0500616 FILE_ALL_INFO find_data;
617 struct cifs_fattr fattr;
Al Viro496ad9a2013-01-23 17:07:38 -0500618 struct inode *inode = file_inode(filp);
Jeff Laytonabab0952010-02-12 07:44:18 -0500619 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Joe Perchesc21dfb62010-07-12 13:50:14 -0700620 struct cifsFileInfo *cfile = filp->private_data;
Steve French96daf2b2011-05-27 04:34:02 +0000621 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky4ad65042012-09-18 16:20:26 -0700622 struct TCP_Server_Info *server = tcon->ses->server;
623
624 if (!server->ops->query_file_info)
625 return -ENOSYS;
Jeff Laytonabab0952010-02-12 07:44:18 -0500626
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400627 xid = get_xid();
Pavel Shilovsky4ad65042012-09-18 16:20:26 -0700628 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400629 switch (rc) {
630 case 0:
Pavel Shilovskyeb85d94b2013-10-23 17:49:47 +0400631 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false,
632 false);
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400633 break;
634 case -EREMOTE:
635 cifs_create_dfs_fattr(&fattr, inode->i_sb);
636 rc = 0;
637 break;
638 case -EOPNOTSUPP:
639 case -EINVAL:
Jeff Laytonabab0952010-02-12 07:44:18 -0500640 /*
641 * FIXME: legacy server -- fall back to path-based call?
Steve Frenchff2157132010-03-09 20:30:42 +0000642 * for now, just skip revalidating and mark inode for
643 * immediate reval.
644 */
Jeff Laytonabab0952010-02-12 07:44:18 -0500645 rc = 0;
646 CIFS_I(inode)->time = 0;
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400647 default:
Jeff Laytonabab0952010-02-12 07:44:18 -0500648 goto cgfi_exit;
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400649 }
Jeff Laytonabab0952010-02-12 07:44:18 -0500650
651 /*
652 * don't bother with SFU junk here -- just mark inode as needing
653 * revalidation.
654 */
Jeff Laytonabab0952010-02-12 07:44:18 -0500655 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
656 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
657 cifs_fattr_to_inode(inode, &fattr);
658cgfi_exit:
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400659 free_xid(xid);
Jeff Laytonabab0952010-02-12 07:44:18 -0500660 return rc;
661}
662
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400663int
664cifs_get_inode_info(struct inode **inode, const char *full_path,
665 FILE_ALL_INFO *data, struct super_block *sb, int xid,
666 const __u16 *fid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667{
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500668 bool validinum = false;
669 __u16 srchflgs;
670 int rc = 0, tmprc = ENOSYS;
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400671 struct cifs_tcon *tcon;
672 struct TCP_Server_Info *server;
Jeff Layton7ffec372010-09-29 19:51:11 -0400673 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 char *buf = NULL;
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400676 bool adjust_tz = false;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400677 struct cifs_fattr fattr;
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500678 struct cifs_search_info *srchinf = NULL;
Pavel Shilovskyeb85d94b2013-10-23 17:49:47 +0400679 bool symlink = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680
Jeff Layton7ffec372010-09-29 19:51:11 -0400681 tlink = cifs_sb_tlink(cifs_sb);
682 if (IS_ERR(tlink))
683 return PTR_ERR(tlink);
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400684 tcon = tlink_tcon(tlink);
685 server = tcon->ses->server;
Jeff Layton7ffec372010-09-29 19:51:11 -0400686
Joe Perchesf96637b2013-05-04 22:12:25 -0500687 cifs_dbg(FYI, "Getting info on %s\n", full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400689 if ((data == NULL) && (*inode != NULL)) {
Pavel Shilovsky18cceb62013-09-05 13:01:06 +0400690 if (CIFS_CACHE_READ(CIFS_I(*inode))) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500691 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
Jeff Layton7ffec372010-09-29 19:51:11 -0400692 goto cgii_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 }
694 }
695
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400696 /* if inode info is not passed, get it from server */
697 if (data == NULL) {
698 if (!server->ops->query_path_info) {
699 rc = -ENOSYS;
700 goto cgii_exit;
701 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
Jeff Layton7ffec372010-09-29 19:51:11 -0400703 if (buf == NULL) {
704 rc = -ENOMEM;
705 goto cgii_exit;
706 }
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400707 data = (FILE_ALL_INFO *)buf;
708 rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path,
Pavel Shilovskyeb85d94b2013-10-23 17:49:47 +0400709 data, &adjust_tz, &symlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400711
712 if (!rc) {
Pavel Shilovskyeb85d94b2013-10-23 17:49:47 +0400713 cifs_all_info_to_fattr(&fattr, data, cifs_sb, adjust_tz,
714 symlink);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400715 } else if (rc == -EREMOTE) {
716 cifs_create_dfs_fattr(&fattr, sb);
Steve Frenchb9a32602008-05-20 21:52:32 +0000717 rc = 0;
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500718 } else if (rc == -EACCES && backup_cred(cifs_sb)) {
719 srchinf = kzalloc(sizeof(struct cifs_search_info),
720 GFP_KERNEL);
721 if (srchinf == NULL) {
722 rc = -ENOMEM;
723 goto cgii_exit;
724 }
725
726 srchinf->endOfSearch = false;
727 srchinf->info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
728
729 srchflgs = CIFS_SEARCH_CLOSE_ALWAYS |
730 CIFS_SEARCH_CLOSE_AT_END |
731 CIFS_SEARCH_BACKUP_SEARCH;
732
733 rc = CIFSFindFirst(xid, tcon, full_path,
734 cifs_sb, NULL, srchflgs, srchinf, false);
735 if (!rc) {
736 data =
737 (FILE_ALL_INFO *)srchinf->srch_entries_start;
738
739 cifs_dir_info_to_fattr(&fattr,
740 (FILE_DIRECTORY_INFO *)data, cifs_sb);
741 fattr.cf_uniqueid = le64_to_cpu(
742 ((SEARCH_ID_FULL_DIR_INFO *)data)->UniqueId);
743 validinum = true;
744
745 cifs_buf_release(srchinf->ntwrk_buf_start);
746 }
747 kfree(srchinf);
748 } else
Igor Mammedov79626702008-03-09 03:44:18 +0000749 goto cgii_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400751 /*
752 * If an inode wasn't passed in, then get the inode number
753 *
754 * Is an i_ino of zero legal? Can we use that to check if the server
755 * supports returning inode numbers? Are there other sanity checks we
756 * can use to ensure that the server is really filling in that field?
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400757 */
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400758 if (*inode == NULL) {
Steve Frenchb9a32602008-05-20 21:52:32 +0000759 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500760 if (validinum == false) {
761 if (server->ops->get_srv_inum)
762 tmprc = server->ops->get_srv_inum(xid,
763 tcon, cifs_sb, full_path,
764 &fattr.cf_uniqueid, data);
765 if (tmprc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500766 cifs_dbg(FYI, "GetSrvInodeNum rc %d\n",
767 tmprc);
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500768 fattr.cf_uniqueid = iunique(sb, ROOT_I);
769 cifs_autodisable_serverino(cifs_sb);
770 }
Jeff Layton132ac7b2009-02-10 07:33:57 -0500771 }
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500772 } else
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400773 fattr.cf_uniqueid = iunique(sb, ROOT_I);
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500774 } else
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400775 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
Steve Frenchb9a32602008-05-20 21:52:32 +0000776
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400777 /* query for SFU type info if supported and needed */
778 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
779 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
780 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
781 if (tmprc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500782 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
Steve Frenchb9a32602008-05-20 21:52:32 +0000783 }
Steve Frenchb9a32602008-05-20 21:52:32 +0000784
Jeff Layton79df1ba2010-12-06 12:52:08 -0500785#ifdef CONFIG_CIFS_ACL
Steve Frenchb9a32602008-05-20 21:52:32 +0000786 /* fill in 0777 bits from ACL */
787 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400788 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, full_path, fid);
Shirish Pargaonkar78415d22010-11-27 11:37:26 -0600789 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500790 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
791 __func__, rc);
Shirish Pargaonkar78415d22010-11-27 11:37:26 -0600792 goto cgii_exit;
793 }
Steve Frenchb9a32602008-05-20 21:52:32 +0000794 }
Jeff Layton79df1ba2010-12-06 12:52:08 -0500795#endif /* CONFIG_CIFS_ACL */
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400796
797 /* fill in remaining high mode bits e.g. SUID, VTX */
798 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
799 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
800
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200801 /* check for Minshall+French symlinks */
802 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
Sachin Prabhu750b8de2013-11-25 17:09:48 +0000803 tmprc = CIFSCheckMFSymlink(xid, tcon, cifs_sb, &fattr,
804 full_path);
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200805 if (tmprc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500806 cifs_dbg(FYI, "CIFSCheckMFSymlink: %d\n", tmprc);
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200807 }
808
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400809 if (!*inode) {
810 *inode = cifs_iget(sb, &fattr);
811 if (!*inode)
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400812 rc = -ENOMEM;
813 } else {
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400814 cifs_fattr_to_inode(*inode, &fattr);
Steve Frenchb9a32602008-05-20 21:52:32 +0000815 }
816
Igor Mammedov79626702008-03-09 03:44:18 +0000817cgii_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 kfree(buf);
Jeff Layton7ffec372010-09-29 19:51:11 -0400819 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 return rc;
821}
822
Steve French7f8ed422007-09-28 22:28:55 +0000823static const struct inode_operations cifs_ipc_inode_ops = {
824 .lookup = cifs_lookup,
825};
826
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400827static int
828cifs_find_inode(struct inode *inode, void *opaque)
829{
830 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
831
Jeff Laytonf30b9c12010-07-19 18:00:17 -0400832 /* don't match inode with different uniqueid */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400833 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
834 return 0;
835
Jeff Layton20054bd2011-01-07 11:30:27 -0500836 /* use createtime like an i_generation field */
837 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
838 return 0;
839
Jeff Laytonf30b9c12010-07-19 18:00:17 -0400840 /* don't match inode of different type */
841 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
842 return 0;
843
Jeff Layton5acfec22010-08-02 17:43:54 -0400844 /* if it's not a directory or has no dentries, then flag it */
Al Virob3d9b7a2012-06-09 13:51:19 -0400845 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
Jeff Layton3d694382010-05-11 14:59:55 -0400846 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
Jeff Layton3d694382010-05-11 14:59:55 -0400847
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400848 return 1;
849}
850
851static int
852cifs_init_inode(struct inode *inode, void *opaque)
853{
854 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
855
856 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
Jeff Layton20054bd2011-01-07 11:30:27 -0500857 CIFS_I(inode)->createtime = fattr->cf_createtime;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400858 return 0;
859}
860
Jeff Layton5acfec22010-08-02 17:43:54 -0400861/*
862 * walk dentry list for an inode and report whether it has aliases that
863 * are hashed. We use this to determine if a directory inode can actually
864 * be used.
865 */
866static bool
867inode_has_hashed_dentries(struct inode *inode)
868{
869 struct dentry *dentry;
870
Nick Piggin873feea2011-01-07 17:50:06 +1100871 spin_lock(&inode->i_lock);
Sasha Levinb67bfe02013-02-27 17:06:00 -0800872 hlist_for_each_entry(dentry, &inode->i_dentry, d_alias) {
Jeff Layton5acfec22010-08-02 17:43:54 -0400873 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
Nick Piggin873feea2011-01-07 17:50:06 +1100874 spin_unlock(&inode->i_lock);
Jeff Layton5acfec22010-08-02 17:43:54 -0400875 return true;
876 }
877 }
Nick Piggin873feea2011-01-07 17:50:06 +1100878 spin_unlock(&inode->i_lock);
Jeff Layton5acfec22010-08-02 17:43:54 -0400879 return false;
880}
881
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400882/* Given fattrs, get a corresponding inode */
883struct inode *
884cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
885{
886 unsigned long hash;
887 struct inode *inode;
888
Jeff Layton3d694382010-05-11 14:59:55 -0400889retry_iget5_locked:
Joe Perchesf96637b2013-05-04 22:12:25 -0500890 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400891
892 /* hash down to 32-bits on 32-bit arch */
893 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
894
895 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400896 if (inode) {
Jeff Layton5acfec22010-08-02 17:43:54 -0400897 /* was there a potentially problematic inode collision? */
Jeff Layton3d694382010-05-11 14:59:55 -0400898 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
Jeff Layton3d694382010-05-11 14:59:55 -0400899 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
Jeff Layton5acfec22010-08-02 17:43:54 -0400900
901 if (inode_has_hashed_dentries(inode)) {
902 cifs_autodisable_serverino(CIFS_SB(sb));
903 iput(inode);
904 fattr->cf_uniqueid = iunique(sb, ROOT_I);
905 goto retry_iget5_locked;
906 }
Jeff Layton3d694382010-05-11 14:59:55 -0400907 }
908
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400909 cifs_fattr_to_inode(inode, fattr);
910 if (sb->s_flags & MS_NOATIME)
911 inode->i_flags |= S_NOATIME | S_NOCMTIME;
912 if (inode->i_state & I_NEW) {
913 inode->i_ino = hash;
Jeff Layton522440e2010-09-29 09:49:54 -0400914 if (S_ISREG(inode->i_mode))
915 inode->i_data.backing_dev_info = sb->s_bdi;
Steve French0ccd4802010-07-16 04:31:02 +0000916#ifdef CONFIG_CIFS_FSCACHE
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530917 /* initialize per-inode cache cookie pointer */
918 CIFS_I(inode)->fscache = NULL;
Steve French0ccd4802010-07-16 04:31:02 +0000919#endif
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400920 unlock_new_inode(inode);
921 }
922 }
923
924 return inode;
925}
926
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927/* gets root inode */
Shirish Pargaonkar9b6763e2011-02-21 23:56:59 -0600928struct inode *cifs_root_iget(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400930 unsigned int xid;
Jeff Layton0d424ad2010-09-20 16:01:35 -0700931 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400932 struct inode *inode = NULL;
David Howellsce634ab2008-02-07 00:15:33 -0800933 long rc;
Steve French96daf2b2011-05-27 04:34:02 +0000934 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
David Howellsce634ab2008-02-07 00:15:33 -0800935
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400936 xid = get_xid();
Jeff Layton0d424ad2010-09-20 16:01:35 -0700937 if (tcon->unix_ext)
Steve Frenchf87d39d2011-05-27 03:50:55 +0000938 rc = cifs_get_inode_info_unix(&inode, "", sb, xid);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400939 else
Steve Frenchf87d39d2011-05-27 03:50:55 +0000940 rc = cifs_get_inode_info(&inode, "", NULL, sb, xid, NULL);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400941
Oskar Schirmera7851ce2010-11-10 21:06:13 +0000942 if (!inode) {
943 inode = ERR_PTR(rc);
944 goto out;
945 }
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400946
Steve French0ccd4802010-07-16 04:31:02 +0000947#ifdef CONFIG_CIFS_FSCACHE
Suresh Jayaramand03382c2010-07-05 18:12:27 +0530948 /* populate tcon->resource_id */
Jeff Layton0d424ad2010-09-20 16:01:35 -0700949 tcon->resource_id = CIFS_I(inode)->uniqueid;
Steve French0ccd4802010-07-16 04:31:02 +0000950#endif
Suresh Jayaramand03382c2010-07-05 18:12:27 +0530951
Jeff Layton0d424ad2010-09-20 16:01:35 -0700952 if (rc && tcon->ipc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500953 cifs_dbg(FYI, "ipc connection - fake read inode\n");
Steve Frenchb7ca6922012-08-03 08:43:01 -0500954 spin_lock(&inode->i_lock);
Steve French7f8ed422007-09-28 22:28:55 +0000955 inode->i_mode |= S_IFDIR;
Miklos Szeredibfe86842011-10-28 14:13:29 +0200956 set_nlink(inode, 2);
Steve French7f8ed422007-09-28 22:28:55 +0000957 inode->i_op = &cifs_ipc_inode_ops;
958 inode->i_fop = &simple_dir_operations;
959 inode->i_uid = cifs_sb->mnt_uid;
960 inode->i_gid = cifs_sb->mnt_gid;
Steve Frenchb7ca6922012-08-03 08:43:01 -0500961 spin_unlock(&inode->i_lock);
Steve Frenchad661332008-08-12 14:14:40 +0000962 } else if (rc) {
David Howellsce634ab2008-02-07 00:15:33 -0800963 iget_failed(inode);
Oskar Schirmera7851ce2010-11-10 21:06:13 +0000964 inode = ERR_PTR(rc);
Steve French7f8ed422007-09-28 22:28:55 +0000965 }
966
Oskar Schirmera7851ce2010-11-10 21:06:13 +0000967out:
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400968 /* can not call macro free_xid here since in a void func
David Howellsce634ab2008-02-07 00:15:33 -0800969 * TODO: This is no longer true
970 */
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400971 _free_xid(xid);
David Howellsce634ab2008-02-07 00:15:33 -0800972 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973}
974
Pavel Shilovskyed6875e2012-09-18 16:20:25 -0700975int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400976cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
Pavel Shilovskyed6875e2012-09-18 16:20:25 -0700977 char *full_path, __u32 dosattr)
Steve French388e57b2008-09-16 23:50:58 +0000978{
Steve French388e57b2008-09-16 23:50:58 +0000979 bool set_time = false;
Steve French388e57b2008-09-16 23:50:58 +0000980 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Pavel Shilovsky6bdf6db2012-09-18 16:20:32 -0700981 struct TCP_Server_Info *server;
Steve French388e57b2008-09-16 23:50:58 +0000982 FILE_BASIC_INFO info_buf;
983
Steve French1adcb712009-02-25 14:19:56 +0000984 if (attrs == NULL)
985 return -EINVAL;
986
Pavel Shilovsky6bdf6db2012-09-18 16:20:32 -0700987 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
988 if (!server->ops->set_file_info)
989 return -ENOSYS;
990
Steve French388e57b2008-09-16 23:50:58 +0000991 if (attrs->ia_valid & ATTR_ATIME) {
992 set_time = true;
993 info_buf.LastAccessTime =
994 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
995 } else
996 info_buf.LastAccessTime = 0;
997
998 if (attrs->ia_valid & ATTR_MTIME) {
999 set_time = true;
1000 info_buf.LastWriteTime =
1001 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1002 } else
1003 info_buf.LastWriteTime = 0;
1004
1005 /*
1006 * Samba throws this field away, but windows may actually use it.
1007 * Do not set ctime unless other time stamps are changed explicitly
1008 * (i.e. by utimes()) since we would then have a mix of client and
1009 * server times.
1010 */
1011 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001012 cifs_dbg(FYI, "CIFS - CTIME changed\n");
Steve French388e57b2008-09-16 23:50:58 +00001013 info_buf.ChangeTime =
1014 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1015 } else
1016 info_buf.ChangeTime = 0;
1017
1018 info_buf.CreationTime = 0; /* don't change */
1019 info_buf.Attributes = cpu_to_le32(dosattr);
1020
Pavel Shilovsky6bdf6db2012-09-18 16:20:32 -07001021 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
Steve French388e57b2008-09-16 23:50:58 +00001022}
1023
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001024/*
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001025 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001026 * and rename it to a random name that hopefully won't conflict with
1027 * anything else.
1028 */
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001029int
1030cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1031 const unsigned int xid)
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001032{
1033 int oplock = 0;
1034 int rc;
1035 __u16 netfid;
Steve French32709582008-10-20 00:44:19 +00001036 struct inode *inode = dentry->d_inode;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001037 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1038 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001039 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001040 struct cifs_tcon *tcon;
Steve French32709582008-10-20 00:44:19 +00001041 __u32 dosattr, origattr;
1042 FILE_BASIC_INFO *info_buf = NULL;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001043
Jeff Layton7ffec372010-09-29 19:51:11 -04001044 tlink = cifs_sb_tlink(cifs_sb);
1045 if (IS_ERR(tlink))
1046 return PTR_ERR(tlink);
1047 tcon = tlink_tcon(tlink);
1048
Sachin Prabhuc483a982013-03-05 19:25:56 +00001049 /*
1050 * We cannot rename the file if the server doesn't support
1051 * CAP_INFOLEVEL_PASSTHRU
1052 */
1053 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1054 rc = -EBUSY;
1055 goto out;
1056 }
1057
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001058 rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
Jeff Laytondd1db2d2008-10-16 19:27:12 -04001059 DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001060 &netfid, &oplock, NULL, cifs_sb->local_nls,
1061 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1062 if (rc != 0)
1063 goto out;
1064
Steve French32709582008-10-20 00:44:19 +00001065 origattr = cifsInode->cifsAttrs;
1066 if (origattr == 0)
1067 origattr |= ATTR_NORMAL;
1068
1069 dosattr = origattr & ~ATTR_READONLY;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001070 if (dosattr == 0)
1071 dosattr |= ATTR_NORMAL;
1072 dosattr |= ATTR_HIDDEN;
1073
Steve French32709582008-10-20 00:44:19 +00001074 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1075 if (dosattr != origattr) {
1076 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1077 if (info_buf == NULL) {
1078 rc = -ENOMEM;
1079 goto out_close;
1080 }
1081 info_buf->Attributes = cpu_to_le32(dosattr);
1082 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1083 current->tgid);
1084 /* although we would like to mark the file hidden
1085 if that fails we will still try to rename it */
Sachin Prabhu72d282d2013-03-05 19:25:55 +00001086 if (!rc)
Steve French32709582008-10-20 00:44:19 +00001087 cifsInode->cifsAttrs = dosattr;
1088 else
1089 dosattr = origattr; /* since not able to change them */
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001090 }
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001091
Jeff Laytondd1db2d2008-10-16 19:27:12 -04001092 /* rename the file */
1093 rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001094 cifs_sb->mnt_cifs_flags &
1095 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French32709582008-10-20 00:44:19 +00001096 if (rc != 0) {
Sachin Prabhu47c78f42013-03-11 13:08:49 +00001097 rc = -EBUSY;
Steve French32709582008-10-20 00:44:19 +00001098 goto undo_setattr;
1099 }
Jeff Layton6d22f092008-09-23 11:48:35 -04001100
Steve French32709582008-10-20 00:44:19 +00001101 /* try to set DELETE_ON_CLOSE */
1102 if (!cifsInode->delete_pending) {
1103 rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
1104 current->tgid);
1105 /*
1106 * some samba versions return -ENOENT when we try to set the
1107 * file disposition here. Likely a samba bug, but work around
1108 * it for now. This means that some cifsXXX files may hang
1109 * around after they shouldn't.
1110 *
1111 * BB: remove this hack after more servers have the fix
1112 */
1113 if (rc == -ENOENT)
1114 rc = 0;
1115 else if (rc != 0) {
Sachin Prabhu47c78f42013-03-11 13:08:49 +00001116 rc = -EBUSY;
Steve French32709582008-10-20 00:44:19 +00001117 goto undo_rename;
1118 }
1119 cifsInode->delete_pending = true;
1120 }
Jeff Layton7ce86d52008-09-24 11:32:59 -04001121
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001122out_close:
1123 CIFSSMBClose(xid, tcon, netfid);
1124out:
Steve French32709582008-10-20 00:44:19 +00001125 kfree(info_buf);
Jeff Layton7ffec372010-09-29 19:51:11 -04001126 cifs_put_tlink(tlink);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001127 return rc;
Steve French32709582008-10-20 00:44:19 +00001128
1129 /*
1130 * reset everything back to the original state. Don't bother
1131 * dealing with errors here since we can't do anything about
1132 * them anyway.
1133 */
1134undo_rename:
1135 CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
1136 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1137 CIFS_MOUNT_MAP_SPECIAL_CHR);
1138undo_setattr:
1139 if (dosattr != origattr) {
1140 info_buf->Attributes = cpu_to_le32(origattr);
1141 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1142 current->tgid))
1143 cifsInode->cifsAttrs = origattr;
1144 }
1145
1146 goto out_close;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001147}
1148
Steve Frenchb7ca6922012-08-03 08:43:01 -05001149/* copied from fs/nfs/dir.c with small changes */
1150static void
1151cifs_drop_nlink(struct inode *inode)
1152{
1153 spin_lock(&inode->i_lock);
1154 if (inode->i_nlink > 0)
1155 drop_nlink(inode);
1156 spin_unlock(&inode->i_lock);
1157}
Steve Frenchff694522009-04-20 19:45:13 +00001158
1159/*
1160 * If dentry->d_inode is null (usually meaning the cached dentry
1161 * is a negative dentry) then we would attempt a standard SMB delete, but
André Goddard Rosaaf901ca2009-11-14 13:09:05 -02001162 * if that fails we can not attempt the fall back mechanisms on EACCESS
1163 * but will return the EACCESS to the caller. Note that the VFS does not call
Steve Frenchff694522009-04-20 19:45:13 +00001164 * unlink on negative dentries currently.
1165 */
Jeff Layton5f0319a2008-09-16 14:05:16 -04001166int cifs_unlink(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167{
1168 int rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001169 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 char *full_path = NULL;
Jeff Layton5f0319a2008-09-16 14:05:16 -04001171 struct inode *inode = dentry->d_inode;
Steve Frenchff694522009-04-20 19:45:13 +00001172 struct cifsInodeInfo *cifs_inode;
Jeff Layton5f0319a2008-09-16 14:05:16 -04001173 struct super_block *sb = dir->i_sb;
1174 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001175 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001176 struct cifs_tcon *tcon;
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001177 struct TCP_Server_Info *server;
Steve French60502472008-10-07 18:42:52 +00001178 struct iattr *attrs = NULL;
1179 __u32 dosattr = 0, origattr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180
Joe Perchesf96637b2013-05-04 22:12:25 -05001181 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182
Jeff Layton7ffec372010-09-29 19:51:11 -04001183 tlink = cifs_sb_tlink(cifs_sb);
1184 if (IS_ERR(tlink))
1185 return PTR_ERR(tlink);
1186 tcon = tlink_tcon(tlink);
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001187 server = tcon->ses->server;
Jeff Layton7ffec372010-09-29 19:51:11 -04001188
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001189 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190
Jeff Layton5f0319a2008-09-16 14:05:16 -04001191 /* Unlink can be called from rename so we can not take the
1192 * sb->s_vfs_rename_mutex here */
1193 full_path = build_path_from_dentry(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301195 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001196 goto unlink_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 }
Steve French2d785a52007-07-15 01:48:57 +00001198
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001199 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1200 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001201 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
Steve French2d785a52007-07-15 01:48:57 +00001202 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1203 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Joe Perchesf96637b2013-05-04 22:12:25 -05001204 cifs_dbg(FYI, "posix del rc %d\n", rc);
Steve French2d785a52007-07-15 01:48:57 +00001205 if ((rc == 0) || (rc == -ENOENT))
1206 goto psx_del_no_retry;
1207 }
1208
Steve French60502472008-10-07 18:42:52 +00001209retry_std_delete:
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001210 if (!server->ops->unlink) {
1211 rc = -ENOSYS;
1212 goto psx_del_no_retry;
1213 }
1214
1215 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
Steve French60502472008-10-07 18:42:52 +00001216
Steve French2d785a52007-07-15 01:48:57 +00001217psx_del_no_retry:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218 if (!rc) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001219 if (inode)
Steve Frenchb7ca6922012-08-03 08:43:01 -05001220 cifs_drop_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 } else if (rc == -ENOENT) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001222 d_drop(dentry);
Sachin Prabhu47c78f42013-03-11 13:08:49 +00001223 } else if (rc == -EBUSY) {
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001224 if (server->ops->rename_pending_delete) {
1225 rc = server->ops->rename_pending_delete(full_path,
1226 dentry, xid);
1227 if (rc == 0)
1228 cifs_drop_nlink(inode);
1229 }
Steve Frenchff694522009-04-20 19:45:13 +00001230 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
Steve French388e57b2008-09-16 23:50:58 +00001231 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1232 if (attrs == NULL) {
1233 rc = -ENOMEM;
1234 goto out_reval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235 }
Steve French388e57b2008-09-16 23:50:58 +00001236
1237 /* try to reset dos attributes */
Steve Frenchff694522009-04-20 19:45:13 +00001238 cifs_inode = CIFS_I(inode);
1239 origattr = cifs_inode->cifsAttrs;
Steve French60502472008-10-07 18:42:52 +00001240 if (origattr == 0)
1241 origattr |= ATTR_NORMAL;
1242 dosattr = origattr & ~ATTR_READONLY;
Steve French388e57b2008-09-16 23:50:58 +00001243 if (dosattr == 0)
1244 dosattr |= ATTR_NORMAL;
1245 dosattr |= ATTR_HIDDEN;
1246
1247 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
Steve French388e57b2008-09-16 23:50:58 +00001248 if (rc != 0)
1249 goto out_reval;
Steve French60502472008-10-07 18:42:52 +00001250
1251 goto retry_std_delete;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 }
Steve French60502472008-10-07 18:42:52 +00001253
1254 /* undo the setattr if we errored out and it's needed */
1255 if (rc != 0 && dosattr != 0)
1256 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1257
Steve French388e57b2008-09-16 23:50:58 +00001258out_reval:
Jeff Layton5f0319a2008-09-16 14:05:16 -04001259 if (inode) {
Steve Frenchff694522009-04-20 19:45:13 +00001260 cifs_inode = CIFS_I(inode);
1261 cifs_inode->time = 0; /* will force revalidate to get info
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001262 when needed */
Jeff Layton5f0319a2008-09-16 14:05:16 -04001263 inode->i_ctime = current_fs_time(sb);
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001264 }
Jeff Layton5f0319a2008-09-16 14:05:16 -04001265 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
Steve Frenchff694522009-04-20 19:45:13 +00001266 cifs_inode = CIFS_I(dir);
Steve French60502472008-10-07 18:42:52 +00001267 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
Jeff Layton7ffec372010-09-29 19:51:11 -04001268unlink_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 kfree(full_path);
Steve French60502472008-10-07 18:42:52 +00001270 kfree(attrs);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001271 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001272 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 return rc;
1274}
1275
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001276static int
Jeff Layton101b92d2012-09-19 06:22:45 -07001277cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001278 const char *full_path, struct cifs_sb_info *cifs_sb,
1279 struct cifs_tcon *tcon, const unsigned int xid)
1280{
1281 int rc = 0;
Jeff Layton101b92d2012-09-19 06:22:45 -07001282 struct inode *inode = NULL;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001283
1284 if (tcon->unix_ext)
Jeff Layton101b92d2012-09-19 06:22:45 -07001285 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001286 xid);
1287 else
Jeff Layton101b92d2012-09-19 06:22:45 -07001288 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1289 xid, NULL);
1290
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001291 if (rc)
1292 return rc;
1293
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001294 /*
1295 * setting nlink not necessary except in cases where we failed to get it
Jeff Layton101b92d2012-09-19 06:22:45 -07001296 * from the server or was set bogus. Also, since this is a brand new
1297 * inode, no need to grab the i_lock before setting the i_nlink.
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001298 */
Jeff Layton101b92d2012-09-19 06:22:45 -07001299 if (inode->i_nlink < 2)
1300 set_nlink(inode, 2);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001301 mode &= ~current_umask();
1302 /* must turn on setgid bit if parent dir has it */
Jeff Layton101b92d2012-09-19 06:22:45 -07001303 if (parent->i_mode & S_ISGID)
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001304 mode |= S_ISGID;
1305
1306 if (tcon->unix_ext) {
1307 struct cifs_unix_set_info_args args = {
1308 .mode = mode,
1309 .ctime = NO_CHANGE_64,
1310 .atime = NO_CHANGE_64,
1311 .mtime = NO_CHANGE_64,
1312 .device = 0,
1313 };
1314 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
Eric W. Biederman49418b22013-02-06 00:57:56 -08001315 args.uid = current_fsuid();
Jeff Layton101b92d2012-09-19 06:22:45 -07001316 if (parent->i_mode & S_ISGID)
Eric W. Biederman49418b22013-02-06 00:57:56 -08001317 args.gid = parent->i_gid;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001318 else
Eric W. Biederman49418b22013-02-06 00:57:56 -08001319 args.gid = current_fsgid();
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001320 } else {
Eric W. Biederman49418b22013-02-06 00:57:56 -08001321 args.uid = INVALID_UID; /* no change */
1322 args.gid = INVALID_GID; /* no change */
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001323 }
1324 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1325 cifs_sb->local_nls,
1326 cifs_sb->mnt_cifs_flags &
1327 CIFS_MOUNT_MAP_SPECIAL_CHR);
1328 } else {
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001329 struct TCP_Server_Info *server = tcon->ses->server;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001330 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001331 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
Jeff Layton101b92d2012-09-19 06:22:45 -07001332 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001333 tcon, xid);
Jeff Layton101b92d2012-09-19 06:22:45 -07001334 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1335 inode->i_mode = (mode | S_IFDIR);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001336
Jeff Layton101b92d2012-09-19 06:22:45 -07001337 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1338 inode->i_uid = current_fsuid();
1339 if (inode->i_mode & S_ISGID)
1340 inode->i_gid = parent->i_gid;
1341 else
1342 inode->i_gid = current_fsgid();
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001343 }
1344 }
Jeff Layton101b92d2012-09-19 06:22:45 -07001345 d_instantiate(dentry, inode);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001346 return rc;
1347}
1348
1349static int
1350cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1351 const char *full_path, struct cifs_sb_info *cifs_sb,
1352 struct cifs_tcon *tcon, const unsigned int xid)
1353{
1354 int rc = 0;
1355 u32 oplock = 0;
1356 FILE_UNIX_BASIC_INFO *info = NULL;
1357 struct inode *newinode = NULL;
1358 struct cifs_fattr fattr;
1359
1360 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1361 if (info == NULL) {
1362 rc = -ENOMEM;
1363 goto posix_mkdir_out;
1364 }
1365
1366 mode &= ~current_umask();
1367 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1368 NULL /* netfid */, info, &oplock, full_path,
1369 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1370 CIFS_MOUNT_MAP_SPECIAL_CHR);
1371 if (rc == -EOPNOTSUPP)
1372 goto posix_mkdir_out;
1373 else if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001374 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001375 d_drop(dentry);
1376 goto posix_mkdir_out;
1377 }
1378
1379 if (info->Type == cpu_to_le32(-1))
1380 /* no return info, go query for it */
1381 goto posix_mkdir_get_info;
1382 /*
1383 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1384 * need to set uid/gid.
1385 */
1386
1387 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1388 cifs_fill_uniqueid(inode->i_sb, &fattr);
1389 newinode = cifs_iget(inode->i_sb, &fattr);
1390 if (!newinode)
1391 goto posix_mkdir_get_info;
1392
1393 d_instantiate(dentry, newinode);
1394
1395#ifdef CONFIG_CIFS_DEBUG2
Joe Perchesf96637b2013-05-04 22:12:25 -05001396 cifs_dbg(FYI, "instantiated dentry %p %s to inode %p\n",
1397 dentry, dentry->d_name.name, newinode);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001398
1399 if (newinode->i_nlink != 2)
Joe Perchesf96637b2013-05-04 22:12:25 -05001400 cifs_dbg(FYI, "unexpected number of links %d\n",
1401 newinode->i_nlink);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001402#endif
1403
1404posix_mkdir_out:
1405 kfree(info);
1406 return rc;
1407posix_mkdir_get_info:
1408 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1409 xid);
1410 goto posix_mkdir_out;
1411}
1412
Al Viro18bb1db2011-07-26 01:41:39 -04001413int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414{
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001415 int rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001416 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001418 struct tcon_link *tlink;
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001419 struct cifs_tcon *tcon;
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001420 struct TCP_Server_Info *server;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001421 char *full_path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422
Joe Perchesf96637b2013-05-04 22:12:25 -05001423 cifs_dbg(FYI, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1424 mode, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001427 tlink = cifs_sb_tlink(cifs_sb);
1428 if (IS_ERR(tlink))
1429 return PTR_ERR(tlink);
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001430 tcon = tlink_tcon(tlink);
Jeff Layton7ffec372010-09-29 19:51:11 -04001431
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001432 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433
Steve French7f573562005-08-30 11:32:14 -07001434 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301436 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001437 goto mkdir_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438 }
Steve French50c2f752007-07-13 00:33:32 +00001439
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001440 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1441 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001442 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1443 tcon, xid);
1444 if (rc != -EOPNOTSUPP)
Steve French2dd29d32007-04-23 22:07:35 +00001445 goto mkdir_out;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001446 }
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001447
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001448 server = tcon->ses->server;
1449
1450 if (!server->ops->mkdir) {
1451 rc = -ENOSYS;
1452 goto mkdir_out;
1453 }
1454
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 /* BB add setting the equivalent of mode via CreateX w/ACLs */
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001456 rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001458 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 d_drop(direntry);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001460 goto mkdir_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461 }
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001462
1463 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1464 xid);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001465mkdir_out:
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +03001466 /*
1467 * Force revalidate to get parent dir info when needed since cached
1468 * attributes are invalid now.
1469 */
1470 CIFS_I(inode)->time = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001472 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001473 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 return rc;
1475}
1476
1477int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1478{
1479 int rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001480 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001482 struct tcon_link *tlink;
Pavel Shilovskyf958ca52012-07-10 16:14:18 +04001483 struct cifs_tcon *tcon;
1484 struct TCP_Server_Info *server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485 char *full_path = NULL;
1486 struct cifsInodeInfo *cifsInode;
1487
Joe Perchesf96637b2013-05-04 22:12:25 -05001488 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001490 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491
Steve French7f573562005-08-30 11:32:14 -07001492 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301494 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001495 goto rmdir_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496 }
1497
Jeff Layton7ffec372010-09-29 19:51:11 -04001498 cifs_sb = CIFS_SB(inode->i_sb);
1499 tlink = cifs_sb_tlink(cifs_sb);
1500 if (IS_ERR(tlink)) {
1501 rc = PTR_ERR(tlink);
1502 goto rmdir_exit;
1503 }
Pavel Shilovskyf958ca52012-07-10 16:14:18 +04001504 tcon = tlink_tcon(tlink);
1505 server = tcon->ses->server;
Jeff Layton7ffec372010-09-29 19:51:11 -04001506
Pavel Shilovskyf958ca52012-07-10 16:14:18 +04001507 if (!server->ops->rmdir) {
1508 rc = -ENOSYS;
1509 cifs_put_tlink(tlink);
1510 goto rmdir_exit;
1511 }
1512
1513 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001514 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515
1516 if (!rc) {
Steve French3677db12007-02-26 16:46:11 +00001517 spin_lock(&direntry->d_inode->i_lock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001518 i_size_write(direntry->d_inode, 0);
Dave Hansence71ec32006-09-30 23:29:06 -07001519 clear_nlink(direntry->d_inode);
Steve French3677db12007-02-26 16:46:11 +00001520 spin_unlock(&direntry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521 }
1522
1523 cifsInode = CIFS_I(direntry->d_inode);
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +03001524 /* force revalidate to go get info when needed */
1525 cifsInode->time = 0;
Steve French42c24542009-01-13 22:03:55 +00001526
1527 cifsInode = CIFS_I(inode);
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +03001528 /*
1529 * Force revalidate to get parent dir info when needed since cached
1530 * attributes are invalid now.
1531 */
1532 cifsInode->time = 0;
Steve French42c24542009-01-13 22:03:55 +00001533
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1535 current_fs_time(inode->i_sb);
1536
Jeff Layton7ffec372010-09-29 19:51:11 -04001537rmdir_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001539 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540 return rc;
1541}
1542
Steve Frenchee2fd962008-09-23 18:23:33 +00001543static int
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001544cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1545 const char *from_path, struct dentry *to_dentry,
1546 const char *to_path)
Steve Frenchee2fd962008-09-23 18:23:33 +00001547{
1548 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001549 struct tcon_link *tlink;
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001550 struct cifs_tcon *tcon;
1551 struct TCP_Server_Info *server;
Steve Frenchee2fd962008-09-23 18:23:33 +00001552 __u16 srcfid;
1553 int oplock, rc;
1554
Jeff Layton7ffec372010-09-29 19:51:11 -04001555 tlink = cifs_sb_tlink(cifs_sb);
1556 if (IS_ERR(tlink))
1557 return PTR_ERR(tlink);
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001558 tcon = tlink_tcon(tlink);
1559 server = tcon->ses->server;
1560
1561 if (!server->ops->rename)
1562 return -ENOSYS;
Jeff Layton7ffec372010-09-29 19:51:11 -04001563
Steve Frenchee2fd962008-09-23 18:23:33 +00001564 /* try path-based rename first */
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001565 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
Steve Frenchee2fd962008-09-23 18:23:33 +00001566
1567 /*
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001568 * Don't bother with rename by filehandle unless file is busy and
1569 * source. Note that cross directory moves do not work with
Steve Frenchee2fd962008-09-23 18:23:33 +00001570 * rename by filehandle to various Windows servers.
1571 */
Sachin Prabhu47c78f42013-03-11 13:08:49 +00001572 if (rc == 0 || rc != -EBUSY)
Jeff Layton7ffec372010-09-29 19:51:11 -04001573 goto do_rename_exit;
Steve Frenchee2fd962008-09-23 18:23:33 +00001574
Jeff Laytoned0e3ac2010-06-01 16:21:01 -04001575 /* open-file renames don't work across directories */
1576 if (to_dentry->d_parent != from_dentry->d_parent)
Jeff Layton7ffec372010-09-29 19:51:11 -04001577 goto do_rename_exit;
Jeff Laytoned0e3ac2010-06-01 16:21:01 -04001578
Steve Frenchee2fd962008-09-23 18:23:33 +00001579 /* open the file to be renamed -- we need DELETE perms */
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001580 rc = CIFSSMBOpen(xid, tcon, from_path, FILE_OPEN, DELETE,
Steve Frenchee2fd962008-09-23 18:23:33 +00001581 CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1582 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1583 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve Frenchee2fd962008-09-23 18:23:33 +00001584 if (rc == 0) {
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001585 rc = CIFSSMBRenameOpenFile(xid, tcon, srcfid,
Steve Frenchee2fd962008-09-23 18:23:33 +00001586 (const char *) to_dentry->d_name.name,
1587 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1588 CIFS_MOUNT_MAP_SPECIAL_CHR);
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001589 CIFSSMBClose(xid, tcon, srcfid);
Steve Frenchee2fd962008-09-23 18:23:33 +00001590 }
Jeff Layton7ffec372010-09-29 19:51:11 -04001591do_rename_exit:
1592 cifs_put_tlink(tlink);
Steve Frenchee2fd962008-09-23 18:23:33 +00001593 return rc;
1594}
1595
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001596int
1597cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1598 struct inode *target_dir, struct dentry *target_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599{
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001600 char *from_name = NULL;
1601 char *to_name = NULL;
Jeff Layton639e7a92010-09-03 11:50:09 -04001602 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001603 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001604 struct cifs_tcon *tcon;
Steve Frenchee2fd962008-09-23 18:23:33 +00001605 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1606 FILE_UNIX_BASIC_INFO *info_buf_target;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001607 unsigned int xid;
1608 int rc, tmprc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609
Jeff Layton639e7a92010-09-03 11:50:09 -04001610 cifs_sb = CIFS_SB(source_dir->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001611 tlink = cifs_sb_tlink(cifs_sb);
1612 if (IS_ERR(tlink))
1613 return PTR_ERR(tlink);
1614 tcon = tlink_tcon(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001616 xid = get_xid();
Steve Frenchee2fd962008-09-23 18:23:33 +00001617
1618 /*
Steve Frenchee2fd962008-09-23 18:23:33 +00001619 * we already have the rename sem so we do not need to
1620 * grab it again here to protect the path integrity
1621 */
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001622 from_name = build_path_from_dentry(source_dentry);
1623 if (from_name == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624 rc = -ENOMEM;
1625 goto cifs_rename_exit;
1626 }
1627
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001628 to_name = build_path_from_dentry(target_dentry);
1629 if (to_name == NULL) {
Steve Frenchee2fd962008-09-23 18:23:33 +00001630 rc = -ENOMEM;
1631 goto cifs_rename_exit;
1632 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001634 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1635 to_name);
Steve Frenchee2fd962008-09-23 18:23:33 +00001636
Jeff Layton14121bd2008-10-20 14:45:22 -04001637 if (rc == -EEXIST && tcon->unix_ext) {
Steve Frenchee2fd962008-09-23 18:23:33 +00001638 /*
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001639 * Are src and dst hardlinks of same inode? We can only tell
1640 * with unix extensions enabled.
Steve Frenchee2fd962008-09-23 18:23:33 +00001641 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001642 info_buf_source =
1643 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1644 GFP_KERNEL);
1645 if (info_buf_source == NULL) {
1646 rc = -ENOMEM;
1647 goto cifs_rename_exit;
1648 }
1649
1650 info_buf_target = info_buf_source + 1;
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001651 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1652 info_buf_source,
1653 cifs_sb->local_nls,
1654 cifs_sb->mnt_cifs_flags &
1655 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton8d281ef2008-10-22 13:57:01 -04001656 if (tmprc != 0)
Jeff Layton14121bd2008-10-20 14:45:22 -04001657 goto unlink_target;
1658
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001659 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1660 info_buf_target,
1661 cifs_sb->local_nls,
1662 cifs_sb->mnt_cifs_flags &
1663 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton14121bd2008-10-20 14:45:22 -04001664
Jeff Layton8d281ef2008-10-22 13:57:01 -04001665 if (tmprc == 0 && (info_buf_source->UniqueId ==
Jeff Laytonae6884a2008-11-03 14:05:08 -05001666 info_buf_target->UniqueId)) {
Jeff Layton14121bd2008-10-20 14:45:22 -04001667 /* same file, POSIX says that this is a noop */
Jeff Laytonae6884a2008-11-03 14:05:08 -05001668 rc = 0;
Jeff Layton14121bd2008-10-20 14:45:22 -04001669 goto cifs_rename_exit;
Jeff Laytonae6884a2008-11-03 14:05:08 -05001670 }
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001671 }
1672 /*
1673 * else ... BB we could add the same check for Windows by
1674 * checking the UniqueId via FILE_INTERNAL_INFO
1675 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001676
Jeff Layton14121bd2008-10-20 14:45:22 -04001677unlink_target:
Jeff Laytonfc6f3942009-04-17 11:45:30 -04001678 /* Try unlinking the target dentry if it's not negative */
1679 if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
Jeff Layton8d281ef2008-10-22 13:57:01 -04001680 tmprc = cifs_unlink(target_dir, target_dentry);
Jeff Layton14121bd2008-10-20 14:45:22 -04001681 if (tmprc)
1682 goto cifs_rename_exit;
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001683 rc = cifs_do_rename(xid, source_dentry, from_name,
1684 target_dentry, to_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685 }
1686
1687cifs_rename_exit:
Steve Frenchee2fd962008-09-23 18:23:33 +00001688 kfree(info_buf_source);
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001689 kfree(from_name);
1690 kfree(to_name);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001691 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001692 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693 return rc;
1694}
1695
Jeff Laytondf2cf172010-02-12 07:44:16 -05001696static bool
1697cifs_inode_needs_reval(struct inode *inode)
1698{
1699 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301700 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Laytondf2cf172010-02-12 07:44:16 -05001701
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001702 if (CIFS_CACHE_READ(cifs_i))
Jeff Laytondf2cf172010-02-12 07:44:16 -05001703 return false;
1704
1705 if (!lookupCacheEnabled)
1706 return true;
1707
1708 if (cifs_i->time == 0)
1709 return true;
1710
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301711 if (!time_in_range(jiffies, cifs_i->time,
1712 cifs_i->time + cifs_sb->actimeo))
Jeff Laytondf2cf172010-02-12 07:44:16 -05001713 return true;
1714
Jeff Laytondb192722010-05-17 14:51:49 -04001715 /* hardlinked files w/ noserverino get "special" treatment */
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301716 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
Jeff Laytondb192722010-05-17 14:51:49 -04001717 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1718 return true;
1719
Jeff Laytondf2cf172010-02-12 07:44:16 -05001720 return false;
1721}
1722
Suresh Jayaraman523fb8c2010-11-29 22:39:47 +05301723/*
1724 * Zap the cache. Called when invalid_mapping flag is set.
1725 */
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001726int
Jeff Laytondf2cf172010-02-12 07:44:16 -05001727cifs_invalidate_mapping(struct inode *inode)
1728{
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001729 int rc = 0;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001730 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1731
1732 cifs_i->invalid_mapping = false;
1733
Jeff Laytondf2cf172010-02-12 07:44:16 -05001734 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
Pavel Shilovsky257fb1f2011-03-16 01:55:32 +03001735 rc = invalidate_inode_pages2(inode->i_mapping);
1736 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001737 cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1738 __func__, inode);
Pavel Shilovsky257fb1f2011-03-16 01:55:32 +03001739 cifs_i->invalid_mapping = true;
1740 }
Jeff Laytondf2cf172010-02-12 07:44:16 -05001741 }
Pavel Shilovsky257fb1f2011-03-16 01:55:32 +03001742
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +05301743 cifs_fscache_reset_inode_cookie(inode);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001744 return rc;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001745}
1746
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001747int cifs_revalidate_file_attr(struct file *filp)
Jeff Laytonabab0952010-02-12 07:44:18 -05001748{
1749 int rc = 0;
Al Viro496ad9a2013-01-23 17:07:38 -05001750 struct inode *inode = file_inode(filp);
Jeff Laytonba00ba62010-09-20 16:01:31 -07001751 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
Jeff Laytonabab0952010-02-12 07:44:18 -05001752
1753 if (!cifs_inode_needs_reval(inode))
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001754 return rc;
Jeff Laytonabab0952010-02-12 07:44:18 -05001755
Jeff Layton13cfb732010-09-29 19:51:11 -04001756 if (tlink_tcon(cfile->tlink)->unix_ext)
Jeff Laytonabab0952010-02-12 07:44:18 -05001757 rc = cifs_get_file_info_unix(filp);
1758 else
1759 rc = cifs_get_file_info(filp);
1760
Jeff Laytonabab0952010-02-12 07:44:18 -05001761 return rc;
1762}
1763
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001764int cifs_revalidate_dentry_attr(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001766 unsigned int xid;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001767 int rc = 0;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001768 struct inode *inode = dentry->d_inode;
1769 struct super_block *sb = dentry->d_sb;
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001770 char *full_path = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771
Jeff Laytondf2cf172010-02-12 07:44:16 -05001772 if (inode == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773 return -ENOENT;
1774
Jeff Laytondf2cf172010-02-12 07:44:16 -05001775 if (!cifs_inode_needs_reval(inode))
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001776 return rc;
1777
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001778 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779
1780 /* can not safely grab the rename sem here if rename calls revalidate
1781 since that would deadlock */
Jeff Laytondf2cf172010-02-12 07:44:16 -05001782 full_path = build_path_from_dentry(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301784 rc = -ENOMEM;
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001785 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786 }
Jeff Laytondf2cf172010-02-12 07:44:16 -05001787
Joe Perchesf96637b2013-05-04 22:12:25 -05001788 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1789 full_path, inode, inode->i_count.counter,
Steve Frenchf19159d2010-04-21 04:12:10 +00001790 dentry, dentry->d_time, jiffies);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791
Jeff Layton0d424ad2010-09-20 16:01:35 -07001792 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
Jeff Laytondf2cf172010-02-12 07:44:16 -05001793 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1794 else
1795 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1796 xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001798out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001800 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801 return rc;
1802}
1803
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001804int cifs_revalidate_file(struct file *filp)
1805{
1806 int rc;
Al Viro496ad9a2013-01-23 17:07:38 -05001807 struct inode *inode = file_inode(filp);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001808
1809 rc = cifs_revalidate_file_attr(filp);
1810 if (rc)
1811 return rc;
1812
1813 if (CIFS_I(inode)->invalid_mapping)
1814 rc = cifs_invalidate_mapping(inode);
1815 return rc;
1816}
1817
1818/* revalidate a dentry's inode attributes */
1819int cifs_revalidate_dentry(struct dentry *dentry)
1820{
1821 int rc;
1822 struct inode *inode = dentry->d_inode;
1823
1824 rc = cifs_revalidate_dentry_attr(dentry);
1825 if (rc)
1826 return rc;
1827
1828 if (CIFS_I(inode)->invalid_mapping)
1829 rc = cifs_invalidate_mapping(inode);
1830 return rc;
1831}
1832
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
Jeff Layton1c456012010-10-12 11:32:42 -04001834 struct kstat *stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835{
Jeff Layton3aa1c8c2010-10-07 14:46:28 -04001836 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
Steve French96daf2b2011-05-27 04:34:02 +00001837 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001838 struct inode *inode = dentry->d_inode;
1839 int rc;
Jeff Layton3aa1c8c2010-10-07 14:46:28 -04001840
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001841 /*
1842 * We need to be sure that all dirty pages are written and the server
1843 * has actual ctime, mtime and file length.
1844 */
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001845 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001846 inode->i_mapping->nrpages != 0) {
1847 rc = filemap_fdatawait(inode->i_mapping);
Steve French156ecb22011-05-20 17:00:01 +00001848 if (rc) {
1849 mapping_set_error(inode->i_mapping, rc);
1850 return rc;
1851 }
Steve French5fe14c82006-11-07 19:26:33 +00001852 }
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001853
1854 rc = cifs_revalidate_dentry_attr(dentry);
1855 if (rc)
1856 return rc;
1857
1858 generic_fillattr(inode, stat);
1859 stat->blksize = CIFS_MAX_MSGSIZE;
1860 stat->ino = CIFS_I(inode)->uniqueid;
1861
1862 /*
Jeff Laytond3d1fce2012-11-25 08:00:40 -05001863 * If on a multiuser mount without unix extensions or cifsacl being
1864 * enabled, and the admin hasn't overridden them, set the ownership
1865 * to the fsuid/fsgid of the current process.
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001866 */
1867 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
Jeff Laytond3d1fce2012-11-25 08:00:40 -05001868 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001869 !tcon->unix_ext) {
1870 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1871 stat->uid = current_fsuid();
1872 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1873 stat->gid = current_fsgid();
1874 }
1875 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876}
1877
1878static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1879{
1880 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1881 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1882 struct page *page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883 int rc = 0;
1884
1885 page = grab_cache_page(mapping, index);
1886 if (!page)
1887 return -ENOMEM;
1888
Christoph Lametereebd2aa2008-02-04 22:28:29 -08001889 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 unlock_page(page);
1891 page_cache_release(page);
1892 return rc;
1893}
1894
Christoph Hellwig1b947462010-07-18 17:51:21 -04001895static void cifs_setsize(struct inode *inode, loff_t offset)
Steve French3677db12007-02-26 16:46:11 +00001896{
Steve Frenchba6a46a2007-02-26 20:06:29 +00001897 spin_lock(&inode->i_lock);
Steve French3677db12007-02-26 16:46:11 +00001898 i_size_write(inode, offset);
Steve Frenchba6a46a2007-02-26 20:06:29 +00001899 spin_unlock(&inode->i_lock);
Christoph Hellwig1b947462010-07-18 17:51:21 -04001900
Kirill A. Shutemov7caef262013-09-12 15:13:56 -07001901 truncate_pagecache(inode, offset);
Steve French3677db12007-02-26 16:46:11 +00001902}
1903
Jeff Layton8efdbde2008-07-23 21:28:12 +00001904static int
1905cifs_set_file_size(struct inode *inode, struct iattr *attrs,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001906 unsigned int xid, char *full_path)
Jeff Layton8efdbde2008-07-23 21:28:12 +00001907{
1908 int rc;
1909 struct cifsFileInfo *open_file;
1910 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1911 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001912 struct tcon_link *tlink = NULL;
Pavel Shilovskyd1433412012-09-18 16:20:31 -07001913 struct cifs_tcon *tcon = NULL;
1914 struct TCP_Server_Info *server;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001915 struct cifs_io_parms io_parms;
Jeff Layton8efdbde2008-07-23 21:28:12 +00001916
1917 /*
1918 * To avoid spurious oplock breaks from server, in the case of
1919 * inodes that we already have open, avoid doing path based
1920 * setting of file size if we can do it by handle.
1921 * This keeps our caching token (oplock) and avoids timeouts
1922 * when the local oplock break takes longer to flush
1923 * writebehind data than the SMB timeout for the SetPathInfo
1924 * request would allow
1925 */
Jeff Layton6508d902010-09-29 19:51:11 -04001926 open_file = find_writable_file(cifsInode, true);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001927 if (open_file) {
Pavel Shilovskyd1433412012-09-18 16:20:31 -07001928 tcon = tlink_tcon(open_file->tlink);
1929 server = tcon->ses->server;
1930 if (server->ops->set_file_size)
1931 rc = server->ops->set_file_size(xid, tcon, open_file,
1932 attrs->ia_size, false);
1933 else
1934 rc = -ENOSYS;
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001935 cifsFileInfo_put(open_file);
Joe Perchesf96637b2013-05-04 22:12:25 -05001936 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001937 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1938 unsigned int bytes_written;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001939
Pavel Shilovskyd1433412012-09-18 16:20:31 -07001940 io_parms.netfid = open_file->fid.netfid;
1941 io_parms.pid = open_file->pid;
1942 io_parms.tcon = tcon;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001943 io_parms.offset = 0;
1944 io_parms.length = attrs->ia_size;
1945 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written,
1946 NULL, NULL, 1);
Joe Perchesf96637b2013-05-04 22:12:25 -05001947 cifs_dbg(FYI, "Wrt seteof rc %d\n", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001948 }
1949 } else
1950 rc = -EINVAL;
1951
Pavel Shilovskyd1433412012-09-18 16:20:31 -07001952 if (!rc)
1953 goto set_size_out;
Jeff Laytonba00ba62010-09-20 16:01:31 -07001954
Pavel Shilovskyd1433412012-09-18 16:20:31 -07001955 if (tcon == NULL) {
1956 tlink = cifs_sb_tlink(cifs_sb);
1957 if (IS_ERR(tlink))
1958 return PTR_ERR(tlink);
1959 tcon = tlink_tcon(tlink);
1960 server = tcon->ses->server;
Jeff Layton8efdbde2008-07-23 21:28:12 +00001961 }
1962
Pavel Shilovskyd1433412012-09-18 16:20:31 -07001963 /*
1964 * Set file size by pathname rather than by handle either because no
1965 * valid, writeable file handle for it was found or because there was
1966 * an error setting it by handle.
1967 */
1968 if (server->ops->set_path_size)
1969 rc = server->ops->set_path_size(xid, tcon, full_path,
1970 attrs->ia_size, cifs_sb, false);
1971 else
1972 rc = -ENOSYS;
Joe Perchesf96637b2013-05-04 22:12:25 -05001973 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
Pavel Shilovskyd1433412012-09-18 16:20:31 -07001974 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1975 __u16 netfid;
1976 int oplock = 0;
1977
1978 rc = SMBLegacyOpen(xid, tcon, full_path, FILE_OPEN,
1979 GENERIC_WRITE, CREATE_NOT_DIR, &netfid,
1980 &oplock, NULL, cifs_sb->local_nls,
1981 cifs_sb->mnt_cifs_flags &
1982 CIFS_MOUNT_MAP_SPECIAL_CHR);
1983 if (rc == 0) {
1984 unsigned int bytes_written;
1985
1986 io_parms.netfid = netfid;
1987 io_parms.pid = current->tgid;
1988 io_parms.tcon = tcon;
1989 io_parms.offset = 0;
1990 io_parms.length = attrs->ia_size;
1991 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written, NULL,
1992 NULL, 1);
Joe Perchesf96637b2013-05-04 22:12:25 -05001993 cifs_dbg(FYI, "wrt seteof rc %d\n", rc);
Pavel Shilovskyd1433412012-09-18 16:20:31 -07001994 CIFSSMBClose(xid, tcon, netfid);
1995 }
1996 }
1997 if (tlink)
1998 cifs_put_tlink(tlink);
1999
2000set_size_out:
Jeff Layton8efdbde2008-07-23 21:28:12 +00002001 if (rc == 0) {
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04002002 cifsInode->server_eof = attrs->ia_size;
Christoph Hellwig1b947462010-07-18 17:51:21 -04002003 cifs_setsize(inode, attrs->ia_size);
Jeff Layton8efdbde2008-07-23 21:28:12 +00002004 cifs_truncate_page(inode->i_mapping, inode->i_size);
2005 }
2006
2007 return rc;
2008}
2009
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002010static int
2011cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2012{
2013 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002014 unsigned int xid;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002015 char *full_path = NULL;
2016 struct inode *inode = direntry->d_inode;
2017 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2018 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04002019 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00002020 struct cifs_tcon *pTcon;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002021 struct cifs_unix_set_info_args *args = NULL;
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002022 struct cifsFileInfo *open_file;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002023
Joe Perchesf96637b2013-05-04 22:12:25 -05002024 cifs_dbg(FYI, "setattr_unix on file %s attrs->ia_valid=0x%x\n",
Joe Perchesb6b38f72010-04-21 03:50:45 +00002025 direntry->d_name.name, attrs->ia_valid);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002026
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002027 xid = get_xid();
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002028
Christoph Hellwigdb78b872010-06-04 11:30:03 +02002029 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2030 attrs->ia_valid |= ATTR_FORCE;
2031
2032 rc = inode_change_ok(inode, attrs);
2033 if (rc < 0)
2034 goto out;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002035
2036 full_path = build_path_from_dentry(direntry);
2037 if (full_path == NULL) {
2038 rc = -ENOMEM;
2039 goto out;
2040 }
2041
Jeff Layton0f4d6342009-03-26 13:35:37 -04002042 /*
2043 * Attempt to flush data before changing attributes. We need to do
2044 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2045 * ownership or mode then we may also need to do this. Here, we take
2046 * the safe way out and just do the flush on all setattr requests. If
2047 * the flush returns error, store it to report later and continue.
2048 *
2049 * BB: This should be smarter. Why bother flushing pages that
2050 * will be truncated anyway? Also, should we error out here if
2051 * the flush returns error?
2052 */
2053 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002054 mapping_set_error(inode->i_mapping, rc);
2055 rc = 0;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002056
2057 if (attrs->ia_valid & ATTR_SIZE) {
2058 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2059 if (rc != 0)
2060 goto out;
2061 }
2062
2063 /* skip mode change if it's just for clearing setuid/setgid */
2064 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2065 attrs->ia_valid &= ~ATTR_MODE;
2066
2067 args = kmalloc(sizeof(*args), GFP_KERNEL);
2068 if (args == NULL) {
2069 rc = -ENOMEM;
2070 goto out;
2071 }
2072
2073 /* set up the struct */
2074 if (attrs->ia_valid & ATTR_MODE)
2075 args->mode = attrs->ia_mode;
2076 else
2077 args->mode = NO_CHANGE_64;
2078
2079 if (attrs->ia_valid & ATTR_UID)
2080 args->uid = attrs->ia_uid;
2081 else
Eric W. Biederman49418b22013-02-06 00:57:56 -08002082 args->uid = INVALID_UID; /* no change */
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002083
2084 if (attrs->ia_valid & ATTR_GID)
2085 args->gid = attrs->ia_gid;
2086 else
Eric W. Biederman49418b22013-02-06 00:57:56 -08002087 args->gid = INVALID_GID; /* no change */
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002088
2089 if (attrs->ia_valid & ATTR_ATIME)
2090 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2091 else
2092 args->atime = NO_CHANGE_64;
2093
2094 if (attrs->ia_valid & ATTR_MTIME)
2095 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2096 else
2097 args->mtime = NO_CHANGE_64;
2098
2099 if (attrs->ia_valid & ATTR_CTIME)
2100 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2101 else
2102 args->ctime = NO_CHANGE_64;
2103
2104 args->device = 0;
Jeff Layton6508d902010-09-29 19:51:11 -04002105 open_file = find_writable_file(cifsInode, true);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002106 if (open_file) {
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07002107 u16 nfid = open_file->fid.netfid;
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002108 u32 npid = open_file->pid;
Jeff Layton13cfb732010-09-29 19:51:11 -04002109 pTcon = tlink_tcon(open_file->tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002110 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04002111 cifsFileInfo_put(open_file);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002112 } else {
Jeff Layton7ffec372010-09-29 19:51:11 -04002113 tlink = cifs_sb_tlink(cifs_sb);
2114 if (IS_ERR(tlink)) {
2115 rc = PTR_ERR(tlink);
2116 goto out;
2117 }
2118 pTcon = tlink_tcon(tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002119 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
Jeff Layton01ea95e2009-07-09 20:02:49 -04002120 cifs_sb->local_nls,
2121 cifs_sb->mnt_cifs_flags &
2122 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton7ffec372010-09-29 19:51:11 -04002123 cifs_put_tlink(tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002124 }
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002125
Christoph Hellwig10257742010-06-04 11:30:02 +02002126 if (rc)
2127 goto out;
Steve Frenchccd4bb12010-02-08 17:39:58 +00002128
Christoph Hellwig10257742010-06-04 11:30:02 +02002129 if ((attrs->ia_valid & ATTR_SIZE) &&
Christoph Hellwig1b947462010-07-18 17:51:21 -04002130 attrs->ia_size != i_size_read(inode))
2131 truncate_setsize(inode, attrs->ia_size);
Christoph Hellwig10257742010-06-04 11:30:02 +02002132
2133 setattr_copy(inode, attrs);
2134 mark_inode_dirty(inode);
2135
2136 /* force revalidate when any of these times are set since some
2137 of the fs types (eg ext3, fat) do not have fine enough
2138 time granularity to match protocol, and we do not have a
2139 a way (yet) to query the server fs's time granularity (and
2140 whether it rounds times down).
2141 */
2142 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2143 cifsInode->time = 0;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002144out:
2145 kfree(args);
2146 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002147 free_xid(xid);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002148 return rc;
2149}
2150
Jeff Layton0510eeb2008-08-02 07:26:12 -04002151static int
2152cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002154 unsigned int xid;
Eric W. Biederman8abf2772013-02-06 00:33:17 -08002155 kuid_t uid = INVALID_UID;
2156 kgid_t gid = INVALID_GID;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002157 struct inode *inode = direntry->d_inode;
2158 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002159 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002160 char *full_path = NULL;
2161 int rc = -EACCES;
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002162 __u32 dosattr = 0;
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04002163 __u64 mode = NO_CHANGE_64;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002164
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002165 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002166
Joe Perchesf96637b2013-05-04 22:12:25 -05002167 cifs_dbg(FYI, "setattr on file %s attrs->iavalid 0x%x\n",
Joe Perchesb6b38f72010-04-21 03:50:45 +00002168 direntry->d_name.name, attrs->ia_valid);
Steve French6473a552005-11-29 20:20:10 -08002169
Christoph Hellwigdb78b872010-06-04 11:30:03 +02002170 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2171 attrs->ia_valid |= ATTR_FORCE;
2172
2173 rc = inode_change_ok(inode, attrs);
2174 if (rc < 0) {
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002175 free_xid(xid);
Christoph Hellwigdb78b872010-06-04 11:30:03 +02002176 return rc;
Steve French6473a552005-11-29 20:20:10 -08002177 }
Steve French50c2f752007-07-13 00:33:32 +00002178
Steve French7f573562005-08-30 11:32:14 -07002179 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002180 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302181 rc = -ENOMEM;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002182 free_xid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302183 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002184 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185
Jeff Layton0f4d6342009-03-26 13:35:37 -04002186 /*
2187 * Attempt to flush data before changing attributes. We need to do
2188 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2189 * ownership or mode then we may also need to do this. Here, we take
2190 * the safe way out and just do the flush on all setattr requests. If
2191 * the flush returns error, store it to report later and continue.
2192 *
2193 * BB: This should be smarter. Why bother flushing pages that
2194 * will be truncated anyway? Also, should we error out here if
2195 * the flush returns error?
2196 */
2197 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002198 mapping_set_error(inode->i_mapping, rc);
2199 rc = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +00002200
Steve French50531442008-03-14 19:21:31 +00002201 if (attrs->ia_valid & ATTR_SIZE) {
Jeff Layton8efdbde2008-07-23 21:28:12 +00002202 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2203 if (rc != 0)
Steve Frenche30dcf32005-09-20 20:49:16 -07002204 goto cifs_setattr_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205 }
Jeff Layton4ca691a2008-05-22 09:33:34 -04002206
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002207 if (attrs->ia_valid & ATTR_UID)
2208 uid = attrs->ia_uid;
2209
2210 if (attrs->ia_valid & ATTR_GID)
2211 gid = attrs->ia_gid;
2212
2213#ifdef CONFIG_CIFS_ACL
2214 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
Eric W. Biederman8abf2772013-02-06 00:33:17 -08002215 if (uid_valid(uid) || gid_valid(gid)) {
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002216 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2217 uid, gid);
2218 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002219 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2220 __func__, rc);
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002221 goto cifs_setattr_exit;
2222 }
2223 }
2224 } else
2225#endif /* CONFIG_CIFS_ACL */
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002226 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
Jeff Layton4ca691a2008-05-22 09:33:34 -04002227 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228
Jeff Laytond32c4f22007-10-18 03:05:22 -07002229 /* skip mode change if it's just for clearing setuid/setgid */
2230 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2231 attrs->ia_valid &= ~ATTR_MODE;
2232
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233 if (attrs->ia_valid & ATTR_MODE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002234 mode = attrs->ia_mode;
Steve Frenchcdbce9c2005-11-19 21:04:52 -08002235 rc = 0;
Jeff Layton79df1ba2010-12-06 12:52:08 -05002236#ifdef CONFIG_CIFS_ACL
Shirish Pargaonkar78415d22010-11-27 11:37:26 -06002237 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002238 rc = id_mode_to_cifs_acl(inode, full_path, mode,
Eric W. Biederman8abf2772013-02-06 00:33:17 -08002239 INVALID_UID, INVALID_GID);
Shirish Pargaonkar78415d22010-11-27 11:37:26 -06002240 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002241 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2242 __func__, rc);
Shirish Pargaonkar78415d22010-11-27 11:37:26 -06002243 goto cifs_setattr_exit;
2244 }
2245 } else
Jeff Layton79df1ba2010-12-06 12:52:08 -05002246#endif /* CONFIG_CIFS_ACL */
Jeff Layton51328612008-05-22 09:33:34 -04002247 if (((mode & S_IWUGO) == 0) &&
2248 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002249
2250 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2251
Jeff Layton51328612008-05-22 09:33:34 -04002252 /* fix up mode if we're not using dynperm */
2253 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2254 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2255 } else if ((mode & S_IWUGO) &&
2256 (cifsInode->cifsAttrs & ATTR_READONLY)) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002257
2258 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2259 /* Attributes of 0 are ignored */
2260 if (dosattr == 0)
2261 dosattr |= ATTR_NORMAL;
Jeff Layton51328612008-05-22 09:33:34 -04002262
2263 /* reset local inode permissions to normal */
2264 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2265 attrs->ia_mode &= ~(S_IALLUGO);
2266 if (S_ISDIR(inode->i_mode))
2267 attrs->ia_mode |=
2268 cifs_sb->mnt_dir_mode;
2269 else
2270 attrs->ia_mode |=
2271 cifs_sb->mnt_file_mode;
2272 }
2273 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2274 /* ignore mode change - ATTR_READONLY hasn't changed */
2275 attrs->ia_valid &= ~ATTR_MODE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002276 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002277 }
2278
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002279 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2280 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2281 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2282 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283
Steve Frenche30dcf32005-09-20 20:49:16 -07002284 /* Even if error on time set, no sense failing the call if
2285 the server would set the time to a reasonable value anyway,
2286 and this check ensures that we are not being called from
2287 sys_utimes in which case we ought to fail the call back to
2288 the user when the server rejects the call */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002289 if ((rc) && (attrs->ia_valid &
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002290 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
Steve Frenche30dcf32005-09-20 20:49:16 -07002291 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002292 }
2293
2294 /* do not need local check to inode_check_ok since the server does
2295 that */
Christoph Hellwig10257742010-06-04 11:30:02 +02002296 if (rc)
2297 goto cifs_setattr_exit;
2298
2299 if ((attrs->ia_valid & ATTR_SIZE) &&
Christoph Hellwig1b947462010-07-18 17:51:21 -04002300 attrs->ia_size != i_size_read(inode))
2301 truncate_setsize(inode, attrs->ia_size);
Christoph Hellwig10257742010-06-04 11:30:02 +02002302
2303 setattr_copy(inode, attrs);
2304 mark_inode_dirty(inode);
Christoph Hellwig10257742010-06-04 11:30:02 +02002305
Steve Frenche30dcf32005-09-20 20:49:16 -07002306cifs_setattr_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002308 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309 return rc;
2310}
2311
Jeff Layton0510eeb2008-08-02 07:26:12 -04002312int
2313cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2314{
2315 struct inode *inode = direntry->d_inode;
2316 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Steve French96daf2b2011-05-27 04:34:02 +00002317 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
Jeff Layton0510eeb2008-08-02 07:26:12 -04002318
2319 if (pTcon->unix_ext)
2320 return cifs_setattr_unix(direntry, attrs);
2321
2322 return cifs_setattr_nounix(direntry, attrs);
2323
2324 /* BB: add cifs_setattr_legacy for really old servers */
2325}
2326
Steve French99ee4db2007-02-27 05:35:17 +00002327#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07002328void cifs_delete_inode(struct inode *inode)
2329{
Joe Perchesf96637b2013-05-04 22:12:25 -05002330 cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331 /* may have to add back in if and when safe distributed caching of
2332 directories added e.g. via FindNotify */
2333}
Steve French99ee4db2007-02-27 05:35:17 +00002334#endif