blob: 9b018c8334fa1d67bf090db12f8821700341c1df [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);
565 if (rc == -EOPNOTSUPP || rc == -EINVAL) {
566 /*
567 * FIXME: legacy server -- fall back to path-based call?
Steve Frenchff2157132010-03-09 20:30:42 +0000568 * for now, just skip revalidating and mark inode for
569 * immediate reval.
570 */
Jeff Laytonabab0952010-02-12 07:44:18 -0500571 rc = 0;
572 CIFS_I(inode)->time = 0;
573 goto cgfi_exit;
574 } else if (rc == -EREMOTE) {
575 cifs_create_dfs_fattr(&fattr, inode->i_sb);
576 rc = 0;
577 } else if (rc)
578 goto cgfi_exit;
579
580 /*
581 * don't bother with SFU junk here -- just mark inode as needing
582 * revalidation.
583 */
584 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false);
585 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
586 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
587 cifs_fattr_to_inode(inode, &fattr);
588cgfi_exit:
589 FreeXid(xid);
590 return rc;
591}
592
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593int cifs_get_inode_info(struct inode **pinode,
Steve French646dd532008-05-15 01:50:56 +0000594 const unsigned char *full_path, FILE_ALL_INFO *pfindData,
Steve French8b1327f2008-03-14 22:37:16 +0000595 struct super_block *sb, int xid, const __u16 *pfid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596{
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400597 int rc = 0, tmprc;
Steve French96daf2b2011-05-27 04:34:02 +0000598 struct cifs_tcon *pTcon;
Jeff Layton7ffec372010-09-29 19:51:11 -0400599 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 char *buf = NULL;
Steve French5ade9de2008-05-02 20:56:23 +0000602 bool adjustTZ = false;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400603 struct cifs_fattr fattr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604
Jeff Layton7ffec372010-09-29 19:51:11 -0400605 tlink = cifs_sb_tlink(cifs_sb);
606 if (IS_ERR(tlink))
607 return PTR_ERR(tlink);
608 pTcon = tlink_tcon(tlink);
609
Joe Perchesb6b38f72010-04-21 03:50:45 +0000610 cFYI(1, "Getting info on %s", full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611
Steve Frenchd0d2f2d2005-06-02 15:12:36 -0700612 if ((pfindData == NULL) && (*pinode != NULL)) {
613 if (CIFS_I(*pinode)->clientCanCacheRead) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000614 cFYI(1, "No need to revalidate cached inode sizes");
Jeff Layton7ffec372010-09-29 19:51:11 -0400615 goto cgii_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 }
617 }
618
619 /* if file info not passed in then get it from server */
Steve Frenchd0d2f2d2005-06-02 15:12:36 -0700620 if (pfindData == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
Jeff Layton7ffec372010-09-29 19:51:11 -0400622 if (buf == NULL) {
623 rc = -ENOMEM;
624 goto cgii_exit;
625 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 pfindData = (FILE_ALL_INFO *)buf;
Igor Mammedov79626702008-03-09 03:44:18 +0000627
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 /* could do find first instead but this returns more info */
Igor Mammedov79626702008-03-09 03:44:18 +0000629 rc = CIFSSMBQPathInfo(xid, pTcon, full_path, pfindData,
Steve Frenchacf1a1b2006-10-12 03:28:28 +0000630 0 /* not legacy */,
Steve French6b8edfe2005-08-23 20:26:03 -0700631 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700632 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French6b8edfe2005-08-23 20:26:03 -0700633 /* BB optimize code so we do not make the above call
634 when server claims no NT SMB support and the above call
635 failed at least once - set flag in tcon or mount */
Steve French4523cc32007-04-30 20:13:06 +0000636 if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
Igor Mammedov79626702008-03-09 03:44:18 +0000637 rc = SMBQueryInformation(xid, pTcon, full_path,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000638 pfindData, cifs_sb->local_nls,
Steve French6b8edfe2005-08-23 20:26:03 -0700639 cifs_sb->mnt_cifs_flags &
640 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French4b18f2a2008-04-29 00:06:05 +0000641 adjustTZ = true;
Steve French6b8edfe2005-08-23 20:26:03 -0700642 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400644
645 if (!rc) {
646 cifs_all_info_to_fattr(&fattr, (FILE_ALL_INFO *) pfindData,
647 cifs_sb, adjustTZ);
648 } else if (rc == -EREMOTE) {
649 cifs_create_dfs_fattr(&fattr, sb);
Steve Frenchb9a32602008-05-20 21:52:32 +0000650 rc = 0;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400651 } else {
Igor Mammedov79626702008-03-09 03:44:18 +0000652 goto cgii_exit;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400653 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400655 /*
656 * If an inode wasn't passed in, then get the inode number
657 *
658 * Is an i_ino of zero legal? Can we use that to check if the server
659 * supports returning inode numbers? Are there other sanity checks we
660 * can use to ensure that the server is really filling in that field?
661 *
662 * We can not use the IndexNumber field by default from Windows or
663 * Samba (in ALL_INFO buf) but we can request it explicitly. The SNIA
664 * CIFS spec claims that this value is unique within the scope of a
665 * share, and the windows docs hint that it's actually unique
666 * per-machine.
667 *
668 * There may be higher info levels that work but are there Windows
669 * server or network appliances for which IndexNumber field is not
670 * guaranteed unique?
671 */
Steve Frenchb9a32602008-05-20 21:52:32 +0000672 if (*pinode == NULL) {
Steve Frenchb9a32602008-05-20 21:52:32 +0000673 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
674 int rc1 = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675
Steve Frenchb9a32602008-05-20 21:52:32 +0000676 rc1 = CIFSGetSrvInodeNumber(xid, pTcon,
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400677 full_path, &fattr.cf_uniqueid,
Steve French737b7582005-04-28 22:41:06 -0700678 cifs_sb->local_nls,
679 cifs_sb->mnt_cifs_flags &
680 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Laytonec06aed2009-11-06 14:18:29 -0500681 if (rc1 || !fattr.cf_uniqueid) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000682 cFYI(1, "GetSrvInodeNum rc %d", rc1);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400683 fattr.cf_uniqueid = iunique(sb, ROOT_I);
Jeff Laytonec06aed2009-11-06 14:18:29 -0500684 cifs_autodisable_serverino(cifs_sb);
Jeff Layton132ac7b2009-02-10 07:33:57 -0500685 }
Jeff Layton132ac7b2009-02-10 07:33:57 -0500686 } else {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400687 fattr.cf_uniqueid = iunique(sb, ROOT_I);
Jeff Layton132ac7b2009-02-10 07:33:57 -0500688 }
Steve Frenchb9a32602008-05-20 21:52:32 +0000689 } else {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400690 fattr.cf_uniqueid = CIFS_I(*pinode)->uniqueid;
Steve Frenchb9a32602008-05-20 21:52:32 +0000691 }
692
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400693 /* query for SFU type info if supported and needed */
694 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
695 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
696 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
697 if (tmprc)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000698 cFYI(1, "cifs_sfu_type failed: %d", tmprc);
Steve Frenchb9a32602008-05-20 21:52:32 +0000699 }
Steve Frenchb9a32602008-05-20 21:52:32 +0000700
Jeff Layton79df1ba2010-12-06 12:52:08 -0500701#ifdef CONFIG_CIFS_ACL
Steve Frenchb9a32602008-05-20 21:52:32 +0000702 /* fill in 0777 bits from ACL */
703 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
Shirish Pargaonkar78415d22010-11-27 11:37:26 -0600704 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *pinode, full_path,
705 pfid);
706 if (rc) {
707 cFYI(1, "%s: Getting ACL failed with error: %d",
708 __func__, rc);
709 goto cgii_exit;
710 }
Steve Frenchb9a32602008-05-20 21:52:32 +0000711 }
Jeff Layton79df1ba2010-12-06 12:52:08 -0500712#endif /* CONFIG_CIFS_ACL */
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400713
714 /* fill in remaining high mode bits e.g. SUID, VTX */
715 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
716 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
717
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200718 /* check for Minshall+French symlinks */
719 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
720 tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
721 if (tmprc)
722 cFYI(1, "CIFSCheckMFSymlink: %d", tmprc);
723 }
724
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400725 if (!*pinode) {
726 *pinode = cifs_iget(sb, &fattr);
727 if (!*pinode)
728 rc = -ENOMEM;
729 } else {
730 cifs_fattr_to_inode(*pinode, &fattr);
Steve Frenchb9a32602008-05-20 21:52:32 +0000731 }
732
Igor Mammedov79626702008-03-09 03:44:18 +0000733cgii_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 kfree(buf);
Jeff Layton7ffec372010-09-29 19:51:11 -0400735 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 return rc;
737}
738
Steve French7f8ed422007-09-28 22:28:55 +0000739static const struct inode_operations cifs_ipc_inode_ops = {
740 .lookup = cifs_lookup,
741};
742
Steve Frenchf87d39d2011-05-27 03:50:55 +0000743char *cifs_build_path_to_root(struct smb_vol *vol, struct cifs_sb_info *cifs_sb,
Steve French96daf2b2011-05-27 04:34:02 +0000744 struct cifs_tcon *tcon)
Steve French8be0ed42008-12-05 19:14:12 +0000745{
Steve Frenchf87d39d2011-05-27 03:50:55 +0000746 int pplen = vol->prepath ? strlen(vol->prepath) : 0;
Steve French8be0ed42008-12-05 19:14:12 +0000747 int dfsplen;
748 char *full_path = NULL;
749
750 /* if no prefix path, simply set path to the root of share to "" */
751 if (pplen == 0) {
752 full_path = kmalloc(1, GFP_KERNEL);
753 if (full_path)
754 full_path[0] = 0;
755 return full_path;
756 }
757
Jeff Layton0d424ad2010-09-20 16:01:35 -0700758 if (tcon->Flags & SMB_SHARE_IS_IN_DFS)
759 dfsplen = strnlen(tcon->treeName, MAX_TREE_SIZE + 1);
Steve French8be0ed42008-12-05 19:14:12 +0000760 else
761 dfsplen = 0;
762
763 full_path = kmalloc(dfsplen + pplen + 1, GFP_KERNEL);
764 if (full_path == NULL)
765 return full_path;
766
767 if (dfsplen) {
Jeff Layton0d424ad2010-09-20 16:01:35 -0700768 strncpy(full_path, tcon->treeName, dfsplen);
Steve French8be0ed42008-12-05 19:14:12 +0000769 /* switch slash direction in prepath depending on whether
770 * windows or posix style path names
771 */
772 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
773 int i;
774 for (i = 0; i < dfsplen; i++) {
775 if (full_path[i] == '\\')
776 full_path[i] = '/';
777 }
778 }
779 }
Steve Frenchf87d39d2011-05-27 03:50:55 +0000780 strncpy(full_path + dfsplen, vol->prepath, pplen);
Steve French8be0ed42008-12-05 19:14:12 +0000781 full_path[dfsplen + pplen] = 0; /* add trailing null */
782 return full_path;
783}
784
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400785static int
786cifs_find_inode(struct inode *inode, void *opaque)
787{
788 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
789
Jeff Laytonf30b9c12010-07-19 18:00:17 -0400790 /* don't match inode with different uniqueid */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400791 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
792 return 0;
793
Jeff Layton20054bd2011-01-07 11:30:27 -0500794 /* use createtime like an i_generation field */
795 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
796 return 0;
797
Jeff Laytonf30b9c12010-07-19 18:00:17 -0400798 /* don't match inode of different type */
799 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
800 return 0;
801
Jeff Layton5acfec22010-08-02 17:43:54 -0400802 /* if it's not a directory or has no dentries, then flag it */
803 if (S_ISDIR(inode->i_mode) && !list_empty(&inode->i_dentry))
Jeff Layton3d694382010-05-11 14:59:55 -0400804 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
Jeff Layton3d694382010-05-11 14:59:55 -0400805
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400806 return 1;
807}
808
809static int
810cifs_init_inode(struct inode *inode, void *opaque)
811{
812 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
813
814 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
Jeff Layton20054bd2011-01-07 11:30:27 -0500815 CIFS_I(inode)->createtime = fattr->cf_createtime;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400816 return 0;
817}
818
Jeff Layton5acfec22010-08-02 17:43:54 -0400819/*
820 * walk dentry list for an inode and report whether it has aliases that
821 * are hashed. We use this to determine if a directory inode can actually
822 * be used.
823 */
824static bool
825inode_has_hashed_dentries(struct inode *inode)
826{
827 struct dentry *dentry;
828
Nick Piggin873feea2011-01-07 17:50:06 +1100829 spin_lock(&inode->i_lock);
Jeff Layton5acfec22010-08-02 17:43:54 -0400830 list_for_each_entry(dentry, &inode->i_dentry, d_alias) {
831 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
Nick Piggin873feea2011-01-07 17:50:06 +1100832 spin_unlock(&inode->i_lock);
Jeff Layton5acfec22010-08-02 17:43:54 -0400833 return true;
834 }
835 }
Nick Piggin873feea2011-01-07 17:50:06 +1100836 spin_unlock(&inode->i_lock);
Jeff Layton5acfec22010-08-02 17:43:54 -0400837 return false;
838}
839
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400840/* Given fattrs, get a corresponding inode */
841struct inode *
842cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
843{
844 unsigned long hash;
845 struct inode *inode;
846
Jeff Layton3d694382010-05-11 14:59:55 -0400847retry_iget5_locked:
Joe Perchesb6b38f72010-04-21 03:50:45 +0000848 cFYI(1, "looking for uniqueid=%llu", fattr->cf_uniqueid);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400849
850 /* hash down to 32-bits on 32-bit arch */
851 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
852
853 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400854 if (inode) {
Jeff Layton5acfec22010-08-02 17:43:54 -0400855 /* was there a potentially problematic inode collision? */
Jeff Layton3d694382010-05-11 14:59:55 -0400856 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
Jeff Layton3d694382010-05-11 14:59:55 -0400857 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
Jeff Layton5acfec22010-08-02 17:43:54 -0400858
859 if (inode_has_hashed_dentries(inode)) {
860 cifs_autodisable_serverino(CIFS_SB(sb));
861 iput(inode);
862 fattr->cf_uniqueid = iunique(sb, ROOT_I);
863 goto retry_iget5_locked;
864 }
Jeff Layton3d694382010-05-11 14:59:55 -0400865 }
866
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400867 cifs_fattr_to_inode(inode, fattr);
868 if (sb->s_flags & MS_NOATIME)
869 inode->i_flags |= S_NOATIME | S_NOCMTIME;
870 if (inode->i_state & I_NEW) {
871 inode->i_ino = hash;
Jeff Layton522440e2010-09-29 09:49:54 -0400872 if (S_ISREG(inode->i_mode))
873 inode->i_data.backing_dev_info = sb->s_bdi;
Steve French0ccd4802010-07-16 04:31:02 +0000874#ifdef CONFIG_CIFS_FSCACHE
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530875 /* initialize per-inode cache cookie pointer */
876 CIFS_I(inode)->fscache = NULL;
Steve French0ccd4802010-07-16 04:31:02 +0000877#endif
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400878 unlock_new_inode(inode);
879 }
880 }
881
882 return inode;
883}
884
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885/* gets root inode */
Shirish Pargaonkar9b6763e2011-02-21 23:56:59 -0600886struct inode *cifs_root_iget(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887{
David Howellsce634ab2008-02-07 00:15:33 -0800888 int xid;
Jeff Layton0d424ad2010-09-20 16:01:35 -0700889 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400890 struct inode *inode = NULL;
David Howellsce634ab2008-02-07 00:15:33 -0800891 long rc;
Steve French96daf2b2011-05-27 04:34:02 +0000892 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
David Howellsce634ab2008-02-07 00:15:33 -0800893
Steve French8be0ed42008-12-05 19:14:12 +0000894 xid = GetXid();
Jeff Layton0d424ad2010-09-20 16:01:35 -0700895 if (tcon->unix_ext)
Steve Frenchf87d39d2011-05-27 03:50:55 +0000896 rc = cifs_get_inode_info_unix(&inode, "", sb, xid);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400897 else
Steve Frenchf87d39d2011-05-27 03:50:55 +0000898 rc = cifs_get_inode_info(&inode, "", NULL, sb, xid, NULL);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400899
Oskar Schirmera7851ce2010-11-10 21:06:13 +0000900 if (!inode) {
901 inode = ERR_PTR(rc);
902 goto out;
903 }
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400904
Steve French0ccd4802010-07-16 04:31:02 +0000905#ifdef CONFIG_CIFS_FSCACHE
Suresh Jayaramand03382c2010-07-05 18:12:27 +0530906 /* populate tcon->resource_id */
Jeff Layton0d424ad2010-09-20 16:01:35 -0700907 tcon->resource_id = CIFS_I(inode)->uniqueid;
Steve French0ccd4802010-07-16 04:31:02 +0000908#endif
Suresh Jayaramand03382c2010-07-05 18:12:27 +0530909
Jeff Layton0d424ad2010-09-20 16:01:35 -0700910 if (rc && tcon->ipc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000911 cFYI(1, "ipc connection - fake read inode");
Steve French7f8ed422007-09-28 22:28:55 +0000912 inode->i_mode |= S_IFDIR;
913 inode->i_nlink = 2;
914 inode->i_op = &cifs_ipc_inode_ops;
915 inode->i_fop = &simple_dir_operations;
916 inode->i_uid = cifs_sb->mnt_uid;
917 inode->i_gid = cifs_sb->mnt_gid;
Steve Frenchad661332008-08-12 14:14:40 +0000918 } else if (rc) {
David Howellsce634ab2008-02-07 00:15:33 -0800919 iget_failed(inode);
Oskar Schirmera7851ce2010-11-10 21:06:13 +0000920 inode = ERR_PTR(rc);
Steve French7f8ed422007-09-28 22:28:55 +0000921 }
922
Oskar Schirmera7851ce2010-11-10 21:06:13 +0000923out:
David Howellsce634ab2008-02-07 00:15:33 -0800924 /* can not call macro FreeXid here since in a void func
925 * TODO: This is no longer true
926 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 _FreeXid(xid);
David Howellsce634ab2008-02-07 00:15:33 -0800928 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929}
930
Steve French388e57b2008-09-16 23:50:58 +0000931static int
932cifs_set_file_info(struct inode *inode, struct iattr *attrs, int xid,
933 char *full_path, __u32 dosattr)
934{
935 int rc;
936 int oplock = 0;
937 __u16 netfid;
938 __u32 netpid;
939 bool set_time = false;
940 struct cifsFileInfo *open_file;
941 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
942 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400943 struct tcon_link *tlink = NULL;
Steve French96daf2b2011-05-27 04:34:02 +0000944 struct cifs_tcon *pTcon;
Steve French388e57b2008-09-16 23:50:58 +0000945 FILE_BASIC_INFO info_buf;
946
Steve French1adcb712009-02-25 14:19:56 +0000947 if (attrs == NULL)
948 return -EINVAL;
949
Steve French388e57b2008-09-16 23:50:58 +0000950 if (attrs->ia_valid & ATTR_ATIME) {
951 set_time = true;
952 info_buf.LastAccessTime =
953 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
954 } else
955 info_buf.LastAccessTime = 0;
956
957 if (attrs->ia_valid & ATTR_MTIME) {
958 set_time = true;
959 info_buf.LastWriteTime =
960 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
961 } else
962 info_buf.LastWriteTime = 0;
963
964 /*
965 * Samba throws this field away, but windows may actually use it.
966 * Do not set ctime unless other time stamps are changed explicitly
967 * (i.e. by utimes()) since we would then have a mix of client and
968 * server times.
969 */
970 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000971 cFYI(1, "CIFS - CTIME changed");
Steve French388e57b2008-09-16 23:50:58 +0000972 info_buf.ChangeTime =
973 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
974 } else
975 info_buf.ChangeTime = 0;
976
977 info_buf.CreationTime = 0; /* don't change */
978 info_buf.Attributes = cpu_to_le32(dosattr);
979
980 /*
981 * If the file is already open for write, just use that fileid
982 */
Jeff Layton6508d902010-09-29 19:51:11 -0400983 open_file = find_writable_file(cifsInode, true);
Steve French388e57b2008-09-16 23:50:58 +0000984 if (open_file) {
985 netfid = open_file->netfid;
986 netpid = open_file->pid;
Jeff Layton13cfb732010-09-29 19:51:11 -0400987 pTcon = tlink_tcon(open_file->tlink);
Steve French388e57b2008-09-16 23:50:58 +0000988 goto set_via_filehandle;
989 }
990
Jeff Layton7ffec372010-09-29 19:51:11 -0400991 tlink = cifs_sb_tlink(cifs_sb);
992 if (IS_ERR(tlink)) {
993 rc = PTR_ERR(tlink);
994 tlink = NULL;
995 goto out;
996 }
997 pTcon = tlink_tcon(tlink);
Jeff Laytonba00ba62010-09-20 16:01:31 -0700998
Steve French388e57b2008-09-16 23:50:58 +0000999 /*
1000 * NT4 apparently returns success on this call, but it doesn't
1001 * really work.
1002 */
1003 if (!(pTcon->ses->flags & CIFS_SES_NT4)) {
1004 rc = CIFSSMBSetPathInfo(xid, pTcon, full_path,
1005 &info_buf, cifs_sb->local_nls,
1006 cifs_sb->mnt_cifs_flags &
1007 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton6b37faa2008-10-06 21:54:41 +00001008 if (rc == 0) {
1009 cifsInode->cifsAttrs = dosattr;
1010 goto out;
1011 } else if (rc != -EOPNOTSUPP && rc != -EINVAL)
Steve French388e57b2008-09-16 23:50:58 +00001012 goto out;
1013 }
1014
Joe Perchesb6b38f72010-04-21 03:50:45 +00001015 cFYI(1, "calling SetFileInfo since SetPathInfo for "
1016 "times not supported by this server");
Steve French388e57b2008-09-16 23:50:58 +00001017 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
1018 SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
1019 CREATE_NOT_DIR, &netfid, &oplock,
1020 NULL, cifs_sb->local_nls,
1021 cifs_sb->mnt_cifs_flags &
1022 CIFS_MOUNT_MAP_SPECIAL_CHR);
1023
1024 if (rc != 0) {
1025 if (rc == -EIO)
1026 rc = -EINVAL;
1027 goto out;
1028 }
1029
1030 netpid = current->tgid;
1031
1032set_via_filehandle:
1033 rc = CIFSSMBSetFileInfo(xid, pTcon, &info_buf, netfid, netpid);
Steve Frenchd3889082008-09-24 19:22:52 +00001034 if (!rc)
1035 cifsInode->cifsAttrs = dosattr;
1036
Steve French388e57b2008-09-16 23:50:58 +00001037 if (open_file == NULL)
1038 CIFSSMBClose(xid, pTcon, netfid);
1039 else
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001040 cifsFileInfo_put(open_file);
Steve French388e57b2008-09-16 23:50:58 +00001041out:
Jeff Layton7ffec372010-09-29 19:51:11 -04001042 if (tlink != NULL)
1043 cifs_put_tlink(tlink);
Steve French388e57b2008-09-16 23:50:58 +00001044 return rc;
1045}
1046
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001047/*
1048 * open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1049 * and rename it to a random name that hopefully won't conflict with
1050 * anything else.
1051 */
1052static int
Steve French32709582008-10-20 00:44:19 +00001053cifs_rename_pending_delete(char *full_path, struct dentry *dentry, int xid)
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001054{
1055 int oplock = 0;
1056 int rc;
1057 __u16 netfid;
Steve French32709582008-10-20 00:44:19 +00001058 struct inode *inode = dentry->d_inode;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001059 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1060 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001061 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001062 struct cifs_tcon *tcon;
Steve French32709582008-10-20 00:44:19 +00001063 __u32 dosattr, origattr;
1064 FILE_BASIC_INFO *info_buf = NULL;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001065
Jeff Layton7ffec372010-09-29 19:51:11 -04001066 tlink = cifs_sb_tlink(cifs_sb);
1067 if (IS_ERR(tlink))
1068 return PTR_ERR(tlink);
1069 tcon = tlink_tcon(tlink);
1070
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001071 rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
Jeff Laytondd1db2d2008-10-16 19:27:12 -04001072 DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001073 &netfid, &oplock, NULL, cifs_sb->local_nls,
1074 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1075 if (rc != 0)
1076 goto out;
1077
Steve French32709582008-10-20 00:44:19 +00001078 origattr = cifsInode->cifsAttrs;
1079 if (origattr == 0)
1080 origattr |= ATTR_NORMAL;
1081
1082 dosattr = origattr & ~ATTR_READONLY;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001083 if (dosattr == 0)
1084 dosattr |= ATTR_NORMAL;
1085 dosattr |= ATTR_HIDDEN;
1086
Steve French32709582008-10-20 00:44:19 +00001087 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1088 if (dosattr != origattr) {
1089 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1090 if (info_buf == NULL) {
1091 rc = -ENOMEM;
1092 goto out_close;
1093 }
1094 info_buf->Attributes = cpu_to_le32(dosattr);
1095 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1096 current->tgid);
1097 /* although we would like to mark the file hidden
1098 if that fails we will still try to rename it */
Steve French41346092008-10-20 18:24:42 +00001099 if (rc != 0)
Steve French32709582008-10-20 00:44:19 +00001100 cifsInode->cifsAttrs = dosattr;
1101 else
1102 dosattr = origattr; /* since not able to change them */
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001103 }
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001104
Jeff Laytondd1db2d2008-10-16 19:27:12 -04001105 /* rename the file */
1106 rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001107 cifs_sb->mnt_cifs_flags &
1108 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French32709582008-10-20 00:44:19 +00001109 if (rc != 0) {
1110 rc = -ETXTBSY;
1111 goto undo_setattr;
1112 }
Jeff Layton6d22f092008-09-23 11:48:35 -04001113
Steve French32709582008-10-20 00:44:19 +00001114 /* try to set DELETE_ON_CLOSE */
1115 if (!cifsInode->delete_pending) {
1116 rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
1117 current->tgid);
1118 /*
1119 * some samba versions return -ENOENT when we try to set the
1120 * file disposition here. Likely a samba bug, but work around
1121 * it for now. This means that some cifsXXX files may hang
1122 * around after they shouldn't.
1123 *
1124 * BB: remove this hack after more servers have the fix
1125 */
1126 if (rc == -ENOENT)
1127 rc = 0;
1128 else if (rc != 0) {
1129 rc = -ETXTBSY;
1130 goto undo_rename;
1131 }
1132 cifsInode->delete_pending = true;
1133 }
Jeff Layton7ce86d52008-09-24 11:32:59 -04001134
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001135out_close:
1136 CIFSSMBClose(xid, tcon, netfid);
1137out:
Steve French32709582008-10-20 00:44:19 +00001138 kfree(info_buf);
Jeff Layton7ffec372010-09-29 19:51:11 -04001139 cifs_put_tlink(tlink);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001140 return rc;
Steve French32709582008-10-20 00:44:19 +00001141
1142 /*
1143 * reset everything back to the original state. Don't bother
1144 * dealing with errors here since we can't do anything about
1145 * them anyway.
1146 */
1147undo_rename:
1148 CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
1149 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1150 CIFS_MOUNT_MAP_SPECIAL_CHR);
1151undo_setattr:
1152 if (dosattr != origattr) {
1153 info_buf->Attributes = cpu_to_le32(origattr);
1154 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1155 current->tgid))
1156 cifsInode->cifsAttrs = origattr;
1157 }
1158
1159 goto out_close;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001160}
1161
Steve Frenchff694522009-04-20 19:45:13 +00001162
1163/*
1164 * If dentry->d_inode is null (usually meaning the cached dentry
1165 * is a negative dentry) then we would attempt a standard SMB delete, but
André Goddard Rosaaf901ca2009-11-14 13:09:05 -02001166 * if that fails we can not attempt the fall back mechanisms on EACCESS
1167 * but will return the EACCESS to the caller. Note that the VFS does not call
Steve Frenchff694522009-04-20 19:45:13 +00001168 * unlink on negative dentries currently.
1169 */
Jeff Layton5f0319a2008-09-16 14:05:16 -04001170int cifs_unlink(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171{
1172 int rc = 0;
1173 int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174 char *full_path = NULL;
Jeff Layton5f0319a2008-09-16 14:05:16 -04001175 struct inode *inode = dentry->d_inode;
Steve Frenchff694522009-04-20 19:45:13 +00001176 struct cifsInodeInfo *cifs_inode;
Jeff Layton5f0319a2008-09-16 14:05:16 -04001177 struct super_block *sb = dir->i_sb;
1178 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001179 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001180 struct cifs_tcon *tcon;
Steve French60502472008-10-07 18:42:52 +00001181 struct iattr *attrs = NULL;
1182 __u32 dosattr = 0, origattr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183
Joe Perchesb6b38f72010-04-21 03:50:45 +00001184 cFYI(1, "cifs_unlink, dir=0x%p, dentry=0x%p", dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185
Jeff Layton7ffec372010-09-29 19:51:11 -04001186 tlink = cifs_sb_tlink(cifs_sb);
1187 if (IS_ERR(tlink))
1188 return PTR_ERR(tlink);
1189 tcon = tlink_tcon(tlink);
1190
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 xid = GetXid();
1192
Jeff Layton5f0319a2008-09-16 14:05:16 -04001193 /* Unlink can be called from rename so we can not take the
1194 * sb->s_vfs_rename_mutex here */
1195 full_path = build_path_from_dentry(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301197 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001198 goto unlink_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 }
Steve French2d785a52007-07-15 01:48:57 +00001200
Jeff Layton5f0319a2008-09-16 14:05:16 -04001201 if ((tcon->ses->capabilities & CAP_UNIX) &&
Steve French2d785a52007-07-15 01:48:57 +00001202 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
Jeff Layton5f0319a2008-09-16 14:05:16 -04001203 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1204 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
Steve French2d785a52007-07-15 01:48:57 +00001205 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1206 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001207 cFYI(1, "posix del rc %d", rc);
Steve French2d785a52007-07-15 01:48:57 +00001208 if ((rc == 0) || (rc == -ENOENT))
1209 goto psx_del_no_retry;
1210 }
1211
Steve French60502472008-10-07 18:42:52 +00001212retry_std_delete:
Jeff Layton5f0319a2008-09-16 14:05:16 -04001213 rc = CIFSSMBDelFile(xid, tcon, full_path, cifs_sb->local_nls,
Steve French737b7582005-04-28 22:41:06 -07001214 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French60502472008-10-07 18:42:52 +00001215
Steve French2d785a52007-07-15 01:48:57 +00001216psx_del_no_retry:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217 if (!rc) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001218 if (inode)
1219 drop_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220 } else if (rc == -ENOENT) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001221 d_drop(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 } else if (rc == -ETXTBSY) {
Steve French32709582008-10-20 00:44:19 +00001223 rc = cifs_rename_pending_delete(full_path, dentry, xid);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001224 if (rc == 0)
1225 drop_nlink(inode);
Steve Frenchff694522009-04-20 19:45:13 +00001226 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
Steve French388e57b2008-09-16 23:50:58 +00001227 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1228 if (attrs == NULL) {
1229 rc = -ENOMEM;
1230 goto out_reval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231 }
Steve French388e57b2008-09-16 23:50:58 +00001232
1233 /* try to reset dos attributes */
Steve Frenchff694522009-04-20 19:45:13 +00001234 cifs_inode = CIFS_I(inode);
1235 origattr = cifs_inode->cifsAttrs;
Steve French60502472008-10-07 18:42:52 +00001236 if (origattr == 0)
1237 origattr |= ATTR_NORMAL;
1238 dosattr = origattr & ~ATTR_READONLY;
Steve French388e57b2008-09-16 23:50:58 +00001239 if (dosattr == 0)
1240 dosattr |= ATTR_NORMAL;
1241 dosattr |= ATTR_HIDDEN;
1242
1243 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
Steve French388e57b2008-09-16 23:50:58 +00001244 if (rc != 0)
1245 goto out_reval;
Steve French60502472008-10-07 18:42:52 +00001246
1247 goto retry_std_delete;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248 }
Steve French60502472008-10-07 18:42:52 +00001249
1250 /* undo the setattr if we errored out and it's needed */
1251 if (rc != 0 && dosattr != 0)
1252 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1253
Steve French388e57b2008-09-16 23:50:58 +00001254out_reval:
Jeff Layton5f0319a2008-09-16 14:05:16 -04001255 if (inode) {
Steve Frenchff694522009-04-20 19:45:13 +00001256 cifs_inode = CIFS_I(inode);
1257 cifs_inode->time = 0; /* will force revalidate to get info
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001258 when needed */
Jeff Layton5f0319a2008-09-16 14:05:16 -04001259 inode->i_ctime = current_fs_time(sb);
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001260 }
Jeff Layton5f0319a2008-09-16 14:05:16 -04001261 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
Steve Frenchff694522009-04-20 19:45:13 +00001262 cifs_inode = CIFS_I(dir);
Steve French60502472008-10-07 18:42:52 +00001263 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
Jeff Layton7ffec372010-09-29 19:51:11 -04001264unlink_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 kfree(full_path);
Steve French60502472008-10-07 18:42:52 +00001266 kfree(attrs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 FreeXid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001268 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 return rc;
1270}
1271
1272int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
1273{
Jeff Layton6b37faa2008-10-06 21:54:41 +00001274 int rc = 0, tmprc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 int xid;
1276 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001277 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001278 struct cifs_tcon *pTcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279 char *full_path = NULL;
1280 struct inode *newinode = NULL;
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001281 struct cifs_fattr fattr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282
Joe Perchesb6b38f72010-04-21 03:50:45 +00001283 cFYI(1, "In cifs_mkdir, mode = 0x%x inode = 0x%p", mode, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001286 tlink = cifs_sb_tlink(cifs_sb);
1287 if (IS_ERR(tlink))
1288 return PTR_ERR(tlink);
1289 pTcon = tlink_tcon(tlink);
1290
1291 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292
Steve French7f573562005-08-30 11:32:14 -07001293 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301295 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001296 goto mkdir_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297 }
Steve French50c2f752007-07-13 00:33:32 +00001298
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001299 if ((pTcon->ses->capabilities & CAP_UNIX) &&
1300 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
Steve French2dd29d32007-04-23 22:07:35 +00001301 le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
1302 u32 oplock = 0;
Steve Frenchf6d09982008-01-08 23:18:22 +00001303 FILE_UNIX_BASIC_INFO *pInfo =
Steve French2dd29d32007-04-23 22:07:35 +00001304 kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001305 if (pInfo == NULL) {
Steve French2dd29d32007-04-23 22:07:35 +00001306 rc = -ENOMEM;
1307 goto mkdir_out;
1308 }
Steve French50c2f752007-07-13 00:33:32 +00001309
Al Viroce3b0f82009-03-29 19:08:22 -04001310 mode &= ~current_umask();
Steve French2dd29d32007-04-23 22:07:35 +00001311 rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
1312 mode, NULL /* netfid */, pInfo, &oplock,
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001313 full_path, cifs_sb->local_nls,
1314 cifs_sb->mnt_cifs_flags &
Steve French2dd29d32007-04-23 22:07:35 +00001315 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve Frenchc45d7072007-09-17 02:04:21 +00001316 if (rc == -EOPNOTSUPP) {
1317 kfree(pInfo);
1318 goto mkdir_retry_old;
1319 } else if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001320 cFYI(1, "posix mkdir returned 0x%x", rc);
Steve French2dd29d32007-04-23 22:07:35 +00001321 d_drop(direntry);
1322 } else {
Cyril Gorcunov8f2376a2007-10-14 17:58:43 +00001323 if (pInfo->Type == cpu_to_le32(-1)) {
1324 /* no return info, go query for it */
Steve French5a07cdf2007-09-16 23:12:47 +00001325 kfree(pInfo);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001326 goto mkdir_get_info;
Steve French5a07cdf2007-09-16 23:12:47 +00001327 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001328/*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
1329 to set uid/gid */
Steve French2dd29d32007-04-23 22:07:35 +00001330 inc_nlink(inode);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001331
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001332 cifs_unix_basic_to_fattr(&fattr, pInfo, cifs_sb);
Jeff Layton4065c802010-05-17 07:18:58 -04001333 cifs_fill_uniqueid(inode->i_sb, &fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001334 newinode = cifs_iget(inode->i_sb, &fattr);
1335 if (!newinode) {
Steve French5a07cdf2007-09-16 23:12:47 +00001336 kfree(pInfo);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001337 goto mkdir_get_info;
Steve French5a07cdf2007-09-16 23:12:47 +00001338 }
Jeff Layton6b37faa2008-10-06 21:54:41 +00001339
Steve French2dd29d32007-04-23 22:07:35 +00001340 d_instantiate(direntry, newinode);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001341
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001342#ifdef CONFIG_CIFS_DEBUG2
Joe Perchesb6b38f72010-04-21 03:50:45 +00001343 cFYI(1, "instantiated dentry %p %s to inode %p",
1344 direntry, direntry->d_name.name, newinode);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001345
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001346 if (newinode->i_nlink != 2)
Joe Perchesb6b38f72010-04-21 03:50:45 +00001347 cFYI(1, "unexpected number of links %d",
1348 newinode->i_nlink);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001349#endif
Steve French2dd29d32007-04-23 22:07:35 +00001350 }
1351 kfree(pInfo);
1352 goto mkdir_out;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001353 }
Steve Frenchc45d7072007-09-17 02:04:21 +00001354mkdir_retry_old:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 /* BB add setting the equivalent of mode via CreateX w/ACLs */
Steve French737b7582005-04-28 22:41:06 -07001356 rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
1357 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001359 cFYI(1, "cifs_mkdir returned 0x%x", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 d_drop(direntry);
1361 } else {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001362mkdir_get_info:
Dave Hansend8c76e62006-09-30 23:29:04 -07001363 inc_nlink(inode);
Steve Frenchc18c8422007-07-18 23:21:09 +00001364 if (pTcon->unix_ext)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 rc = cifs_get_inode_info_unix(&newinode, full_path,
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001366 inode->i_sb, xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 else
1368 rc = cifs_get_inode_info(&newinode, full_path, NULL,
Steve French8b1327f2008-03-14 22:37:16 +00001369 inode->i_sb, xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 d_instantiate(direntry, newinode);
Steve French2dd29d32007-04-23 22:07:35 +00001372 /* setting nlink not necessary except in cases where we
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001373 * failed to get it from the server or was set bogus */
Steve French2dd29d32007-04-23 22:07:35 +00001374 if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001375 direntry->d_inode->i_nlink = 2;
Jeff Layton95089912008-08-06 04:39:02 +00001376
Al Viroce3b0f82009-03-29 19:08:22 -04001377 mode &= ~current_umask();
Jeff Layton95089912008-08-06 04:39:02 +00001378 /* must turn on setgid bit if parent dir has it */
1379 if (inode->i_mode & S_ISGID)
1380 mode |= S_ISGID;
1381
Steve Frenchc18c8422007-07-18 23:21:09 +00001382 if (pTcon->unix_ext) {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04001383 struct cifs_unix_set_info_args args = {
1384 .mode = mode,
1385 .ctime = NO_CHANGE_64,
1386 .atime = NO_CHANGE_64,
1387 .mtime = NO_CHANGE_64,
1388 .device = 0,
1389 };
Steve Frenchd0d2f2d2005-06-02 15:12:36 -07001390 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
David Howellsa001e5b2008-11-14 10:38:47 +11001391 args.uid = (__u64)current_fsuid();
Jeff Layton95089912008-08-06 04:39:02 +00001392 if (inode->i_mode & S_ISGID)
1393 args.gid = (__u64)inode->i_gid;
1394 else
David Howellsa001e5b2008-11-14 10:38:47 +11001395 args.gid = (__u64)current_fsgid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396 } else {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04001397 args.uid = NO_CHANGE_64;
1398 args.gid = NO_CHANGE_64;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399 }
Jeff Layton01ea95e2009-07-09 20:02:49 -04001400 CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
1401 cifs_sb->local_nls,
1402 cifs_sb->mnt_cifs_flags &
1403 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French3ce53fc2007-06-08 14:55:14 +00001404 } else {
Jeff Layton67750fb2008-05-09 22:28:02 +00001405 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1406 (mode & S_IWUGO) == 0) {
1407 FILE_BASIC_INFO pInfo;
Jeff Layton6b37faa2008-10-06 21:54:41 +00001408 struct cifsInodeInfo *cifsInode;
1409 u32 dosattrs;
1410
Jeff Layton67750fb2008-05-09 22:28:02 +00001411 memset(&pInfo, 0, sizeof(pInfo));
Jeff Layton6b37faa2008-10-06 21:54:41 +00001412 cifsInode = CIFS_I(newinode);
1413 dosattrs = cifsInode->cifsAttrs|ATTR_READONLY;
1414 pInfo.Attributes = cpu_to_le32(dosattrs);
1415 tmprc = CIFSSMBSetPathInfo(xid, pTcon,
1416 full_path, &pInfo,
1417 cifs_sb->local_nls,
Jeff Layton67750fb2008-05-09 22:28:02 +00001418 cifs_sb->mnt_cifs_flags &
1419 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton6b37faa2008-10-06 21:54:41 +00001420 if (tmprc == 0)
1421 cifsInode->cifsAttrs = dosattrs;
Jeff Layton67750fb2008-05-09 22:28:02 +00001422 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001423 if (direntry->d_inode) {
Jeff Laytonb0fd30d2008-05-22 09:33:34 -04001424 if (cifs_sb->mnt_cifs_flags &
1425 CIFS_MOUNT_DYNPERM)
1426 direntry->d_inode->i_mode =
1427 (mode | S_IFDIR);
Steve French4e94a102008-05-23 18:22:46 +00001428
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001429 if (cifs_sb->mnt_cifs_flags &
Steve French6473a552005-11-29 20:20:10 -08001430 CIFS_MOUNT_SET_UID) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001431 direntry->d_inode->i_uid =
David Howellsa001e5b2008-11-14 10:38:47 +11001432 current_fsuid();
Jeff Layton95089912008-08-06 04:39:02 +00001433 if (inode->i_mode & S_ISGID)
1434 direntry->d_inode->i_gid =
1435 inode->i_gid;
1436 else
1437 direntry->d_inode->i_gid =
David Howellsa001e5b2008-11-14 10:38:47 +11001438 current_fsgid();
Steve French6473a552005-11-29 20:20:10 -08001439 }
1440 }
Steve French2a138ebb2005-11-29 21:22:19 -08001441 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001443mkdir_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 kfree(full_path);
1445 FreeXid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001446 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447 return rc;
1448}
1449
1450int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1451{
1452 int rc = 0;
1453 int xid;
1454 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001455 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001456 struct cifs_tcon *pTcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 char *full_path = NULL;
1458 struct cifsInodeInfo *cifsInode;
1459
Joe Perchesb6b38f72010-04-21 03:50:45 +00001460 cFYI(1, "cifs_rmdir, inode = 0x%p", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461
1462 xid = GetXid();
1463
Steve French7f573562005-08-30 11:32:14 -07001464 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301466 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001467 goto rmdir_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468 }
1469
Jeff Layton7ffec372010-09-29 19:51:11 -04001470 cifs_sb = CIFS_SB(inode->i_sb);
1471 tlink = cifs_sb_tlink(cifs_sb);
1472 if (IS_ERR(tlink)) {
1473 rc = PTR_ERR(tlink);
1474 goto rmdir_exit;
1475 }
1476 pTcon = tlink_tcon(tlink);
1477
Steve French737b7582005-04-28 22:41:06 -07001478 rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
1479 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton7ffec372010-09-29 19:51:11 -04001480 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481
1482 if (!rc) {
Dave Hansen9a53c3a2006-09-30 23:29:03 -07001483 drop_nlink(inode);
Steve French3677db12007-02-26 16:46:11 +00001484 spin_lock(&direntry->d_inode->i_lock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001485 i_size_write(direntry->d_inode, 0);
Dave Hansence71ec32006-09-30 23:29:06 -07001486 clear_nlink(direntry->d_inode);
Steve French3677db12007-02-26 16:46:11 +00001487 spin_unlock(&direntry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488 }
1489
1490 cifsInode = CIFS_I(direntry->d_inode);
1491 cifsInode->time = 0; /* force revalidate to go get info when
1492 needed */
Steve French42c24542009-01-13 22:03:55 +00001493
1494 cifsInode = CIFS_I(inode);
1495 cifsInode->time = 0; /* force revalidate to get parent dir info
1496 since cached search results now invalid */
1497
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1499 current_fs_time(inode->i_sb);
1500
Jeff Layton7ffec372010-09-29 19:51:11 -04001501rmdir_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502 kfree(full_path);
1503 FreeXid(xid);
1504 return rc;
1505}
1506
Steve Frenchee2fd962008-09-23 18:23:33 +00001507static int
1508cifs_do_rename(int xid, struct dentry *from_dentry, const char *fromPath,
1509 struct dentry *to_dentry, const char *toPath)
1510{
1511 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001512 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001513 struct cifs_tcon *pTcon;
Steve Frenchee2fd962008-09-23 18:23:33 +00001514 __u16 srcfid;
1515 int oplock, rc;
1516
Jeff Layton7ffec372010-09-29 19:51:11 -04001517 tlink = cifs_sb_tlink(cifs_sb);
1518 if (IS_ERR(tlink))
1519 return PTR_ERR(tlink);
1520 pTcon = tlink_tcon(tlink);
1521
Steve Frenchee2fd962008-09-23 18:23:33 +00001522 /* try path-based rename first */
1523 rc = CIFSSMBRename(xid, pTcon, fromPath, toPath, cifs_sb->local_nls,
1524 cifs_sb->mnt_cifs_flags &
1525 CIFS_MOUNT_MAP_SPECIAL_CHR);
1526
1527 /*
1528 * don't bother with rename by filehandle unless file is busy and
1529 * source Note that cross directory moves do not work with
1530 * rename by filehandle to various Windows servers.
1531 */
1532 if (rc == 0 || rc != -ETXTBSY)
Jeff Layton7ffec372010-09-29 19:51:11 -04001533 goto do_rename_exit;
Steve Frenchee2fd962008-09-23 18:23:33 +00001534
Jeff Laytoned0e3ac2010-06-01 16:21:01 -04001535 /* open-file renames don't work across directories */
1536 if (to_dentry->d_parent != from_dentry->d_parent)
Jeff Layton7ffec372010-09-29 19:51:11 -04001537 goto do_rename_exit;
Jeff Laytoned0e3ac2010-06-01 16:21:01 -04001538
Steve Frenchee2fd962008-09-23 18:23:33 +00001539 /* open the file to be renamed -- we need DELETE perms */
1540 rc = CIFSSMBOpen(xid, pTcon, fromPath, FILE_OPEN, DELETE,
1541 CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1542 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1543 CIFS_MOUNT_MAP_SPECIAL_CHR);
1544
1545 if (rc == 0) {
1546 rc = CIFSSMBRenameOpenFile(xid, pTcon, srcfid,
1547 (const char *) to_dentry->d_name.name,
1548 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1549 CIFS_MOUNT_MAP_SPECIAL_CHR);
1550
1551 CIFSSMBClose(xid, pTcon, srcfid);
1552 }
Jeff Layton7ffec372010-09-29 19:51:11 -04001553do_rename_exit:
1554 cifs_put_tlink(tlink);
Steve Frenchee2fd962008-09-23 18:23:33 +00001555 return rc;
1556}
1557
Jeff Layton14121bd2008-10-20 14:45:22 -04001558int cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1559 struct inode *target_dir, struct dentry *target_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560{
Steve Frenchee2fd962008-09-23 18:23:33 +00001561 char *fromName = NULL;
1562 char *toName = NULL;
Jeff Layton639e7a92010-09-03 11:50:09 -04001563 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001564 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001565 struct cifs_tcon *tcon;
Steve Frenchee2fd962008-09-23 18:23:33 +00001566 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1567 FILE_UNIX_BASIC_INFO *info_buf_target;
Jeff Layton8d281ef2008-10-22 13:57:01 -04001568 int xid, rc, tmprc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569
Jeff Layton639e7a92010-09-03 11:50:09 -04001570 cifs_sb = CIFS_SB(source_dir->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001571 tlink = cifs_sb_tlink(cifs_sb);
1572 if (IS_ERR(tlink))
1573 return PTR_ERR(tlink);
1574 tcon = tlink_tcon(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575
Steve Frenchee2fd962008-09-23 18:23:33 +00001576 xid = GetXid();
1577
1578 /*
Steve Frenchee2fd962008-09-23 18:23:33 +00001579 * we already have the rename sem so we do not need to
1580 * grab it again here to protect the path integrity
1581 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001582 fromName = build_path_from_dentry(source_dentry);
Steve Frenchee2fd962008-09-23 18:23:33 +00001583 if (fromName == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 rc = -ENOMEM;
1585 goto cifs_rename_exit;
1586 }
1587
Jeff Layton14121bd2008-10-20 14:45:22 -04001588 toName = build_path_from_dentry(target_dentry);
Steve Frenchee2fd962008-09-23 18:23:33 +00001589 if (toName == NULL) {
1590 rc = -ENOMEM;
1591 goto cifs_rename_exit;
1592 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593
Jeff Layton14121bd2008-10-20 14:45:22 -04001594 rc = cifs_do_rename(xid, source_dentry, fromName,
1595 target_dentry, toName);
Steve Frenchee2fd962008-09-23 18:23:33 +00001596
Jeff Layton14121bd2008-10-20 14:45:22 -04001597 if (rc == -EEXIST && tcon->unix_ext) {
Steve Frenchee2fd962008-09-23 18:23:33 +00001598 /*
Jeff Layton14121bd2008-10-20 14:45:22 -04001599 * Are src and dst hardlinks of same inode? We can
1600 * only tell with unix extensions enabled
Steve Frenchee2fd962008-09-23 18:23:33 +00001601 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001602 info_buf_source =
1603 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1604 GFP_KERNEL);
1605 if (info_buf_source == NULL) {
1606 rc = -ENOMEM;
1607 goto cifs_rename_exit;
1608 }
1609
1610 info_buf_target = info_buf_source + 1;
Jeff Layton8d281ef2008-10-22 13:57:01 -04001611 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, fromName,
Jeff Layton14121bd2008-10-20 14:45:22 -04001612 info_buf_source,
Jeff Layton639e7a92010-09-03 11:50:09 -04001613 cifs_sb->local_nls,
1614 cifs_sb->mnt_cifs_flags &
Jeff Layton14121bd2008-10-20 14:45:22 -04001615 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton8d281ef2008-10-22 13:57:01 -04001616 if (tmprc != 0)
Jeff Layton14121bd2008-10-20 14:45:22 -04001617 goto unlink_target;
1618
Jeff Layton639e7a92010-09-03 11:50:09 -04001619 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, toName,
1620 info_buf_target,
1621 cifs_sb->local_nls,
1622 cifs_sb->mnt_cifs_flags &
Jeff Layton14121bd2008-10-20 14:45:22 -04001623 CIFS_MOUNT_MAP_SPECIAL_CHR);
1624
Jeff Layton8d281ef2008-10-22 13:57:01 -04001625 if (tmprc == 0 && (info_buf_source->UniqueId ==
Jeff Laytonae6884a2008-11-03 14:05:08 -05001626 info_buf_target->UniqueId)) {
Jeff Layton14121bd2008-10-20 14:45:22 -04001627 /* same file, POSIX says that this is a noop */
Jeff Laytonae6884a2008-11-03 14:05:08 -05001628 rc = 0;
Jeff Layton14121bd2008-10-20 14:45:22 -04001629 goto cifs_rename_exit;
Jeff Laytonae6884a2008-11-03 14:05:08 -05001630 }
Jeff Layton14121bd2008-10-20 14:45:22 -04001631 } /* else ... BB we could add the same check for Windows by
1632 checking the UniqueId via FILE_INTERNAL_INFO */
1633
Jeff Layton14121bd2008-10-20 14:45:22 -04001634unlink_target:
Jeff Laytonfc6f3942009-04-17 11:45:30 -04001635 /* Try unlinking the target dentry if it's not negative */
1636 if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
Jeff Layton8d281ef2008-10-22 13:57:01 -04001637 tmprc = cifs_unlink(target_dir, target_dentry);
Jeff Layton14121bd2008-10-20 14:45:22 -04001638 if (tmprc)
1639 goto cifs_rename_exit;
1640
Jeff Layton14121bd2008-10-20 14:45:22 -04001641 rc = cifs_do_rename(xid, source_dentry, fromName,
1642 target_dentry, toName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 }
1644
1645cifs_rename_exit:
Steve Frenchee2fd962008-09-23 18:23:33 +00001646 kfree(info_buf_source);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647 kfree(fromName);
1648 kfree(toName);
1649 FreeXid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001650 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 return rc;
1652}
1653
Jeff Laytondf2cf172010-02-12 07:44:16 -05001654static bool
1655cifs_inode_needs_reval(struct inode *inode)
1656{
1657 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301658 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Laytondf2cf172010-02-12 07:44:16 -05001659
1660 if (cifs_i->clientCanCacheRead)
1661 return false;
1662
1663 if (!lookupCacheEnabled)
1664 return true;
1665
1666 if (cifs_i->time == 0)
1667 return true;
1668
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301669 if (!time_in_range(jiffies, cifs_i->time,
1670 cifs_i->time + cifs_sb->actimeo))
Jeff Laytondf2cf172010-02-12 07:44:16 -05001671 return true;
1672
Jeff Laytondb192722010-05-17 14:51:49 -04001673 /* hardlinked files w/ noserverino get "special" treatment */
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301674 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
Jeff Laytondb192722010-05-17 14:51:49 -04001675 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1676 return true;
1677
Jeff Laytondf2cf172010-02-12 07:44:16 -05001678 return false;
1679}
1680
Suresh Jayaraman523fb8c2010-11-29 22:39:47 +05301681/*
1682 * Zap the cache. Called when invalid_mapping flag is set.
1683 */
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001684int
Jeff Laytondf2cf172010-02-12 07:44:16 -05001685cifs_invalidate_mapping(struct inode *inode)
1686{
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001687 int rc = 0;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001688 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1689
1690 cifs_i->invalid_mapping = false;
1691
Jeff Laytondf2cf172010-02-12 07:44:16 -05001692 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
Pavel Shilovsky257fb1f2011-03-16 01:55:32 +03001693 rc = invalidate_inode_pages2(inode->i_mapping);
1694 if (rc) {
1695 cERROR(1, "%s: could not invalidate inode %p", __func__,
1696 inode);
1697 cifs_i->invalid_mapping = true;
1698 }
Jeff Laytondf2cf172010-02-12 07:44:16 -05001699 }
Pavel Shilovsky257fb1f2011-03-16 01:55:32 +03001700
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +05301701 cifs_fscache_reset_inode_cookie(inode);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001702 return rc;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001703}
1704
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001705int cifs_revalidate_file_attr(struct file *filp)
Jeff Laytonabab0952010-02-12 07:44:18 -05001706{
1707 int rc = 0;
1708 struct inode *inode = filp->f_path.dentry->d_inode;
Jeff Laytonba00ba62010-09-20 16:01:31 -07001709 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
Jeff Laytonabab0952010-02-12 07:44:18 -05001710
1711 if (!cifs_inode_needs_reval(inode))
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001712 return rc;
Jeff Laytonabab0952010-02-12 07:44:18 -05001713
Jeff Layton13cfb732010-09-29 19:51:11 -04001714 if (tlink_tcon(cfile->tlink)->unix_ext)
Jeff Laytonabab0952010-02-12 07:44:18 -05001715 rc = cifs_get_file_info_unix(filp);
1716 else
1717 rc = cifs_get_file_info(filp);
1718
Jeff Laytonabab0952010-02-12 07:44:18 -05001719 return rc;
1720}
1721
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001722int cifs_revalidate_dentry_attr(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723{
1724 int xid;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001725 int rc = 0;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001726 struct inode *inode = dentry->d_inode;
1727 struct super_block *sb = dentry->d_sb;
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001728 char *full_path = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729
Jeff Laytondf2cf172010-02-12 07:44:16 -05001730 if (inode == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731 return -ENOENT;
1732
Jeff Laytondf2cf172010-02-12 07:44:16 -05001733 if (!cifs_inode_needs_reval(inode))
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001734 return rc;
1735
1736 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737
1738 /* can not safely grab the rename sem here if rename calls revalidate
1739 since that would deadlock */
Jeff Laytondf2cf172010-02-12 07:44:16 -05001740 full_path = build_path_from_dentry(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301742 rc = -ENOMEM;
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001743 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744 }
Jeff Laytondf2cf172010-02-12 07:44:16 -05001745
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001746 cFYI(1, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time "
1747 "%ld jiffies %ld", full_path, inode, inode->i_count.counter,
Steve Frenchf19159d2010-04-21 04:12:10 +00001748 dentry, dentry->d_time, jiffies);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749
Jeff Layton0d424ad2010-09-20 16:01:35 -07001750 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
Jeff Laytondf2cf172010-02-12 07:44:16 -05001751 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1752 else
1753 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1754 xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001755
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001756out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 kfree(full_path);
1758 FreeXid(xid);
1759 return rc;
1760}
1761
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001762int cifs_revalidate_file(struct file *filp)
1763{
1764 int rc;
1765 struct inode *inode = filp->f_path.dentry->d_inode;
1766
1767 rc = cifs_revalidate_file_attr(filp);
1768 if (rc)
1769 return rc;
1770
1771 if (CIFS_I(inode)->invalid_mapping)
1772 rc = cifs_invalidate_mapping(inode);
1773 return rc;
1774}
1775
1776/* revalidate a dentry's inode attributes */
1777int cifs_revalidate_dentry(struct dentry *dentry)
1778{
1779 int rc;
1780 struct inode *inode = dentry->d_inode;
1781
1782 rc = cifs_revalidate_dentry_attr(dentry);
1783 if (rc)
1784 return rc;
1785
1786 if (CIFS_I(inode)->invalid_mapping)
1787 rc = cifs_invalidate_mapping(inode);
1788 return rc;
1789}
1790
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
Jeff Layton1c456012010-10-12 11:32:42 -04001792 struct kstat *stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793{
Jeff Layton3aa1c8c2010-10-07 14:46:28 -04001794 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
Steve French96daf2b2011-05-27 04:34:02 +00001795 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001796 struct inode *inode = dentry->d_inode;
1797 int rc;
Jeff Layton3aa1c8c2010-10-07 14:46:28 -04001798
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001799 /*
1800 * We need to be sure that all dirty pages are written and the server
1801 * has actual ctime, mtime and file length.
1802 */
1803 if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping &&
1804 inode->i_mapping->nrpages != 0) {
1805 rc = filemap_fdatawait(inode->i_mapping);
Steve French156ecb22011-05-20 17:00:01 +00001806 if (rc) {
1807 mapping_set_error(inode->i_mapping, rc);
1808 return rc;
1809 }
Steve French5fe14c82006-11-07 19:26:33 +00001810 }
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001811
1812 rc = cifs_revalidate_dentry_attr(dentry);
1813 if (rc)
1814 return rc;
1815
1816 generic_fillattr(inode, stat);
1817 stat->blksize = CIFS_MAX_MSGSIZE;
1818 stat->ino = CIFS_I(inode)->uniqueid;
1819
1820 /*
1821 * If on a multiuser mount without unix extensions, and the admin hasn't
1822 * overridden them, set the ownership to the fsuid/fsgid of the current
1823 * process.
1824 */
1825 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
1826 !tcon->unix_ext) {
1827 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1828 stat->uid = current_fsuid();
1829 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1830 stat->gid = current_fsgid();
1831 }
1832 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833}
1834
1835static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1836{
1837 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1838 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1839 struct page *page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001840 int rc = 0;
1841
1842 page = grab_cache_page(mapping, index);
1843 if (!page)
1844 return -ENOMEM;
1845
Christoph Lametereebd2aa2008-02-04 22:28:29 -08001846 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847 unlock_page(page);
1848 page_cache_release(page);
1849 return rc;
1850}
1851
Christoph Hellwig1b947462010-07-18 17:51:21 -04001852static void cifs_setsize(struct inode *inode, loff_t offset)
Steve French3677db12007-02-26 16:46:11 +00001853{
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001854 loff_t oldsize;
Steve French3677db12007-02-26 16:46:11 +00001855
Steve Frenchba6a46a2007-02-26 20:06:29 +00001856 spin_lock(&inode->i_lock);
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001857 oldsize = inode->i_size;
Steve French3677db12007-02-26 16:46:11 +00001858 i_size_write(inode, offset);
Steve Frenchba6a46a2007-02-26 20:06:29 +00001859 spin_unlock(&inode->i_lock);
Christoph Hellwig1b947462010-07-18 17:51:21 -04001860
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001861 truncate_pagecache(inode, oldsize, offset);
Steve French3677db12007-02-26 16:46:11 +00001862}
1863
Jeff Layton8efdbde2008-07-23 21:28:12 +00001864static int
1865cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1866 int xid, char *full_path)
1867{
1868 int rc;
1869 struct cifsFileInfo *open_file;
1870 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1871 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001872 struct tcon_link *tlink = NULL;
Steve French96daf2b2011-05-27 04:34:02 +00001873 struct cifs_tcon *pTcon = NULL;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001874 struct cifs_io_parms io_parms;
Jeff Layton8efdbde2008-07-23 21:28:12 +00001875
1876 /*
1877 * To avoid spurious oplock breaks from server, in the case of
1878 * inodes that we already have open, avoid doing path based
1879 * setting of file size if we can do it by handle.
1880 * This keeps our caching token (oplock) and avoids timeouts
1881 * when the local oplock break takes longer to flush
1882 * writebehind data than the SMB timeout for the SetPathInfo
1883 * request would allow
1884 */
Jeff Layton6508d902010-09-29 19:51:11 -04001885 open_file = find_writable_file(cifsInode, true);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001886 if (open_file) {
1887 __u16 nfid = open_file->netfid;
1888 __u32 npid = open_file->pid;
Jeff Layton13cfb732010-09-29 19:51:11 -04001889 pTcon = tlink_tcon(open_file->tlink);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001890 rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size, nfid,
1891 npid, false);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001892 cifsFileInfo_put(open_file);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001893 cFYI(1, "SetFSize for attrs rc = %d", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001894 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1895 unsigned int bytes_written;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001896
1897 io_parms.netfid = nfid;
1898 io_parms.pid = npid;
1899 io_parms.tcon = pTcon;
1900 io_parms.offset = 0;
1901 io_parms.length = attrs->ia_size;
1902 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written,
1903 NULL, NULL, 1);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001904 cFYI(1, "Wrt seteof rc %d", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001905 }
1906 } else
1907 rc = -EINVAL;
1908
1909 if (rc != 0) {
Jeff Layton7ffec372010-09-29 19:51:11 -04001910 if (pTcon == NULL) {
1911 tlink = cifs_sb_tlink(cifs_sb);
1912 if (IS_ERR(tlink))
1913 return PTR_ERR(tlink);
1914 pTcon = tlink_tcon(tlink);
1915 }
Jeff Laytonba00ba62010-09-20 16:01:31 -07001916
Jeff Layton8efdbde2008-07-23 21:28:12 +00001917 /* Set file size by pathname rather than by handle
1918 either because no valid, writeable file handle for
1919 it was found or because there was an error setting
1920 it by handle */
1921 rc = CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size,
1922 false, cifs_sb->local_nls,
1923 cifs_sb->mnt_cifs_flags &
1924 CIFS_MOUNT_MAP_SPECIAL_CHR);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001925 cFYI(1, "SetEOF by path (setattrs) rc = %d", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001926 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1927 __u16 netfid;
1928 int oplock = 0;
1929
1930 rc = SMBLegacyOpen(xid, pTcon, full_path,
1931 FILE_OPEN, GENERIC_WRITE,
1932 CREATE_NOT_DIR, &netfid, &oplock, NULL,
1933 cifs_sb->local_nls,
1934 cifs_sb->mnt_cifs_flags &
1935 CIFS_MOUNT_MAP_SPECIAL_CHR);
1936 if (rc == 0) {
1937 unsigned int bytes_written;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001938
1939 io_parms.netfid = netfid;
1940 io_parms.pid = current->tgid;
1941 io_parms.tcon = pTcon;
1942 io_parms.offset = 0;
1943 io_parms.length = attrs->ia_size;
1944 rc = CIFSSMBWrite(xid, &io_parms,
1945 &bytes_written,
1946 NULL, NULL, 1);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001947 cFYI(1, "wrt seteof rc %d", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001948 CIFSSMBClose(xid, pTcon, netfid);
1949 }
1950 }
Jeff Layton7ffec372010-09-29 19:51:11 -04001951 if (tlink)
1952 cifs_put_tlink(tlink);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001953 }
1954
1955 if (rc == 0) {
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001956 cifsInode->server_eof = attrs->ia_size;
Christoph Hellwig1b947462010-07-18 17:51:21 -04001957 cifs_setsize(inode, attrs->ia_size);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001958 cifs_truncate_page(inode->i_mapping, inode->i_size);
1959 }
1960
1961 return rc;
1962}
1963
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001964static int
1965cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1966{
1967 int rc;
1968 int xid;
1969 char *full_path = NULL;
1970 struct inode *inode = direntry->d_inode;
1971 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1972 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001973 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +00001974 struct cifs_tcon *pTcon;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001975 struct cifs_unix_set_info_args *args = NULL;
Jeff Layton3bbeeb32009-07-09 20:02:50 -04001976 struct cifsFileInfo *open_file;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001977
Joe Perchesb6b38f72010-04-21 03:50:45 +00001978 cFYI(1, "setattr_unix on file %s attrs->ia_valid=0x%x",
1979 direntry->d_name.name, attrs->ia_valid);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001980
1981 xid = GetXid();
1982
Christoph Hellwigdb78b872010-06-04 11:30:03 +02001983 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
1984 attrs->ia_valid |= ATTR_FORCE;
1985
1986 rc = inode_change_ok(inode, attrs);
1987 if (rc < 0)
1988 goto out;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001989
1990 full_path = build_path_from_dentry(direntry);
1991 if (full_path == NULL) {
1992 rc = -ENOMEM;
1993 goto out;
1994 }
1995
Jeff Layton0f4d6342009-03-26 13:35:37 -04001996 /*
1997 * Attempt to flush data before changing attributes. We need to do
1998 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1999 * ownership or mode then we may also need to do this. Here, we take
2000 * the safe way out and just do the flush on all setattr requests. If
2001 * the flush returns error, store it to report later and continue.
2002 *
2003 * BB: This should be smarter. Why bother flushing pages that
2004 * will be truncated anyway? Also, should we error out here if
2005 * the flush returns error?
2006 */
2007 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002008 mapping_set_error(inode->i_mapping, rc);
2009 rc = 0;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002010
2011 if (attrs->ia_valid & ATTR_SIZE) {
2012 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2013 if (rc != 0)
2014 goto out;
2015 }
2016
2017 /* skip mode change if it's just for clearing setuid/setgid */
2018 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2019 attrs->ia_valid &= ~ATTR_MODE;
2020
2021 args = kmalloc(sizeof(*args), GFP_KERNEL);
2022 if (args == NULL) {
2023 rc = -ENOMEM;
2024 goto out;
2025 }
2026
2027 /* set up the struct */
2028 if (attrs->ia_valid & ATTR_MODE)
2029 args->mode = attrs->ia_mode;
2030 else
2031 args->mode = NO_CHANGE_64;
2032
2033 if (attrs->ia_valid & ATTR_UID)
2034 args->uid = attrs->ia_uid;
2035 else
2036 args->uid = NO_CHANGE_64;
2037
2038 if (attrs->ia_valid & ATTR_GID)
2039 args->gid = attrs->ia_gid;
2040 else
2041 args->gid = NO_CHANGE_64;
2042
2043 if (attrs->ia_valid & ATTR_ATIME)
2044 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2045 else
2046 args->atime = NO_CHANGE_64;
2047
2048 if (attrs->ia_valid & ATTR_MTIME)
2049 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2050 else
2051 args->mtime = NO_CHANGE_64;
2052
2053 if (attrs->ia_valid & ATTR_CTIME)
2054 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2055 else
2056 args->ctime = NO_CHANGE_64;
2057
2058 args->device = 0;
Jeff Layton6508d902010-09-29 19:51:11 -04002059 open_file = find_writable_file(cifsInode, true);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002060 if (open_file) {
2061 u16 nfid = open_file->netfid;
2062 u32 npid = open_file->pid;
Jeff Layton13cfb732010-09-29 19:51:11 -04002063 pTcon = tlink_tcon(open_file->tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002064 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04002065 cifsFileInfo_put(open_file);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002066 } else {
Jeff Layton7ffec372010-09-29 19:51:11 -04002067 tlink = cifs_sb_tlink(cifs_sb);
2068 if (IS_ERR(tlink)) {
2069 rc = PTR_ERR(tlink);
2070 goto out;
2071 }
2072 pTcon = tlink_tcon(tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002073 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
Jeff Layton01ea95e2009-07-09 20:02:49 -04002074 cifs_sb->local_nls,
2075 cifs_sb->mnt_cifs_flags &
2076 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton7ffec372010-09-29 19:51:11 -04002077 cifs_put_tlink(tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002078 }
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002079
Christoph Hellwig10257742010-06-04 11:30:02 +02002080 if (rc)
2081 goto out;
Steve Frenchccd4bb12010-02-08 17:39:58 +00002082
Christoph Hellwig10257742010-06-04 11:30:02 +02002083 if ((attrs->ia_valid & ATTR_SIZE) &&
Christoph Hellwig1b947462010-07-18 17:51:21 -04002084 attrs->ia_size != i_size_read(inode))
2085 truncate_setsize(inode, attrs->ia_size);
Christoph Hellwig10257742010-06-04 11:30:02 +02002086
2087 setattr_copy(inode, attrs);
2088 mark_inode_dirty(inode);
2089
2090 /* force revalidate when any of these times are set since some
2091 of the fs types (eg ext3, fat) do not have fine enough
2092 time granularity to match protocol, and we do not have a
2093 a way (yet) to query the server fs's time granularity (and
2094 whether it rounds times down).
2095 */
2096 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2097 cifsInode->time = 0;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002098out:
2099 kfree(args);
2100 kfree(full_path);
2101 FreeXid(xid);
2102 return rc;
2103}
2104
Jeff Layton0510eeb2008-08-02 07:26:12 -04002105static int
2106cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107{
2108 int xid;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002109 struct inode *inode = direntry->d_inode;
2110 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002111 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002112 char *full_path = NULL;
2113 int rc = -EACCES;
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002114 __u32 dosattr = 0;
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04002115 __u64 mode = NO_CHANGE_64;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002116
Linus Torvalds1da177e2005-04-16 15:20:36 -07002117 xid = GetXid();
2118
Joe Perchesb6b38f72010-04-21 03:50:45 +00002119 cFYI(1, "setattr on file %s attrs->iavalid 0x%x",
2120 direntry->d_name.name, attrs->ia_valid);
Steve French6473a552005-11-29 20:20:10 -08002121
Christoph Hellwigdb78b872010-06-04 11:30:03 +02002122 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2123 attrs->ia_valid |= ATTR_FORCE;
2124
2125 rc = inode_change_ok(inode, attrs);
2126 if (rc < 0) {
2127 FreeXid(xid);
2128 return rc;
Steve French6473a552005-11-29 20:20:10 -08002129 }
Steve French50c2f752007-07-13 00:33:32 +00002130
Steve French7f573562005-08-30 11:32:14 -07002131 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302133 rc = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302135 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002136 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137
Jeff Layton0f4d6342009-03-26 13:35:37 -04002138 /*
2139 * Attempt to flush data before changing attributes. We need to do
2140 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2141 * ownership or mode then we may also need to do this. Here, we take
2142 * the safe way out and just do the flush on all setattr requests. If
2143 * the flush returns error, store it to report later and continue.
2144 *
2145 * BB: This should be smarter. Why bother flushing pages that
2146 * will be truncated anyway? Also, should we error out here if
2147 * the flush returns error?
2148 */
2149 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002150 mapping_set_error(inode->i_mapping, rc);
2151 rc = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +00002152
Steve French50531442008-03-14 19:21:31 +00002153 if (attrs->ia_valid & ATTR_SIZE) {
Jeff Layton8efdbde2008-07-23 21:28:12 +00002154 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2155 if (rc != 0)
Steve Frenche30dcf32005-09-20 20:49:16 -07002156 goto cifs_setattr_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002157 }
Jeff Layton4ca691a2008-05-22 09:33:34 -04002158
2159 /*
2160 * Without unix extensions we can't send ownership changes to the
2161 * server, so silently ignore them. This is consistent with how
2162 * local DOS/Windows filesystems behave (VFAT, NTFS, etc). With
2163 * CIFSACL support + proper Windows to Unix idmapping, we may be
2164 * able to support this in the future.
2165 */
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002166 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
Jeff Layton4ca691a2008-05-22 09:33:34 -04002167 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168
Jeff Laytond32c4f22007-10-18 03:05:22 -07002169 /* skip mode change if it's just for clearing setuid/setgid */
2170 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2171 attrs->ia_valid &= ~ATTR_MODE;
2172
Linus Torvalds1da177e2005-04-16 15:20:36 -07002173 if (attrs->ia_valid & ATTR_MODE) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002174 cFYI(1, "Mode changed to 0%o", attrs->ia_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002175 mode = attrs->ia_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002176 }
2177
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002178 if (attrs->ia_valid & ATTR_MODE) {
Steve Frenchcdbce9c2005-11-19 21:04:52 -08002179 rc = 0;
Jeff Layton79df1ba2010-12-06 12:52:08 -05002180#ifdef CONFIG_CIFS_ACL
Shirish Pargaonkar78415d22010-11-27 11:37:26 -06002181 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2182 rc = mode_to_cifs_acl(inode, full_path, mode);
2183 if (rc) {
2184 cFYI(1, "%s: Setting ACL failed with error: %d",
2185 __func__, rc);
2186 goto cifs_setattr_exit;
2187 }
2188 } else
Jeff Layton79df1ba2010-12-06 12:52:08 -05002189#endif /* CONFIG_CIFS_ACL */
Jeff Layton51328612008-05-22 09:33:34 -04002190 if (((mode & S_IWUGO) == 0) &&
2191 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002192
2193 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2194
Jeff Layton51328612008-05-22 09:33:34 -04002195 /* fix up mode if we're not using dynperm */
2196 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2197 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2198 } else if ((mode & S_IWUGO) &&
2199 (cifsInode->cifsAttrs & ATTR_READONLY)) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002200
2201 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2202 /* Attributes of 0 are ignored */
2203 if (dosattr == 0)
2204 dosattr |= ATTR_NORMAL;
Jeff Layton51328612008-05-22 09:33:34 -04002205
2206 /* reset local inode permissions to normal */
2207 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2208 attrs->ia_mode &= ~(S_IALLUGO);
2209 if (S_ISDIR(inode->i_mode))
2210 attrs->ia_mode |=
2211 cifs_sb->mnt_dir_mode;
2212 else
2213 attrs->ia_mode |=
2214 cifs_sb->mnt_file_mode;
2215 }
2216 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2217 /* ignore mode change - ATTR_READONLY hasn't changed */
2218 attrs->ia_valid &= ~ATTR_MODE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002219 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002220 }
2221
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002222 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2223 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2224 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2225 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226
Steve Frenche30dcf32005-09-20 20:49:16 -07002227 /* Even if error on time set, no sense failing the call if
2228 the server would set the time to a reasonable value anyway,
2229 and this check ensures that we are not being called from
2230 sys_utimes in which case we ought to fail the call back to
2231 the user when the server rejects the call */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002232 if ((rc) && (attrs->ia_valid &
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002233 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
Steve Frenche30dcf32005-09-20 20:49:16 -07002234 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235 }
2236
2237 /* do not need local check to inode_check_ok since the server does
2238 that */
Christoph Hellwig10257742010-06-04 11:30:02 +02002239 if (rc)
2240 goto cifs_setattr_exit;
2241
2242 if ((attrs->ia_valid & ATTR_SIZE) &&
Christoph Hellwig1b947462010-07-18 17:51:21 -04002243 attrs->ia_size != i_size_read(inode))
2244 truncate_setsize(inode, attrs->ia_size);
Christoph Hellwig10257742010-06-04 11:30:02 +02002245
2246 setattr_copy(inode, attrs);
2247 mark_inode_dirty(inode);
Christoph Hellwig10257742010-06-04 11:30:02 +02002248
Steve Frenche30dcf32005-09-20 20:49:16 -07002249cifs_setattr_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002250 kfree(full_path);
2251 FreeXid(xid);
2252 return rc;
2253}
2254
Jeff Layton0510eeb2008-08-02 07:26:12 -04002255int
2256cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2257{
2258 struct inode *inode = direntry->d_inode;
2259 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Steve French96daf2b2011-05-27 04:34:02 +00002260 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
Jeff Layton0510eeb2008-08-02 07:26:12 -04002261
2262 if (pTcon->unix_ext)
2263 return cifs_setattr_unix(direntry, attrs);
2264
2265 return cifs_setattr_nounix(direntry, attrs);
2266
2267 /* BB: add cifs_setattr_legacy for really old servers */
2268}
2269
Steve French99ee4db2007-02-27 05:35:17 +00002270#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07002271void cifs_delete_inode(struct inode *inode)
2272{
Joe Perchesb6b38f72010-04-21 03:50:45 +00002273 cFYI(1, "In cifs_delete_inode, inode = 0x%p", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002274 /* may have to add back in if and when safe distributed caching of
2275 directories added e.g. via FindNotify */
2276}
Steve French99ee4db2007-02-27 05:35:17 +00002277#endif