blob: 2c50bd2f65d1a2d614585a24e2aba989ba370ff8 [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);
127 unsigned long oldtime = cifs_i->time;
Christoph Hellwig75f12982008-02-25 20:25:21 +0000128
Jeff Laytondf2cf172010-02-12 07:44:16 -0500129 cifs_revalidate_cache(inode, fattr);
130
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;
135 inode->i_nlink = fattr->cf_nlink;
136 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
Joe Perchesb6b38f72010-04-21 03:50:45 +0000151 cFYI(1, "inode 0x%p old_time=%ld new_time=%ld", inode,
152 oldtime, cifs_i->time);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400153
154 cifs_i->delete_pending = fattr->cf_flags & CIFS_FATTR_DELETE_PENDING;
Christoph Hellwig75f12982008-02-25 20:25:21 +0000155
Jeff Layton835a36c2010-02-10 16:21:33 -0500156 cifs_i->server_eof = fattr->cf_eof;
Christoph Hellwig75f12982008-02-25 20:25:21 +0000157 /*
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400158 * Can't safely change the file size here if the client is writing to
159 * it due to potential races.
Christoph Hellwig75f12982008-02-25 20:25:21 +0000160 */
Christoph Hellwig75f12982008-02-25 20:25:21 +0000161 spin_lock(&inode->i_lock);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400162 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
163 i_size_write(inode, fattr->cf_eof);
Christoph Hellwig75f12982008-02-25 20:25:21 +0000164
165 /*
166 * i_blocks is not related to (i_size / i_blksize),
167 * but instead 512 byte (2**9) size is required for
168 * calculating num blocks.
169 */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400170 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
Christoph Hellwig75f12982008-02-25 20:25:21 +0000171 }
172 spin_unlock(&inode->i_lock);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400173
David Howells01c64fe2011-01-14 18:45:47 +0000174 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
175 inode->i_flags |= S_AUTOMOUNT;
176 cifs_set_ops(inode);
Christoph Hellwig75f12982008-02-25 20:25:21 +0000177}
178
Jeff Layton4065c802010-05-17 07:18:58 -0400179void
180cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
181{
182 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
183
184 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
185 return;
186
187 fattr->cf_uniqueid = iunique(sb, ROOT_I);
188}
189
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400190/* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
191void
192cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
193 struct cifs_sb_info *cifs_sb)
194{
195 memset(fattr, 0, sizeof(*fattr));
196 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
197 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
198 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
199
200 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
201 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
202 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
203 fattr->cf_mode = le64_to_cpu(info->Permissions);
204
205 /*
206 * Since we set the inode type below we need to mask off
207 * to avoid strange results if bits set above.
208 */
209 fattr->cf_mode &= ~S_IFMT;
210 switch (le32_to_cpu(info->Type)) {
211 case UNIX_FILE:
212 fattr->cf_mode |= S_IFREG;
213 fattr->cf_dtype = DT_REG;
214 break;
215 case UNIX_SYMLINK:
216 fattr->cf_mode |= S_IFLNK;
217 fattr->cf_dtype = DT_LNK;
218 break;
219 case UNIX_DIR:
220 fattr->cf_mode |= S_IFDIR;
221 fattr->cf_dtype = DT_DIR;
222 break;
223 case UNIX_CHARDEV:
224 fattr->cf_mode |= S_IFCHR;
225 fattr->cf_dtype = DT_CHR;
226 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
227 le64_to_cpu(info->DevMinor) & MINORMASK);
228 break;
229 case UNIX_BLOCKDEV:
230 fattr->cf_mode |= S_IFBLK;
231 fattr->cf_dtype = DT_BLK;
232 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
233 le64_to_cpu(info->DevMinor) & MINORMASK);
234 break;
235 case UNIX_FIFO:
236 fattr->cf_mode |= S_IFIFO;
237 fattr->cf_dtype = DT_FIFO;
238 break;
239 case UNIX_SOCKET:
240 fattr->cf_mode |= S_IFSOCK;
241 fattr->cf_dtype = DT_SOCK;
242 break;
243 default:
244 /* safest to call it a file if we do not know */
245 fattr->cf_mode |= S_IFREG;
246 fattr->cf_dtype = DT_REG;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000247 cFYI(1, "unknown type %d", le32_to_cpu(info->Type));
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400248 break;
249 }
250
251 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
252 fattr->cf_uid = cifs_sb->mnt_uid;
253 else
254 fattr->cf_uid = le64_to_cpu(info->Uid);
255
256 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
257 fattr->cf_gid = cifs_sb->mnt_gid;
258 else
259 fattr->cf_gid = le64_to_cpu(info->Gid);
260
261 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
262}
Steve Frenchb9a32602008-05-20 21:52:32 +0000263
264/*
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400265 * Fill a cifs_fattr struct with fake inode info.
266 *
267 * Needed to setup cifs_fattr data for the directory which is the
268 * junction to the new submount (ie to setup the fake directory
269 * which represents a DFS referral).
Steve Frenchb9a32602008-05-20 21:52:32 +0000270 */
Steve Frenchf1230c92009-07-22 23:13:01 +0000271static void
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400272cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
Steve French0e4bbde2008-05-20 19:50:46 +0000273{
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400274 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Steve French0e4bbde2008-05-20 19:50:46 +0000275
Joe Perchesb6b38f72010-04-21 03:50:45 +0000276 cFYI(1, "creating fake fattr for DFS referral");
Steve French0e4bbde2008-05-20 19:50:46 +0000277
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400278 memset(fattr, 0, sizeof(*fattr));
279 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
280 fattr->cf_uid = cifs_sb->mnt_uid;
281 fattr->cf_gid = cifs_sb->mnt_gid;
282 fattr->cf_atime = CURRENT_TIME;
283 fattr->cf_ctime = CURRENT_TIME;
284 fattr->cf_mtime = CURRENT_TIME;
285 fattr->cf_nlink = 2;
286 fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
Steve French0e4bbde2008-05-20 19:50:46 +0000287}
288
Jeff Laytonabab0952010-02-12 07:44:18 -0500289int cifs_get_file_info_unix(struct file *filp)
290{
291 int rc;
292 int xid;
293 FILE_UNIX_BASIC_INFO find_data;
294 struct cifs_fattr fattr;
295 struct inode *inode = filp->f_path.dentry->d_inode;
296 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Joe Perchesc21dfb62010-07-12 13:50:14 -0700297 struct cifsFileInfo *cfile = filp->private_data;
Steve French96daf2b2011-05-27 04:34:02 +0000298 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Jeff Laytonabab0952010-02-12 07:44:18 -0500299
300 xid = GetXid();
301 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->netfid, &find_data);
302 if (!rc) {
303 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
304 } else if (rc == -EREMOTE) {
305 cifs_create_dfs_fattr(&fattr, inode->i_sb);
306 rc = 0;
307 }
308
309 cifs_fattr_to_inode(inode, &fattr);
310 FreeXid(xid);
311 return rc;
312}
313
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314int cifs_get_inode_info_unix(struct inode **pinode,
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400315 const unsigned char *full_path,
316 struct super_block *sb, int xid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317{
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400318 int rc;
Steve French0e4bbde2008-05-20 19:50:46 +0000319 FILE_UNIX_BASIC_INFO find_data;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400320 struct cifs_fattr fattr;
Steve French96daf2b2011-05-27 04:34:02 +0000321 struct cifs_tcon *tcon;
Jeff Layton7ffec372010-09-29 19:51:11 -0400322 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324
Joe Perchesb6b38f72010-04-21 03:50:45 +0000325 cFYI(1, "Getting info on %s", full_path);
Igor Mammedov79626702008-03-09 03:44:18 +0000326
Jeff Layton7ffec372010-09-29 19:51:11 -0400327 tlink = cifs_sb_tlink(cifs_sb);
328 if (IS_ERR(tlink))
329 return PTR_ERR(tlink);
330 tcon = tlink_tcon(tlink);
331
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 /* could have done a find first instead but this returns more info */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400333 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
Steve French737b7582005-04-28 22:41:06 -0700334 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
335 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton7ffec372010-09-29 19:51:11 -0400336 cifs_put_tlink(tlink);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400337
338 if (!rc) {
339 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
340 } else if (rc == -EREMOTE) {
341 cifs_create_dfs_fattr(&fattr, sb);
Jeff Laytone911d0c2008-07-12 13:47:59 -0700342 rc = 0;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400343 } else {
344 return rc;
Steve French0e4bbde2008-05-20 19:50:46 +0000345 }
346
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200347 /* check for Minshall+French symlinks */
348 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
349 int tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
350 if (tmprc)
351 cFYI(1, "CIFSCheckMFSymlink: %d", tmprc);
352 }
353
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400354 if (*pinode == NULL) {
355 /* get new inode */
Jeff Layton4065c802010-05-17 07:18:58 -0400356 cifs_fill_uniqueid(sb, &fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400357 *pinode = cifs_iget(sb, &fattr);
358 if (!*pinode)
359 rc = -ENOMEM;
360 } else {
361 /* we already have inode, update it */
362 cifs_fattr_to_inode(*pinode, &fattr);
363 }
Steve French0e4bbde2008-05-20 19:50:46 +0000364
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 return rc;
366}
367
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400368static int
369cifs_sfu_type(struct cifs_fattr *fattr, const unsigned char *path,
370 struct cifs_sb_info *cifs_sb, int xid)
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800371{
372 int rc;
Steve French4b18f2a2008-04-29 00:06:05 +0000373 int oplock = 0;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800374 __u16 netfid;
Jeff Layton7ffec372010-09-29 19:51:11 -0400375 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +0000376 struct cifs_tcon *tcon;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000377 struct cifs_io_parms io_parms;
Steve French86c96b42005-11-18 20:25:31 -0800378 char buf[24];
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800379 unsigned int bytes_read;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000380 char *pbuf;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800381
382 pbuf = buf;
383
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400384 fattr->cf_mode &= ~S_IFMT;
385
386 if (fattr->cf_eof == 0) {
387 fattr->cf_mode |= S_IFIFO;
388 fattr->cf_dtype = DT_FIFO;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800389 return 0;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400390 } else if (fattr->cf_eof < 8) {
391 fattr->cf_mode |= S_IFREG;
392 fattr->cf_dtype = DT_REG;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800393 return -EINVAL; /* EOPNOTSUPP? */
394 }
Steve French50c2f752007-07-13 00:33:32 +0000395
Jeff Layton7ffec372010-09-29 19:51:11 -0400396 tlink = cifs_sb_tlink(cifs_sb);
397 if (IS_ERR(tlink))
398 return PTR_ERR(tlink);
399 tcon = tlink_tcon(tlink);
400
401 rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, GENERIC_READ,
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800402 CREATE_NOT_DIR, &netfid, &oplock, NULL,
403 cifs_sb->local_nls,
404 cifs_sb->mnt_cifs_flags &
405 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000406 if (rc == 0) {
Steve Frenchec637e32005-12-12 20:53:18 -0800407 int buf_type = CIFS_NO_BUFFER;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800408 /* Read header */
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000409 io_parms.netfid = netfid;
410 io_parms.pid = current->tgid;
411 io_parms.tcon = tcon;
412 io_parms.offset = 0;
413 io_parms.length = 24;
414 rc = CIFSSMBRead(xid, &io_parms, &bytes_read, &pbuf,
415 &buf_type);
Steve French4523cc32007-04-30 20:13:06 +0000416 if ((rc == 0) && (bytes_read >= 8)) {
417 if (memcmp("IntxBLK", pbuf, 8) == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000418 cFYI(1, "Block device");
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400419 fattr->cf_mode |= S_IFBLK;
420 fattr->cf_dtype = DT_BLK;
Steve French4523cc32007-04-30 20:13:06 +0000421 if (bytes_read == 24) {
Steve French86c96b42005-11-18 20:25:31 -0800422 /* we have enough to decode dev num */
423 __u64 mjr; /* major */
424 __u64 mnr; /* minor */
425 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
426 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400427 fattr->cf_rdev = MKDEV(mjr, mnr);
Steve French86c96b42005-11-18 20:25:31 -0800428 }
Steve French4523cc32007-04-30 20:13:06 +0000429 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000430 cFYI(1, "Char device");
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400431 fattr->cf_mode |= S_IFCHR;
432 fattr->cf_dtype = DT_CHR;
Steve French4523cc32007-04-30 20:13:06 +0000433 if (bytes_read == 24) {
Steve French86c96b42005-11-18 20:25:31 -0800434 /* we have enough to decode dev num */
435 __u64 mjr; /* major */
436 __u64 mnr; /* minor */
437 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
438 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400439 fattr->cf_rdev = MKDEV(mjr, mnr);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000440 }
Steve French4523cc32007-04-30 20:13:06 +0000441 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000442 cFYI(1, "Symlink");
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400443 fattr->cf_mode |= S_IFLNK;
444 fattr->cf_dtype = DT_LNK;
Steve French86c96b42005-11-18 20:25:31 -0800445 } else {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400446 fattr->cf_mode |= S_IFREG; /* file? */
447 fattr->cf_dtype = DT_REG;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000448 rc = -EOPNOTSUPP;
Steve French86c96b42005-11-18 20:25:31 -0800449 }
Steve French3020a1f2005-11-18 11:31:10 -0800450 } else {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400451 fattr->cf_mode |= S_IFREG; /* then it is a file */
452 fattr->cf_dtype = DT_REG;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000453 rc = -EOPNOTSUPP; /* or some unknown SFU type */
454 }
Jeff Layton7ffec372010-09-29 19:51:11 -0400455 CIFSSMBClose(xid, tcon, netfid);
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800456 }
Jeff Layton7ffec372010-09-29 19:51:11 -0400457 cifs_put_tlink(tlink);
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800458 return rc;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800459}
460
Steve French9e294f12005-11-17 16:59:21 -0800461#define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
462
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400463/*
464 * Fetch mode bits as provided by SFU.
465 *
466 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
467 */
468static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
469 struct cifs_sb_info *cifs_sb, int xid)
Steve French9e294f12005-11-17 16:59:21 -0800470{
Steve French3020a1f2005-11-18 11:31:10 -0800471#ifdef CONFIG_CIFS_XATTR
Steve French9e294f12005-11-17 16:59:21 -0800472 ssize_t rc;
473 char ea_value[4];
474 __u32 mode;
Jeff Layton7ffec372010-09-29 19:51:11 -0400475 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +0000476 struct cifs_tcon *tcon;
Steve French9e294f12005-11-17 16:59:21 -0800477
Jeff Layton7ffec372010-09-29 19:51:11 -0400478 tlink = cifs_sb_tlink(cifs_sb);
479 if (IS_ERR(tlink))
480 return PTR_ERR(tlink);
481 tcon = tlink_tcon(tlink);
482
483 rc = CIFSSMBQAllEAs(xid, tcon, path, "SETFILEBITS",
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400484 ea_value, 4 /* size of buf */, cifs_sb->local_nls,
485 cifs_sb->mnt_cifs_flags &
486 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton7ffec372010-09-29 19:51:11 -0400487 cifs_put_tlink(tlink);
Steve French4523cc32007-04-30 20:13:06 +0000488 if (rc < 0)
Steve French9e294f12005-11-17 16:59:21 -0800489 return (int)rc;
490 else if (rc > 3) {
491 mode = le32_to_cpu(*((__le32 *)ea_value));
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400492 fattr->cf_mode &= ~SFBITS_MASK;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000493 cFYI(1, "special bits 0%o org mode 0%o", mode,
494 fattr->cf_mode);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400495 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000496 cFYI(1, "special mode bits 0%o", mode);
Steve French9e294f12005-11-17 16:59:21 -0800497 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400498
499 return 0;
Steve French3020a1f2005-11-18 11:31:10 -0800500#else
501 return -EOPNOTSUPP;
502#endif
Steve French9e294f12005-11-17 16:59:21 -0800503}
504
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400505/* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
Steve Frenchf1230c92009-07-22 23:13:01 +0000506static void
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400507cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
508 struct cifs_sb_info *cifs_sb, bool adjust_tz)
Steve Frenchb9a32602008-05-20 21:52:32 +0000509{
Steve French96daf2b2011-05-27 04:34:02 +0000510 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Jeff Layton0d424ad2010-09-20 16:01:35 -0700511
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400512 memset(fattr, 0, sizeof(*fattr));
513 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
514 if (info->DeletePending)
515 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
Steve Frenchb9a32602008-05-20 21:52:32 +0000516
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400517 if (info->LastAccessTime)
518 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
519 else
520 fattr->cf_atime = CURRENT_TIME;
521
522 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
523 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
524
525 if (adjust_tz) {
Jeff Layton0d424ad2010-09-20 16:01:35 -0700526 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
527 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400528 }
529
530 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
531 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
Jeff Layton20054bd2011-01-07 11:30:27 -0500532 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400533
534 if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
535 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
536 fattr->cf_dtype = DT_DIR;
537 } else {
538 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
539 fattr->cf_dtype = DT_REG;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400540
Jeff Laytond0c280d2009-07-09 01:46:44 -0400541 /* clear write bits if ATTR_READONLY is set */
542 if (fattr->cf_cifsattrs & ATTR_READONLY)
543 fattr->cf_mode &= ~(S_IWUGO);
544 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400545
546 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
547
548 fattr->cf_uid = cifs_sb->mnt_uid;
549 fattr->cf_gid = cifs_sb->mnt_gid;
Steve Frenchb9a32602008-05-20 21:52:32 +0000550}
551
Jeff Laytonabab0952010-02-12 07:44:18 -0500552int cifs_get_file_info(struct file *filp)
553{
554 int rc;
555 int xid;
556 FILE_ALL_INFO find_data;
557 struct cifs_fattr fattr;
558 struct inode *inode = filp->f_path.dentry->d_inode;
559 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Joe Perchesc21dfb62010-07-12 13:50:14 -0700560 struct cifsFileInfo *cfile = filp->private_data;
Steve French96daf2b2011-05-27 04:34:02 +0000561 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Jeff Laytonabab0952010-02-12 07:44:18 -0500562
563 xid = GetXid();
564 rc = CIFSSMBQFileInfo(xid, tcon, cfile->netfid, &find_data);
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400565 switch (rc) {
566 case 0:
567 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false);
568 break;
569 case -EREMOTE:
570 cifs_create_dfs_fattr(&fattr, inode->i_sb);
571 rc = 0;
572 break;
573 case -EOPNOTSUPP:
574 case -EINVAL:
Jeff Laytonabab0952010-02-12 07:44:18 -0500575 /*
576 * FIXME: legacy server -- fall back to path-based call?
Steve Frenchff2157132010-03-09 20:30:42 +0000577 * for now, just skip revalidating and mark inode for
578 * immediate reval.
579 */
Jeff Laytonabab0952010-02-12 07:44:18 -0500580 rc = 0;
581 CIFS_I(inode)->time = 0;
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400582 default:
Jeff Laytonabab0952010-02-12 07:44:18 -0500583 goto cgfi_exit;
Pavel Shilovsky42274bb2011-10-22 14:37:50 +0400584 }
Jeff Laytonabab0952010-02-12 07:44:18 -0500585
586 /*
587 * don't bother with SFU junk here -- just mark inode as needing
588 * revalidation.
589 */
Jeff Laytonabab0952010-02-12 07:44:18 -0500590 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
591 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
592 cifs_fattr_to_inode(inode, &fattr);
593cgfi_exit:
594 FreeXid(xid);
595 return rc;
596}
597
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598int cifs_get_inode_info(struct inode **pinode,
Steve French646dd532008-05-15 01:50:56 +0000599 const unsigned char *full_path, FILE_ALL_INFO *pfindData,
Steve French8b1327f2008-03-14 22:37:16 +0000600 struct super_block *sb, int xid, const __u16 *pfid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601{
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400602 int rc = 0, tmprc;
Steve French96daf2b2011-05-27 04:34:02 +0000603 struct cifs_tcon *pTcon;
Jeff Layton7ffec372010-09-29 19:51:11 -0400604 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 char *buf = NULL;
Steve French5ade9de2008-05-02 20:56:23 +0000607 bool adjustTZ = false;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400608 struct cifs_fattr fattr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609
Jeff Layton7ffec372010-09-29 19:51:11 -0400610 tlink = cifs_sb_tlink(cifs_sb);
611 if (IS_ERR(tlink))
612 return PTR_ERR(tlink);
613 pTcon = tlink_tcon(tlink);
614
Joe Perchesb6b38f72010-04-21 03:50:45 +0000615 cFYI(1, "Getting info on %s", full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616
Steve Frenchd0d2f2d2005-06-02 15:12:36 -0700617 if ((pfindData == NULL) && (*pinode != NULL)) {
618 if (CIFS_I(*pinode)->clientCanCacheRead) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000619 cFYI(1, "No need to revalidate cached inode sizes");
Jeff Layton7ffec372010-09-29 19:51:11 -0400620 goto cgii_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 }
622 }
623
624 /* if file info not passed in then get it from server */
Steve Frenchd0d2f2d2005-06-02 15:12:36 -0700625 if (pfindData == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
Jeff Layton7ffec372010-09-29 19:51:11 -0400627 if (buf == NULL) {
628 rc = -ENOMEM;
629 goto cgii_exit;
630 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 pfindData = (FILE_ALL_INFO *)buf;
Igor Mammedov79626702008-03-09 03:44:18 +0000632
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 /* could do find first instead but this returns more info */
Igor Mammedov79626702008-03-09 03:44:18 +0000634 rc = CIFSSMBQPathInfo(xid, pTcon, full_path, pfindData,
Steve Frenchacf1a1b2006-10-12 03:28:28 +0000635 0 /* not legacy */,
Steve French6b8edfe2005-08-23 20:26:03 -0700636 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700637 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French6b8edfe2005-08-23 20:26:03 -0700638 /* BB optimize code so we do not make the above call
639 when server claims no NT SMB support and the above call
640 failed at least once - set flag in tcon or mount */
Steve French4523cc32007-04-30 20:13:06 +0000641 if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
Igor Mammedov79626702008-03-09 03:44:18 +0000642 rc = SMBQueryInformation(xid, pTcon, full_path,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000643 pfindData, cifs_sb->local_nls,
Steve French6b8edfe2005-08-23 20:26:03 -0700644 cifs_sb->mnt_cifs_flags &
645 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French4b18f2a2008-04-29 00:06:05 +0000646 adjustTZ = true;
Steve French6b8edfe2005-08-23 20:26:03 -0700647 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400649
650 if (!rc) {
651 cifs_all_info_to_fattr(&fattr, (FILE_ALL_INFO *) pfindData,
652 cifs_sb, adjustTZ);
653 } else if (rc == -EREMOTE) {
654 cifs_create_dfs_fattr(&fattr, sb);
Steve Frenchb9a32602008-05-20 21:52:32 +0000655 rc = 0;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400656 } else {
Igor Mammedov79626702008-03-09 03:44:18 +0000657 goto cgii_exit;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400658 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400660 /*
661 * If an inode wasn't passed in, then get the inode number
662 *
663 * Is an i_ino of zero legal? Can we use that to check if the server
664 * supports returning inode numbers? Are there other sanity checks we
665 * can use to ensure that the server is really filling in that field?
666 *
667 * We can not use the IndexNumber field by default from Windows or
668 * Samba (in ALL_INFO buf) but we can request it explicitly. The SNIA
669 * CIFS spec claims that this value is unique within the scope of a
670 * share, and the windows docs hint that it's actually unique
671 * per-machine.
672 *
673 * There may be higher info levels that work but are there Windows
674 * server or network appliances for which IndexNumber field is not
675 * guaranteed unique?
676 */
Steve Frenchb9a32602008-05-20 21:52:32 +0000677 if (*pinode == NULL) {
Steve Frenchb9a32602008-05-20 21:52:32 +0000678 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
679 int rc1 = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680
Steve Frenchb9a32602008-05-20 21:52:32 +0000681 rc1 = CIFSGetSrvInodeNumber(xid, pTcon,
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400682 full_path, &fattr.cf_uniqueid,
Steve French737b7582005-04-28 22:41:06 -0700683 cifs_sb->local_nls,
684 cifs_sb->mnt_cifs_flags &
685 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Laytonec06aed2009-11-06 14:18:29 -0500686 if (rc1 || !fattr.cf_uniqueid) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000687 cFYI(1, "GetSrvInodeNum rc %d", rc1);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400688 fattr.cf_uniqueid = iunique(sb, ROOT_I);
Jeff Laytonec06aed2009-11-06 14:18:29 -0500689 cifs_autodisable_serverino(cifs_sb);
Jeff Layton132ac7b2009-02-10 07:33:57 -0500690 }
Jeff Layton132ac7b2009-02-10 07:33:57 -0500691 } else {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400692 fattr.cf_uniqueid = iunique(sb, ROOT_I);
Jeff Layton132ac7b2009-02-10 07:33:57 -0500693 }
Steve Frenchb9a32602008-05-20 21:52:32 +0000694 } else {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400695 fattr.cf_uniqueid = CIFS_I(*pinode)->uniqueid;
Steve Frenchb9a32602008-05-20 21:52:32 +0000696 }
697
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400698 /* query for SFU type info if supported and needed */
699 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
700 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
701 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
702 if (tmprc)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000703 cFYI(1, "cifs_sfu_type failed: %d", tmprc);
Steve Frenchb9a32602008-05-20 21:52:32 +0000704 }
Steve Frenchb9a32602008-05-20 21:52:32 +0000705
Jeff Layton79df1ba2010-12-06 12:52:08 -0500706#ifdef CONFIG_CIFS_ACL
Steve Frenchb9a32602008-05-20 21:52:32 +0000707 /* fill in 0777 bits from ACL */
708 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
Shirish Pargaonkar78415d22010-11-27 11:37:26 -0600709 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *pinode, full_path,
710 pfid);
711 if (rc) {
712 cFYI(1, "%s: Getting ACL failed with error: %d",
713 __func__, rc);
714 goto cgii_exit;
715 }
Steve Frenchb9a32602008-05-20 21:52:32 +0000716 }
Jeff Layton79df1ba2010-12-06 12:52:08 -0500717#endif /* CONFIG_CIFS_ACL */
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400718
719 /* fill in remaining high mode bits e.g. SUID, VTX */
720 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
721 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
722
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200723 /* check for Minshall+French symlinks */
724 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
725 tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
726 if (tmprc)
727 cFYI(1, "CIFSCheckMFSymlink: %d", tmprc);
728 }
729
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400730 if (!*pinode) {
731 *pinode = cifs_iget(sb, &fattr);
732 if (!*pinode)
733 rc = -ENOMEM;
734 } else {
735 cifs_fattr_to_inode(*pinode, &fattr);
Steve Frenchb9a32602008-05-20 21:52:32 +0000736 }
737
Igor Mammedov79626702008-03-09 03:44:18 +0000738cgii_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 kfree(buf);
Jeff Layton7ffec372010-09-29 19:51:11 -0400740 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 return rc;
742}
743
Steve French7f8ed422007-09-28 22:28:55 +0000744static const struct inode_operations cifs_ipc_inode_ops = {
745 .lookup = cifs_lookup,
746};
747
Steve Frenchf87d39d2011-05-27 03:50:55 +0000748char *cifs_build_path_to_root(struct smb_vol *vol, struct cifs_sb_info *cifs_sb,
Steve French96daf2b2011-05-27 04:34:02 +0000749 struct cifs_tcon *tcon)
Steve French8be0ed42008-12-05 19:14:12 +0000750{
Steve Frenchf87d39d2011-05-27 03:50:55 +0000751 int pplen = vol->prepath ? strlen(vol->prepath) : 0;
Steve French8be0ed42008-12-05 19:14:12 +0000752 int dfsplen;
753 char *full_path = NULL;
754
755 /* if no prefix path, simply set path to the root of share to "" */
756 if (pplen == 0) {
757 full_path = kmalloc(1, GFP_KERNEL);
758 if (full_path)
759 full_path[0] = 0;
760 return full_path;
761 }
762
Jeff Layton0d424ad2010-09-20 16:01:35 -0700763 if (tcon->Flags & SMB_SHARE_IS_IN_DFS)
764 dfsplen = strnlen(tcon->treeName, MAX_TREE_SIZE + 1);
Steve French8be0ed42008-12-05 19:14:12 +0000765 else
766 dfsplen = 0;
767
768 full_path = kmalloc(dfsplen + pplen + 1, GFP_KERNEL);
769 if (full_path == NULL)
770 return full_path;
771
Jeff Laytonf9e8c452011-08-05 10:28:01 -0400772 if (dfsplen)
Jeff Layton0d424ad2010-09-20 16:01:35 -0700773 strncpy(full_path, tcon->treeName, dfsplen);
Steve Frenchf87d39d2011-05-27 03:50:55 +0000774 strncpy(full_path + dfsplen, vol->prepath, pplen);
Jeff Laytonf9e8c452011-08-05 10:28:01 -0400775 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
Steve French8be0ed42008-12-05 19:14:12 +0000776 full_path[dfsplen + pplen] = 0; /* add trailing null */
777 return full_path;
778}
779
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400780static int
781cifs_find_inode(struct inode *inode, void *opaque)
782{
783 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
784
Jeff Laytonf30b9c12010-07-19 18:00:17 -0400785 /* don't match inode with different uniqueid */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400786 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
787 return 0;
788
Jeff Layton20054bd2011-01-07 11:30:27 -0500789 /* use createtime like an i_generation field */
790 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
791 return 0;
792
Jeff Laytonf30b9c12010-07-19 18:00:17 -0400793 /* don't match inode of different type */
794 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
795 return 0;
796
Jeff Layton5acfec22010-08-02 17:43:54 -0400797 /* if it's not a directory or has no dentries, then flag it */
798 if (S_ISDIR(inode->i_mode) && !list_empty(&inode->i_dentry))
Jeff Layton3d694382010-05-11 14:59:55 -0400799 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
Jeff Layton3d694382010-05-11 14:59:55 -0400800
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400801 return 1;
802}
803
804static int
805cifs_init_inode(struct inode *inode, void *opaque)
806{
807 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
808
809 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
Jeff Layton20054bd2011-01-07 11:30:27 -0500810 CIFS_I(inode)->createtime = fattr->cf_createtime;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400811 return 0;
812}
813
Jeff Layton5acfec22010-08-02 17:43:54 -0400814/*
815 * walk dentry list for an inode and report whether it has aliases that
816 * are hashed. We use this to determine if a directory inode can actually
817 * be used.
818 */
819static bool
820inode_has_hashed_dentries(struct inode *inode)
821{
822 struct dentry *dentry;
823
Nick Piggin873feea2011-01-07 17:50:06 +1100824 spin_lock(&inode->i_lock);
Jeff Layton5acfec22010-08-02 17:43:54 -0400825 list_for_each_entry(dentry, &inode->i_dentry, d_alias) {
826 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
Nick Piggin873feea2011-01-07 17:50:06 +1100827 spin_unlock(&inode->i_lock);
Jeff Layton5acfec22010-08-02 17:43:54 -0400828 return true;
829 }
830 }
Nick Piggin873feea2011-01-07 17:50:06 +1100831 spin_unlock(&inode->i_lock);
Jeff Layton5acfec22010-08-02 17:43:54 -0400832 return false;
833}
834
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400835/* Given fattrs, get a corresponding inode */
836struct inode *
837cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
838{
839 unsigned long hash;
840 struct inode *inode;
841
Jeff Layton3d694382010-05-11 14:59:55 -0400842retry_iget5_locked:
Joe Perchesb6b38f72010-04-21 03:50:45 +0000843 cFYI(1, "looking for uniqueid=%llu", fattr->cf_uniqueid);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400844
845 /* hash down to 32-bits on 32-bit arch */
846 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
847
848 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400849 if (inode) {
Jeff Layton5acfec22010-08-02 17:43:54 -0400850 /* was there a potentially problematic inode collision? */
Jeff Layton3d694382010-05-11 14:59:55 -0400851 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
Jeff Layton3d694382010-05-11 14:59:55 -0400852 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
Jeff Layton5acfec22010-08-02 17:43:54 -0400853
854 if (inode_has_hashed_dentries(inode)) {
855 cifs_autodisable_serverino(CIFS_SB(sb));
856 iput(inode);
857 fattr->cf_uniqueid = iunique(sb, ROOT_I);
858 goto retry_iget5_locked;
859 }
Jeff Layton3d694382010-05-11 14:59:55 -0400860 }
861
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400862 cifs_fattr_to_inode(inode, fattr);
863 if (sb->s_flags & MS_NOATIME)
864 inode->i_flags |= S_NOATIME | S_NOCMTIME;
865 if (inode->i_state & I_NEW) {
866 inode->i_ino = hash;
Jeff Layton522440e2010-09-29 09:49:54 -0400867 if (S_ISREG(inode->i_mode))
868 inode->i_data.backing_dev_info = sb->s_bdi;
Steve French0ccd4802010-07-16 04:31:02 +0000869#ifdef CONFIG_CIFS_FSCACHE
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530870 /* initialize per-inode cache cookie pointer */
871 CIFS_I(inode)->fscache = NULL;
Steve French0ccd4802010-07-16 04:31:02 +0000872#endif
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400873 unlock_new_inode(inode);
874 }
875 }
876
877 return inode;
878}
879
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880/* gets root inode */
Shirish Pargaonkar9b6763e2011-02-21 23:56:59 -0600881struct inode *cifs_root_iget(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882{
David Howellsce634ab2008-02-07 00:15:33 -0800883 int xid;
Jeff Layton0d424ad2010-09-20 16:01:35 -0700884 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400885 struct inode *inode = NULL;
David Howellsce634ab2008-02-07 00:15:33 -0800886 long rc;
Steve French96daf2b2011-05-27 04:34:02 +0000887 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
David Howellsce634ab2008-02-07 00:15:33 -0800888
Steve French8be0ed42008-12-05 19:14:12 +0000889 xid = GetXid();
Jeff Layton0d424ad2010-09-20 16:01:35 -0700890 if (tcon->unix_ext)
Steve Frenchf87d39d2011-05-27 03:50:55 +0000891 rc = cifs_get_inode_info_unix(&inode, "", sb, xid);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400892 else
Steve Frenchf87d39d2011-05-27 03:50:55 +0000893 rc = cifs_get_inode_info(&inode, "", NULL, sb, xid, NULL);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400894
Oskar Schirmera7851ce2010-11-10 21:06:13 +0000895 if (!inode) {
896 inode = ERR_PTR(rc);
897 goto out;
898 }
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400899
Steve French0ccd4802010-07-16 04:31:02 +0000900#ifdef CONFIG_CIFS_FSCACHE
Suresh Jayaramand03382c2010-07-05 18:12:27 +0530901 /* populate tcon->resource_id */
Jeff Layton0d424ad2010-09-20 16:01:35 -0700902 tcon->resource_id = CIFS_I(inode)->uniqueid;
Steve French0ccd4802010-07-16 04:31:02 +0000903#endif
Suresh Jayaramand03382c2010-07-05 18:12:27 +0530904
Jeff Layton0d424ad2010-09-20 16:01:35 -0700905 if (rc && tcon->ipc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000906 cFYI(1, "ipc connection - fake read inode");
Steve French7f8ed422007-09-28 22:28:55 +0000907 inode->i_mode |= S_IFDIR;
908 inode->i_nlink = 2;
909 inode->i_op = &cifs_ipc_inode_ops;
910 inode->i_fop = &simple_dir_operations;
911 inode->i_uid = cifs_sb->mnt_uid;
912 inode->i_gid = cifs_sb->mnt_gid;
Steve Frenchad661332008-08-12 14:14:40 +0000913 } else if (rc) {
David Howellsce634ab2008-02-07 00:15:33 -0800914 iget_failed(inode);
Oskar Schirmera7851ce2010-11-10 21:06:13 +0000915 inode = ERR_PTR(rc);
Steve French7f8ed422007-09-28 22:28:55 +0000916 }
917
Oskar Schirmera7851ce2010-11-10 21:06:13 +0000918out:
David Howellsce634ab2008-02-07 00:15:33 -0800919 /* can not call macro FreeXid here since in a void func
920 * TODO: This is no longer true
921 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 _FreeXid(xid);
David Howellsce634ab2008-02-07 00:15:33 -0800923 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924}
925
Steve French388e57b2008-09-16 23:50:58 +0000926static int
927cifs_set_file_info(struct inode *inode, struct iattr *attrs, int xid,
928 char *full_path, __u32 dosattr)
929{
930 int rc;
931 int oplock = 0;
932 __u16 netfid;
933 __u32 netpid;
934 bool set_time = false;
935 struct cifsFileInfo *open_file;
936 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
937 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400938 struct tcon_link *tlink = NULL;
Steve French96daf2b2011-05-27 04:34:02 +0000939 struct cifs_tcon *pTcon;
Steve French388e57b2008-09-16 23:50:58 +0000940 FILE_BASIC_INFO info_buf;
941
Steve French1adcb712009-02-25 14:19:56 +0000942 if (attrs == NULL)
943 return -EINVAL;
944
Steve French388e57b2008-09-16 23:50:58 +0000945 if (attrs->ia_valid & ATTR_ATIME) {
946 set_time = true;
947 info_buf.LastAccessTime =
948 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
949 } else
950 info_buf.LastAccessTime = 0;
951
952 if (attrs->ia_valid & ATTR_MTIME) {
953 set_time = true;
954 info_buf.LastWriteTime =
955 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
956 } else
957 info_buf.LastWriteTime = 0;
958
959 /*
960 * Samba throws this field away, but windows may actually use it.
961 * Do not set ctime unless other time stamps are changed explicitly
962 * (i.e. by utimes()) since we would then have a mix of client and
963 * server times.
964 */
965 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000966 cFYI(1, "CIFS - CTIME changed");
Steve French388e57b2008-09-16 23:50:58 +0000967 info_buf.ChangeTime =
968 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
969 } else
970 info_buf.ChangeTime = 0;
971
972 info_buf.CreationTime = 0; /* don't change */
973 info_buf.Attributes = cpu_to_le32(dosattr);
974
975 /*
976 * If the file is already open for write, just use that fileid
977 */
Jeff Layton6508d902010-09-29 19:51:11 -0400978 open_file = find_writable_file(cifsInode, true);
Steve French388e57b2008-09-16 23:50:58 +0000979 if (open_file) {
980 netfid = open_file->netfid;
981 netpid = open_file->pid;
Jeff Layton13cfb732010-09-29 19:51:11 -0400982 pTcon = tlink_tcon(open_file->tlink);
Steve French388e57b2008-09-16 23:50:58 +0000983 goto set_via_filehandle;
984 }
985
Jeff Layton7ffec372010-09-29 19:51:11 -0400986 tlink = cifs_sb_tlink(cifs_sb);
987 if (IS_ERR(tlink)) {
988 rc = PTR_ERR(tlink);
989 tlink = NULL;
990 goto out;
991 }
992 pTcon = tlink_tcon(tlink);
Jeff Laytonba00ba62010-09-20 16:01:31 -0700993
Steve French388e57b2008-09-16 23:50:58 +0000994 /*
995 * NT4 apparently returns success on this call, but it doesn't
996 * really work.
997 */
998 if (!(pTcon->ses->flags & CIFS_SES_NT4)) {
999 rc = CIFSSMBSetPathInfo(xid, pTcon, full_path,
1000 &info_buf, cifs_sb->local_nls,
1001 cifs_sb->mnt_cifs_flags &
1002 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton6b37faa2008-10-06 21:54:41 +00001003 if (rc == 0) {
1004 cifsInode->cifsAttrs = dosattr;
1005 goto out;
1006 } else if (rc != -EOPNOTSUPP && rc != -EINVAL)
Steve French388e57b2008-09-16 23:50:58 +00001007 goto out;
1008 }
1009
Joe Perchesb6b38f72010-04-21 03:50:45 +00001010 cFYI(1, "calling SetFileInfo since SetPathInfo for "
1011 "times not supported by this server");
Steve French388e57b2008-09-16 23:50:58 +00001012 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
1013 SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
1014 CREATE_NOT_DIR, &netfid, &oplock,
1015 NULL, cifs_sb->local_nls,
1016 cifs_sb->mnt_cifs_flags &
1017 CIFS_MOUNT_MAP_SPECIAL_CHR);
1018
1019 if (rc != 0) {
1020 if (rc == -EIO)
1021 rc = -EINVAL;
1022 goto out;
1023 }
1024
1025 netpid = current->tgid;
1026
1027set_via_filehandle:
1028 rc = CIFSSMBSetFileInfo(xid, pTcon, &info_buf, netfid, netpid);
Steve Frenchd3889082008-09-24 19:22:52 +00001029 if (!rc)
1030 cifsInode->cifsAttrs = dosattr;
1031
Steve French388e57b2008-09-16 23:50:58 +00001032 if (open_file == NULL)
1033 CIFSSMBClose(xid, pTcon, netfid);
1034 else
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001035 cifsFileInfo_put(open_file);
Steve French388e57b2008-09-16 23:50:58 +00001036out:
Jeff Layton7ffec372010-09-29 19:51:11 -04001037 if (tlink != NULL)
1038 cifs_put_tlink(tlink);
Steve French388e57b2008-09-16 23:50:58 +00001039 return rc;
1040}
1041
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001042/*
1043 * open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1044 * and rename it to a random name that hopefully won't conflict with
1045 * anything else.
1046 */
1047static int
Steve French32709582008-10-20 00:44:19 +00001048cifs_rename_pending_delete(char *full_path, struct dentry *dentry, int xid)
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001049{
1050 int oplock = 0;
1051 int rc;
1052 __u16 netfid;
Steve French32709582008-10-20 00:44:19 +00001053 struct inode *inode = dentry->d_inode;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001054 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1055 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001056 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001057 struct cifs_tcon *tcon;
Steve French32709582008-10-20 00:44:19 +00001058 __u32 dosattr, origattr;
1059 FILE_BASIC_INFO *info_buf = NULL;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001060
Jeff Layton7ffec372010-09-29 19:51:11 -04001061 tlink = cifs_sb_tlink(cifs_sb);
1062 if (IS_ERR(tlink))
1063 return PTR_ERR(tlink);
1064 tcon = tlink_tcon(tlink);
1065
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001066 rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
Jeff Laytondd1db2d2008-10-16 19:27:12 -04001067 DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001068 &netfid, &oplock, NULL, cifs_sb->local_nls,
1069 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1070 if (rc != 0)
1071 goto out;
1072
Steve French32709582008-10-20 00:44:19 +00001073 origattr = cifsInode->cifsAttrs;
1074 if (origattr == 0)
1075 origattr |= ATTR_NORMAL;
1076
1077 dosattr = origattr & ~ATTR_READONLY;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001078 if (dosattr == 0)
1079 dosattr |= ATTR_NORMAL;
1080 dosattr |= ATTR_HIDDEN;
1081
Steve French32709582008-10-20 00:44:19 +00001082 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1083 if (dosattr != origattr) {
1084 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1085 if (info_buf == NULL) {
1086 rc = -ENOMEM;
1087 goto out_close;
1088 }
1089 info_buf->Attributes = cpu_to_le32(dosattr);
1090 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1091 current->tgid);
1092 /* although we would like to mark the file hidden
1093 if that fails we will still try to rename it */
Steve French41346092008-10-20 18:24:42 +00001094 if (rc != 0)
Steve French32709582008-10-20 00:44:19 +00001095 cifsInode->cifsAttrs = dosattr;
1096 else
1097 dosattr = origattr; /* since not able to change them */
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001098 }
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001099
Jeff Laytondd1db2d2008-10-16 19:27:12 -04001100 /* rename the file */
1101 rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001102 cifs_sb->mnt_cifs_flags &
1103 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French32709582008-10-20 00:44:19 +00001104 if (rc != 0) {
1105 rc = -ETXTBSY;
1106 goto undo_setattr;
1107 }
Jeff Layton6d22f092008-09-23 11:48:35 -04001108
Steve French32709582008-10-20 00:44:19 +00001109 /* try to set DELETE_ON_CLOSE */
1110 if (!cifsInode->delete_pending) {
1111 rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
1112 current->tgid);
1113 /*
1114 * some samba versions return -ENOENT when we try to set the
1115 * file disposition here. Likely a samba bug, but work around
1116 * it for now. This means that some cifsXXX files may hang
1117 * around after they shouldn't.
1118 *
1119 * BB: remove this hack after more servers have the fix
1120 */
1121 if (rc == -ENOENT)
1122 rc = 0;
1123 else if (rc != 0) {
1124 rc = -ETXTBSY;
1125 goto undo_rename;
1126 }
1127 cifsInode->delete_pending = true;
1128 }
Jeff Layton7ce86d52008-09-24 11:32:59 -04001129
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001130out_close:
1131 CIFSSMBClose(xid, tcon, netfid);
1132out:
Steve French32709582008-10-20 00:44:19 +00001133 kfree(info_buf);
Jeff Layton7ffec372010-09-29 19:51:11 -04001134 cifs_put_tlink(tlink);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001135 return rc;
Steve French32709582008-10-20 00:44:19 +00001136
1137 /*
1138 * reset everything back to the original state. Don't bother
1139 * dealing with errors here since we can't do anything about
1140 * them anyway.
1141 */
1142undo_rename:
1143 CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
1144 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1145 CIFS_MOUNT_MAP_SPECIAL_CHR);
1146undo_setattr:
1147 if (dosattr != origattr) {
1148 info_buf->Attributes = cpu_to_le32(origattr);
1149 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1150 current->tgid))
1151 cifsInode->cifsAttrs = origattr;
1152 }
1153
1154 goto out_close;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001155}
1156
Steve Frenchff694522009-04-20 19:45:13 +00001157
1158/*
1159 * If dentry->d_inode is null (usually meaning the cached dentry
1160 * is a negative dentry) then we would attempt a standard SMB delete, but
André Goddard Rosaaf901ca2009-11-14 13:09:05 -02001161 * if that fails we can not attempt the fall back mechanisms on EACCESS
1162 * but will return the EACCESS to the caller. Note that the VFS does not call
Steve Frenchff694522009-04-20 19:45:13 +00001163 * unlink on negative dentries currently.
1164 */
Jeff Layton5f0319a2008-09-16 14:05:16 -04001165int cifs_unlink(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166{
1167 int rc = 0;
1168 int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 char *full_path = NULL;
Jeff Layton5f0319a2008-09-16 14:05:16 -04001170 struct inode *inode = dentry->d_inode;
Steve Frenchff694522009-04-20 19:45:13 +00001171 struct cifsInodeInfo *cifs_inode;
Jeff Layton5f0319a2008-09-16 14:05:16 -04001172 struct super_block *sb = dir->i_sb;
1173 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001174 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001175 struct cifs_tcon *tcon;
Steve French60502472008-10-07 18:42:52 +00001176 struct iattr *attrs = NULL;
1177 __u32 dosattr = 0, origattr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178
Joe Perchesb6b38f72010-04-21 03:50:45 +00001179 cFYI(1, "cifs_unlink, dir=0x%p, dentry=0x%p", dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180
Jeff Layton7ffec372010-09-29 19:51:11 -04001181 tlink = cifs_sb_tlink(cifs_sb);
1182 if (IS_ERR(tlink))
1183 return PTR_ERR(tlink);
1184 tcon = tlink_tcon(tlink);
1185
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 xid = GetXid();
1187
Jeff Layton5f0319a2008-09-16 14:05:16 -04001188 /* Unlink can be called from rename so we can not take the
1189 * sb->s_vfs_rename_mutex here */
1190 full_path = build_path_from_dentry(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301192 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001193 goto unlink_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 }
Steve French2d785a52007-07-15 01:48:57 +00001195
Jeff Layton5f0319a2008-09-16 14:05:16 -04001196 if ((tcon->ses->capabilities & CAP_UNIX) &&
Steve French2d785a52007-07-15 01:48:57 +00001197 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
Jeff Layton5f0319a2008-09-16 14:05:16 -04001198 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1199 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
Steve French2d785a52007-07-15 01:48:57 +00001200 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1201 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001202 cFYI(1, "posix del rc %d", rc);
Steve French2d785a52007-07-15 01:48:57 +00001203 if ((rc == 0) || (rc == -ENOENT))
1204 goto psx_del_no_retry;
1205 }
1206
Steve French60502472008-10-07 18:42:52 +00001207retry_std_delete:
Jeff Layton5f0319a2008-09-16 14:05:16 -04001208 rc = CIFSSMBDelFile(xid, tcon, full_path, cifs_sb->local_nls,
Steve French737b7582005-04-28 22:41:06 -07001209 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French60502472008-10-07 18:42:52 +00001210
Steve French2d785a52007-07-15 01:48:57 +00001211psx_del_no_retry:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212 if (!rc) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001213 if (inode)
1214 drop_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 } else if (rc == -ENOENT) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001216 d_drop(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217 } else if (rc == -ETXTBSY) {
Steve French32709582008-10-20 00:44:19 +00001218 rc = cifs_rename_pending_delete(full_path, dentry, xid);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001219 if (rc == 0)
1220 drop_nlink(inode);
Steve Frenchff694522009-04-20 19:45:13 +00001221 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
Steve French388e57b2008-09-16 23:50:58 +00001222 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1223 if (attrs == NULL) {
1224 rc = -ENOMEM;
1225 goto out_reval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226 }
Steve French388e57b2008-09-16 23:50:58 +00001227
1228 /* try to reset dos attributes */
Steve Frenchff694522009-04-20 19:45:13 +00001229 cifs_inode = CIFS_I(inode);
1230 origattr = cifs_inode->cifsAttrs;
Steve French60502472008-10-07 18:42:52 +00001231 if (origattr == 0)
1232 origattr |= ATTR_NORMAL;
1233 dosattr = origattr & ~ATTR_READONLY;
Steve French388e57b2008-09-16 23:50:58 +00001234 if (dosattr == 0)
1235 dosattr |= ATTR_NORMAL;
1236 dosattr |= ATTR_HIDDEN;
1237
1238 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
Steve French388e57b2008-09-16 23:50:58 +00001239 if (rc != 0)
1240 goto out_reval;
Steve French60502472008-10-07 18:42:52 +00001241
1242 goto retry_std_delete;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 }
Steve French60502472008-10-07 18:42:52 +00001244
1245 /* undo the setattr if we errored out and it's needed */
1246 if (rc != 0 && dosattr != 0)
1247 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1248
Steve French388e57b2008-09-16 23:50:58 +00001249out_reval:
Jeff Layton5f0319a2008-09-16 14:05:16 -04001250 if (inode) {
Steve Frenchff694522009-04-20 19:45:13 +00001251 cifs_inode = CIFS_I(inode);
1252 cifs_inode->time = 0; /* will force revalidate to get info
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001253 when needed */
Jeff Layton5f0319a2008-09-16 14:05:16 -04001254 inode->i_ctime = current_fs_time(sb);
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001255 }
Jeff Layton5f0319a2008-09-16 14:05:16 -04001256 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
Steve Frenchff694522009-04-20 19:45:13 +00001257 cifs_inode = CIFS_I(dir);
Steve French60502472008-10-07 18:42:52 +00001258 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
Jeff Layton7ffec372010-09-29 19:51:11 -04001259unlink_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 kfree(full_path);
Steve French60502472008-10-07 18:42:52 +00001261 kfree(attrs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 FreeXid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001263 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 return rc;
1265}
1266
1267int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
1268{
Jeff Layton6b37faa2008-10-06 21:54:41 +00001269 int rc = 0, tmprc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270 int xid;
1271 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001272 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001273 struct cifs_tcon *pTcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274 char *full_path = NULL;
1275 struct inode *newinode = NULL;
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001276 struct cifs_fattr fattr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277
Joe Perchesb6b38f72010-04-21 03:50:45 +00001278 cFYI(1, "In cifs_mkdir, mode = 0x%x inode = 0x%p", mode, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001281 tlink = cifs_sb_tlink(cifs_sb);
1282 if (IS_ERR(tlink))
1283 return PTR_ERR(tlink);
1284 pTcon = tlink_tcon(tlink);
1285
1286 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287
Steve French7f573562005-08-30 11:32:14 -07001288 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301290 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001291 goto mkdir_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 }
Steve French50c2f752007-07-13 00:33:32 +00001293
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001294 if ((pTcon->ses->capabilities & CAP_UNIX) &&
1295 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
Steve French2dd29d32007-04-23 22:07:35 +00001296 le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
1297 u32 oplock = 0;
Steve Frenchf6d09982008-01-08 23:18:22 +00001298 FILE_UNIX_BASIC_INFO *pInfo =
Steve French2dd29d32007-04-23 22:07:35 +00001299 kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001300 if (pInfo == NULL) {
Steve French2dd29d32007-04-23 22:07:35 +00001301 rc = -ENOMEM;
1302 goto mkdir_out;
1303 }
Steve French50c2f752007-07-13 00:33:32 +00001304
Al Viroce3b0f82009-03-29 19:08:22 -04001305 mode &= ~current_umask();
Steve French2dd29d32007-04-23 22:07:35 +00001306 rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
1307 mode, NULL /* netfid */, pInfo, &oplock,
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001308 full_path, cifs_sb->local_nls,
1309 cifs_sb->mnt_cifs_flags &
Steve French2dd29d32007-04-23 22:07:35 +00001310 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve Frenchc45d7072007-09-17 02:04:21 +00001311 if (rc == -EOPNOTSUPP) {
1312 kfree(pInfo);
1313 goto mkdir_retry_old;
1314 } else if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001315 cFYI(1, "posix mkdir returned 0x%x", rc);
Steve French2dd29d32007-04-23 22:07:35 +00001316 d_drop(direntry);
1317 } else {
Cyril Gorcunov8f2376a2007-10-14 17:58:43 +00001318 if (pInfo->Type == cpu_to_le32(-1)) {
1319 /* no return info, go query for it */
Steve French5a07cdf2007-09-16 23:12:47 +00001320 kfree(pInfo);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001321 goto mkdir_get_info;
Steve French5a07cdf2007-09-16 23:12:47 +00001322 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001323/*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
1324 to set uid/gid */
Steve French2dd29d32007-04-23 22:07:35 +00001325 inc_nlink(inode);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001326
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001327 cifs_unix_basic_to_fattr(&fattr, pInfo, cifs_sb);
Jeff Layton4065c802010-05-17 07:18:58 -04001328 cifs_fill_uniqueid(inode->i_sb, &fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001329 newinode = cifs_iget(inode->i_sb, &fattr);
1330 if (!newinode) {
Steve French5a07cdf2007-09-16 23:12:47 +00001331 kfree(pInfo);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001332 goto mkdir_get_info;
Steve French5a07cdf2007-09-16 23:12:47 +00001333 }
Jeff Layton6b37faa2008-10-06 21:54:41 +00001334
Steve French2dd29d32007-04-23 22:07:35 +00001335 d_instantiate(direntry, newinode);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001336
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001337#ifdef CONFIG_CIFS_DEBUG2
Joe Perchesb6b38f72010-04-21 03:50:45 +00001338 cFYI(1, "instantiated dentry %p %s to inode %p",
1339 direntry, direntry->d_name.name, newinode);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001340
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001341 if (newinode->i_nlink != 2)
Joe Perchesb6b38f72010-04-21 03:50:45 +00001342 cFYI(1, "unexpected number of links %d",
1343 newinode->i_nlink);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001344#endif
Steve French2dd29d32007-04-23 22:07:35 +00001345 }
1346 kfree(pInfo);
1347 goto mkdir_out;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001348 }
Steve Frenchc45d7072007-09-17 02:04:21 +00001349mkdir_retry_old:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 /* BB add setting the equivalent of mode via CreateX w/ACLs */
Steve French737b7582005-04-28 22:41:06 -07001351 rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
1352 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001354 cFYI(1, "cifs_mkdir returned 0x%x", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 d_drop(direntry);
1356 } else {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001357mkdir_get_info:
Dave Hansend8c76e62006-09-30 23:29:04 -07001358 inc_nlink(inode);
Steve Frenchc18c8422007-07-18 23:21:09 +00001359 if (pTcon->unix_ext)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 rc = cifs_get_inode_info_unix(&newinode, full_path,
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001361 inode->i_sb, xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 else
1363 rc = cifs_get_inode_info(&newinode, full_path, NULL,
Steve French8b1327f2008-03-14 22:37:16 +00001364 inode->i_sb, xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 d_instantiate(direntry, newinode);
Steve French2dd29d32007-04-23 22:07:35 +00001367 /* setting nlink not necessary except in cases where we
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001368 * failed to get it from the server or was set bogus */
Steve French2dd29d32007-04-23 22:07:35 +00001369 if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001370 direntry->d_inode->i_nlink = 2;
Jeff Layton95089912008-08-06 04:39:02 +00001371
Al Viroce3b0f82009-03-29 19:08:22 -04001372 mode &= ~current_umask();
Jeff Layton95089912008-08-06 04:39:02 +00001373 /* must turn on setgid bit if parent dir has it */
1374 if (inode->i_mode & S_ISGID)
1375 mode |= S_ISGID;
1376
Steve Frenchc18c8422007-07-18 23:21:09 +00001377 if (pTcon->unix_ext) {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04001378 struct cifs_unix_set_info_args args = {
1379 .mode = mode,
1380 .ctime = NO_CHANGE_64,
1381 .atime = NO_CHANGE_64,
1382 .mtime = NO_CHANGE_64,
1383 .device = 0,
1384 };
Steve Frenchd0d2f2d2005-06-02 15:12:36 -07001385 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
David Howellsa001e5b2008-11-14 10:38:47 +11001386 args.uid = (__u64)current_fsuid();
Jeff Layton95089912008-08-06 04:39:02 +00001387 if (inode->i_mode & S_ISGID)
1388 args.gid = (__u64)inode->i_gid;
1389 else
David Howellsa001e5b2008-11-14 10:38:47 +11001390 args.gid = (__u64)current_fsgid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391 } else {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04001392 args.uid = NO_CHANGE_64;
1393 args.gid = NO_CHANGE_64;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 }
Jeff Layton01ea95e2009-07-09 20:02:49 -04001395 CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
1396 cifs_sb->local_nls,
1397 cifs_sb->mnt_cifs_flags &
1398 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French3ce53fc2007-06-08 14:55:14 +00001399 } else {
Jeff Layton67750fb2008-05-09 22:28:02 +00001400 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1401 (mode & S_IWUGO) == 0) {
1402 FILE_BASIC_INFO pInfo;
Jeff Layton6b37faa2008-10-06 21:54:41 +00001403 struct cifsInodeInfo *cifsInode;
1404 u32 dosattrs;
1405
Jeff Layton67750fb2008-05-09 22:28:02 +00001406 memset(&pInfo, 0, sizeof(pInfo));
Jeff Layton6b37faa2008-10-06 21:54:41 +00001407 cifsInode = CIFS_I(newinode);
1408 dosattrs = cifsInode->cifsAttrs|ATTR_READONLY;
1409 pInfo.Attributes = cpu_to_le32(dosattrs);
1410 tmprc = CIFSSMBSetPathInfo(xid, pTcon,
1411 full_path, &pInfo,
1412 cifs_sb->local_nls,
Jeff Layton67750fb2008-05-09 22:28:02 +00001413 cifs_sb->mnt_cifs_flags &
1414 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton6b37faa2008-10-06 21:54:41 +00001415 if (tmprc == 0)
1416 cifsInode->cifsAttrs = dosattrs;
Jeff Layton67750fb2008-05-09 22:28:02 +00001417 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001418 if (direntry->d_inode) {
Jeff Laytonb0fd30d2008-05-22 09:33:34 -04001419 if (cifs_sb->mnt_cifs_flags &
1420 CIFS_MOUNT_DYNPERM)
1421 direntry->d_inode->i_mode =
1422 (mode | S_IFDIR);
Steve French4e94a102008-05-23 18:22:46 +00001423
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001424 if (cifs_sb->mnt_cifs_flags &
Steve French6473a552005-11-29 20:20:10 -08001425 CIFS_MOUNT_SET_UID) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001426 direntry->d_inode->i_uid =
David Howellsa001e5b2008-11-14 10:38:47 +11001427 current_fsuid();
Jeff Layton95089912008-08-06 04:39:02 +00001428 if (inode->i_mode & S_ISGID)
1429 direntry->d_inode->i_gid =
1430 inode->i_gid;
1431 else
1432 direntry->d_inode->i_gid =
David Howellsa001e5b2008-11-14 10:38:47 +11001433 current_fsgid();
Steve French6473a552005-11-29 20:20:10 -08001434 }
1435 }
Steve French2a138ebb2005-11-29 21:22:19 -08001436 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001438mkdir_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439 kfree(full_path);
1440 FreeXid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001441 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 return rc;
1443}
1444
1445int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1446{
1447 int rc = 0;
1448 int xid;
1449 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001450 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001451 struct cifs_tcon *pTcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452 char *full_path = NULL;
1453 struct cifsInodeInfo *cifsInode;
1454
Joe Perchesb6b38f72010-04-21 03:50:45 +00001455 cFYI(1, "cifs_rmdir, inode = 0x%p", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456
1457 xid = GetXid();
1458
Steve French7f573562005-08-30 11:32:14 -07001459 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301461 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001462 goto rmdir_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 }
1464
Jeff Layton7ffec372010-09-29 19:51:11 -04001465 cifs_sb = CIFS_SB(inode->i_sb);
1466 tlink = cifs_sb_tlink(cifs_sb);
1467 if (IS_ERR(tlink)) {
1468 rc = PTR_ERR(tlink);
1469 goto rmdir_exit;
1470 }
1471 pTcon = tlink_tcon(tlink);
1472
Steve French737b7582005-04-28 22:41:06 -07001473 rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
1474 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton7ffec372010-09-29 19:51:11 -04001475 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476
1477 if (!rc) {
Dave Hansen9a53c3a2006-09-30 23:29:03 -07001478 drop_nlink(inode);
Steve French3677db12007-02-26 16:46:11 +00001479 spin_lock(&direntry->d_inode->i_lock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001480 i_size_write(direntry->d_inode, 0);
Dave Hansence71ec32006-09-30 23:29:06 -07001481 clear_nlink(direntry->d_inode);
Steve French3677db12007-02-26 16:46:11 +00001482 spin_unlock(&direntry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483 }
1484
1485 cifsInode = CIFS_I(direntry->d_inode);
1486 cifsInode->time = 0; /* force revalidate to go get info when
1487 needed */
Steve French42c24542009-01-13 22:03:55 +00001488
1489 cifsInode = CIFS_I(inode);
1490 cifsInode->time = 0; /* force revalidate to get parent dir info
1491 since cached search results now invalid */
1492
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1494 current_fs_time(inode->i_sb);
1495
Jeff Layton7ffec372010-09-29 19:51:11 -04001496rmdir_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 kfree(full_path);
1498 FreeXid(xid);
1499 return rc;
1500}
1501
Steve Frenchee2fd962008-09-23 18:23:33 +00001502static int
1503cifs_do_rename(int xid, struct dentry *from_dentry, const char *fromPath,
1504 struct dentry *to_dentry, const char *toPath)
1505{
1506 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001507 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001508 struct cifs_tcon *pTcon;
Steve Frenchee2fd962008-09-23 18:23:33 +00001509 __u16 srcfid;
1510 int oplock, rc;
1511
Jeff Layton7ffec372010-09-29 19:51:11 -04001512 tlink = cifs_sb_tlink(cifs_sb);
1513 if (IS_ERR(tlink))
1514 return PTR_ERR(tlink);
1515 pTcon = tlink_tcon(tlink);
1516
Steve Frenchee2fd962008-09-23 18:23:33 +00001517 /* try path-based rename first */
1518 rc = CIFSSMBRename(xid, pTcon, fromPath, toPath, cifs_sb->local_nls,
1519 cifs_sb->mnt_cifs_flags &
1520 CIFS_MOUNT_MAP_SPECIAL_CHR);
1521
1522 /*
1523 * don't bother with rename by filehandle unless file is busy and
1524 * source Note that cross directory moves do not work with
1525 * rename by filehandle to various Windows servers.
1526 */
1527 if (rc == 0 || rc != -ETXTBSY)
Jeff Layton7ffec372010-09-29 19:51:11 -04001528 goto do_rename_exit;
Steve Frenchee2fd962008-09-23 18:23:33 +00001529
Jeff Laytoned0e3ac2010-06-01 16:21:01 -04001530 /* open-file renames don't work across directories */
1531 if (to_dentry->d_parent != from_dentry->d_parent)
Jeff Layton7ffec372010-09-29 19:51:11 -04001532 goto do_rename_exit;
Jeff Laytoned0e3ac2010-06-01 16:21:01 -04001533
Steve Frenchee2fd962008-09-23 18:23:33 +00001534 /* open the file to be renamed -- we need DELETE perms */
1535 rc = CIFSSMBOpen(xid, pTcon, fromPath, FILE_OPEN, DELETE,
1536 CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1537 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1538 CIFS_MOUNT_MAP_SPECIAL_CHR);
1539
1540 if (rc == 0) {
1541 rc = CIFSSMBRenameOpenFile(xid, pTcon, srcfid,
1542 (const char *) to_dentry->d_name.name,
1543 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1544 CIFS_MOUNT_MAP_SPECIAL_CHR);
1545
1546 CIFSSMBClose(xid, pTcon, srcfid);
1547 }
Jeff Layton7ffec372010-09-29 19:51:11 -04001548do_rename_exit:
1549 cifs_put_tlink(tlink);
Steve Frenchee2fd962008-09-23 18:23:33 +00001550 return rc;
1551}
1552
Jeff Layton14121bd2008-10-20 14:45:22 -04001553int cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1554 struct inode *target_dir, struct dentry *target_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555{
Steve Frenchee2fd962008-09-23 18:23:33 +00001556 char *fromName = NULL;
1557 char *toName = NULL;
Jeff Layton639e7a92010-09-03 11:50:09 -04001558 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001559 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001560 struct cifs_tcon *tcon;
Steve Frenchee2fd962008-09-23 18:23:33 +00001561 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1562 FILE_UNIX_BASIC_INFO *info_buf_target;
Jeff Layton8d281ef2008-10-22 13:57:01 -04001563 int xid, rc, tmprc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564
Jeff Layton639e7a92010-09-03 11:50:09 -04001565 cifs_sb = CIFS_SB(source_dir->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001566 tlink = cifs_sb_tlink(cifs_sb);
1567 if (IS_ERR(tlink))
1568 return PTR_ERR(tlink);
1569 tcon = tlink_tcon(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570
Steve Frenchee2fd962008-09-23 18:23:33 +00001571 xid = GetXid();
1572
1573 /*
Steve Frenchee2fd962008-09-23 18:23:33 +00001574 * we already have the rename sem so we do not need to
1575 * grab it again here to protect the path integrity
1576 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001577 fromName = build_path_from_dentry(source_dentry);
Steve Frenchee2fd962008-09-23 18:23:33 +00001578 if (fromName == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 rc = -ENOMEM;
1580 goto cifs_rename_exit;
1581 }
1582
Jeff Layton14121bd2008-10-20 14:45:22 -04001583 toName = build_path_from_dentry(target_dentry);
Steve Frenchee2fd962008-09-23 18:23:33 +00001584 if (toName == NULL) {
1585 rc = -ENOMEM;
1586 goto cifs_rename_exit;
1587 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588
Jeff Layton14121bd2008-10-20 14:45:22 -04001589 rc = cifs_do_rename(xid, source_dentry, fromName,
1590 target_dentry, toName);
Steve Frenchee2fd962008-09-23 18:23:33 +00001591
Jeff Layton14121bd2008-10-20 14:45:22 -04001592 if (rc == -EEXIST && tcon->unix_ext) {
Steve Frenchee2fd962008-09-23 18:23:33 +00001593 /*
Jeff Layton14121bd2008-10-20 14:45:22 -04001594 * Are src and dst hardlinks of same inode? We can
1595 * only tell with unix extensions enabled
Steve Frenchee2fd962008-09-23 18:23:33 +00001596 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001597 info_buf_source =
1598 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1599 GFP_KERNEL);
1600 if (info_buf_source == NULL) {
1601 rc = -ENOMEM;
1602 goto cifs_rename_exit;
1603 }
1604
1605 info_buf_target = info_buf_source + 1;
Jeff Layton8d281ef2008-10-22 13:57:01 -04001606 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, fromName,
Jeff Layton14121bd2008-10-20 14:45:22 -04001607 info_buf_source,
Jeff Layton639e7a92010-09-03 11:50:09 -04001608 cifs_sb->local_nls,
1609 cifs_sb->mnt_cifs_flags &
Jeff Layton14121bd2008-10-20 14:45:22 -04001610 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton8d281ef2008-10-22 13:57:01 -04001611 if (tmprc != 0)
Jeff Layton14121bd2008-10-20 14:45:22 -04001612 goto unlink_target;
1613
Jeff Layton639e7a92010-09-03 11:50:09 -04001614 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, toName,
1615 info_buf_target,
1616 cifs_sb->local_nls,
1617 cifs_sb->mnt_cifs_flags &
Jeff Layton14121bd2008-10-20 14:45:22 -04001618 CIFS_MOUNT_MAP_SPECIAL_CHR);
1619
Jeff Layton8d281ef2008-10-22 13:57:01 -04001620 if (tmprc == 0 && (info_buf_source->UniqueId ==
Jeff Laytonae6884a2008-11-03 14:05:08 -05001621 info_buf_target->UniqueId)) {
Jeff Layton14121bd2008-10-20 14:45:22 -04001622 /* same file, POSIX says that this is a noop */
Jeff Laytonae6884a2008-11-03 14:05:08 -05001623 rc = 0;
Jeff Layton14121bd2008-10-20 14:45:22 -04001624 goto cifs_rename_exit;
Jeff Laytonae6884a2008-11-03 14:05:08 -05001625 }
Jeff Layton14121bd2008-10-20 14:45:22 -04001626 } /* else ... BB we could add the same check for Windows by
1627 checking the UniqueId via FILE_INTERNAL_INFO */
1628
Jeff Layton14121bd2008-10-20 14:45:22 -04001629unlink_target:
Jeff Laytonfc6f3942009-04-17 11:45:30 -04001630 /* Try unlinking the target dentry if it's not negative */
1631 if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
Jeff Layton8d281ef2008-10-22 13:57:01 -04001632 tmprc = cifs_unlink(target_dir, target_dentry);
Jeff Layton14121bd2008-10-20 14:45:22 -04001633 if (tmprc)
1634 goto cifs_rename_exit;
1635
Jeff Layton14121bd2008-10-20 14:45:22 -04001636 rc = cifs_do_rename(xid, source_dentry, fromName,
1637 target_dentry, toName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638 }
1639
1640cifs_rename_exit:
Steve Frenchee2fd962008-09-23 18:23:33 +00001641 kfree(info_buf_source);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 kfree(fromName);
1643 kfree(toName);
1644 FreeXid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001645 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646 return rc;
1647}
1648
Jeff Laytondf2cf172010-02-12 07:44:16 -05001649static bool
1650cifs_inode_needs_reval(struct inode *inode)
1651{
1652 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301653 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Laytondf2cf172010-02-12 07:44:16 -05001654
1655 if (cifs_i->clientCanCacheRead)
1656 return false;
1657
1658 if (!lookupCacheEnabled)
1659 return true;
1660
1661 if (cifs_i->time == 0)
1662 return true;
1663
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301664 if (!time_in_range(jiffies, cifs_i->time,
1665 cifs_i->time + cifs_sb->actimeo))
Jeff Laytondf2cf172010-02-12 07:44:16 -05001666 return true;
1667
Jeff Laytondb192722010-05-17 14:51:49 -04001668 /* hardlinked files w/ noserverino get "special" treatment */
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301669 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
Jeff Laytondb192722010-05-17 14:51:49 -04001670 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1671 return true;
1672
Jeff Laytondf2cf172010-02-12 07:44:16 -05001673 return false;
1674}
1675
Suresh Jayaraman523fb8c2010-11-29 22:39:47 +05301676/*
1677 * Zap the cache. Called when invalid_mapping flag is set.
1678 */
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001679int
Jeff Laytondf2cf172010-02-12 07:44:16 -05001680cifs_invalidate_mapping(struct inode *inode)
1681{
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001682 int rc = 0;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001683 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1684
1685 cifs_i->invalid_mapping = false;
1686
Jeff Laytondf2cf172010-02-12 07:44:16 -05001687 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
Pavel Shilovsky257fb1f2011-03-16 01:55:32 +03001688 rc = invalidate_inode_pages2(inode->i_mapping);
1689 if (rc) {
1690 cERROR(1, "%s: could not invalidate inode %p", __func__,
1691 inode);
1692 cifs_i->invalid_mapping = true;
1693 }
Jeff Laytondf2cf172010-02-12 07:44:16 -05001694 }
Pavel Shilovsky257fb1f2011-03-16 01:55:32 +03001695
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +05301696 cifs_fscache_reset_inode_cookie(inode);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001697 return rc;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001698}
1699
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001700int cifs_revalidate_file_attr(struct file *filp)
Jeff Laytonabab0952010-02-12 07:44:18 -05001701{
1702 int rc = 0;
1703 struct inode *inode = filp->f_path.dentry->d_inode;
Jeff Laytonba00ba62010-09-20 16:01:31 -07001704 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
Jeff Laytonabab0952010-02-12 07:44:18 -05001705
1706 if (!cifs_inode_needs_reval(inode))
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001707 return rc;
Jeff Laytonabab0952010-02-12 07:44:18 -05001708
Jeff Layton13cfb732010-09-29 19:51:11 -04001709 if (tlink_tcon(cfile->tlink)->unix_ext)
Jeff Laytonabab0952010-02-12 07:44:18 -05001710 rc = cifs_get_file_info_unix(filp);
1711 else
1712 rc = cifs_get_file_info(filp);
1713
Jeff Laytonabab0952010-02-12 07:44:18 -05001714 return rc;
1715}
1716
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001717int cifs_revalidate_dentry_attr(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718{
1719 int xid;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001720 int rc = 0;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001721 struct inode *inode = dentry->d_inode;
1722 struct super_block *sb = dentry->d_sb;
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001723 char *full_path = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724
Jeff Laytondf2cf172010-02-12 07:44:16 -05001725 if (inode == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726 return -ENOENT;
1727
Jeff Laytondf2cf172010-02-12 07:44:16 -05001728 if (!cifs_inode_needs_reval(inode))
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001729 return rc;
1730
1731 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732
1733 /* can not safely grab the rename sem here if rename calls revalidate
1734 since that would deadlock */
Jeff Laytondf2cf172010-02-12 07:44:16 -05001735 full_path = build_path_from_dentry(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301737 rc = -ENOMEM;
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001738 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739 }
Jeff Laytondf2cf172010-02-12 07:44:16 -05001740
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001741 cFYI(1, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time "
1742 "%ld jiffies %ld", full_path, inode, inode->i_count.counter,
Steve Frenchf19159d2010-04-21 04:12:10 +00001743 dentry, dentry->d_time, jiffies);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744
Jeff Layton0d424ad2010-09-20 16:01:35 -07001745 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
Jeff Laytondf2cf172010-02-12 07:44:16 -05001746 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1747 else
1748 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1749 xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001751out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752 kfree(full_path);
1753 FreeXid(xid);
1754 return rc;
1755}
1756
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001757int cifs_revalidate_file(struct file *filp)
1758{
1759 int rc;
1760 struct inode *inode = filp->f_path.dentry->d_inode;
1761
1762 rc = cifs_revalidate_file_attr(filp);
1763 if (rc)
1764 return rc;
1765
1766 if (CIFS_I(inode)->invalid_mapping)
1767 rc = cifs_invalidate_mapping(inode);
1768 return rc;
1769}
1770
1771/* revalidate a dentry's inode attributes */
1772int cifs_revalidate_dentry(struct dentry *dentry)
1773{
1774 int rc;
1775 struct inode *inode = dentry->d_inode;
1776
1777 rc = cifs_revalidate_dentry_attr(dentry);
1778 if (rc)
1779 return rc;
1780
1781 if (CIFS_I(inode)->invalid_mapping)
1782 rc = cifs_invalidate_mapping(inode);
1783 return rc;
1784}
1785
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
Jeff Layton1c456012010-10-12 11:32:42 -04001787 struct kstat *stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788{
Jeff Layton3aa1c8c2010-10-07 14:46:28 -04001789 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
Steve French96daf2b2011-05-27 04:34:02 +00001790 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001791 struct inode *inode = dentry->d_inode;
1792 int rc;
Jeff Layton3aa1c8c2010-10-07 14:46:28 -04001793
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001794 /*
1795 * We need to be sure that all dirty pages are written and the server
1796 * has actual ctime, mtime and file length.
1797 */
1798 if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping &&
1799 inode->i_mapping->nrpages != 0) {
1800 rc = filemap_fdatawait(inode->i_mapping);
Steve French156ecb22011-05-20 17:00:01 +00001801 if (rc) {
1802 mapping_set_error(inode->i_mapping, rc);
1803 return rc;
1804 }
Steve French5fe14c82006-11-07 19:26:33 +00001805 }
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001806
1807 rc = cifs_revalidate_dentry_attr(dentry);
1808 if (rc)
1809 return rc;
1810
1811 generic_fillattr(inode, stat);
1812 stat->blksize = CIFS_MAX_MSGSIZE;
1813 stat->ino = CIFS_I(inode)->uniqueid;
1814
1815 /*
1816 * If on a multiuser mount without unix extensions, and the admin hasn't
1817 * overridden them, set the ownership to the fsuid/fsgid of the current
1818 * process.
1819 */
1820 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
1821 !tcon->unix_ext) {
1822 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1823 stat->uid = current_fsuid();
1824 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1825 stat->gid = current_fsgid();
1826 }
1827 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828}
1829
1830static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1831{
1832 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1833 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1834 struct page *page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835 int rc = 0;
1836
1837 page = grab_cache_page(mapping, index);
1838 if (!page)
1839 return -ENOMEM;
1840
Christoph Lametereebd2aa2008-02-04 22:28:29 -08001841 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842 unlock_page(page);
1843 page_cache_release(page);
1844 return rc;
1845}
1846
Christoph Hellwig1b947462010-07-18 17:51:21 -04001847static void cifs_setsize(struct inode *inode, loff_t offset)
Steve French3677db12007-02-26 16:46:11 +00001848{
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001849 loff_t oldsize;
Steve French3677db12007-02-26 16:46:11 +00001850
Steve Frenchba6a46a2007-02-26 20:06:29 +00001851 spin_lock(&inode->i_lock);
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001852 oldsize = inode->i_size;
Steve French3677db12007-02-26 16:46:11 +00001853 i_size_write(inode, offset);
Steve Frenchba6a46a2007-02-26 20:06:29 +00001854 spin_unlock(&inode->i_lock);
Christoph Hellwig1b947462010-07-18 17:51:21 -04001855
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001856 truncate_pagecache(inode, oldsize, offset);
Steve French3677db12007-02-26 16:46:11 +00001857}
1858
Jeff Layton8efdbde2008-07-23 21:28:12 +00001859static int
1860cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1861 int xid, char *full_path)
1862{
1863 int rc;
1864 struct cifsFileInfo *open_file;
1865 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1866 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001867 struct tcon_link *tlink = NULL;
Steve French96daf2b2011-05-27 04:34:02 +00001868 struct cifs_tcon *pTcon = NULL;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001869 struct cifs_io_parms io_parms;
Jeff Layton8efdbde2008-07-23 21:28:12 +00001870
1871 /*
1872 * To avoid spurious oplock breaks from server, in the case of
1873 * inodes that we already have open, avoid doing path based
1874 * setting of file size if we can do it by handle.
1875 * This keeps our caching token (oplock) and avoids timeouts
1876 * when the local oplock break takes longer to flush
1877 * writebehind data than the SMB timeout for the SetPathInfo
1878 * request would allow
1879 */
Jeff Layton6508d902010-09-29 19:51:11 -04001880 open_file = find_writable_file(cifsInode, true);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001881 if (open_file) {
1882 __u16 nfid = open_file->netfid;
1883 __u32 npid = open_file->pid;
Jeff Layton13cfb732010-09-29 19:51:11 -04001884 pTcon = tlink_tcon(open_file->tlink);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001885 rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size, nfid,
1886 npid, false);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001887 cifsFileInfo_put(open_file);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001888 cFYI(1, "SetFSize for attrs rc = %d", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001889 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1890 unsigned int bytes_written;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001891
1892 io_parms.netfid = nfid;
1893 io_parms.pid = npid;
1894 io_parms.tcon = pTcon;
1895 io_parms.offset = 0;
1896 io_parms.length = attrs->ia_size;
1897 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written,
1898 NULL, NULL, 1);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001899 cFYI(1, "Wrt seteof rc %d", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001900 }
1901 } else
1902 rc = -EINVAL;
1903
1904 if (rc != 0) {
Jeff Layton7ffec372010-09-29 19:51:11 -04001905 if (pTcon == NULL) {
1906 tlink = cifs_sb_tlink(cifs_sb);
1907 if (IS_ERR(tlink))
1908 return PTR_ERR(tlink);
1909 pTcon = tlink_tcon(tlink);
1910 }
Jeff Laytonba00ba62010-09-20 16:01:31 -07001911
Jeff Layton8efdbde2008-07-23 21:28:12 +00001912 /* Set file size by pathname rather than by handle
1913 either because no valid, writeable file handle for
1914 it was found or because there was an error setting
1915 it by handle */
1916 rc = CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size,
1917 false, cifs_sb->local_nls,
1918 cifs_sb->mnt_cifs_flags &
1919 CIFS_MOUNT_MAP_SPECIAL_CHR);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001920 cFYI(1, "SetEOF by path (setattrs) rc = %d", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001921 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1922 __u16 netfid;
1923 int oplock = 0;
1924
1925 rc = SMBLegacyOpen(xid, pTcon, full_path,
1926 FILE_OPEN, GENERIC_WRITE,
1927 CREATE_NOT_DIR, &netfid, &oplock, NULL,
1928 cifs_sb->local_nls,
1929 cifs_sb->mnt_cifs_flags &
1930 CIFS_MOUNT_MAP_SPECIAL_CHR);
1931 if (rc == 0) {
1932 unsigned int bytes_written;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001933
1934 io_parms.netfid = netfid;
1935 io_parms.pid = current->tgid;
1936 io_parms.tcon = pTcon;
1937 io_parms.offset = 0;
1938 io_parms.length = attrs->ia_size;
1939 rc = CIFSSMBWrite(xid, &io_parms,
1940 &bytes_written,
1941 NULL, NULL, 1);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001942 cFYI(1, "wrt seteof rc %d", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001943 CIFSSMBClose(xid, pTcon, netfid);
1944 }
1945 }
Jeff Layton7ffec372010-09-29 19:51:11 -04001946 if (tlink)
1947 cifs_put_tlink(tlink);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001948 }
1949
1950 if (rc == 0) {
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001951 cifsInode->server_eof = attrs->ia_size;
Christoph Hellwig1b947462010-07-18 17:51:21 -04001952 cifs_setsize(inode, attrs->ia_size);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001953 cifs_truncate_page(inode->i_mapping, inode->i_size);
1954 }
1955
1956 return rc;
1957}
1958
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001959static int
1960cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1961{
1962 int rc;
1963 int xid;
1964 char *full_path = NULL;
1965 struct inode *inode = direntry->d_inode;
1966 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1967 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001968 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001969 struct cifs_tcon *pTcon;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001970 struct cifs_unix_set_info_args *args = NULL;
Jeff Layton3bbeeb32009-07-09 20:02:50 -04001971 struct cifsFileInfo *open_file;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001972
Joe Perchesb6b38f72010-04-21 03:50:45 +00001973 cFYI(1, "setattr_unix on file %s attrs->ia_valid=0x%x",
1974 direntry->d_name.name, attrs->ia_valid);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001975
1976 xid = GetXid();
1977
Christoph Hellwigdb78b872010-06-04 11:30:03 +02001978 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
1979 attrs->ia_valid |= ATTR_FORCE;
1980
1981 rc = inode_change_ok(inode, attrs);
1982 if (rc < 0)
1983 goto out;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001984
1985 full_path = build_path_from_dentry(direntry);
1986 if (full_path == NULL) {
1987 rc = -ENOMEM;
1988 goto out;
1989 }
1990
Jeff Layton0f4d6342009-03-26 13:35:37 -04001991 /*
1992 * Attempt to flush data before changing attributes. We need to do
1993 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1994 * ownership or mode then we may also need to do this. Here, we take
1995 * the safe way out and just do the flush on all setattr requests. If
1996 * the flush returns error, store it to report later and continue.
1997 *
1998 * BB: This should be smarter. Why bother flushing pages that
1999 * will be truncated anyway? Also, should we error out here if
2000 * the flush returns error?
2001 */
2002 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002003 mapping_set_error(inode->i_mapping, rc);
2004 rc = 0;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002005
2006 if (attrs->ia_valid & ATTR_SIZE) {
2007 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2008 if (rc != 0)
2009 goto out;
2010 }
2011
2012 /* skip mode change if it's just for clearing setuid/setgid */
2013 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2014 attrs->ia_valid &= ~ATTR_MODE;
2015
2016 args = kmalloc(sizeof(*args), GFP_KERNEL);
2017 if (args == NULL) {
2018 rc = -ENOMEM;
2019 goto out;
2020 }
2021
2022 /* set up the struct */
2023 if (attrs->ia_valid & ATTR_MODE)
2024 args->mode = attrs->ia_mode;
2025 else
2026 args->mode = NO_CHANGE_64;
2027
2028 if (attrs->ia_valid & ATTR_UID)
2029 args->uid = attrs->ia_uid;
2030 else
2031 args->uid = NO_CHANGE_64;
2032
2033 if (attrs->ia_valid & ATTR_GID)
2034 args->gid = attrs->ia_gid;
2035 else
2036 args->gid = NO_CHANGE_64;
2037
2038 if (attrs->ia_valid & ATTR_ATIME)
2039 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2040 else
2041 args->atime = NO_CHANGE_64;
2042
2043 if (attrs->ia_valid & ATTR_MTIME)
2044 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2045 else
2046 args->mtime = NO_CHANGE_64;
2047
2048 if (attrs->ia_valid & ATTR_CTIME)
2049 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2050 else
2051 args->ctime = NO_CHANGE_64;
2052
2053 args->device = 0;
Jeff Layton6508d902010-09-29 19:51:11 -04002054 open_file = find_writable_file(cifsInode, true);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002055 if (open_file) {
2056 u16 nfid = open_file->netfid;
2057 u32 npid = open_file->pid;
Jeff Layton13cfb732010-09-29 19:51:11 -04002058 pTcon = tlink_tcon(open_file->tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002059 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04002060 cifsFileInfo_put(open_file);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002061 } else {
Jeff Layton7ffec372010-09-29 19:51:11 -04002062 tlink = cifs_sb_tlink(cifs_sb);
2063 if (IS_ERR(tlink)) {
2064 rc = PTR_ERR(tlink);
2065 goto out;
2066 }
2067 pTcon = tlink_tcon(tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002068 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
Jeff Layton01ea95e2009-07-09 20:02:49 -04002069 cifs_sb->local_nls,
2070 cifs_sb->mnt_cifs_flags &
2071 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton7ffec372010-09-29 19:51:11 -04002072 cifs_put_tlink(tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002073 }
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002074
Christoph Hellwig10257742010-06-04 11:30:02 +02002075 if (rc)
2076 goto out;
Steve Frenchccd4bb12010-02-08 17:39:58 +00002077
Christoph Hellwig10257742010-06-04 11:30:02 +02002078 if ((attrs->ia_valid & ATTR_SIZE) &&
Christoph Hellwig1b947462010-07-18 17:51:21 -04002079 attrs->ia_size != i_size_read(inode))
2080 truncate_setsize(inode, attrs->ia_size);
Christoph Hellwig10257742010-06-04 11:30:02 +02002081
2082 setattr_copy(inode, attrs);
2083 mark_inode_dirty(inode);
2084
2085 /* force revalidate when any of these times are set since some
2086 of the fs types (eg ext3, fat) do not have fine enough
2087 time granularity to match protocol, and we do not have a
2088 a way (yet) to query the server fs's time granularity (and
2089 whether it rounds times down).
2090 */
2091 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2092 cifsInode->time = 0;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002093out:
2094 kfree(args);
2095 kfree(full_path);
2096 FreeXid(xid);
2097 return rc;
2098}
2099
Jeff Layton0510eeb2008-08-02 07:26:12 -04002100static int
2101cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002102{
2103 int xid;
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002104 uid_t uid = NO_CHANGE_32;
2105 gid_t gid = NO_CHANGE_32;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002106 struct inode *inode = direntry->d_inode;
2107 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002108 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109 char *full_path = NULL;
2110 int rc = -EACCES;
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002111 __u32 dosattr = 0;
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04002112 __u64 mode = NO_CHANGE_64;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002113
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114 xid = GetXid();
2115
Joe Perchesb6b38f72010-04-21 03:50:45 +00002116 cFYI(1, "setattr on file %s attrs->iavalid 0x%x",
2117 direntry->d_name.name, attrs->ia_valid);
Steve French6473a552005-11-29 20:20:10 -08002118
Christoph Hellwigdb78b872010-06-04 11:30:03 +02002119 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2120 attrs->ia_valid |= ATTR_FORCE;
2121
2122 rc = inode_change_ok(inode, attrs);
2123 if (rc < 0) {
2124 FreeXid(xid);
2125 return rc;
Steve French6473a552005-11-29 20:20:10 -08002126 }
Steve French50c2f752007-07-13 00:33:32 +00002127
Steve French7f573562005-08-30 11:32:14 -07002128 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302130 rc = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002131 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302132 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002133 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134
Jeff Layton0f4d6342009-03-26 13:35:37 -04002135 /*
2136 * Attempt to flush data before changing attributes. We need to do
2137 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2138 * ownership or mode then we may also need to do this. Here, we take
2139 * the safe way out and just do the flush on all setattr requests. If
2140 * the flush returns error, store it to report later and continue.
2141 *
2142 * BB: This should be smarter. Why bother flushing pages that
2143 * will be truncated anyway? Also, should we error out here if
2144 * the flush returns error?
2145 */
2146 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002147 mapping_set_error(inode->i_mapping, rc);
2148 rc = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +00002149
Steve French50531442008-03-14 19:21:31 +00002150 if (attrs->ia_valid & ATTR_SIZE) {
Jeff Layton8efdbde2008-07-23 21:28:12 +00002151 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2152 if (rc != 0)
Steve Frenche30dcf32005-09-20 20:49:16 -07002153 goto cifs_setattr_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002154 }
Jeff Layton4ca691a2008-05-22 09:33:34 -04002155
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002156 if (attrs->ia_valid & ATTR_UID)
2157 uid = attrs->ia_uid;
2158
2159 if (attrs->ia_valid & ATTR_GID)
2160 gid = attrs->ia_gid;
2161
2162#ifdef CONFIG_CIFS_ACL
2163 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2164 if (uid != NO_CHANGE_32 || gid != NO_CHANGE_32) {
2165 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2166 uid, gid);
2167 if (rc) {
2168 cFYI(1, "%s: Setting id failed with error: %d",
2169 __func__, rc);
2170 goto cifs_setattr_exit;
2171 }
2172 }
2173 } else
2174#endif /* CONFIG_CIFS_ACL */
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002175 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
Jeff Layton4ca691a2008-05-22 09:33:34 -04002176 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177
Jeff Laytond32c4f22007-10-18 03:05:22 -07002178 /* skip mode change if it's just for clearing setuid/setgid */
2179 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2180 attrs->ia_valid &= ~ATTR_MODE;
2181
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182 if (attrs->ia_valid & ATTR_MODE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183 mode = attrs->ia_mode;
Steve Frenchcdbce9c2005-11-19 21:04:52 -08002184 rc = 0;
Jeff Layton79df1ba2010-12-06 12:52:08 -05002185#ifdef CONFIG_CIFS_ACL
Shirish Pargaonkar78415d22010-11-27 11:37:26 -06002186 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05002187 rc = id_mode_to_cifs_acl(inode, full_path, mode,
2188 NO_CHANGE_32, NO_CHANGE_32);
Shirish Pargaonkar78415d22010-11-27 11:37:26 -06002189 if (rc) {
2190 cFYI(1, "%s: Setting ACL failed with error: %d",
2191 __func__, rc);
2192 goto cifs_setattr_exit;
2193 }
2194 } else
Jeff Layton79df1ba2010-12-06 12:52:08 -05002195#endif /* CONFIG_CIFS_ACL */
Jeff Layton51328612008-05-22 09:33:34 -04002196 if (((mode & S_IWUGO) == 0) &&
2197 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002198
2199 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2200
Jeff Layton51328612008-05-22 09:33:34 -04002201 /* fix up mode if we're not using dynperm */
2202 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2203 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2204 } else if ((mode & S_IWUGO) &&
2205 (cifsInode->cifsAttrs & ATTR_READONLY)) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002206
2207 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2208 /* Attributes of 0 are ignored */
2209 if (dosattr == 0)
2210 dosattr |= ATTR_NORMAL;
Jeff Layton51328612008-05-22 09:33:34 -04002211
2212 /* reset local inode permissions to normal */
2213 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2214 attrs->ia_mode &= ~(S_IALLUGO);
2215 if (S_ISDIR(inode->i_mode))
2216 attrs->ia_mode |=
2217 cifs_sb->mnt_dir_mode;
2218 else
2219 attrs->ia_mode |=
2220 cifs_sb->mnt_file_mode;
2221 }
2222 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2223 /* ignore mode change - ATTR_READONLY hasn't changed */
2224 attrs->ia_valid &= ~ATTR_MODE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226 }
2227
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002228 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2229 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2230 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2231 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232
Steve Frenche30dcf32005-09-20 20:49:16 -07002233 /* Even if error on time set, no sense failing the call if
2234 the server would set the time to a reasonable value anyway,
2235 and this check ensures that we are not being called from
2236 sys_utimes in which case we ought to fail the call back to
2237 the user when the server rejects the call */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002238 if ((rc) && (attrs->ia_valid &
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002239 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
Steve Frenche30dcf32005-09-20 20:49:16 -07002240 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002241 }
2242
2243 /* do not need local check to inode_check_ok since the server does
2244 that */
Christoph Hellwig10257742010-06-04 11:30:02 +02002245 if (rc)
2246 goto cifs_setattr_exit;
2247
2248 if ((attrs->ia_valid & ATTR_SIZE) &&
Christoph Hellwig1b947462010-07-18 17:51:21 -04002249 attrs->ia_size != i_size_read(inode))
2250 truncate_setsize(inode, attrs->ia_size);
Christoph Hellwig10257742010-06-04 11:30:02 +02002251
2252 setattr_copy(inode, attrs);
2253 mark_inode_dirty(inode);
Christoph Hellwig10257742010-06-04 11:30:02 +02002254
Steve Frenche30dcf32005-09-20 20:49:16 -07002255cifs_setattr_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256 kfree(full_path);
2257 FreeXid(xid);
2258 return rc;
2259}
2260
Jeff Layton0510eeb2008-08-02 07:26:12 -04002261int
2262cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2263{
2264 struct inode *inode = direntry->d_inode;
2265 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Steve French96daf2b2011-05-27 04:34:02 +00002266 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
Jeff Layton0510eeb2008-08-02 07:26:12 -04002267
2268 if (pTcon->unix_ext)
2269 return cifs_setattr_unix(direntry, attrs);
2270
2271 return cifs_setattr_nounix(direntry, attrs);
2272
2273 /* BB: add cifs_setattr_legacy for really old servers */
2274}
2275
Steve French99ee4db2007-02-27 05:35:17 +00002276#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07002277void cifs_delete_inode(struct inode *inode)
2278{
Joe Perchesb6b38f72010-04-21 03:50:45 +00002279 cFYI(1, "In cifs_delete_inode, inode = 0x%p", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002280 /* may have to add back in if and when safe distributed caching of
2281 directories added e.g. via FindNotify */
2282}
Steve French99ee4db2007-02-27 05:35:17 +00002283#endif