blob: ed6208ff85a770771841a0fe54da82dff26bdfa3 [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
Steve Frenchf19159d2010-04-21 04:12:10 +000094 cFYI(1, "%s: revalidating inode %llu", __func__, cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -050095
96 if (inode->i_state & I_NEW) {
Steve Frenchf19159d2010-04-21 04:12:10 +000097 cFYI(1, "%s: inode %llu is new", __func__, cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -050098 return;
99 }
100
101 /* don't bother with revalidation if we have an oplock */
102 if (cifs_i->clientCanCacheRead) {
Steve Frenchf19159d2010-04-21 04:12:10 +0000103 cFYI(1, "%s: inode %llu is oplocked", __func__,
104 cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -0500105 return;
106 }
107
108 /* revalidate if mtime or size have changed */
109 if (timespec_equal(&inode->i_mtime, &fattr->cf_mtime) &&
110 cifs_i->server_eof == fattr->cf_eof) {
Steve Frenchf19159d2010-04-21 04:12:10 +0000111 cFYI(1, "%s: inode %llu is unchanged", __func__,
112 cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -0500113 return;
114 }
115
Steve Frenchf19159d2010-04-21 04:12:10 +0000116 cFYI(1, "%s: invalidating inode %llu mapping", __func__,
117 cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -0500118 cifs_i->invalid_mapping = true;
119}
120
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400121/* populate an inode with info from a cifs_fattr struct */
122void
123cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
Christoph Hellwig75f12982008-02-25 20:25:21 +0000124{
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400125 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400126 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Christoph Hellwig75f12982008-02-25 20:25:21 +0000127
Jeff Laytondf2cf172010-02-12 07:44:16 -0500128 cifs_revalidate_cache(inode, fattr);
129
Steve Frenchb7ca6922012-08-03 08:43:01 -0500130 spin_lock(&inode->i_lock);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400131 inode->i_atime = fattr->cf_atime;
132 inode->i_mtime = fattr->cf_mtime;
133 inode->i_ctime = fattr->cf_ctime;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400134 inode->i_rdev = fattr->cf_rdev;
Miklos Szeredibfe86842011-10-28 14:13:29 +0200135 set_nlink(inode, fattr->cf_nlink);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400136 inode->i_uid = fattr->cf_uid;
137 inode->i_gid = fattr->cf_gid;
138
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400139 /* if dynperm is set, don't clobber existing mode */
140 if (inode->i_state & I_NEW ||
141 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
142 inode->i_mode = fattr->cf_mode;
143
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400144 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400145
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400146 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
147 cifs_i->time = 0;
148 else
149 cifs_i->time = jiffies;
150
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400151 cifs_i->delete_pending = fattr->cf_flags & CIFS_FATTR_DELETE_PENDING;
Christoph Hellwig75f12982008-02-25 20:25:21 +0000152
Jeff Layton835a36c2010-02-10 16:21:33 -0500153 cifs_i->server_eof = fattr->cf_eof;
Christoph Hellwig75f12982008-02-25 20:25:21 +0000154 /*
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400155 * Can't safely change the file size here if the client is writing to
156 * it due to potential races.
Christoph Hellwig75f12982008-02-25 20:25:21 +0000157 */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400158 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
159 i_size_write(inode, fattr->cf_eof);
Christoph Hellwig75f12982008-02-25 20:25:21 +0000160
161 /*
162 * i_blocks is not related to (i_size / i_blksize),
163 * but instead 512 byte (2**9) size is required for
164 * calculating num blocks.
165 */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400166 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
Christoph Hellwig75f12982008-02-25 20:25:21 +0000167 }
168 spin_unlock(&inode->i_lock);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400169
David Howells01c64fe2011-01-14 18:45:47 +0000170 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
171 inode->i_flags |= S_AUTOMOUNT;
172 cifs_set_ops(inode);
Christoph Hellwig75f12982008-02-25 20:25:21 +0000173}
174
Jeff Layton4065c802010-05-17 07:18:58 -0400175void
176cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
177{
178 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
179
180 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
181 return;
182
183 fattr->cf_uniqueid = iunique(sb, ROOT_I);
184}
185
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400186/* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
187void
188cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
189 struct cifs_sb_info *cifs_sb)
190{
191 memset(fattr, 0, sizeof(*fattr));
192 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
193 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
194 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
195
196 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
197 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
198 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
199 fattr->cf_mode = le64_to_cpu(info->Permissions);
200
201 /*
202 * Since we set the inode type below we need to mask off
203 * to avoid strange results if bits set above.
204 */
205 fattr->cf_mode &= ~S_IFMT;
206 switch (le32_to_cpu(info->Type)) {
207 case UNIX_FILE:
208 fattr->cf_mode |= S_IFREG;
209 fattr->cf_dtype = DT_REG;
210 break;
211 case UNIX_SYMLINK:
212 fattr->cf_mode |= S_IFLNK;
213 fattr->cf_dtype = DT_LNK;
214 break;
215 case UNIX_DIR:
216 fattr->cf_mode |= S_IFDIR;
217 fattr->cf_dtype = DT_DIR;
218 break;
219 case UNIX_CHARDEV:
220 fattr->cf_mode |= S_IFCHR;
221 fattr->cf_dtype = DT_CHR;
222 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
223 le64_to_cpu(info->DevMinor) & MINORMASK);
224 break;
225 case UNIX_BLOCKDEV:
226 fattr->cf_mode |= S_IFBLK;
227 fattr->cf_dtype = DT_BLK;
228 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
229 le64_to_cpu(info->DevMinor) & MINORMASK);
230 break;
231 case UNIX_FIFO:
232 fattr->cf_mode |= S_IFIFO;
233 fattr->cf_dtype = DT_FIFO;
234 break;
235 case UNIX_SOCKET:
236 fattr->cf_mode |= S_IFSOCK;
237 fattr->cf_dtype = DT_SOCK;
238 break;
239 default:
240 /* safest to call it a file if we do not know */
241 fattr->cf_mode |= S_IFREG;
242 fattr->cf_dtype = DT_REG;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000243 cFYI(1, "unknown type %d", le32_to_cpu(info->Type));
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400244 break;
245 }
246
247 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
248 fattr->cf_uid = cifs_sb->mnt_uid;
249 else
250 fattr->cf_uid = le64_to_cpu(info->Uid);
251
252 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
253 fattr->cf_gid = cifs_sb->mnt_gid;
254 else
255 fattr->cf_gid = le64_to_cpu(info->Gid);
256
257 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
258}
Steve Frenchb9a32602008-05-20 21:52:32 +0000259
260/*
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400261 * Fill a cifs_fattr struct with fake inode info.
262 *
263 * Needed to setup cifs_fattr data for the directory which is the
264 * junction to the new submount (ie to setup the fake directory
265 * which represents a DFS referral).
Steve Frenchb9a32602008-05-20 21:52:32 +0000266 */
Steve Frenchf1230c92009-07-22 23:13:01 +0000267static void
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400268cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
Steve French0e4bbde2008-05-20 19:50:46 +0000269{
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400270 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Steve French0e4bbde2008-05-20 19:50:46 +0000271
Joe Perchesb6b38f72010-04-21 03:50:45 +0000272 cFYI(1, "creating fake fattr for DFS referral");
Steve French0e4bbde2008-05-20 19:50:46 +0000273
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400274 memset(fattr, 0, sizeof(*fattr));
275 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
276 fattr->cf_uid = cifs_sb->mnt_uid;
277 fattr->cf_gid = cifs_sb->mnt_gid;
278 fattr->cf_atime = CURRENT_TIME;
279 fattr->cf_ctime = CURRENT_TIME;
280 fattr->cf_mtime = CURRENT_TIME;
281 fattr->cf_nlink = 2;
282 fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
Steve French0e4bbde2008-05-20 19:50:46 +0000283}
284
Pavel Shilovsky4ad65042012-09-18 16:20:26 -0700285static int
286cifs_get_file_info_unix(struct file *filp)
Jeff Laytonabab0952010-02-12 07:44:18 -0500287{
288 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400289 unsigned int xid;
Jeff Laytonabab0952010-02-12 07:44:18 -0500290 FILE_UNIX_BASIC_INFO find_data;
291 struct cifs_fattr fattr;
292 struct inode *inode = filp->f_path.dentry->d_inode;
293 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Joe Perchesc21dfb62010-07-12 13:50:14 -0700294 struct cifsFileInfo *cfile = filp->private_data;
Steve French96daf2b2011-05-27 04:34:02 +0000295 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Jeff Laytonabab0952010-02-12 07:44:18 -0500296
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400297 xid = get_xid();
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700298 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
Jeff Laytonabab0952010-02-12 07:44:18 -0500299 if (!rc) {
300 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
301 } else if (rc == -EREMOTE) {
302 cifs_create_dfs_fattr(&fattr, inode->i_sb);
303 rc = 0;
304 }
305
306 cifs_fattr_to_inode(inode, &fattr);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400307 free_xid(xid);
Jeff Laytonabab0952010-02-12 07:44:18 -0500308 return rc;
309}
310
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311int cifs_get_inode_info_unix(struct inode **pinode,
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400312 const unsigned char *full_path,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400313 struct super_block *sb, unsigned int xid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314{
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400315 int rc;
Steve French0e4bbde2008-05-20 19:50:46 +0000316 FILE_UNIX_BASIC_INFO find_data;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400317 struct cifs_fattr fattr;
Steve French96daf2b2011-05-27 04:34:02 +0000318 struct cifs_tcon *tcon;
Jeff Layton7ffec372010-09-29 19:51:11 -0400319 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321
Joe Perchesb6b38f72010-04-21 03:50:45 +0000322 cFYI(1, "Getting info on %s", full_path);
Igor Mammedov79626702008-03-09 03:44:18 +0000323
Jeff Layton7ffec372010-09-29 19:51:11 -0400324 tlink = cifs_sb_tlink(cifs_sb);
325 if (IS_ERR(tlink))
326 return PTR_ERR(tlink);
327 tcon = tlink_tcon(tlink);
328
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 /* could have done a find first instead but this returns more info */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400330 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
Steve French737b7582005-04-28 22:41:06 -0700331 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
332 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton7ffec372010-09-29 19:51:11 -0400333 cifs_put_tlink(tlink);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400334
335 if (!rc) {
336 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
337 } else if (rc == -EREMOTE) {
338 cifs_create_dfs_fattr(&fattr, sb);
Jeff Laytone911d0c2008-07-12 13:47:59 -0700339 rc = 0;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400340 } else {
341 return rc;
Steve French0e4bbde2008-05-20 19:50:46 +0000342 }
343
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200344 /* check for Minshall+French symlinks */
345 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
346 int tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
347 if (tmprc)
348 cFYI(1, "CIFSCheckMFSymlink: %d", tmprc);
349 }
350
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400351 if (*pinode == NULL) {
352 /* get new inode */
Jeff Layton4065c802010-05-17 07:18:58 -0400353 cifs_fill_uniqueid(sb, &fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400354 *pinode = cifs_iget(sb, &fattr);
355 if (!*pinode)
356 rc = -ENOMEM;
357 } else {
358 /* we already have inode, update it */
359 cifs_fattr_to_inode(*pinode, &fattr);
360 }
Steve French0e4bbde2008-05-20 19:50:46 +0000361
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 return rc;
363}
364
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400365static int
366cifs_sfu_type(struct cifs_fattr *fattr, const unsigned char *path,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400367 struct cifs_sb_info *cifs_sb, unsigned int xid)
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800368{
369 int rc;
Steve French4b18f2a2008-04-29 00:06:05 +0000370 int oplock = 0;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800371 __u16 netfid;
Jeff Layton7ffec372010-09-29 19:51:11 -0400372 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +0000373 struct cifs_tcon *tcon;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000374 struct cifs_io_parms io_parms;
Steve French86c96b42005-11-18 20:25:31 -0800375 char buf[24];
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800376 unsigned int bytes_read;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000377 char *pbuf;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800378
379 pbuf = buf;
380
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400381 fattr->cf_mode &= ~S_IFMT;
382
383 if (fattr->cf_eof == 0) {
384 fattr->cf_mode |= S_IFIFO;
385 fattr->cf_dtype = DT_FIFO;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800386 return 0;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400387 } else if (fattr->cf_eof < 8) {
388 fattr->cf_mode |= S_IFREG;
389 fattr->cf_dtype = DT_REG;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800390 return -EINVAL; /* EOPNOTSUPP? */
391 }
Steve French50c2f752007-07-13 00:33:32 +0000392
Jeff Layton7ffec372010-09-29 19:51:11 -0400393 tlink = cifs_sb_tlink(cifs_sb);
394 if (IS_ERR(tlink))
395 return PTR_ERR(tlink);
396 tcon = tlink_tcon(tlink);
397
398 rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, GENERIC_READ,
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800399 CREATE_NOT_DIR, &netfid, &oplock, NULL,
400 cifs_sb->local_nls,
401 cifs_sb->mnt_cifs_flags &
402 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000403 if (rc == 0) {
Steve Frenchec637e32005-12-12 20:53:18 -0800404 int buf_type = CIFS_NO_BUFFER;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800405 /* Read header */
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000406 io_parms.netfid = netfid;
407 io_parms.pid = current->tgid;
408 io_parms.tcon = tcon;
409 io_parms.offset = 0;
410 io_parms.length = 24;
411 rc = CIFSSMBRead(xid, &io_parms, &bytes_read, &pbuf,
412 &buf_type);
Steve French4523cc32007-04-30 20:13:06 +0000413 if ((rc == 0) && (bytes_read >= 8)) {
414 if (memcmp("IntxBLK", pbuf, 8) == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000415 cFYI(1, "Block device");
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400416 fattr->cf_mode |= S_IFBLK;
417 fattr->cf_dtype = DT_BLK;
Steve French4523cc32007-04-30 20:13:06 +0000418 if (bytes_read == 24) {
Steve French86c96b42005-11-18 20:25:31 -0800419 /* we have enough to decode dev num */
420 __u64 mjr; /* major */
421 __u64 mnr; /* minor */
422 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
423 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400424 fattr->cf_rdev = MKDEV(mjr, mnr);
Steve French86c96b42005-11-18 20:25:31 -0800425 }
Steve French4523cc32007-04-30 20:13:06 +0000426 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000427 cFYI(1, "Char device");
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400428 fattr->cf_mode |= S_IFCHR;
429 fattr->cf_dtype = DT_CHR;
Steve French4523cc32007-04-30 20:13:06 +0000430 if (bytes_read == 24) {
Steve French86c96b42005-11-18 20:25:31 -0800431 /* we have enough to decode dev num */
432 __u64 mjr; /* major */
433 __u64 mnr; /* minor */
434 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
435 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400436 fattr->cf_rdev = MKDEV(mjr, mnr);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000437 }
Steve French4523cc32007-04-30 20:13:06 +0000438 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000439 cFYI(1, "Symlink");
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400440 fattr->cf_mode |= S_IFLNK;
441 fattr->cf_dtype = DT_LNK;
Steve French86c96b42005-11-18 20:25:31 -0800442 } else {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400443 fattr->cf_mode |= S_IFREG; /* file? */
444 fattr->cf_dtype = DT_REG;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000445 rc = -EOPNOTSUPP;
Steve French86c96b42005-11-18 20:25:31 -0800446 }
Steve French3020a1f2005-11-18 11:31:10 -0800447 } else {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400448 fattr->cf_mode |= S_IFREG; /* then it is a file */
449 fattr->cf_dtype = DT_REG;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000450 rc = -EOPNOTSUPP; /* or some unknown SFU type */
451 }
Jeff Layton7ffec372010-09-29 19:51:11 -0400452 CIFSSMBClose(xid, tcon, netfid);
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800453 }
Jeff Layton7ffec372010-09-29 19:51:11 -0400454 cifs_put_tlink(tlink);
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800455 return rc;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800456}
457
Steve French9e294f12005-11-17 16:59:21 -0800458#define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
459
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400460/*
461 * Fetch mode bits as provided by SFU.
462 *
463 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
464 */
465static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400466 struct cifs_sb_info *cifs_sb, unsigned int xid)
Steve French9e294f12005-11-17 16:59:21 -0800467{
Steve French3020a1f2005-11-18 11:31:10 -0800468#ifdef CONFIG_CIFS_XATTR
Steve French9e294f12005-11-17 16:59:21 -0800469 ssize_t rc;
470 char ea_value[4];
471 __u32 mode;
Jeff Layton7ffec372010-09-29 19:51:11 -0400472 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +0000473 struct cifs_tcon *tcon;
Steve French9e294f12005-11-17 16:59:21 -0800474
Jeff Layton7ffec372010-09-29 19:51:11 -0400475 tlink = cifs_sb_tlink(cifs_sb);
476 if (IS_ERR(tlink))
477 return PTR_ERR(tlink);
478 tcon = tlink_tcon(tlink);
479
480 rc = CIFSSMBQAllEAs(xid, tcon, path, "SETFILEBITS",
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400481 ea_value, 4 /* size of buf */, cifs_sb->local_nls,
482 cifs_sb->mnt_cifs_flags &
483 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton7ffec372010-09-29 19:51:11 -0400484 cifs_put_tlink(tlink);
Steve French4523cc32007-04-30 20:13:06 +0000485 if (rc < 0)
Steve French9e294f12005-11-17 16:59:21 -0800486 return (int)rc;
487 else if (rc > 3) {
488 mode = le32_to_cpu(*((__le32 *)ea_value));
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400489 fattr->cf_mode &= ~SFBITS_MASK;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000490 cFYI(1, "special bits 0%o org mode 0%o", mode,
491 fattr->cf_mode);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400492 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000493 cFYI(1, "special mode bits 0%o", mode);
Steve French9e294f12005-11-17 16:59:21 -0800494 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400495
496 return 0;
Steve French3020a1f2005-11-18 11:31:10 -0800497#else
498 return -EOPNOTSUPP;
499#endif
Steve French9e294f12005-11-17 16:59:21 -0800500}
501
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400502/* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
Steve Frenchf1230c92009-07-22 23:13:01 +0000503static void
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400504cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
505 struct cifs_sb_info *cifs_sb, bool adjust_tz)
Steve Frenchb9a32602008-05-20 21:52:32 +0000506{
Steve French96daf2b2011-05-27 04:34:02 +0000507 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Jeff Layton0d424ad2010-09-20 16:01:35 -0700508
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400509 memset(fattr, 0, sizeof(*fattr));
510 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
511 if (info->DeletePending)
512 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
Steve Frenchb9a32602008-05-20 21:52:32 +0000513
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400514 if (info->LastAccessTime)
515 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
516 else
517 fattr->cf_atime = CURRENT_TIME;
518
519 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
520 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
521
522 if (adjust_tz) {
Jeff Layton0d424ad2010-09-20 16:01:35 -0700523 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
524 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400525 }
526
527 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
528 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
Jeff Layton20054bd2011-01-07 11:30:27 -0500529 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400530
531 if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
532 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
533 fattr->cf_dtype = DT_DIR;
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +0300534 /*
535 * Server can return wrong NumberOfLinks value for directories
536 * when Unix extensions are disabled - fake it.
537 */
538 fattr->cf_nlink = 2;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400539 } else {
540 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
541 fattr->cf_dtype = DT_REG;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400542
Jeff Laytond0c280d2009-07-09 01:46:44 -0400543 /* clear write bits if ATTR_READONLY is set */
544 if (fattr->cf_cifsattrs & ATTR_READONLY)
545 fattr->cf_mode &= ~(S_IWUGO);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400546
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +0300547 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
548 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400549
550 fattr->cf_uid = cifs_sb->mnt_uid;
551 fattr->cf_gid = cifs_sb->mnt_gid;
Steve Frenchb9a32602008-05-20 21:52:32 +0000552}
553
Pavel Shilovsky4ad65042012-09-18 16:20:26 -0700554static int
555cifs_get_file_info(struct file *filp)
Jeff Laytonabab0952010-02-12 07:44:18 -0500556{
557 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400558 unsigned int xid;
Jeff Laytonabab0952010-02-12 07:44:18 -0500559 FILE_ALL_INFO find_data;
560 struct cifs_fattr fattr;
561 struct inode *inode = filp->f_path.dentry->d_inode;
562 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Joe Perchesc21dfb62010-07-12 13:50:14 -0700563 struct cifsFileInfo *cfile = filp->private_data;
Steve French96daf2b2011-05-27 04:34:02 +0000564 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky4ad65042012-09-18 16:20:26 -0700565 struct TCP_Server_Info *server = tcon->ses->server;
566
567 if (!server->ops->query_file_info)
568 return -ENOSYS;
Jeff Laytonabab0952010-02-12 07:44:18 -0500569
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400570 xid = get_xid();
Pavel Shilovsky4ad65042012-09-18 16:20:26 -0700571 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400572 switch (rc) {
573 case 0:
574 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false);
575 break;
576 case -EREMOTE:
577 cifs_create_dfs_fattr(&fattr, inode->i_sb);
578 rc = 0;
579 break;
580 case -EOPNOTSUPP:
581 case -EINVAL:
Jeff Laytonabab0952010-02-12 07:44:18 -0500582 /*
583 * FIXME: legacy server -- fall back to path-based call?
Steve Frenchff2157132010-03-09 20:30:42 +0000584 * for now, just skip revalidating and mark inode for
585 * immediate reval.
586 */
Jeff Laytonabab0952010-02-12 07:44:18 -0500587 rc = 0;
588 CIFS_I(inode)->time = 0;
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400589 default:
Jeff Laytonabab0952010-02-12 07:44:18 -0500590 goto cgfi_exit;
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400591 }
Jeff Laytonabab0952010-02-12 07:44:18 -0500592
593 /*
594 * don't bother with SFU junk here -- just mark inode as needing
595 * revalidation.
596 */
Jeff Laytonabab0952010-02-12 07:44:18 -0500597 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
598 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
599 cifs_fattr_to_inode(inode, &fattr);
600cgfi_exit:
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400601 free_xid(xid);
Jeff Laytonabab0952010-02-12 07:44:18 -0500602 return rc;
603}
604
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400605int
606cifs_get_inode_info(struct inode **inode, const char *full_path,
607 FILE_ALL_INFO *data, struct super_block *sb, int xid,
608 const __u16 *fid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609{
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500610 bool validinum = false;
611 __u16 srchflgs;
612 int rc = 0, tmprc = ENOSYS;
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400613 struct cifs_tcon *tcon;
614 struct TCP_Server_Info *server;
Jeff Layton7ffec372010-09-29 19:51:11 -0400615 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 char *buf = NULL;
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400618 bool adjust_tz = false;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400619 struct cifs_fattr fattr;
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500620 struct cifs_search_info *srchinf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621
Jeff Layton7ffec372010-09-29 19:51:11 -0400622 tlink = cifs_sb_tlink(cifs_sb);
623 if (IS_ERR(tlink))
624 return PTR_ERR(tlink);
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400625 tcon = tlink_tcon(tlink);
626 server = tcon->ses->server;
Jeff Layton7ffec372010-09-29 19:51:11 -0400627
Joe Perchesb6b38f72010-04-21 03:50:45 +0000628 cFYI(1, "Getting info on %s", full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400630 if ((data == NULL) && (*inode != NULL)) {
631 if (CIFS_I(*inode)->clientCanCacheRead) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000632 cFYI(1, "No need to revalidate cached inode sizes");
Jeff Layton7ffec372010-09-29 19:51:11 -0400633 goto cgii_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 }
635 }
636
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400637 /* if inode info is not passed, get it from server */
638 if (data == NULL) {
639 if (!server->ops->query_path_info) {
640 rc = -ENOSYS;
641 goto cgii_exit;
642 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
Jeff Layton7ffec372010-09-29 19:51:11 -0400644 if (buf == NULL) {
645 rc = -ENOMEM;
646 goto cgii_exit;
647 }
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400648 data = (FILE_ALL_INFO *)buf;
649 rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path,
650 data, &adjust_tz);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400652
653 if (!rc) {
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400654 cifs_all_info_to_fattr(&fattr, (FILE_ALL_INFO *)data, cifs_sb,
655 adjust_tz);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400656 } else if (rc == -EREMOTE) {
657 cifs_create_dfs_fattr(&fattr, sb);
Steve Frenchb9a32602008-05-20 21:52:32 +0000658 rc = 0;
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500659 } else if (rc == -EACCES && backup_cred(cifs_sb)) {
660 srchinf = kzalloc(sizeof(struct cifs_search_info),
661 GFP_KERNEL);
662 if (srchinf == NULL) {
663 rc = -ENOMEM;
664 goto cgii_exit;
665 }
666
667 srchinf->endOfSearch = false;
668 srchinf->info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
669
670 srchflgs = CIFS_SEARCH_CLOSE_ALWAYS |
671 CIFS_SEARCH_CLOSE_AT_END |
672 CIFS_SEARCH_BACKUP_SEARCH;
673
674 rc = CIFSFindFirst(xid, tcon, full_path,
675 cifs_sb, NULL, srchflgs, srchinf, false);
676 if (!rc) {
677 data =
678 (FILE_ALL_INFO *)srchinf->srch_entries_start;
679
680 cifs_dir_info_to_fattr(&fattr,
681 (FILE_DIRECTORY_INFO *)data, cifs_sb);
682 fattr.cf_uniqueid = le64_to_cpu(
683 ((SEARCH_ID_FULL_DIR_INFO *)data)->UniqueId);
684 validinum = true;
685
686 cifs_buf_release(srchinf->ntwrk_buf_start);
687 }
688 kfree(srchinf);
689 } else
Igor Mammedov79626702008-03-09 03:44:18 +0000690 goto cgii_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400692 /*
693 * If an inode wasn't passed in, then get the inode number
694 *
695 * Is an i_ino of zero legal? Can we use that to check if the server
696 * supports returning inode numbers? Are there other sanity checks we
697 * can use to ensure that the server is really filling in that field?
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400698 */
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400699 if (*inode == NULL) {
Steve Frenchb9a32602008-05-20 21:52:32 +0000700 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500701 if (validinum == false) {
702 if (server->ops->get_srv_inum)
703 tmprc = server->ops->get_srv_inum(xid,
704 tcon, cifs_sb, full_path,
705 &fattr.cf_uniqueid, data);
706 if (tmprc) {
707 cFYI(1, "GetSrvInodeNum rc %d", tmprc);
708 fattr.cf_uniqueid = iunique(sb, ROOT_I);
709 cifs_autodisable_serverino(cifs_sb);
710 }
Jeff Layton132ac7b2009-02-10 07:33:57 -0500711 }
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500712 } else
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400713 fattr.cf_uniqueid = iunique(sb, ROOT_I);
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -0500714 } else
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400715 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
Steve Frenchb9a32602008-05-20 21:52:32 +0000716
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400717 /* query for SFU type info if supported and needed */
718 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
719 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
720 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
721 if (tmprc)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000722 cFYI(1, "cifs_sfu_type failed: %d", tmprc);
Steve Frenchb9a32602008-05-20 21:52:32 +0000723 }
Steve Frenchb9a32602008-05-20 21:52:32 +0000724
Jeff Layton79df1ba2010-12-06 12:52:08 -0500725#ifdef CONFIG_CIFS_ACL
Steve Frenchb9a32602008-05-20 21:52:32 +0000726 /* fill in 0777 bits from ACL */
727 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400728 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, full_path, fid);
Shirish Pargaonkar78415d22010-11-27 11:37:26 -0600729 if (rc) {
730 cFYI(1, "%s: Getting ACL failed with error: %d",
731 __func__, rc);
732 goto cgii_exit;
733 }
Steve Frenchb9a32602008-05-20 21:52:32 +0000734 }
Jeff Layton79df1ba2010-12-06 12:52:08 -0500735#endif /* CONFIG_CIFS_ACL */
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400736
737 /* fill in remaining high mode bits e.g. SUID, VTX */
738 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
739 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
740
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200741 /* check for Minshall+French symlinks */
742 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
743 tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
744 if (tmprc)
745 cFYI(1, "CIFSCheckMFSymlink: %d", tmprc);
746 }
747
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400748 if (!*inode) {
749 *inode = cifs_iget(sb, &fattr);
750 if (!*inode)
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400751 rc = -ENOMEM;
752 } else {
Pavel Shilovsky1208ef12012-05-27 17:34:43 +0400753 cifs_fattr_to_inode(*inode, &fattr);
Steve Frenchb9a32602008-05-20 21:52:32 +0000754 }
755
Igor Mammedov79626702008-03-09 03:44:18 +0000756cgii_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 kfree(buf);
Jeff Layton7ffec372010-09-29 19:51:11 -0400758 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 return rc;
760}
761
Steve French7f8ed422007-09-28 22:28:55 +0000762static const struct inode_operations cifs_ipc_inode_ops = {
763 .lookup = cifs_lookup,
764};
765
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400766static int
767cifs_find_inode(struct inode *inode, void *opaque)
768{
769 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
770
Jeff Laytonf30b9c12010-07-19 18:00:17 -0400771 /* don't match inode with different uniqueid */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400772 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
773 return 0;
774
Jeff Layton20054bd2011-01-07 11:30:27 -0500775 /* use createtime like an i_generation field */
776 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
777 return 0;
778
Jeff Laytonf30b9c12010-07-19 18:00:17 -0400779 /* don't match inode of different type */
780 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
781 return 0;
782
Jeff Layton5acfec22010-08-02 17:43:54 -0400783 /* if it's not a directory or has no dentries, then flag it */
Al Virob3d9b7a2012-06-09 13:51:19 -0400784 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
Jeff Layton3d694382010-05-11 14:59:55 -0400785 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
Jeff Layton3d694382010-05-11 14:59:55 -0400786
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400787 return 1;
788}
789
790static int
791cifs_init_inode(struct inode *inode, void *opaque)
792{
793 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
794
795 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
Jeff Layton20054bd2011-01-07 11:30:27 -0500796 CIFS_I(inode)->createtime = fattr->cf_createtime;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400797 return 0;
798}
799
Jeff Layton5acfec22010-08-02 17:43:54 -0400800/*
801 * walk dentry list for an inode and report whether it has aliases that
802 * are hashed. We use this to determine if a directory inode can actually
803 * be used.
804 */
805static bool
806inode_has_hashed_dentries(struct inode *inode)
807{
808 struct dentry *dentry;
Al Virob3d9b7a2012-06-09 13:51:19 -0400809 struct hlist_node *p;
Jeff Layton5acfec22010-08-02 17:43:54 -0400810
Nick Piggin873feea2011-01-07 17:50:06 +1100811 spin_lock(&inode->i_lock);
Al Virob3d9b7a2012-06-09 13:51:19 -0400812 hlist_for_each_entry(dentry, p, &inode->i_dentry, d_alias) {
Jeff Layton5acfec22010-08-02 17:43:54 -0400813 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
Nick Piggin873feea2011-01-07 17:50:06 +1100814 spin_unlock(&inode->i_lock);
Jeff Layton5acfec22010-08-02 17:43:54 -0400815 return true;
816 }
817 }
Nick Piggin873feea2011-01-07 17:50:06 +1100818 spin_unlock(&inode->i_lock);
Jeff Layton5acfec22010-08-02 17:43:54 -0400819 return false;
820}
821
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400822/* Given fattrs, get a corresponding inode */
823struct inode *
824cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
825{
826 unsigned long hash;
827 struct inode *inode;
828
Jeff Layton3d694382010-05-11 14:59:55 -0400829retry_iget5_locked:
Joe Perchesb6b38f72010-04-21 03:50:45 +0000830 cFYI(1, "looking for uniqueid=%llu", fattr->cf_uniqueid);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400831
832 /* hash down to 32-bits on 32-bit arch */
833 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
834
835 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400836 if (inode) {
Jeff Layton5acfec22010-08-02 17:43:54 -0400837 /* was there a potentially problematic inode collision? */
Jeff Layton3d694382010-05-11 14:59:55 -0400838 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
Jeff Layton3d694382010-05-11 14:59:55 -0400839 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
Jeff Layton5acfec22010-08-02 17:43:54 -0400840
841 if (inode_has_hashed_dentries(inode)) {
842 cifs_autodisable_serverino(CIFS_SB(sb));
843 iput(inode);
844 fattr->cf_uniqueid = iunique(sb, ROOT_I);
845 goto retry_iget5_locked;
846 }
Jeff Layton3d694382010-05-11 14:59:55 -0400847 }
848
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400849 cifs_fattr_to_inode(inode, fattr);
850 if (sb->s_flags & MS_NOATIME)
851 inode->i_flags |= S_NOATIME | S_NOCMTIME;
852 if (inode->i_state & I_NEW) {
853 inode->i_ino = hash;
Jeff Layton522440e2010-09-29 09:49:54 -0400854 if (S_ISREG(inode->i_mode))
855 inode->i_data.backing_dev_info = sb->s_bdi;
Steve French0ccd4802010-07-16 04:31:02 +0000856#ifdef CONFIG_CIFS_FSCACHE
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530857 /* initialize per-inode cache cookie pointer */
858 CIFS_I(inode)->fscache = NULL;
Steve French0ccd4802010-07-16 04:31:02 +0000859#endif
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400860 unlock_new_inode(inode);
861 }
862 }
863
864 return inode;
865}
866
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867/* gets root inode */
Shirish Pargaonkar9b6763e2011-02-21 23:56:59 -0600868struct inode *cifs_root_iget(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400870 unsigned int xid;
Jeff Layton0d424ad2010-09-20 16:01:35 -0700871 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400872 struct inode *inode = NULL;
David Howellsce634ab2008-02-07 00:15:33 -0800873 long rc;
Steve French96daf2b2011-05-27 04:34:02 +0000874 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
David Howellsce634ab2008-02-07 00:15:33 -0800875
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400876 xid = get_xid();
Jeff Layton0d424ad2010-09-20 16:01:35 -0700877 if (tcon->unix_ext)
Steve Frenchf87d39d2011-05-27 03:50:55 +0000878 rc = cifs_get_inode_info_unix(&inode, "", sb, xid);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400879 else
Steve Frenchf87d39d2011-05-27 03:50:55 +0000880 rc = cifs_get_inode_info(&inode, "", NULL, sb, xid, NULL);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400881
Oskar Schirmera7851ce2010-11-10 21:06:13 +0000882 if (!inode) {
883 inode = ERR_PTR(rc);
884 goto out;
885 }
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400886
Steve French0ccd4802010-07-16 04:31:02 +0000887#ifdef CONFIG_CIFS_FSCACHE
Suresh Jayaramand03382c2010-07-05 18:12:27 +0530888 /* populate tcon->resource_id */
Jeff Layton0d424ad2010-09-20 16:01:35 -0700889 tcon->resource_id = CIFS_I(inode)->uniqueid;
Steve French0ccd4802010-07-16 04:31:02 +0000890#endif
Suresh Jayaramand03382c2010-07-05 18:12:27 +0530891
Jeff Layton0d424ad2010-09-20 16:01:35 -0700892 if (rc && tcon->ipc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000893 cFYI(1, "ipc connection - fake read inode");
Steve Frenchb7ca6922012-08-03 08:43:01 -0500894 spin_lock(&inode->i_lock);
Steve French7f8ed422007-09-28 22:28:55 +0000895 inode->i_mode |= S_IFDIR;
Miklos Szeredibfe86842011-10-28 14:13:29 +0200896 set_nlink(inode, 2);
Steve French7f8ed422007-09-28 22:28:55 +0000897 inode->i_op = &cifs_ipc_inode_ops;
898 inode->i_fop = &simple_dir_operations;
899 inode->i_uid = cifs_sb->mnt_uid;
900 inode->i_gid = cifs_sb->mnt_gid;
Steve Frenchb7ca6922012-08-03 08:43:01 -0500901 spin_unlock(&inode->i_lock);
Steve Frenchad661332008-08-12 14:14:40 +0000902 } else if (rc) {
David Howellsce634ab2008-02-07 00:15:33 -0800903 iget_failed(inode);
Oskar Schirmera7851ce2010-11-10 21:06:13 +0000904 inode = ERR_PTR(rc);
Steve French7f8ed422007-09-28 22:28:55 +0000905 }
906
Oskar Schirmera7851ce2010-11-10 21:06:13 +0000907out:
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400908 /* can not call macro free_xid here since in a void func
David Howellsce634ab2008-02-07 00:15:33 -0800909 * TODO: This is no longer true
910 */
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400911 _free_xid(xid);
David Howellsce634ab2008-02-07 00:15:33 -0800912 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913}
914
Pavel Shilovskyed6875e2012-09-18 16:20:25 -0700915int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400916cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
Pavel Shilovskyed6875e2012-09-18 16:20:25 -0700917 char *full_path, __u32 dosattr)
Steve French388e57b2008-09-16 23:50:58 +0000918{
Steve French388e57b2008-09-16 23:50:58 +0000919 bool set_time = false;
Steve French388e57b2008-09-16 23:50:58 +0000920 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Pavel Shilovsky6bdf6db2012-09-18 16:20:32 -0700921 struct TCP_Server_Info *server;
Steve French388e57b2008-09-16 23:50:58 +0000922 FILE_BASIC_INFO info_buf;
923
Steve French1adcb712009-02-25 14:19:56 +0000924 if (attrs == NULL)
925 return -EINVAL;
926
Pavel Shilovsky6bdf6db2012-09-18 16:20:32 -0700927 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
928 if (!server->ops->set_file_info)
929 return -ENOSYS;
930
Steve French388e57b2008-09-16 23:50:58 +0000931 if (attrs->ia_valid & ATTR_ATIME) {
932 set_time = true;
933 info_buf.LastAccessTime =
934 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
935 } else
936 info_buf.LastAccessTime = 0;
937
938 if (attrs->ia_valid & ATTR_MTIME) {
939 set_time = true;
940 info_buf.LastWriteTime =
941 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
942 } else
943 info_buf.LastWriteTime = 0;
944
945 /*
946 * Samba throws this field away, but windows may actually use it.
947 * Do not set ctime unless other time stamps are changed explicitly
948 * (i.e. by utimes()) since we would then have a mix of client and
949 * server times.
950 */
951 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000952 cFYI(1, "CIFS - CTIME changed");
Steve French388e57b2008-09-16 23:50:58 +0000953 info_buf.ChangeTime =
954 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
955 } else
956 info_buf.ChangeTime = 0;
957
958 info_buf.CreationTime = 0; /* don't change */
959 info_buf.Attributes = cpu_to_le32(dosattr);
960
Pavel Shilovsky6bdf6db2012-09-18 16:20:32 -0700961 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
Steve French388e57b2008-09-16 23:50:58 +0000962}
963
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400964/*
Pavel Shilovskyed6875e2012-09-18 16:20:25 -0700965 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400966 * and rename it to a random name that hopefully won't conflict with
967 * anything else.
968 */
Pavel Shilovskyed6875e2012-09-18 16:20:25 -0700969int
970cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
971 const unsigned int xid)
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400972{
973 int oplock = 0;
974 int rc;
975 __u16 netfid;
Steve French32709582008-10-20 00:44:19 +0000976 struct inode *inode = dentry->d_inode;
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400977 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
978 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400979 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +0000980 struct cifs_tcon *tcon;
Steve French32709582008-10-20 00:44:19 +0000981 __u32 dosattr, origattr;
982 FILE_BASIC_INFO *info_buf = NULL;
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400983
Jeff Layton7ffec372010-09-29 19:51:11 -0400984 tlink = cifs_sb_tlink(cifs_sb);
985 if (IS_ERR(tlink))
986 return PTR_ERR(tlink);
987 tcon = tlink_tcon(tlink);
988
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400989 rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
Jeff Laytondd1db2d2008-10-16 19:27:12 -0400990 DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400991 &netfid, &oplock, NULL, cifs_sb->local_nls,
992 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
993 if (rc != 0)
994 goto out;
995
Steve French32709582008-10-20 00:44:19 +0000996 origattr = cifsInode->cifsAttrs;
997 if (origattr == 0)
998 origattr |= ATTR_NORMAL;
999
1000 dosattr = origattr & ~ATTR_READONLY;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001001 if (dosattr == 0)
1002 dosattr |= ATTR_NORMAL;
1003 dosattr |= ATTR_HIDDEN;
1004
Steve French32709582008-10-20 00:44:19 +00001005 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1006 if (dosattr != origattr) {
1007 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1008 if (info_buf == NULL) {
1009 rc = -ENOMEM;
1010 goto out_close;
1011 }
1012 info_buf->Attributes = cpu_to_le32(dosattr);
1013 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1014 current->tgid);
1015 /* although we would like to mark the file hidden
1016 if that fails we will still try to rename it */
Steve French41346092008-10-20 18:24:42 +00001017 if (rc != 0)
Steve French32709582008-10-20 00:44:19 +00001018 cifsInode->cifsAttrs = dosattr;
1019 else
1020 dosattr = origattr; /* since not able to change them */
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001021 }
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001022
Jeff Laytondd1db2d2008-10-16 19:27:12 -04001023 /* rename the file */
1024 rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001025 cifs_sb->mnt_cifs_flags &
1026 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French32709582008-10-20 00:44:19 +00001027 if (rc != 0) {
1028 rc = -ETXTBSY;
1029 goto undo_setattr;
1030 }
Jeff Layton6d22f092008-09-23 11:48:35 -04001031
Steve French32709582008-10-20 00:44:19 +00001032 /* try to set DELETE_ON_CLOSE */
1033 if (!cifsInode->delete_pending) {
1034 rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
1035 current->tgid);
1036 /*
1037 * some samba versions return -ENOENT when we try to set the
1038 * file disposition here. Likely a samba bug, but work around
1039 * it for now. This means that some cifsXXX files may hang
1040 * around after they shouldn't.
1041 *
1042 * BB: remove this hack after more servers have the fix
1043 */
1044 if (rc == -ENOENT)
1045 rc = 0;
1046 else if (rc != 0) {
1047 rc = -ETXTBSY;
1048 goto undo_rename;
1049 }
1050 cifsInode->delete_pending = true;
1051 }
Jeff Layton7ce86d52008-09-24 11:32:59 -04001052
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001053out_close:
1054 CIFSSMBClose(xid, tcon, netfid);
1055out:
Steve French32709582008-10-20 00:44:19 +00001056 kfree(info_buf);
Jeff Layton7ffec372010-09-29 19:51:11 -04001057 cifs_put_tlink(tlink);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001058 return rc;
Steve French32709582008-10-20 00:44:19 +00001059
1060 /*
1061 * reset everything back to the original state. Don't bother
1062 * dealing with errors here since we can't do anything about
1063 * them anyway.
1064 */
1065undo_rename:
1066 CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
1067 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1068 CIFS_MOUNT_MAP_SPECIAL_CHR);
1069undo_setattr:
1070 if (dosattr != origattr) {
1071 info_buf->Attributes = cpu_to_le32(origattr);
1072 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1073 current->tgid))
1074 cifsInode->cifsAttrs = origattr;
1075 }
1076
1077 goto out_close;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001078}
1079
Steve Frenchb7ca6922012-08-03 08:43:01 -05001080/* copied from fs/nfs/dir.c with small changes */
1081static void
1082cifs_drop_nlink(struct inode *inode)
1083{
1084 spin_lock(&inode->i_lock);
1085 if (inode->i_nlink > 0)
1086 drop_nlink(inode);
1087 spin_unlock(&inode->i_lock);
1088}
Steve Frenchff694522009-04-20 19:45:13 +00001089
1090/*
1091 * If dentry->d_inode is null (usually meaning the cached dentry
1092 * is a negative dentry) then we would attempt a standard SMB delete, but
André Goddard Rosaaf901ca2009-11-14 13:09:05 -02001093 * if that fails we can not attempt the fall back mechanisms on EACCESS
1094 * but will return the EACCESS to the caller. Note that the VFS does not call
Steve Frenchff694522009-04-20 19:45:13 +00001095 * unlink on negative dentries currently.
1096 */
Jeff Layton5f0319a2008-09-16 14:05:16 -04001097int cifs_unlink(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098{
1099 int rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001100 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 char *full_path = NULL;
Jeff Layton5f0319a2008-09-16 14:05:16 -04001102 struct inode *inode = dentry->d_inode;
Steve Frenchff694522009-04-20 19:45:13 +00001103 struct cifsInodeInfo *cifs_inode;
Jeff Layton5f0319a2008-09-16 14:05:16 -04001104 struct super_block *sb = dir->i_sb;
1105 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001106 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001107 struct cifs_tcon *tcon;
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001108 struct TCP_Server_Info *server;
Steve French60502472008-10-07 18:42:52 +00001109 struct iattr *attrs = NULL;
1110 __u32 dosattr = 0, origattr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111
Joe Perchesb6b38f72010-04-21 03:50:45 +00001112 cFYI(1, "cifs_unlink, dir=0x%p, dentry=0x%p", dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113
Jeff Layton7ffec372010-09-29 19:51:11 -04001114 tlink = cifs_sb_tlink(cifs_sb);
1115 if (IS_ERR(tlink))
1116 return PTR_ERR(tlink);
1117 tcon = tlink_tcon(tlink);
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001118 server = tcon->ses->server;
Jeff Layton7ffec372010-09-29 19:51:11 -04001119
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001120 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121
Jeff Layton5f0319a2008-09-16 14:05:16 -04001122 /* Unlink can be called from rename so we can not take the
1123 * sb->s_vfs_rename_mutex here */
1124 full_path = build_path_from_dentry(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301126 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001127 goto unlink_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 }
Steve French2d785a52007-07-15 01:48:57 +00001129
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001130 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1131 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001132 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
Steve French2d785a52007-07-15 01:48:57 +00001133 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1134 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001135 cFYI(1, "posix del rc %d", rc);
Steve French2d785a52007-07-15 01:48:57 +00001136 if ((rc == 0) || (rc == -ENOENT))
1137 goto psx_del_no_retry;
1138 }
1139
Steve French60502472008-10-07 18:42:52 +00001140retry_std_delete:
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001141 if (!server->ops->unlink) {
1142 rc = -ENOSYS;
1143 goto psx_del_no_retry;
1144 }
1145
1146 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
Steve French60502472008-10-07 18:42:52 +00001147
Steve French2d785a52007-07-15 01:48:57 +00001148psx_del_no_retry:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149 if (!rc) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001150 if (inode)
Steve Frenchb7ca6922012-08-03 08:43:01 -05001151 cifs_drop_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 } else if (rc == -ENOENT) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001153 d_drop(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 } else if (rc == -ETXTBSY) {
Pavel Shilovskyed6875e2012-09-18 16:20:25 -07001155 if (server->ops->rename_pending_delete) {
1156 rc = server->ops->rename_pending_delete(full_path,
1157 dentry, xid);
1158 if (rc == 0)
1159 cifs_drop_nlink(inode);
1160 }
1161 if (rc == -ETXTBSY)
1162 rc = -EBUSY;
Steve Frenchff694522009-04-20 19:45:13 +00001163 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
Steve French388e57b2008-09-16 23:50:58 +00001164 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1165 if (attrs == NULL) {
1166 rc = -ENOMEM;
1167 goto out_reval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168 }
Steve French388e57b2008-09-16 23:50:58 +00001169
1170 /* try to reset dos attributes */
Steve Frenchff694522009-04-20 19:45:13 +00001171 cifs_inode = CIFS_I(inode);
1172 origattr = cifs_inode->cifsAttrs;
Steve French60502472008-10-07 18:42:52 +00001173 if (origattr == 0)
1174 origattr |= ATTR_NORMAL;
1175 dosattr = origattr & ~ATTR_READONLY;
Steve French388e57b2008-09-16 23:50:58 +00001176 if (dosattr == 0)
1177 dosattr |= ATTR_NORMAL;
1178 dosattr |= ATTR_HIDDEN;
1179
1180 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
Steve French388e57b2008-09-16 23:50:58 +00001181 if (rc != 0)
1182 goto out_reval;
Steve French60502472008-10-07 18:42:52 +00001183
1184 goto retry_std_delete;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185 }
Steve French60502472008-10-07 18:42:52 +00001186
1187 /* undo the setattr if we errored out and it's needed */
1188 if (rc != 0 && dosattr != 0)
1189 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1190
Steve French388e57b2008-09-16 23:50:58 +00001191out_reval:
Jeff Layton5f0319a2008-09-16 14:05:16 -04001192 if (inode) {
Steve Frenchff694522009-04-20 19:45:13 +00001193 cifs_inode = CIFS_I(inode);
1194 cifs_inode->time = 0; /* will force revalidate to get info
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001195 when needed */
Jeff Layton5f0319a2008-09-16 14:05:16 -04001196 inode->i_ctime = current_fs_time(sb);
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001197 }
Jeff Layton5f0319a2008-09-16 14:05:16 -04001198 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
Steve Frenchff694522009-04-20 19:45:13 +00001199 cifs_inode = CIFS_I(dir);
Steve French60502472008-10-07 18:42:52 +00001200 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
Jeff Layton7ffec372010-09-29 19:51:11 -04001201unlink_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 kfree(full_path);
Steve French60502472008-10-07 18:42:52 +00001203 kfree(attrs);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001204 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001205 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 return rc;
1207}
1208
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001209static int
Jeff Layton101b92d2012-09-19 06:22:45 -07001210cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001211 const char *full_path, struct cifs_sb_info *cifs_sb,
1212 struct cifs_tcon *tcon, const unsigned int xid)
1213{
1214 int rc = 0;
Jeff Layton101b92d2012-09-19 06:22:45 -07001215 struct inode *inode = NULL;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001216
1217 if (tcon->unix_ext)
Jeff Layton101b92d2012-09-19 06:22:45 -07001218 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001219 xid);
1220 else
Jeff Layton101b92d2012-09-19 06:22:45 -07001221 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1222 xid, NULL);
1223
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001224 if (rc)
1225 return rc;
1226
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001227 /*
1228 * setting nlink not necessary except in cases where we failed to get it
Jeff Layton101b92d2012-09-19 06:22:45 -07001229 * from the server or was set bogus. Also, since this is a brand new
1230 * inode, no need to grab the i_lock before setting the i_nlink.
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001231 */
Jeff Layton101b92d2012-09-19 06:22:45 -07001232 if (inode->i_nlink < 2)
1233 set_nlink(inode, 2);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001234 mode &= ~current_umask();
1235 /* must turn on setgid bit if parent dir has it */
Jeff Layton101b92d2012-09-19 06:22:45 -07001236 if (parent->i_mode & S_ISGID)
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001237 mode |= S_ISGID;
1238
1239 if (tcon->unix_ext) {
1240 struct cifs_unix_set_info_args args = {
1241 .mode = mode,
1242 .ctime = NO_CHANGE_64,
1243 .atime = NO_CHANGE_64,
1244 .mtime = NO_CHANGE_64,
1245 .device = 0,
1246 };
1247 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1248 args.uid = (__u64)current_fsuid();
Jeff Layton101b92d2012-09-19 06:22:45 -07001249 if (parent->i_mode & S_ISGID)
1250 args.gid = (__u64)parent->i_gid;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001251 else
1252 args.gid = (__u64)current_fsgid();
1253 } else {
1254 args.uid = NO_CHANGE_64;
1255 args.gid = NO_CHANGE_64;
1256 }
1257 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1258 cifs_sb->local_nls,
1259 cifs_sb->mnt_cifs_flags &
1260 CIFS_MOUNT_MAP_SPECIAL_CHR);
1261 } else {
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001262 struct TCP_Server_Info *server = tcon->ses->server;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001263 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001264 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
Jeff Layton101b92d2012-09-19 06:22:45 -07001265 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001266 tcon, xid);
Jeff Layton101b92d2012-09-19 06:22:45 -07001267 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1268 inode->i_mode = (mode | S_IFDIR);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001269
Jeff Layton101b92d2012-09-19 06:22:45 -07001270 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1271 inode->i_uid = current_fsuid();
1272 if (inode->i_mode & S_ISGID)
1273 inode->i_gid = parent->i_gid;
1274 else
1275 inode->i_gid = current_fsgid();
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001276 }
1277 }
Jeff Layton101b92d2012-09-19 06:22:45 -07001278 d_instantiate(dentry, inode);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001279 return rc;
1280}
1281
1282static int
1283cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1284 const char *full_path, struct cifs_sb_info *cifs_sb,
1285 struct cifs_tcon *tcon, const unsigned int xid)
1286{
1287 int rc = 0;
1288 u32 oplock = 0;
1289 FILE_UNIX_BASIC_INFO *info = NULL;
1290 struct inode *newinode = NULL;
1291 struct cifs_fattr fattr;
1292
1293 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1294 if (info == NULL) {
1295 rc = -ENOMEM;
1296 goto posix_mkdir_out;
1297 }
1298
1299 mode &= ~current_umask();
1300 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1301 NULL /* netfid */, info, &oplock, full_path,
1302 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1303 CIFS_MOUNT_MAP_SPECIAL_CHR);
1304 if (rc == -EOPNOTSUPP)
1305 goto posix_mkdir_out;
1306 else if (rc) {
1307 cFYI(1, "posix mkdir returned 0x%x", rc);
1308 d_drop(dentry);
1309 goto posix_mkdir_out;
1310 }
1311
1312 if (info->Type == cpu_to_le32(-1))
1313 /* no return info, go query for it */
1314 goto posix_mkdir_get_info;
1315 /*
1316 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1317 * need to set uid/gid.
1318 */
1319
1320 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1321 cifs_fill_uniqueid(inode->i_sb, &fattr);
1322 newinode = cifs_iget(inode->i_sb, &fattr);
1323 if (!newinode)
1324 goto posix_mkdir_get_info;
1325
1326 d_instantiate(dentry, newinode);
1327
1328#ifdef CONFIG_CIFS_DEBUG2
1329 cFYI(1, "instantiated dentry %p %s to inode %p", dentry,
1330 dentry->d_name.name, newinode);
1331
1332 if (newinode->i_nlink != 2)
1333 cFYI(1, "unexpected number of links %d", newinode->i_nlink);
1334#endif
1335
1336posix_mkdir_out:
1337 kfree(info);
1338 return rc;
1339posix_mkdir_get_info:
1340 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1341 xid);
1342 goto posix_mkdir_out;
1343}
1344
Al Viro18bb1db2011-07-26 01:41:39 -04001345int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346{
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001347 int rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001348 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001350 struct tcon_link *tlink;
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001351 struct cifs_tcon *tcon;
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001352 struct TCP_Server_Info *server;
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001353 char *full_path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354
Al Viro18bb1db2011-07-26 01:41:39 -04001355 cFYI(1, "In cifs_mkdir, mode = 0x%hx inode = 0x%p", mode, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001358 tlink = cifs_sb_tlink(cifs_sb);
1359 if (IS_ERR(tlink))
1360 return PTR_ERR(tlink);
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001361 tcon = tlink_tcon(tlink);
Jeff Layton7ffec372010-09-29 19:51:11 -04001362
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001363 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364
Steve French7f573562005-08-30 11:32:14 -07001365 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301367 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001368 goto mkdir_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 }
Steve French50c2f752007-07-13 00:33:32 +00001370
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001371 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1372 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001373 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1374 tcon, xid);
1375 if (rc != -EOPNOTSUPP)
Steve French2dd29d32007-04-23 22:07:35 +00001376 goto mkdir_out;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001377 }
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001378
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001379 server = tcon->ses->server;
1380
1381 if (!server->ops->mkdir) {
1382 rc = -ENOSYS;
1383 goto mkdir_out;
1384 }
1385
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 /* BB add setting the equivalent of mode via CreateX w/ACLs */
Pavel Shilovskyf4367202012-03-17 11:41:12 +03001387 rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001389 cFYI(1, "cifs_mkdir returned 0x%x", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 d_drop(direntry);
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001391 goto mkdir_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392 }
Pavel Shilovskyff691e92012-07-13 14:04:46 +04001393
1394 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1395 xid);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001396mkdir_out:
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +03001397 /*
1398 * Force revalidate to get parent dir info when needed since cached
1399 * attributes are invalid now.
1400 */
1401 CIFS_I(inode)->time = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001403 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001404 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 return rc;
1406}
1407
1408int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1409{
1410 int rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001411 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001413 struct tcon_link *tlink;
Pavel Shilovskyf958ca52012-07-10 16:14:18 +04001414 struct cifs_tcon *tcon;
1415 struct TCP_Server_Info *server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416 char *full_path = NULL;
1417 struct cifsInodeInfo *cifsInode;
1418
Joe Perchesb6b38f72010-04-21 03:50:45 +00001419 cFYI(1, "cifs_rmdir, inode = 0x%p", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001421 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422
Steve French7f573562005-08-30 11:32:14 -07001423 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301425 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001426 goto rmdir_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 }
1428
Jeff Layton7ffec372010-09-29 19:51:11 -04001429 cifs_sb = CIFS_SB(inode->i_sb);
1430 tlink = cifs_sb_tlink(cifs_sb);
1431 if (IS_ERR(tlink)) {
1432 rc = PTR_ERR(tlink);
1433 goto rmdir_exit;
1434 }
Pavel Shilovskyf958ca52012-07-10 16:14:18 +04001435 tcon = tlink_tcon(tlink);
1436 server = tcon->ses->server;
Jeff Layton7ffec372010-09-29 19:51:11 -04001437
Pavel Shilovskyf958ca52012-07-10 16:14:18 +04001438 if (!server->ops->rmdir) {
1439 rc = -ENOSYS;
1440 cifs_put_tlink(tlink);
1441 goto rmdir_exit;
1442 }
1443
1444 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001445 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446
1447 if (!rc) {
Steve French3677db12007-02-26 16:46:11 +00001448 spin_lock(&direntry->d_inode->i_lock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001449 i_size_write(direntry->d_inode, 0);
Dave Hansence71ec32006-09-30 23:29:06 -07001450 clear_nlink(direntry->d_inode);
Steve French3677db12007-02-26 16:46:11 +00001451 spin_unlock(&direntry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452 }
1453
1454 cifsInode = CIFS_I(direntry->d_inode);
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +03001455 /* force revalidate to go get info when needed */
1456 cifsInode->time = 0;
Steve French42c24542009-01-13 22:03:55 +00001457
1458 cifsInode = CIFS_I(inode);
Pavel Shilovsky6de2ce42012-02-17 16:13:30 +03001459 /*
1460 * Force revalidate to get parent dir info when needed since cached
1461 * attributes are invalid now.
1462 */
1463 cifsInode->time = 0;
Steve French42c24542009-01-13 22:03:55 +00001464
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1466 current_fs_time(inode->i_sb);
1467
Jeff Layton7ffec372010-09-29 19:51:11 -04001468rmdir_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001470 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471 return rc;
1472}
1473
Steve Frenchee2fd962008-09-23 18:23:33 +00001474static int
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001475cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1476 const char *from_path, struct dentry *to_dentry,
1477 const char *to_path)
Steve Frenchee2fd962008-09-23 18:23:33 +00001478{
1479 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001480 struct tcon_link *tlink;
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001481 struct cifs_tcon *tcon;
1482 struct TCP_Server_Info *server;
Steve Frenchee2fd962008-09-23 18:23:33 +00001483 __u16 srcfid;
1484 int oplock, rc;
1485
Jeff Layton7ffec372010-09-29 19:51:11 -04001486 tlink = cifs_sb_tlink(cifs_sb);
1487 if (IS_ERR(tlink))
1488 return PTR_ERR(tlink);
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001489 tcon = tlink_tcon(tlink);
1490 server = tcon->ses->server;
1491
1492 if (!server->ops->rename)
1493 return -ENOSYS;
Jeff Layton7ffec372010-09-29 19:51:11 -04001494
Steve Frenchee2fd962008-09-23 18:23:33 +00001495 /* try path-based rename first */
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001496 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
Steve Frenchee2fd962008-09-23 18:23:33 +00001497
1498 /*
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001499 * Don't bother with rename by filehandle unless file is busy and
1500 * source. Note that cross directory moves do not work with
Steve Frenchee2fd962008-09-23 18:23:33 +00001501 * rename by filehandle to various Windows servers.
1502 */
1503 if (rc == 0 || rc != -ETXTBSY)
Jeff Layton7ffec372010-09-29 19:51:11 -04001504 goto do_rename_exit;
Steve Frenchee2fd962008-09-23 18:23:33 +00001505
Jeff Laytoned0e3ac2010-06-01 16:21:01 -04001506 /* open-file renames don't work across directories */
1507 if (to_dentry->d_parent != from_dentry->d_parent)
Jeff Layton7ffec372010-09-29 19:51:11 -04001508 goto do_rename_exit;
Jeff Laytoned0e3ac2010-06-01 16:21:01 -04001509
Steve Frenchee2fd962008-09-23 18:23:33 +00001510 /* open the file to be renamed -- we need DELETE perms */
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001511 rc = CIFSSMBOpen(xid, tcon, from_path, FILE_OPEN, DELETE,
Steve Frenchee2fd962008-09-23 18:23:33 +00001512 CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1513 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1514 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve Frenchee2fd962008-09-23 18:23:33 +00001515 if (rc == 0) {
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001516 rc = CIFSSMBRenameOpenFile(xid, tcon, srcfid,
Steve Frenchee2fd962008-09-23 18:23:33 +00001517 (const char *) to_dentry->d_name.name,
1518 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1519 CIFS_MOUNT_MAP_SPECIAL_CHR);
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001520 CIFSSMBClose(xid, tcon, srcfid);
Steve Frenchee2fd962008-09-23 18:23:33 +00001521 }
Jeff Layton7ffec372010-09-29 19:51:11 -04001522do_rename_exit:
1523 cifs_put_tlink(tlink);
Steve Frenchee2fd962008-09-23 18:23:33 +00001524 return rc;
1525}
1526
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001527int
1528cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1529 struct inode *target_dir, struct dentry *target_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530{
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001531 char *from_name = NULL;
1532 char *to_name = NULL;
Jeff Layton639e7a92010-09-03 11:50:09 -04001533 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001534 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001535 struct cifs_tcon *tcon;
Steve Frenchee2fd962008-09-23 18:23:33 +00001536 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1537 FILE_UNIX_BASIC_INFO *info_buf_target;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001538 unsigned int xid;
1539 int rc, tmprc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540
Jeff Layton639e7a92010-09-03 11:50:09 -04001541 cifs_sb = CIFS_SB(source_dir->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001542 tlink = cifs_sb_tlink(cifs_sb);
1543 if (IS_ERR(tlink))
1544 return PTR_ERR(tlink);
1545 tcon = tlink_tcon(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001547 xid = get_xid();
Steve Frenchee2fd962008-09-23 18:23:33 +00001548
1549 /*
Steve Frenchee2fd962008-09-23 18:23:33 +00001550 * we already have the rename sem so we do not need to
1551 * grab it again here to protect the path integrity
1552 */
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001553 from_name = build_path_from_dentry(source_dentry);
1554 if (from_name == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555 rc = -ENOMEM;
1556 goto cifs_rename_exit;
1557 }
1558
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001559 to_name = build_path_from_dentry(target_dentry);
1560 if (to_name == NULL) {
Steve Frenchee2fd962008-09-23 18:23:33 +00001561 rc = -ENOMEM;
1562 goto cifs_rename_exit;
1563 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001565 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1566 to_name);
Steve Frenchee2fd962008-09-23 18:23:33 +00001567
Jeff Layton14121bd2008-10-20 14:45:22 -04001568 if (rc == -EEXIST && tcon->unix_ext) {
Steve Frenchee2fd962008-09-23 18:23:33 +00001569 /*
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001570 * Are src and dst hardlinks of same inode? We can only tell
1571 * with unix extensions enabled.
Steve Frenchee2fd962008-09-23 18:23:33 +00001572 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001573 info_buf_source =
1574 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1575 GFP_KERNEL);
1576 if (info_buf_source == NULL) {
1577 rc = -ENOMEM;
1578 goto cifs_rename_exit;
1579 }
1580
1581 info_buf_target = info_buf_source + 1;
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001582 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1583 info_buf_source,
1584 cifs_sb->local_nls,
1585 cifs_sb->mnt_cifs_flags &
1586 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton8d281ef2008-10-22 13:57:01 -04001587 if (tmprc != 0)
Jeff Layton14121bd2008-10-20 14:45:22 -04001588 goto unlink_target;
1589
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001590 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1591 info_buf_target,
1592 cifs_sb->local_nls,
1593 cifs_sb->mnt_cifs_flags &
1594 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton14121bd2008-10-20 14:45:22 -04001595
Jeff Layton8d281ef2008-10-22 13:57:01 -04001596 if (tmprc == 0 && (info_buf_source->UniqueId ==
Jeff Laytonae6884a2008-11-03 14:05:08 -05001597 info_buf_target->UniqueId)) {
Jeff Layton14121bd2008-10-20 14:45:22 -04001598 /* same file, POSIX says that this is a noop */
Jeff Laytonae6884a2008-11-03 14:05:08 -05001599 rc = 0;
Jeff Layton14121bd2008-10-20 14:45:22 -04001600 goto cifs_rename_exit;
Jeff Laytonae6884a2008-11-03 14:05:08 -05001601 }
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001602 }
1603 /*
1604 * else ... BB we could add the same check for Windows by
1605 * checking the UniqueId via FILE_INTERNAL_INFO
1606 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001607
Jeff Layton14121bd2008-10-20 14:45:22 -04001608unlink_target:
Jeff Laytonfc6f3942009-04-17 11:45:30 -04001609 /* Try unlinking the target dentry if it's not negative */
1610 if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
Jeff Layton8d281ef2008-10-22 13:57:01 -04001611 tmprc = cifs_unlink(target_dir, target_dentry);
Jeff Layton14121bd2008-10-20 14:45:22 -04001612 if (tmprc)
1613 goto cifs_rename_exit;
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001614 rc = cifs_do_rename(xid, source_dentry, from_name,
1615 target_dentry, to_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616 }
1617
1618cifs_rename_exit:
Steve Frenchee2fd962008-09-23 18:23:33 +00001619 kfree(info_buf_source);
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07001620 kfree(from_name);
1621 kfree(to_name);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001622 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001623 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624 return rc;
1625}
1626
Jeff Laytondf2cf172010-02-12 07:44:16 -05001627static bool
1628cifs_inode_needs_reval(struct inode *inode)
1629{
1630 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301631 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Laytondf2cf172010-02-12 07:44:16 -05001632
1633 if (cifs_i->clientCanCacheRead)
1634 return false;
1635
1636 if (!lookupCacheEnabled)
1637 return true;
1638
1639 if (cifs_i->time == 0)
1640 return true;
1641
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301642 if (!time_in_range(jiffies, cifs_i->time,
1643 cifs_i->time + cifs_sb->actimeo))
Jeff Laytondf2cf172010-02-12 07:44:16 -05001644 return true;
1645
Jeff Laytondb192722010-05-17 14:51:49 -04001646 /* hardlinked files w/ noserverino get "special" treatment */
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301647 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
Jeff Laytondb192722010-05-17 14:51:49 -04001648 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1649 return true;
1650
Jeff Laytondf2cf172010-02-12 07:44:16 -05001651 return false;
1652}
1653
Suresh Jayaraman523fb8c2010-11-29 22:39:47 +05301654/*
1655 * Zap the cache. Called when invalid_mapping flag is set.
1656 */
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001657int
Jeff Laytondf2cf172010-02-12 07:44:16 -05001658cifs_invalidate_mapping(struct inode *inode)
1659{
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001660 int rc = 0;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001661 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1662
1663 cifs_i->invalid_mapping = false;
1664
Jeff Laytondf2cf172010-02-12 07:44:16 -05001665 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
Pavel Shilovsky257fb1f2011-03-16 01:55:32 +03001666 rc = invalidate_inode_pages2(inode->i_mapping);
1667 if (rc) {
1668 cERROR(1, "%s: could not invalidate inode %p", __func__,
1669 inode);
1670 cifs_i->invalid_mapping = true;
1671 }
Jeff Laytondf2cf172010-02-12 07:44:16 -05001672 }
Pavel Shilovsky257fb1f2011-03-16 01:55:32 +03001673
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +05301674 cifs_fscache_reset_inode_cookie(inode);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001675 return rc;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001676}
1677
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001678int cifs_revalidate_file_attr(struct file *filp)
Jeff Laytonabab0952010-02-12 07:44:18 -05001679{
1680 int rc = 0;
1681 struct inode *inode = filp->f_path.dentry->d_inode;
Jeff Laytonba00ba62010-09-20 16:01:31 -07001682 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
Jeff Laytonabab0952010-02-12 07:44:18 -05001683
1684 if (!cifs_inode_needs_reval(inode))
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001685 return rc;
Jeff Laytonabab0952010-02-12 07:44:18 -05001686
Jeff Layton13cfb732010-09-29 19:51:11 -04001687 if (tlink_tcon(cfile->tlink)->unix_ext)
Jeff Laytonabab0952010-02-12 07:44:18 -05001688 rc = cifs_get_file_info_unix(filp);
1689 else
1690 rc = cifs_get_file_info(filp);
1691
Jeff Laytonabab0952010-02-12 07:44:18 -05001692 return rc;
1693}
1694
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001695int cifs_revalidate_dentry_attr(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001697 unsigned int xid;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001698 int rc = 0;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001699 struct inode *inode = dentry->d_inode;
1700 struct super_block *sb = dentry->d_sb;
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001701 char *full_path = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702
Jeff Laytondf2cf172010-02-12 07:44:16 -05001703 if (inode == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 return -ENOENT;
1705
Jeff Laytondf2cf172010-02-12 07:44:16 -05001706 if (!cifs_inode_needs_reval(inode))
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001707 return rc;
1708
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001709 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710
1711 /* can not safely grab the rename sem here if rename calls revalidate
1712 since that would deadlock */
Jeff Laytondf2cf172010-02-12 07:44:16 -05001713 full_path = build_path_from_dentry(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301715 rc = -ENOMEM;
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001716 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717 }
Jeff Laytondf2cf172010-02-12 07:44:16 -05001718
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001719 cFYI(1, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time "
1720 "%ld jiffies %ld", full_path, inode, inode->i_count.counter,
Steve Frenchf19159d2010-04-21 04:12:10 +00001721 dentry, dentry->d_time, jiffies);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722
Jeff Layton0d424ad2010-09-20 16:01:35 -07001723 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
Jeff Laytondf2cf172010-02-12 07:44:16 -05001724 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1725 else
1726 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1727 xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001729out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001731 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 return rc;
1733}
1734
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001735int cifs_revalidate_file(struct file *filp)
1736{
1737 int rc;
1738 struct inode *inode = filp->f_path.dentry->d_inode;
1739
1740 rc = cifs_revalidate_file_attr(filp);
1741 if (rc)
1742 return rc;
1743
1744 if (CIFS_I(inode)->invalid_mapping)
1745 rc = cifs_invalidate_mapping(inode);
1746 return rc;
1747}
1748
1749/* revalidate a dentry's inode attributes */
1750int cifs_revalidate_dentry(struct dentry *dentry)
1751{
1752 int rc;
1753 struct inode *inode = dentry->d_inode;
1754
1755 rc = cifs_revalidate_dentry_attr(dentry);
1756 if (rc)
1757 return rc;
1758
1759 if (CIFS_I(inode)->invalid_mapping)
1760 rc = cifs_invalidate_mapping(inode);
1761 return rc;
1762}
1763
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
Jeff Layton1c456012010-10-12 11:32:42 -04001765 struct kstat *stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766{
Jeff Layton3aa1c8c2010-10-07 14:46:28 -04001767 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
Steve French96daf2b2011-05-27 04:34:02 +00001768 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001769 struct inode *inode = dentry->d_inode;
1770 int rc;
Jeff Layton3aa1c8c2010-10-07 14:46:28 -04001771
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001772 /*
1773 * We need to be sure that all dirty pages are written and the server
1774 * has actual ctime, mtime and file length.
1775 */
1776 if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping &&
1777 inode->i_mapping->nrpages != 0) {
1778 rc = filemap_fdatawait(inode->i_mapping);
Steve French156ecb22011-05-20 17:00:01 +00001779 if (rc) {
1780 mapping_set_error(inode->i_mapping, rc);
1781 return rc;
1782 }
Steve French5fe14c82006-11-07 19:26:33 +00001783 }
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001784
1785 rc = cifs_revalidate_dentry_attr(dentry);
1786 if (rc)
1787 return rc;
1788
1789 generic_fillattr(inode, stat);
1790 stat->blksize = CIFS_MAX_MSGSIZE;
1791 stat->ino = CIFS_I(inode)->uniqueid;
1792
1793 /*
Jeff Laytond3d1fce2012-11-25 08:00:40 -05001794 * If on a multiuser mount without unix extensions or cifsacl being
1795 * enabled, and the admin hasn't overridden them, set the ownership
1796 * to the fsuid/fsgid of the current process.
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001797 */
1798 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
Jeff Laytond3d1fce2012-11-25 08:00:40 -05001799 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001800 !tcon->unix_ext) {
1801 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1802 stat->uid = current_fsuid();
1803 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1804 stat->gid = current_fsgid();
1805 }
1806 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807}
1808
1809static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1810{
1811 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1812 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1813 struct page *page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814 int rc = 0;
1815
1816 page = grab_cache_page(mapping, index);
1817 if (!page)
1818 return -ENOMEM;
1819
Christoph Lametereebd2aa2008-02-04 22:28:29 -08001820 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 unlock_page(page);
1822 page_cache_release(page);
1823 return rc;
1824}
1825
Christoph Hellwig1b947462010-07-18 17:51:21 -04001826static void cifs_setsize(struct inode *inode, loff_t offset)
Steve French3677db12007-02-26 16:46:11 +00001827{
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001828 loff_t oldsize;
Steve French3677db12007-02-26 16:46:11 +00001829
Steve Frenchba6a46a2007-02-26 20:06:29 +00001830 spin_lock(&inode->i_lock);
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001831 oldsize = inode->i_size;
Steve French3677db12007-02-26 16:46:11 +00001832 i_size_write(inode, offset);
Steve Frenchba6a46a2007-02-26 20:06:29 +00001833 spin_unlock(&inode->i_lock);
Christoph Hellwig1b947462010-07-18 17:51:21 -04001834
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001835 truncate_pagecache(inode, oldsize, offset);
Steve French3677db12007-02-26 16:46:11 +00001836}
1837
Jeff Layton8efdbde2008-07-23 21:28:12 +00001838static int
1839cifs_set_file_size(struct inode *inode, struct iattr *attrs,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001840 unsigned int xid, char *full_path)
Jeff Layton8efdbde2008-07-23 21:28:12 +00001841{
1842 int rc;
1843 struct cifsFileInfo *open_file;
1844 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1845 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001846 struct tcon_link *tlink = NULL;
Pavel Shilovskyd1433412012-09-18 16:20:31 -07001847 struct cifs_tcon *tcon = NULL;
1848 struct TCP_Server_Info *server;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001849 struct cifs_io_parms io_parms;
Jeff Layton8efdbde2008-07-23 21:28:12 +00001850
1851 /*
1852 * To avoid spurious oplock breaks from server, in the case of
1853 * inodes that we already have open, avoid doing path based
1854 * setting of file size if we can do it by handle.
1855 * This keeps our caching token (oplock) and avoids timeouts
1856 * when the local oplock break takes longer to flush
1857 * writebehind data than the SMB timeout for the SetPathInfo
1858 * request would allow
1859 */
Jeff Layton6508d902010-09-29 19:51:11 -04001860 open_file = find_writable_file(cifsInode, true);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001861 if (open_file) {
Pavel Shilovskyd1433412012-09-18 16:20:31 -07001862 tcon = tlink_tcon(open_file->tlink);
1863 server = tcon->ses->server;
1864 if (server->ops->set_file_size)
1865 rc = server->ops->set_file_size(xid, tcon, open_file,
1866 attrs->ia_size, false);
1867 else
1868 rc = -ENOSYS;
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001869 cifsFileInfo_put(open_file);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001870 cFYI(1, "SetFSize for attrs rc = %d", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001871 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1872 unsigned int bytes_written;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001873
Pavel Shilovskyd1433412012-09-18 16:20:31 -07001874 io_parms.netfid = open_file->fid.netfid;
1875 io_parms.pid = open_file->pid;
1876 io_parms.tcon = tcon;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001877 io_parms.offset = 0;
1878 io_parms.length = attrs->ia_size;
1879 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written,
1880 NULL, NULL, 1);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001881 cFYI(1, "Wrt seteof rc %d", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001882 }
1883 } else
1884 rc = -EINVAL;
1885
Pavel Shilovskyd1433412012-09-18 16:20:31 -07001886 if (!rc)
1887 goto set_size_out;
Jeff Laytonba00ba62010-09-20 16:01:31 -07001888
Pavel Shilovskyd1433412012-09-18 16:20:31 -07001889 if (tcon == NULL) {
1890 tlink = cifs_sb_tlink(cifs_sb);
1891 if (IS_ERR(tlink))
1892 return PTR_ERR(tlink);
1893 tcon = tlink_tcon(tlink);
1894 server = tcon->ses->server;
Jeff Layton8efdbde2008-07-23 21:28:12 +00001895 }
1896
Pavel Shilovskyd1433412012-09-18 16:20:31 -07001897 /*
1898 * Set file size by pathname rather than by handle either because no
1899 * valid, writeable file handle for it was found or because there was
1900 * an error setting it by handle.
1901 */
1902 if (server->ops->set_path_size)
1903 rc = server->ops->set_path_size(xid, tcon, full_path,
1904 attrs->ia_size, cifs_sb, false);
1905 else
1906 rc = -ENOSYS;
1907 cFYI(1, "SetEOF by path (setattrs) rc = %d", rc);
1908 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1909 __u16 netfid;
1910 int oplock = 0;
1911
1912 rc = SMBLegacyOpen(xid, tcon, full_path, FILE_OPEN,
1913 GENERIC_WRITE, CREATE_NOT_DIR, &netfid,
1914 &oplock, NULL, cifs_sb->local_nls,
1915 cifs_sb->mnt_cifs_flags &
1916 CIFS_MOUNT_MAP_SPECIAL_CHR);
1917 if (rc == 0) {
1918 unsigned int bytes_written;
1919
1920 io_parms.netfid = netfid;
1921 io_parms.pid = current->tgid;
1922 io_parms.tcon = tcon;
1923 io_parms.offset = 0;
1924 io_parms.length = attrs->ia_size;
1925 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written, NULL,
1926 NULL, 1);
1927 cFYI(1, "wrt seteof rc %d", rc);
1928 CIFSSMBClose(xid, tcon, netfid);
1929 }
1930 }
1931 if (tlink)
1932 cifs_put_tlink(tlink);
1933
1934set_size_out:
Jeff Layton8efdbde2008-07-23 21:28:12 +00001935 if (rc == 0) {
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001936 cifsInode->server_eof = attrs->ia_size;
Christoph Hellwig1b947462010-07-18 17:51:21 -04001937 cifs_setsize(inode, attrs->ia_size);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001938 cifs_truncate_page(inode->i_mapping, inode->i_size);
1939 }
1940
1941 return rc;
1942}
1943
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001944static int
1945cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1946{
1947 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001948 unsigned int xid;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001949 char *full_path = NULL;
1950 struct inode *inode = direntry->d_inode;
1951 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1952 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001953 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001954 struct cifs_tcon *pTcon;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001955 struct cifs_unix_set_info_args *args = NULL;
Jeff Layton3bbeeb32009-07-09 20:02:50 -04001956 struct cifsFileInfo *open_file;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001957
Joe Perchesb6b38f72010-04-21 03:50:45 +00001958 cFYI(1, "setattr_unix on file %s attrs->ia_valid=0x%x",
1959 direntry->d_name.name, attrs->ia_valid);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001960
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001961 xid = get_xid();
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001962
Christoph Hellwigdb78b872010-06-04 11:30:03 +02001963 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
1964 attrs->ia_valid |= ATTR_FORCE;
1965
1966 rc = inode_change_ok(inode, attrs);
1967 if (rc < 0)
1968 goto out;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001969
1970 full_path = build_path_from_dentry(direntry);
1971 if (full_path == NULL) {
1972 rc = -ENOMEM;
1973 goto out;
1974 }
1975
Jeff Layton0f4d6342009-03-26 13:35:37 -04001976 /*
1977 * Attempt to flush data before changing attributes. We need to do
1978 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1979 * ownership or mode then we may also need to do this. Here, we take
1980 * the safe way out and just do the flush on all setattr requests. If
1981 * the flush returns error, store it to report later and continue.
1982 *
1983 * BB: This should be smarter. Why bother flushing pages that
1984 * will be truncated anyway? Also, should we error out here if
1985 * the flush returns error?
1986 */
1987 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoneb4b7562010-10-22 14:52:29 -04001988 mapping_set_error(inode->i_mapping, rc);
1989 rc = 0;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001990
1991 if (attrs->ia_valid & ATTR_SIZE) {
1992 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1993 if (rc != 0)
1994 goto out;
1995 }
1996
1997 /* skip mode change if it's just for clearing setuid/setgid */
1998 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1999 attrs->ia_valid &= ~ATTR_MODE;
2000
2001 args = kmalloc(sizeof(*args), GFP_KERNEL);
2002 if (args == NULL) {
2003 rc = -ENOMEM;
2004 goto out;
2005 }
2006
2007 /* set up the struct */
2008 if (attrs->ia_valid & ATTR_MODE)
2009 args->mode = attrs->ia_mode;
2010 else
2011 args->mode = NO_CHANGE_64;
2012
2013 if (attrs->ia_valid & ATTR_UID)
2014 args->uid = attrs->ia_uid;
2015 else
2016 args->uid = NO_CHANGE_64;
2017
2018 if (attrs->ia_valid & ATTR_GID)
2019 args->gid = attrs->ia_gid;
2020 else
2021 args->gid = NO_CHANGE_64;
2022
2023 if (attrs->ia_valid & ATTR_ATIME)
2024 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2025 else
2026 args->atime = NO_CHANGE_64;
2027
2028 if (attrs->ia_valid & ATTR_MTIME)
2029 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2030 else
2031 args->mtime = NO_CHANGE_64;
2032
2033 if (attrs->ia_valid & ATTR_CTIME)
2034 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2035 else
2036 args->ctime = NO_CHANGE_64;
2037
2038 args->device = 0;
Jeff Layton6508d902010-09-29 19:51:11 -04002039 open_file = find_writable_file(cifsInode, true);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002040 if (open_file) {
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07002041 u16 nfid = open_file->fid.netfid;
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002042 u32 npid = open_file->pid;
Jeff Layton13cfb732010-09-29 19:51:11 -04002043 pTcon = tlink_tcon(open_file->tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002044 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04002045 cifsFileInfo_put(open_file);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002046 } else {
Jeff Layton7ffec372010-09-29 19:51:11 -04002047 tlink = cifs_sb_tlink(cifs_sb);
2048 if (IS_ERR(tlink)) {
2049 rc = PTR_ERR(tlink);
2050 goto out;
2051 }
2052 pTcon = tlink_tcon(tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002053 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
Jeff Layton01ea95e2009-07-09 20:02:49 -04002054 cifs_sb->local_nls,
2055 cifs_sb->mnt_cifs_flags &
2056 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton7ffec372010-09-29 19:51:11 -04002057 cifs_put_tlink(tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002058 }
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002059
Christoph Hellwig10257742010-06-04 11:30:02 +02002060 if (rc)
2061 goto out;
Steve Frenchccd4bb12010-02-08 17:39:58 +00002062
Christoph Hellwig10257742010-06-04 11:30:02 +02002063 if ((attrs->ia_valid & ATTR_SIZE) &&
Christoph Hellwig1b947462010-07-18 17:51:21 -04002064 attrs->ia_size != i_size_read(inode))
2065 truncate_setsize(inode, attrs->ia_size);
Christoph Hellwig10257742010-06-04 11:30:02 +02002066
2067 setattr_copy(inode, attrs);
2068 mark_inode_dirty(inode);
2069
2070 /* force revalidate when any of these times are set since some
2071 of the fs types (eg ext3, fat) do not have fine enough
2072 time granularity to match protocol, and we do not have a
2073 a way (yet) to query the server fs's time granularity (and
2074 whether it rounds times down).
2075 */
2076 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2077 cifsInode->time = 0;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002078out:
2079 kfree(args);
2080 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002081 free_xid(xid);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002082 return rc;
2083}
2084
Jeff Layton0510eeb2008-08-02 07:26:12 -04002085static int
2086cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002087{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002088 unsigned int xid;
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002089 uid_t uid = NO_CHANGE_32;
2090 gid_t gid = NO_CHANGE_32;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002091 struct inode *inode = direntry->d_inode;
2092 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002093 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094 char *full_path = NULL;
2095 int rc = -EACCES;
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002096 __u32 dosattr = 0;
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04002097 __u64 mode = NO_CHANGE_64;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002098
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002099 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002100
Joe Perchesb6b38f72010-04-21 03:50:45 +00002101 cFYI(1, "setattr on file %s attrs->iavalid 0x%x",
2102 direntry->d_name.name, attrs->ia_valid);
Steve French6473a552005-11-29 20:20:10 -08002103
Christoph Hellwigdb78b872010-06-04 11:30:03 +02002104 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2105 attrs->ia_valid |= ATTR_FORCE;
2106
2107 rc = inode_change_ok(inode, attrs);
2108 if (rc < 0) {
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002109 free_xid(xid);
Christoph Hellwigdb78b872010-06-04 11:30:03 +02002110 return rc;
Steve French6473a552005-11-29 20:20:10 -08002111 }
Steve French50c2f752007-07-13 00:33:32 +00002112
Steve French7f573562005-08-30 11:32:14 -07002113 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302115 rc = -ENOMEM;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002116 free_xid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302117 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119
Jeff Layton0f4d6342009-03-26 13:35:37 -04002120 /*
2121 * Attempt to flush data before changing attributes. We need to do
2122 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2123 * ownership or mode then we may also need to do this. Here, we take
2124 * the safe way out and just do the flush on all setattr requests. If
2125 * the flush returns error, store it to report later and continue.
2126 *
2127 * BB: This should be smarter. Why bother flushing pages that
2128 * will be truncated anyway? Also, should we error out here if
2129 * the flush returns error?
2130 */
2131 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002132 mapping_set_error(inode->i_mapping, rc);
2133 rc = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +00002134
Steve French50531442008-03-14 19:21:31 +00002135 if (attrs->ia_valid & ATTR_SIZE) {
Jeff Layton8efdbde2008-07-23 21:28:12 +00002136 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2137 if (rc != 0)
Steve Frenche30dcf32005-09-20 20:49:16 -07002138 goto cifs_setattr_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139 }
Jeff Layton4ca691a2008-05-22 09:33:34 -04002140
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002141 if (attrs->ia_valid & ATTR_UID)
2142 uid = attrs->ia_uid;
2143
2144 if (attrs->ia_valid & ATTR_GID)
2145 gid = attrs->ia_gid;
2146
2147#ifdef CONFIG_CIFS_ACL
2148 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2149 if (uid != NO_CHANGE_32 || gid != NO_CHANGE_32) {
2150 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2151 uid, gid);
2152 if (rc) {
2153 cFYI(1, "%s: Setting id failed with error: %d",
2154 __func__, rc);
2155 goto cifs_setattr_exit;
2156 }
2157 }
2158 } else
2159#endif /* CONFIG_CIFS_ACL */
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002160 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
Jeff Layton4ca691a2008-05-22 09:33:34 -04002161 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002162
Jeff Laytond32c4f22007-10-18 03:05:22 -07002163 /* skip mode change if it's just for clearing setuid/setgid */
2164 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2165 attrs->ia_valid &= ~ATTR_MODE;
2166
Linus Torvalds1da177e2005-04-16 15:20:36 -07002167 if (attrs->ia_valid & ATTR_MODE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168 mode = attrs->ia_mode;
Steve Frenchcdbce9c2005-11-19 21:04:52 -08002169 rc = 0;
Jeff Layton79df1ba2010-12-06 12:52:08 -05002170#ifdef CONFIG_CIFS_ACL
Shirish Pargaonkar78415d22010-11-27 11:37:26 -06002171 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002172 rc = id_mode_to_cifs_acl(inode, full_path, mode,
2173 NO_CHANGE_32, NO_CHANGE_32);
Shirish Pargaonkar78415d22010-11-27 11:37:26 -06002174 if (rc) {
2175 cFYI(1, "%s: Setting ACL failed with error: %d",
2176 __func__, rc);
2177 goto cifs_setattr_exit;
2178 }
2179 } else
Jeff Layton79df1ba2010-12-06 12:52:08 -05002180#endif /* CONFIG_CIFS_ACL */
Jeff Layton51328612008-05-22 09:33:34 -04002181 if (((mode & S_IWUGO) == 0) &&
2182 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002183
2184 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2185
Jeff Layton51328612008-05-22 09:33:34 -04002186 /* fix up mode if we're not using dynperm */
2187 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2188 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2189 } else if ((mode & S_IWUGO) &&
2190 (cifsInode->cifsAttrs & ATTR_READONLY)) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002191
2192 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2193 /* Attributes of 0 are ignored */
2194 if (dosattr == 0)
2195 dosattr |= ATTR_NORMAL;
Jeff Layton51328612008-05-22 09:33:34 -04002196
2197 /* reset local inode permissions to normal */
2198 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2199 attrs->ia_mode &= ~(S_IALLUGO);
2200 if (S_ISDIR(inode->i_mode))
2201 attrs->ia_mode |=
2202 cifs_sb->mnt_dir_mode;
2203 else
2204 attrs->ia_mode |=
2205 cifs_sb->mnt_file_mode;
2206 }
2207 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2208 /* ignore mode change - ATTR_READONLY hasn't changed */
2209 attrs->ia_valid &= ~ATTR_MODE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002211 }
2212
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002213 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2214 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2215 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2216 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002217
Steve Frenche30dcf32005-09-20 20:49:16 -07002218 /* Even if error on time set, no sense failing the call if
2219 the server would set the time to a reasonable value anyway,
2220 and this check ensures that we are not being called from
2221 sys_utimes in which case we ought to fail the call back to
2222 the user when the server rejects the call */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002223 if ((rc) && (attrs->ia_valid &
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002224 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
Steve Frenche30dcf32005-09-20 20:49:16 -07002225 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226 }
2227
2228 /* do not need local check to inode_check_ok since the server does
2229 that */
Christoph Hellwig10257742010-06-04 11:30:02 +02002230 if (rc)
2231 goto cifs_setattr_exit;
2232
2233 if ((attrs->ia_valid & ATTR_SIZE) &&
Christoph Hellwig1b947462010-07-18 17:51:21 -04002234 attrs->ia_size != i_size_read(inode))
2235 truncate_setsize(inode, attrs->ia_size);
Christoph Hellwig10257742010-06-04 11:30:02 +02002236
2237 setattr_copy(inode, attrs);
2238 mark_inode_dirty(inode);
Christoph Hellwig10257742010-06-04 11:30:02 +02002239
Steve Frenche30dcf32005-09-20 20:49:16 -07002240cifs_setattr_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002241 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002242 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243 return rc;
2244}
2245
Jeff Layton0510eeb2008-08-02 07:26:12 -04002246int
2247cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2248{
2249 struct inode *inode = direntry->d_inode;
2250 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Steve French96daf2b2011-05-27 04:34:02 +00002251 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
Jeff Layton0510eeb2008-08-02 07:26:12 -04002252
2253 if (pTcon->unix_ext)
2254 return cifs_setattr_unix(direntry, attrs);
2255
2256 return cifs_setattr_nounix(direntry, attrs);
2257
2258 /* BB: add cifs_setattr_legacy for really old servers */
2259}
2260
Steve French99ee4db2007-02-27 05:35:17 +00002261#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07002262void cifs_delete_inode(struct inode *inode)
2263{
Joe Perchesb6b38f72010-04-21 03:50:45 +00002264 cFYI(1, "In cifs_delete_inode, inode = 0x%p", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265 /* may have to add back in if and when safe distributed caching of
2266 directories added e.g. via FindNotify */
2267}
Steve French99ee4db2007-02-27 05:35:17 +00002268#endif