blob: a853a89857a5d4fbe9a50590377bace07768e508 [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
Igor Mammedov79626702008-03-09 03:44:18 +000035static void cifs_set_ops(struct inode *inode, const bool is_dfs_referral)
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;
47 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
48 inode->i_fop = &cifs_file_nobrl_ops;
49 else { /* not direct, send byte range locks */
50 inode->i_fop = &cifs_file_ops;
51 }
52
53
54 /* check if server can support readpages */
Jeff Layton0d424ad2010-09-20 16:01:35 -070055 if (cifs_sb_master_tcon(cifs_sb)->ses->server->maxBuf <
Christoph Hellwig70eff552008-02-15 20:55:05 +000056 PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
57 inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
58 else
59 inode->i_data.a_ops = &cifs_addr_ops;
60 break;
61 case S_IFDIR:
Steve Frenchbc5b6e22008-03-11 21:07:48 +000062#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov79626702008-03-09 03:44:18 +000063 if (is_dfs_referral) {
64 inode->i_op = &cifs_dfs_referral_inode_operations;
65 } else {
Steve Frenchbc5b6e22008-03-11 21:07:48 +000066#else /* NO DFS support, treat as a directory */
67 {
68#endif
Igor Mammedov79626702008-03-09 03:44:18 +000069 inode->i_op = &cifs_dir_inode_ops;
70 inode->i_fop = &cifs_dir_ops;
71 }
Christoph Hellwig70eff552008-02-15 20:55:05 +000072 break;
73 case S_IFLNK:
74 inode->i_op = &cifs_symlink_inode_ops;
75 break;
76 default:
77 init_special_inode(inode, inode->i_mode, inode->i_rdev);
78 break;
79 }
80}
81
Jeff Laytondf2cf172010-02-12 07:44:16 -050082/* check inode attributes against fattr. If they don't match, tag the
83 * inode for cache invalidation
84 */
85static void
86cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
87{
88 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
89
Steve Frenchf19159d2010-04-21 04:12:10 +000090 cFYI(1, "%s: revalidating inode %llu", __func__, cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -050091
92 if (inode->i_state & I_NEW) {
Steve Frenchf19159d2010-04-21 04:12:10 +000093 cFYI(1, "%s: inode %llu is new", __func__, cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -050094 return;
95 }
96
97 /* don't bother with revalidation if we have an oplock */
98 if (cifs_i->clientCanCacheRead) {
Steve Frenchf19159d2010-04-21 04:12:10 +000099 cFYI(1, "%s: inode %llu is oplocked", __func__,
100 cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -0500101 return;
102 }
103
104 /* revalidate if mtime or size have changed */
105 if (timespec_equal(&inode->i_mtime, &fattr->cf_mtime) &&
106 cifs_i->server_eof == fattr->cf_eof) {
Steve Frenchf19159d2010-04-21 04:12:10 +0000107 cFYI(1, "%s: inode %llu is unchanged", __func__,
108 cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -0500109 return;
110 }
111
Steve Frenchf19159d2010-04-21 04:12:10 +0000112 cFYI(1, "%s: invalidating inode %llu mapping", __func__,
113 cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -0500114 cifs_i->invalid_mapping = true;
115}
116
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400117/* populate an inode with info from a cifs_fattr struct */
118void
119cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
Christoph Hellwig75f12982008-02-25 20:25:21 +0000120{
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400121 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400122 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
123 unsigned long oldtime = cifs_i->time;
Christoph Hellwig75f12982008-02-25 20:25:21 +0000124
Jeff Laytondf2cf172010-02-12 07:44:16 -0500125 cifs_revalidate_cache(inode, fattr);
126
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400127 inode->i_atime = fattr->cf_atime;
128 inode->i_mtime = fattr->cf_mtime;
129 inode->i_ctime = fattr->cf_ctime;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400130 inode->i_rdev = fattr->cf_rdev;
131 inode->i_nlink = fattr->cf_nlink;
132 inode->i_uid = fattr->cf_uid;
133 inode->i_gid = fattr->cf_gid;
134
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400135 /* if dynperm is set, don't clobber existing mode */
136 if (inode->i_state & I_NEW ||
137 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
138 inode->i_mode = fattr->cf_mode;
139
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400140 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400141
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400142 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
143 cifs_i->time = 0;
144 else
145 cifs_i->time = jiffies;
146
Joe Perchesb6b38f72010-04-21 03:50:45 +0000147 cFYI(1, "inode 0x%p old_time=%ld new_time=%ld", inode,
148 oldtime, cifs_i->time);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400149
150 cifs_i->delete_pending = fattr->cf_flags & CIFS_FATTR_DELETE_PENDING;
Christoph Hellwig75f12982008-02-25 20:25:21 +0000151
Jeff Layton835a36c2010-02-10 16:21:33 -0500152 cifs_i->server_eof = fattr->cf_eof;
Christoph Hellwig75f12982008-02-25 20:25:21 +0000153 /*
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400154 * Can't safely change the file size here if the client is writing to
155 * it due to potential races.
Christoph Hellwig75f12982008-02-25 20:25:21 +0000156 */
Christoph Hellwig75f12982008-02-25 20:25:21 +0000157 spin_lock(&inode->i_lock);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400158 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
159 i_size_write(inode, fattr->cf_eof);
Christoph Hellwig75f12982008-02-25 20:25:21 +0000160
161 /*
162 * i_blocks is not related to (i_size / i_blksize),
163 * but instead 512 byte (2**9) size is required for
164 * calculating num blocks.
165 */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400166 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
Christoph Hellwig75f12982008-02-25 20:25:21 +0000167 }
168 spin_unlock(&inode->i_lock);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400169
170 cifs_set_ops(inode, fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL);
Christoph Hellwig75f12982008-02-25 20:25:21 +0000171}
172
Jeff Layton4065c802010-05-17 07:18:58 -0400173void
174cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
175{
176 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
177
178 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
179 return;
180
181 fattr->cf_uniqueid = iunique(sb, ROOT_I);
182}
183
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400184/* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
185void
186cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
187 struct cifs_sb_info *cifs_sb)
188{
189 memset(fattr, 0, sizeof(*fattr));
190 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
191 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
192 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
193
194 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
195 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
196 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
197 fattr->cf_mode = le64_to_cpu(info->Permissions);
198
199 /*
200 * Since we set the inode type below we need to mask off
201 * to avoid strange results if bits set above.
202 */
203 fattr->cf_mode &= ~S_IFMT;
204 switch (le32_to_cpu(info->Type)) {
205 case UNIX_FILE:
206 fattr->cf_mode |= S_IFREG;
207 fattr->cf_dtype = DT_REG;
208 break;
209 case UNIX_SYMLINK:
210 fattr->cf_mode |= S_IFLNK;
211 fattr->cf_dtype = DT_LNK;
212 break;
213 case UNIX_DIR:
214 fattr->cf_mode |= S_IFDIR;
215 fattr->cf_dtype = DT_DIR;
216 break;
217 case UNIX_CHARDEV:
218 fattr->cf_mode |= S_IFCHR;
219 fattr->cf_dtype = DT_CHR;
220 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
221 le64_to_cpu(info->DevMinor) & MINORMASK);
222 break;
223 case UNIX_BLOCKDEV:
224 fattr->cf_mode |= S_IFBLK;
225 fattr->cf_dtype = DT_BLK;
226 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
227 le64_to_cpu(info->DevMinor) & MINORMASK);
228 break;
229 case UNIX_FIFO:
230 fattr->cf_mode |= S_IFIFO;
231 fattr->cf_dtype = DT_FIFO;
232 break;
233 case UNIX_SOCKET:
234 fattr->cf_mode |= S_IFSOCK;
235 fattr->cf_dtype = DT_SOCK;
236 break;
237 default:
238 /* safest to call it a file if we do not know */
239 fattr->cf_mode |= S_IFREG;
240 fattr->cf_dtype = DT_REG;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000241 cFYI(1, "unknown type %d", le32_to_cpu(info->Type));
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400242 break;
243 }
244
245 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
246 fattr->cf_uid = cifs_sb->mnt_uid;
247 else
248 fattr->cf_uid = le64_to_cpu(info->Uid);
249
250 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
251 fattr->cf_gid = cifs_sb->mnt_gid;
252 else
253 fattr->cf_gid = le64_to_cpu(info->Gid);
254
255 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
256}
Steve Frenchb9a32602008-05-20 21:52:32 +0000257
258/*
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400259 * Fill a cifs_fattr struct with fake inode info.
260 *
261 * Needed to setup cifs_fattr data for the directory which is the
262 * junction to the new submount (ie to setup the fake directory
263 * which represents a DFS referral).
Steve Frenchb9a32602008-05-20 21:52:32 +0000264 */
Steve Frenchf1230c92009-07-22 23:13:01 +0000265static void
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400266cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
Steve French0e4bbde2008-05-20 19:50:46 +0000267{
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400268 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Steve French0e4bbde2008-05-20 19:50:46 +0000269
Joe Perchesb6b38f72010-04-21 03:50:45 +0000270 cFYI(1, "creating fake fattr for DFS referral");
Steve French0e4bbde2008-05-20 19:50:46 +0000271
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400272 memset(fattr, 0, sizeof(*fattr));
273 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
274 fattr->cf_uid = cifs_sb->mnt_uid;
275 fattr->cf_gid = cifs_sb->mnt_gid;
276 fattr->cf_atime = CURRENT_TIME;
277 fattr->cf_ctime = CURRENT_TIME;
278 fattr->cf_mtime = CURRENT_TIME;
279 fattr->cf_nlink = 2;
280 fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
Steve French0e4bbde2008-05-20 19:50:46 +0000281}
282
Jeff Laytonabab0952010-02-12 07:44:18 -0500283int cifs_get_file_info_unix(struct file *filp)
284{
285 int rc;
286 int xid;
287 FILE_UNIX_BASIC_INFO find_data;
288 struct cifs_fattr fattr;
289 struct inode *inode = filp->f_path.dentry->d_inode;
290 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Joe Perchesc21dfb62010-07-12 13:50:14 -0700291 struct cifsFileInfo *cfile = filp->private_data;
Jeff Layton13cfb732010-09-29 19:51:11 -0400292 struct cifsTconInfo *tcon = tlink_tcon(cfile->tlink);
Jeff Laytonabab0952010-02-12 07:44:18 -0500293
294 xid = GetXid();
295 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->netfid, &find_data);
296 if (!rc) {
297 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
298 } else if (rc == -EREMOTE) {
299 cifs_create_dfs_fattr(&fattr, inode->i_sb);
300 rc = 0;
301 }
302
303 cifs_fattr_to_inode(inode, &fattr);
304 FreeXid(xid);
305 return rc;
306}
307
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308int cifs_get_inode_info_unix(struct inode **pinode,
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400309 const unsigned char *full_path,
310 struct super_block *sb, int xid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311{
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400312 int rc;
Steve French0e4bbde2008-05-20 19:50:46 +0000313 FILE_UNIX_BASIC_INFO find_data;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400314 struct cifs_fattr fattr;
315 struct cifsTconInfo *tcon;
Jeff Layton7ffec372010-09-29 19:51:11 -0400316 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318
Joe Perchesb6b38f72010-04-21 03:50:45 +0000319 cFYI(1, "Getting info on %s", full_path);
Igor Mammedov79626702008-03-09 03:44:18 +0000320
Jeff Layton7ffec372010-09-29 19:51:11 -0400321 tlink = cifs_sb_tlink(cifs_sb);
322 if (IS_ERR(tlink))
323 return PTR_ERR(tlink);
324 tcon = tlink_tcon(tlink);
325
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 /* could have done a find first instead but this returns more info */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400327 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
Steve French737b7582005-04-28 22:41:06 -0700328 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
329 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton7ffec372010-09-29 19:51:11 -0400330 cifs_put_tlink(tlink);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400331
332 if (!rc) {
333 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
334 } else if (rc == -EREMOTE) {
335 cifs_create_dfs_fattr(&fattr, sb);
Jeff Laytone911d0c2008-07-12 13:47:59 -0700336 rc = 0;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400337 } else {
338 return rc;
Steve French0e4bbde2008-05-20 19:50:46 +0000339 }
340
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200341 /* check for Minshall+French symlinks */
342 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
343 int tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
344 if (tmprc)
345 cFYI(1, "CIFSCheckMFSymlink: %d", tmprc);
346 }
347
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400348 if (*pinode == NULL) {
349 /* get new inode */
Jeff Layton4065c802010-05-17 07:18:58 -0400350 cifs_fill_uniqueid(sb, &fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400351 *pinode = cifs_iget(sb, &fattr);
352 if (!*pinode)
353 rc = -ENOMEM;
354 } else {
355 /* we already have inode, update it */
356 cifs_fattr_to_inode(*pinode, &fattr);
357 }
Steve French0e4bbde2008-05-20 19:50:46 +0000358
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 return rc;
360}
361
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400362static int
363cifs_sfu_type(struct cifs_fattr *fattr, const unsigned char *path,
364 struct cifs_sb_info *cifs_sb, int xid)
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800365{
366 int rc;
Steve French4b18f2a2008-04-29 00:06:05 +0000367 int oplock = 0;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800368 __u16 netfid;
Jeff Layton7ffec372010-09-29 19:51:11 -0400369 struct tcon_link *tlink;
370 struct cifsTconInfo *tcon;
Steve French86c96b42005-11-18 20:25:31 -0800371 char buf[24];
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800372 unsigned int bytes_read;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000373 char *pbuf;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800374
375 pbuf = buf;
376
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400377 fattr->cf_mode &= ~S_IFMT;
378
379 if (fattr->cf_eof == 0) {
380 fattr->cf_mode |= S_IFIFO;
381 fattr->cf_dtype = DT_FIFO;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800382 return 0;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400383 } else if (fattr->cf_eof < 8) {
384 fattr->cf_mode |= S_IFREG;
385 fattr->cf_dtype = DT_REG;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800386 return -EINVAL; /* EOPNOTSUPP? */
387 }
Steve French50c2f752007-07-13 00:33:32 +0000388
Jeff Layton7ffec372010-09-29 19:51:11 -0400389 tlink = cifs_sb_tlink(cifs_sb);
390 if (IS_ERR(tlink))
391 return PTR_ERR(tlink);
392 tcon = tlink_tcon(tlink);
393
394 rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, GENERIC_READ,
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800395 CREATE_NOT_DIR, &netfid, &oplock, NULL,
396 cifs_sb->local_nls,
397 cifs_sb->mnt_cifs_flags &
398 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000399 if (rc == 0) {
Steve Frenchec637e32005-12-12 20:53:18 -0800400 int buf_type = CIFS_NO_BUFFER;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800401 /* Read header */
Jeff Layton7ffec372010-09-29 19:51:11 -0400402 rc = CIFSSMBRead(xid, tcon, netfid,
Steve French86c96b42005-11-18 20:25:31 -0800403 24 /* length */, 0 /* offset */,
Steve Frenchec637e32005-12-12 20:53:18 -0800404 &bytes_read, &pbuf, &buf_type);
Steve French4523cc32007-04-30 20:13:06 +0000405 if ((rc == 0) && (bytes_read >= 8)) {
406 if (memcmp("IntxBLK", pbuf, 8) == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000407 cFYI(1, "Block device");
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400408 fattr->cf_mode |= S_IFBLK;
409 fattr->cf_dtype = DT_BLK;
Steve French4523cc32007-04-30 20:13:06 +0000410 if (bytes_read == 24) {
Steve French86c96b42005-11-18 20:25:31 -0800411 /* we have enough to decode dev num */
412 __u64 mjr; /* major */
413 __u64 mnr; /* minor */
414 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
415 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400416 fattr->cf_rdev = MKDEV(mjr, mnr);
Steve French86c96b42005-11-18 20:25:31 -0800417 }
Steve French4523cc32007-04-30 20:13:06 +0000418 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000419 cFYI(1, "Char device");
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400420 fattr->cf_mode |= S_IFCHR;
421 fattr->cf_dtype = DT_CHR;
Steve French4523cc32007-04-30 20:13:06 +0000422 if (bytes_read == 24) {
Steve French86c96b42005-11-18 20:25:31 -0800423 /* we have enough to decode dev num */
424 __u64 mjr; /* major */
425 __u64 mnr; /* minor */
426 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
427 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400428 fattr->cf_rdev = MKDEV(mjr, mnr);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000429 }
Steve French4523cc32007-04-30 20:13:06 +0000430 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000431 cFYI(1, "Symlink");
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400432 fattr->cf_mode |= S_IFLNK;
433 fattr->cf_dtype = DT_LNK;
Steve French86c96b42005-11-18 20:25:31 -0800434 } else {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400435 fattr->cf_mode |= S_IFREG; /* file? */
436 fattr->cf_dtype = DT_REG;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000437 rc = -EOPNOTSUPP;
Steve French86c96b42005-11-18 20:25:31 -0800438 }
Steve French3020a1f2005-11-18 11:31:10 -0800439 } else {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400440 fattr->cf_mode |= S_IFREG; /* then it is a file */
441 fattr->cf_dtype = DT_REG;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000442 rc = -EOPNOTSUPP; /* or some unknown SFU type */
443 }
Jeff Layton7ffec372010-09-29 19:51:11 -0400444 CIFSSMBClose(xid, tcon, netfid);
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800445 }
Jeff Layton7ffec372010-09-29 19:51:11 -0400446 cifs_put_tlink(tlink);
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800447 return rc;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800448}
449
Steve French9e294f12005-11-17 16:59:21 -0800450#define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
451
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400452/*
453 * Fetch mode bits as provided by SFU.
454 *
455 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
456 */
457static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
458 struct cifs_sb_info *cifs_sb, int xid)
Steve French9e294f12005-11-17 16:59:21 -0800459{
Steve French3020a1f2005-11-18 11:31:10 -0800460#ifdef CONFIG_CIFS_XATTR
Steve French9e294f12005-11-17 16:59:21 -0800461 ssize_t rc;
462 char ea_value[4];
463 __u32 mode;
Jeff Layton7ffec372010-09-29 19:51:11 -0400464 struct tcon_link *tlink;
465 struct cifsTconInfo *tcon;
Steve French9e294f12005-11-17 16:59:21 -0800466
Jeff Layton7ffec372010-09-29 19:51:11 -0400467 tlink = cifs_sb_tlink(cifs_sb);
468 if (IS_ERR(tlink))
469 return PTR_ERR(tlink);
470 tcon = tlink_tcon(tlink);
471
472 rc = CIFSSMBQAllEAs(xid, tcon, path, "SETFILEBITS",
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400473 ea_value, 4 /* size of buf */, cifs_sb->local_nls,
474 cifs_sb->mnt_cifs_flags &
475 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton7ffec372010-09-29 19:51:11 -0400476 cifs_put_tlink(tlink);
Steve French4523cc32007-04-30 20:13:06 +0000477 if (rc < 0)
Steve French9e294f12005-11-17 16:59:21 -0800478 return (int)rc;
479 else if (rc > 3) {
480 mode = le32_to_cpu(*((__le32 *)ea_value));
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400481 fattr->cf_mode &= ~SFBITS_MASK;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000482 cFYI(1, "special bits 0%o org mode 0%o", mode,
483 fattr->cf_mode);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400484 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000485 cFYI(1, "special mode bits 0%o", mode);
Steve French9e294f12005-11-17 16:59:21 -0800486 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400487
488 return 0;
Steve French3020a1f2005-11-18 11:31:10 -0800489#else
490 return -EOPNOTSUPP;
491#endif
Steve French9e294f12005-11-17 16:59:21 -0800492}
493
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400494/* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
Steve Frenchf1230c92009-07-22 23:13:01 +0000495static void
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400496cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
497 struct cifs_sb_info *cifs_sb, bool adjust_tz)
Steve Frenchb9a32602008-05-20 21:52:32 +0000498{
Jeff Layton0d424ad2010-09-20 16:01:35 -0700499 struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
500
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400501 memset(fattr, 0, sizeof(*fattr));
502 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
503 if (info->DeletePending)
504 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
Steve Frenchb9a32602008-05-20 21:52:32 +0000505
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400506 if (info->LastAccessTime)
507 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
508 else
509 fattr->cf_atime = CURRENT_TIME;
510
511 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
512 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
513
514 if (adjust_tz) {
Jeff Layton0d424ad2010-09-20 16:01:35 -0700515 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
516 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400517 }
518
519 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
520 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
521
522 if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
523 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
524 fattr->cf_dtype = DT_DIR;
525 } else {
526 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
527 fattr->cf_dtype = DT_REG;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400528
Jeff Laytond0c280d2009-07-09 01:46:44 -0400529 /* clear write bits if ATTR_READONLY is set */
530 if (fattr->cf_cifsattrs & ATTR_READONLY)
531 fattr->cf_mode &= ~(S_IWUGO);
532 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400533
534 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
535
536 fattr->cf_uid = cifs_sb->mnt_uid;
537 fattr->cf_gid = cifs_sb->mnt_gid;
Steve Frenchb9a32602008-05-20 21:52:32 +0000538}
539
Jeff Laytonabab0952010-02-12 07:44:18 -0500540int cifs_get_file_info(struct file *filp)
541{
542 int rc;
543 int xid;
544 FILE_ALL_INFO find_data;
545 struct cifs_fattr fattr;
546 struct inode *inode = filp->f_path.dentry->d_inode;
547 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Joe Perchesc21dfb62010-07-12 13:50:14 -0700548 struct cifsFileInfo *cfile = filp->private_data;
Jeff Layton13cfb732010-09-29 19:51:11 -0400549 struct cifsTconInfo *tcon = tlink_tcon(cfile->tlink);
Jeff Laytonabab0952010-02-12 07:44:18 -0500550
551 xid = GetXid();
552 rc = CIFSSMBQFileInfo(xid, tcon, cfile->netfid, &find_data);
553 if (rc == -EOPNOTSUPP || rc == -EINVAL) {
554 /*
555 * FIXME: legacy server -- fall back to path-based call?
Steve Frenchff2157132010-03-09 20:30:42 +0000556 * for now, just skip revalidating and mark inode for
557 * immediate reval.
558 */
Jeff Laytonabab0952010-02-12 07:44:18 -0500559 rc = 0;
560 CIFS_I(inode)->time = 0;
561 goto cgfi_exit;
562 } else if (rc == -EREMOTE) {
563 cifs_create_dfs_fattr(&fattr, inode->i_sb);
564 rc = 0;
565 } else if (rc)
566 goto cgfi_exit;
567
568 /*
569 * don't bother with SFU junk here -- just mark inode as needing
570 * revalidation.
571 */
572 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false);
573 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
574 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
575 cifs_fattr_to_inode(inode, &fattr);
576cgfi_exit:
577 FreeXid(xid);
578 return rc;
579}
580
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581int cifs_get_inode_info(struct inode **pinode,
Steve French646dd532008-05-15 01:50:56 +0000582 const unsigned char *full_path, FILE_ALL_INFO *pfindData,
Steve French8b1327f2008-03-14 22:37:16 +0000583 struct super_block *sb, int xid, const __u16 *pfid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584{
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400585 int rc = 0, tmprc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 struct cifsTconInfo *pTcon;
Jeff Layton7ffec372010-09-29 19:51:11 -0400587 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 char *buf = NULL;
Steve French5ade9de2008-05-02 20:56:23 +0000590 bool adjustTZ = false;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400591 struct cifs_fattr fattr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592
Jeff Layton7ffec372010-09-29 19:51:11 -0400593 tlink = cifs_sb_tlink(cifs_sb);
594 if (IS_ERR(tlink))
595 return PTR_ERR(tlink);
596 pTcon = tlink_tcon(tlink);
597
Joe Perchesb6b38f72010-04-21 03:50:45 +0000598 cFYI(1, "Getting info on %s", full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599
Steve Frenchd0d2f2d2005-06-02 15:12:36 -0700600 if ((pfindData == NULL) && (*pinode != NULL)) {
601 if (CIFS_I(*pinode)->clientCanCacheRead) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000602 cFYI(1, "No need to revalidate cached inode sizes");
Jeff Layton7ffec372010-09-29 19:51:11 -0400603 goto cgii_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 }
605 }
606
607 /* if file info not passed in then get it from server */
Steve Frenchd0d2f2d2005-06-02 15:12:36 -0700608 if (pfindData == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
Jeff Layton7ffec372010-09-29 19:51:11 -0400610 if (buf == NULL) {
611 rc = -ENOMEM;
612 goto cgii_exit;
613 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 pfindData = (FILE_ALL_INFO *)buf;
Igor Mammedov79626702008-03-09 03:44:18 +0000615
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 /* could do find first instead but this returns more info */
Igor Mammedov79626702008-03-09 03:44:18 +0000617 rc = CIFSSMBQPathInfo(xid, pTcon, full_path, pfindData,
Steve Frenchacf1a1b2006-10-12 03:28:28 +0000618 0 /* not legacy */,
Steve French6b8edfe2005-08-23 20:26:03 -0700619 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700620 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French6b8edfe2005-08-23 20:26:03 -0700621 /* BB optimize code so we do not make the above call
622 when server claims no NT SMB support and the above call
623 failed at least once - set flag in tcon or mount */
Steve French4523cc32007-04-30 20:13:06 +0000624 if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
Igor Mammedov79626702008-03-09 03:44:18 +0000625 rc = SMBQueryInformation(xid, pTcon, full_path,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000626 pfindData, cifs_sb->local_nls,
Steve French6b8edfe2005-08-23 20:26:03 -0700627 cifs_sb->mnt_cifs_flags &
628 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French4b18f2a2008-04-29 00:06:05 +0000629 adjustTZ = true;
Steve French6b8edfe2005-08-23 20:26:03 -0700630 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400632
633 if (!rc) {
634 cifs_all_info_to_fattr(&fattr, (FILE_ALL_INFO *) pfindData,
635 cifs_sb, adjustTZ);
636 } else if (rc == -EREMOTE) {
637 cifs_create_dfs_fattr(&fattr, sb);
Steve Frenchb9a32602008-05-20 21:52:32 +0000638 rc = 0;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400639 } else {
Igor Mammedov79626702008-03-09 03:44:18 +0000640 goto cgii_exit;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400641 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400643 /*
644 * If an inode wasn't passed in, then get the inode number
645 *
646 * Is an i_ino of zero legal? Can we use that to check if the server
647 * supports returning inode numbers? Are there other sanity checks we
648 * can use to ensure that the server is really filling in that field?
649 *
650 * We can not use the IndexNumber field by default from Windows or
651 * Samba (in ALL_INFO buf) but we can request it explicitly. The SNIA
652 * CIFS spec claims that this value is unique within the scope of a
653 * share, and the windows docs hint that it's actually unique
654 * per-machine.
655 *
656 * There may be higher info levels that work but are there Windows
657 * server or network appliances for which IndexNumber field is not
658 * guaranteed unique?
659 */
Steve Frenchb9a32602008-05-20 21:52:32 +0000660 if (*pinode == NULL) {
Steve Frenchb9a32602008-05-20 21:52:32 +0000661 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
662 int rc1 = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663
Steve Frenchb9a32602008-05-20 21:52:32 +0000664 rc1 = CIFSGetSrvInodeNumber(xid, pTcon,
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400665 full_path, &fattr.cf_uniqueid,
Steve French737b7582005-04-28 22:41:06 -0700666 cifs_sb->local_nls,
667 cifs_sb->mnt_cifs_flags &
668 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Laytonec06aed2009-11-06 14:18:29 -0500669 if (rc1 || !fattr.cf_uniqueid) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000670 cFYI(1, "GetSrvInodeNum rc %d", rc1);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400671 fattr.cf_uniqueid = iunique(sb, ROOT_I);
Jeff Laytonec06aed2009-11-06 14:18:29 -0500672 cifs_autodisable_serverino(cifs_sb);
Jeff Layton132ac7b2009-02-10 07:33:57 -0500673 }
Jeff Layton132ac7b2009-02-10 07:33:57 -0500674 } else {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400675 fattr.cf_uniqueid = iunique(sb, ROOT_I);
Jeff Layton132ac7b2009-02-10 07:33:57 -0500676 }
Steve Frenchb9a32602008-05-20 21:52:32 +0000677 } else {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400678 fattr.cf_uniqueid = CIFS_I(*pinode)->uniqueid;
Steve Frenchb9a32602008-05-20 21:52:32 +0000679 }
680
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400681 /* query for SFU type info if supported and needed */
682 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
683 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
684 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
685 if (tmprc)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000686 cFYI(1, "cifs_sfu_type failed: %d", tmprc);
Steve Frenchb9a32602008-05-20 21:52:32 +0000687 }
Steve Frenchb9a32602008-05-20 21:52:32 +0000688
Jeff Layton79df1ba2010-12-06 12:52:08 -0500689#ifdef CONFIG_CIFS_ACL
Steve Frenchb9a32602008-05-20 21:52:32 +0000690 /* fill in 0777 bits from ACL */
691 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
Shirish Pargaonkar78415d22010-11-27 11:37:26 -0600692 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *pinode, full_path,
693 pfid);
694 if (rc) {
695 cFYI(1, "%s: Getting ACL failed with error: %d",
696 __func__, rc);
697 goto cgii_exit;
698 }
Steve Frenchb9a32602008-05-20 21:52:32 +0000699 }
Jeff Layton79df1ba2010-12-06 12:52:08 -0500700#endif /* CONFIG_CIFS_ACL */
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400701
702 /* fill in remaining high mode bits e.g. SUID, VTX */
703 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
704 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
705
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200706 /* check for Minshall+French symlinks */
707 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
708 tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
709 if (tmprc)
710 cFYI(1, "CIFSCheckMFSymlink: %d", tmprc);
711 }
712
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400713 if (!*pinode) {
714 *pinode = cifs_iget(sb, &fattr);
715 if (!*pinode)
716 rc = -ENOMEM;
717 } else {
718 cifs_fattr_to_inode(*pinode, &fattr);
Steve Frenchb9a32602008-05-20 21:52:32 +0000719 }
720
Igor Mammedov79626702008-03-09 03:44:18 +0000721cgii_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 kfree(buf);
Jeff Layton7ffec372010-09-29 19:51:11 -0400723 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 return rc;
725}
726
Steve French7f8ed422007-09-28 22:28:55 +0000727static const struct inode_operations cifs_ipc_inode_ops = {
728 .lookup = cifs_lookup,
729};
730
Jeff Layton7d161b72010-12-07 02:10:35 -0500731char *cifs_build_path_to_root(struct cifs_sb_info *cifs_sb,
732 struct cifsTconInfo *tcon)
Steve French8be0ed42008-12-05 19:14:12 +0000733{
734 int pplen = cifs_sb->prepathlen;
735 int dfsplen;
736 char *full_path = NULL;
737
738 /* if no prefix path, simply set path to the root of share to "" */
739 if (pplen == 0) {
740 full_path = kmalloc(1, GFP_KERNEL);
741 if (full_path)
742 full_path[0] = 0;
743 return full_path;
744 }
745
Jeff Layton0d424ad2010-09-20 16:01:35 -0700746 if (tcon->Flags & SMB_SHARE_IS_IN_DFS)
747 dfsplen = strnlen(tcon->treeName, MAX_TREE_SIZE + 1);
Steve French8be0ed42008-12-05 19:14:12 +0000748 else
749 dfsplen = 0;
750
751 full_path = kmalloc(dfsplen + pplen + 1, GFP_KERNEL);
752 if (full_path == NULL)
753 return full_path;
754
755 if (dfsplen) {
Jeff Layton0d424ad2010-09-20 16:01:35 -0700756 strncpy(full_path, tcon->treeName, dfsplen);
Steve French8be0ed42008-12-05 19:14:12 +0000757 /* switch slash direction in prepath depending on whether
758 * windows or posix style path names
759 */
760 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
761 int i;
762 for (i = 0; i < dfsplen; i++) {
763 if (full_path[i] == '\\')
764 full_path[i] = '/';
765 }
766 }
767 }
768 strncpy(full_path + dfsplen, cifs_sb->prepath, pplen);
769 full_path[dfsplen + pplen] = 0; /* add trailing null */
770 return full_path;
771}
772
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400773static int
774cifs_find_inode(struct inode *inode, void *opaque)
775{
776 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
777
Jeff Laytonf30b9c12010-07-19 18:00:17 -0400778 /* don't match inode with different uniqueid */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400779 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
780 return 0;
781
Jeff Laytonf30b9c12010-07-19 18:00:17 -0400782 /* don't match inode of different type */
783 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
784 return 0;
785
Jeff Layton5acfec22010-08-02 17:43:54 -0400786 /* if it's not a directory or has no dentries, then flag it */
787 if (S_ISDIR(inode->i_mode) && !list_empty(&inode->i_dentry))
Jeff Layton3d694382010-05-11 14:59:55 -0400788 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
Jeff Layton3d694382010-05-11 14:59:55 -0400789
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400790 return 1;
791}
792
793static int
794cifs_init_inode(struct inode *inode, void *opaque)
795{
796 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
797
798 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
799 return 0;
800}
801
Jeff Layton5acfec22010-08-02 17:43:54 -0400802/*
803 * walk dentry list for an inode and report whether it has aliases that
804 * are hashed. We use this to determine if a directory inode can actually
805 * be used.
806 */
807static bool
808inode_has_hashed_dentries(struct inode *inode)
809{
810 struct dentry *dentry;
811
Nick Piggin873feea2011-01-07 17:50:06 +1100812 spin_lock(&inode->i_lock);
Jeff Layton5acfec22010-08-02 17:43:54 -0400813 list_for_each_entry(dentry, &inode->i_dentry, d_alias) {
814 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
Nick Piggin873feea2011-01-07 17:50:06 +1100815 spin_unlock(&inode->i_lock);
Jeff Layton5acfec22010-08-02 17:43:54 -0400816 return true;
817 }
818 }
Nick Piggin873feea2011-01-07 17:50:06 +1100819 spin_unlock(&inode->i_lock);
Jeff Layton5acfec22010-08-02 17:43:54 -0400820 return false;
821}
822
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400823/* Given fattrs, get a corresponding inode */
824struct inode *
825cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
826{
827 unsigned long hash;
828 struct inode *inode;
829
Jeff Layton3d694382010-05-11 14:59:55 -0400830retry_iget5_locked:
Joe Perchesb6b38f72010-04-21 03:50:45 +0000831 cFYI(1, "looking for uniqueid=%llu", fattr->cf_uniqueid);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400832
833 /* hash down to 32-bits on 32-bit arch */
834 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
835
836 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400837 if (inode) {
Jeff Layton5acfec22010-08-02 17:43:54 -0400838 /* was there a potentially problematic inode collision? */
Jeff Layton3d694382010-05-11 14:59:55 -0400839 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
Jeff Layton3d694382010-05-11 14:59:55 -0400840 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
Jeff Layton5acfec22010-08-02 17:43:54 -0400841
842 if (inode_has_hashed_dentries(inode)) {
843 cifs_autodisable_serverino(CIFS_SB(sb));
844 iput(inode);
845 fattr->cf_uniqueid = iunique(sb, ROOT_I);
846 goto retry_iget5_locked;
847 }
Jeff Layton3d694382010-05-11 14:59:55 -0400848 }
849
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400850 cifs_fattr_to_inode(inode, fattr);
851 if (sb->s_flags & MS_NOATIME)
852 inode->i_flags |= S_NOATIME | S_NOCMTIME;
853 if (inode->i_state & I_NEW) {
854 inode->i_ino = hash;
Jeff Layton522440e2010-09-29 09:49:54 -0400855 if (S_ISREG(inode->i_mode))
856 inode->i_data.backing_dev_info = sb->s_bdi;
Steve French0ccd4802010-07-16 04:31:02 +0000857#ifdef CONFIG_CIFS_FSCACHE
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530858 /* initialize per-inode cache cookie pointer */
859 CIFS_I(inode)->fscache = NULL;
Steve French0ccd4802010-07-16 04:31:02 +0000860#endif
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400861 unlock_new_inode(inode);
862 }
863 }
864
865 return inode;
866}
867
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868/* gets root inode */
Jeff Laytonbd433d42009-05-27 09:37:34 -0400869struct inode *cifs_root_iget(struct super_block *sb, unsigned long ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870{
David Howellsce634ab2008-02-07 00:15:33 -0800871 int xid;
Jeff Layton0d424ad2010-09-20 16:01:35 -0700872 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400873 struct inode *inode = NULL;
David Howellsce634ab2008-02-07 00:15:33 -0800874 long rc;
Steve French8be0ed42008-12-05 19:14:12 +0000875 char *full_path;
Jeff Layton0d424ad2010-09-20 16:01:35 -0700876 struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
David Howellsce634ab2008-02-07 00:15:33 -0800877
Jeff Layton7d161b72010-12-07 02:10:35 -0500878 full_path = cifs_build_path_to_root(cifs_sb, tcon);
Steve French8be0ed42008-12-05 19:14:12 +0000879 if (full_path == NULL)
880 return ERR_PTR(-ENOMEM);
Steve Frenchc18c8422007-07-18 23:21:09 +0000881
Steve French8be0ed42008-12-05 19:14:12 +0000882 xid = GetXid();
Jeff Layton0d424ad2010-09-20 16:01:35 -0700883 if (tcon->unix_ext)
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400884 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400885 else
886 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
Steve French8be0ed42008-12-05 19:14:12 +0000887 xid, NULL);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400888
Oskar Schirmera7851ce2010-11-10 21:06:13 +0000889 if (!inode) {
890 inode = ERR_PTR(rc);
891 goto out;
892 }
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400893
Steve French0ccd4802010-07-16 04:31:02 +0000894#ifdef CONFIG_CIFS_FSCACHE
Suresh Jayaramand03382c2010-07-05 18:12:27 +0530895 /* populate tcon->resource_id */
Jeff Layton0d424ad2010-09-20 16:01:35 -0700896 tcon->resource_id = CIFS_I(inode)->uniqueid;
Steve French0ccd4802010-07-16 04:31:02 +0000897#endif
Suresh Jayaramand03382c2010-07-05 18:12:27 +0530898
Jeff Layton0d424ad2010-09-20 16:01:35 -0700899 if (rc && tcon->ipc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000900 cFYI(1, "ipc connection - fake read inode");
Steve French7f8ed422007-09-28 22:28:55 +0000901 inode->i_mode |= S_IFDIR;
902 inode->i_nlink = 2;
903 inode->i_op = &cifs_ipc_inode_ops;
904 inode->i_fop = &simple_dir_operations;
905 inode->i_uid = cifs_sb->mnt_uid;
906 inode->i_gid = cifs_sb->mnt_gid;
Steve Frenchad661332008-08-12 14:14:40 +0000907 } else if (rc) {
David Howellsce634ab2008-02-07 00:15:33 -0800908 iget_failed(inode);
Oskar Schirmera7851ce2010-11-10 21:06:13 +0000909 inode = ERR_PTR(rc);
Steve French7f8ed422007-09-28 22:28:55 +0000910 }
911
Oskar Schirmera7851ce2010-11-10 21:06:13 +0000912out:
Steve French8be0ed42008-12-05 19:14:12 +0000913 kfree(full_path);
David Howellsce634ab2008-02-07 00:15:33 -0800914 /* can not call macro FreeXid here since in a void func
915 * TODO: This is no longer true
916 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 _FreeXid(xid);
David Howellsce634ab2008-02-07 00:15:33 -0800918 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919}
920
Steve French388e57b2008-09-16 23:50:58 +0000921static int
922cifs_set_file_info(struct inode *inode, struct iattr *attrs, int xid,
923 char *full_path, __u32 dosattr)
924{
925 int rc;
926 int oplock = 0;
927 __u16 netfid;
928 __u32 netpid;
929 bool set_time = false;
930 struct cifsFileInfo *open_file;
931 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
932 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400933 struct tcon_link *tlink = NULL;
Jeff Laytonba00ba62010-09-20 16:01:31 -0700934 struct cifsTconInfo *pTcon;
Steve French388e57b2008-09-16 23:50:58 +0000935 FILE_BASIC_INFO info_buf;
936
Steve French1adcb712009-02-25 14:19:56 +0000937 if (attrs == NULL)
938 return -EINVAL;
939
Steve French388e57b2008-09-16 23:50:58 +0000940 if (attrs->ia_valid & ATTR_ATIME) {
941 set_time = true;
942 info_buf.LastAccessTime =
943 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
944 } else
945 info_buf.LastAccessTime = 0;
946
947 if (attrs->ia_valid & ATTR_MTIME) {
948 set_time = true;
949 info_buf.LastWriteTime =
950 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
951 } else
952 info_buf.LastWriteTime = 0;
953
954 /*
955 * Samba throws this field away, but windows may actually use it.
956 * Do not set ctime unless other time stamps are changed explicitly
957 * (i.e. by utimes()) since we would then have a mix of client and
958 * server times.
959 */
960 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000961 cFYI(1, "CIFS - CTIME changed");
Steve French388e57b2008-09-16 23:50:58 +0000962 info_buf.ChangeTime =
963 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
964 } else
965 info_buf.ChangeTime = 0;
966
967 info_buf.CreationTime = 0; /* don't change */
968 info_buf.Attributes = cpu_to_le32(dosattr);
969
970 /*
971 * If the file is already open for write, just use that fileid
972 */
Jeff Layton6508d902010-09-29 19:51:11 -0400973 open_file = find_writable_file(cifsInode, true);
Steve French388e57b2008-09-16 23:50:58 +0000974 if (open_file) {
975 netfid = open_file->netfid;
976 netpid = open_file->pid;
Jeff Layton13cfb732010-09-29 19:51:11 -0400977 pTcon = tlink_tcon(open_file->tlink);
Steve French388e57b2008-09-16 23:50:58 +0000978 goto set_via_filehandle;
979 }
980
Jeff Layton7ffec372010-09-29 19:51:11 -0400981 tlink = cifs_sb_tlink(cifs_sb);
982 if (IS_ERR(tlink)) {
983 rc = PTR_ERR(tlink);
984 tlink = NULL;
985 goto out;
986 }
987 pTcon = tlink_tcon(tlink);
Jeff Laytonba00ba62010-09-20 16:01:31 -0700988
Steve French388e57b2008-09-16 23:50:58 +0000989 /*
990 * NT4 apparently returns success on this call, but it doesn't
991 * really work.
992 */
993 if (!(pTcon->ses->flags & CIFS_SES_NT4)) {
994 rc = CIFSSMBSetPathInfo(xid, pTcon, full_path,
995 &info_buf, cifs_sb->local_nls,
996 cifs_sb->mnt_cifs_flags &
997 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton6b37faa2008-10-06 21:54:41 +0000998 if (rc == 0) {
999 cifsInode->cifsAttrs = dosattr;
1000 goto out;
1001 } else if (rc != -EOPNOTSUPP && rc != -EINVAL)
Steve French388e57b2008-09-16 23:50:58 +00001002 goto out;
1003 }
1004
Joe Perchesb6b38f72010-04-21 03:50:45 +00001005 cFYI(1, "calling SetFileInfo since SetPathInfo for "
1006 "times not supported by this server");
Steve French388e57b2008-09-16 23:50:58 +00001007 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
1008 SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
1009 CREATE_NOT_DIR, &netfid, &oplock,
1010 NULL, cifs_sb->local_nls,
1011 cifs_sb->mnt_cifs_flags &
1012 CIFS_MOUNT_MAP_SPECIAL_CHR);
1013
1014 if (rc != 0) {
1015 if (rc == -EIO)
1016 rc = -EINVAL;
1017 goto out;
1018 }
1019
1020 netpid = current->tgid;
1021
1022set_via_filehandle:
1023 rc = CIFSSMBSetFileInfo(xid, pTcon, &info_buf, netfid, netpid);
Steve Frenchd3889082008-09-24 19:22:52 +00001024 if (!rc)
1025 cifsInode->cifsAttrs = dosattr;
1026
Steve French388e57b2008-09-16 23:50:58 +00001027 if (open_file == NULL)
1028 CIFSSMBClose(xid, pTcon, netfid);
1029 else
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001030 cifsFileInfo_put(open_file);
Steve French388e57b2008-09-16 23:50:58 +00001031out:
Jeff Layton7ffec372010-09-29 19:51:11 -04001032 if (tlink != NULL)
1033 cifs_put_tlink(tlink);
Steve French388e57b2008-09-16 23:50:58 +00001034 return rc;
1035}
1036
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001037/*
1038 * open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1039 * and rename it to a random name that hopefully won't conflict with
1040 * anything else.
1041 */
1042static int
Steve French32709582008-10-20 00:44:19 +00001043cifs_rename_pending_delete(char *full_path, struct dentry *dentry, int xid)
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001044{
1045 int oplock = 0;
1046 int rc;
1047 __u16 netfid;
Steve French32709582008-10-20 00:44:19 +00001048 struct inode *inode = dentry->d_inode;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001049 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1050 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001051 struct tcon_link *tlink;
1052 struct cifsTconInfo *tcon;
Steve French32709582008-10-20 00:44:19 +00001053 __u32 dosattr, origattr;
1054 FILE_BASIC_INFO *info_buf = NULL;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001055
Jeff Layton7ffec372010-09-29 19:51:11 -04001056 tlink = cifs_sb_tlink(cifs_sb);
1057 if (IS_ERR(tlink))
1058 return PTR_ERR(tlink);
1059 tcon = tlink_tcon(tlink);
1060
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001061 rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
Jeff Laytondd1db2d2008-10-16 19:27:12 -04001062 DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001063 &netfid, &oplock, NULL, cifs_sb->local_nls,
1064 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1065 if (rc != 0)
1066 goto out;
1067
Steve French32709582008-10-20 00:44:19 +00001068 origattr = cifsInode->cifsAttrs;
1069 if (origattr == 0)
1070 origattr |= ATTR_NORMAL;
1071
1072 dosattr = origattr & ~ATTR_READONLY;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001073 if (dosattr == 0)
1074 dosattr |= ATTR_NORMAL;
1075 dosattr |= ATTR_HIDDEN;
1076
Steve French32709582008-10-20 00:44:19 +00001077 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1078 if (dosattr != origattr) {
1079 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1080 if (info_buf == NULL) {
1081 rc = -ENOMEM;
1082 goto out_close;
1083 }
1084 info_buf->Attributes = cpu_to_le32(dosattr);
1085 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1086 current->tgid);
1087 /* although we would like to mark the file hidden
1088 if that fails we will still try to rename it */
Steve French41346092008-10-20 18:24:42 +00001089 if (rc != 0)
Steve French32709582008-10-20 00:44:19 +00001090 cifsInode->cifsAttrs = dosattr;
1091 else
1092 dosattr = origattr; /* since not able to change them */
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001093 }
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001094
Jeff Laytondd1db2d2008-10-16 19:27:12 -04001095 /* rename the file */
1096 rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001097 cifs_sb->mnt_cifs_flags &
1098 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French32709582008-10-20 00:44:19 +00001099 if (rc != 0) {
1100 rc = -ETXTBSY;
1101 goto undo_setattr;
1102 }
Jeff Layton6d22f092008-09-23 11:48:35 -04001103
Steve French32709582008-10-20 00:44:19 +00001104 /* try to set DELETE_ON_CLOSE */
1105 if (!cifsInode->delete_pending) {
1106 rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
1107 current->tgid);
1108 /*
1109 * some samba versions return -ENOENT when we try to set the
1110 * file disposition here. Likely a samba bug, but work around
1111 * it for now. This means that some cifsXXX files may hang
1112 * around after they shouldn't.
1113 *
1114 * BB: remove this hack after more servers have the fix
1115 */
1116 if (rc == -ENOENT)
1117 rc = 0;
1118 else if (rc != 0) {
1119 rc = -ETXTBSY;
1120 goto undo_rename;
1121 }
1122 cifsInode->delete_pending = true;
1123 }
Jeff Layton7ce86d52008-09-24 11:32:59 -04001124
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001125out_close:
1126 CIFSSMBClose(xid, tcon, netfid);
1127out:
Steve French32709582008-10-20 00:44:19 +00001128 kfree(info_buf);
Jeff Layton7ffec372010-09-29 19:51:11 -04001129 cifs_put_tlink(tlink);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001130 return rc;
Steve French32709582008-10-20 00:44:19 +00001131
1132 /*
1133 * reset everything back to the original state. Don't bother
1134 * dealing with errors here since we can't do anything about
1135 * them anyway.
1136 */
1137undo_rename:
1138 CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
1139 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1140 CIFS_MOUNT_MAP_SPECIAL_CHR);
1141undo_setattr:
1142 if (dosattr != origattr) {
1143 info_buf->Attributes = cpu_to_le32(origattr);
1144 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1145 current->tgid))
1146 cifsInode->cifsAttrs = origattr;
1147 }
1148
1149 goto out_close;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001150}
1151
Steve Frenchff694522009-04-20 19:45:13 +00001152
1153/*
1154 * If dentry->d_inode is null (usually meaning the cached dentry
1155 * is a negative dentry) then we would attempt a standard SMB delete, but
André Goddard Rosaaf901ca2009-11-14 13:09:05 -02001156 * if that fails we can not attempt the fall back mechanisms on EACCESS
1157 * but will return the EACCESS to the caller. Note that the VFS does not call
Steve Frenchff694522009-04-20 19:45:13 +00001158 * unlink on negative dentries currently.
1159 */
Jeff Layton5f0319a2008-09-16 14:05:16 -04001160int cifs_unlink(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161{
1162 int rc = 0;
1163 int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164 char *full_path = NULL;
Jeff Layton5f0319a2008-09-16 14:05:16 -04001165 struct inode *inode = dentry->d_inode;
Steve Frenchff694522009-04-20 19:45:13 +00001166 struct cifsInodeInfo *cifs_inode;
Jeff Layton5f0319a2008-09-16 14:05:16 -04001167 struct super_block *sb = dir->i_sb;
1168 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001169 struct tcon_link *tlink;
1170 struct cifsTconInfo *tcon;
Steve French60502472008-10-07 18:42:52 +00001171 struct iattr *attrs = NULL;
1172 __u32 dosattr = 0, origattr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173
Joe Perchesb6b38f72010-04-21 03:50:45 +00001174 cFYI(1, "cifs_unlink, dir=0x%p, dentry=0x%p", dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175
Jeff Layton7ffec372010-09-29 19:51:11 -04001176 tlink = cifs_sb_tlink(cifs_sb);
1177 if (IS_ERR(tlink))
1178 return PTR_ERR(tlink);
1179 tcon = tlink_tcon(tlink);
1180
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 xid = GetXid();
1182
Jeff Layton5f0319a2008-09-16 14:05:16 -04001183 /* Unlink can be called from rename so we can not take the
1184 * sb->s_vfs_rename_mutex here */
1185 full_path = build_path_from_dentry(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301187 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001188 goto unlink_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 }
Steve French2d785a52007-07-15 01:48:57 +00001190
Jeff Layton5f0319a2008-09-16 14:05:16 -04001191 if ((tcon->ses->capabilities & CAP_UNIX) &&
Steve French2d785a52007-07-15 01:48:57 +00001192 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
Jeff Layton5f0319a2008-09-16 14:05:16 -04001193 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1194 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
Steve French2d785a52007-07-15 01:48:57 +00001195 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1196 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001197 cFYI(1, "posix del rc %d", rc);
Steve French2d785a52007-07-15 01:48:57 +00001198 if ((rc == 0) || (rc == -ENOENT))
1199 goto psx_del_no_retry;
1200 }
1201
Steve French60502472008-10-07 18:42:52 +00001202retry_std_delete:
Jeff Layton5f0319a2008-09-16 14:05:16 -04001203 rc = CIFSSMBDelFile(xid, tcon, full_path, cifs_sb->local_nls,
Steve French737b7582005-04-28 22:41:06 -07001204 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French60502472008-10-07 18:42:52 +00001205
Steve French2d785a52007-07-15 01:48:57 +00001206psx_del_no_retry:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207 if (!rc) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001208 if (inode)
1209 drop_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 } else if (rc == -ENOENT) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001211 d_drop(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212 } else if (rc == -ETXTBSY) {
Steve French32709582008-10-20 00:44:19 +00001213 rc = cifs_rename_pending_delete(full_path, dentry, xid);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001214 if (rc == 0)
1215 drop_nlink(inode);
Steve Frenchff694522009-04-20 19:45:13 +00001216 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
Steve French388e57b2008-09-16 23:50:58 +00001217 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1218 if (attrs == NULL) {
1219 rc = -ENOMEM;
1220 goto out_reval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 }
Steve French388e57b2008-09-16 23:50:58 +00001222
1223 /* try to reset dos attributes */
Steve Frenchff694522009-04-20 19:45:13 +00001224 cifs_inode = CIFS_I(inode);
1225 origattr = cifs_inode->cifsAttrs;
Steve French60502472008-10-07 18:42:52 +00001226 if (origattr == 0)
1227 origattr |= ATTR_NORMAL;
1228 dosattr = origattr & ~ATTR_READONLY;
Steve French388e57b2008-09-16 23:50:58 +00001229 if (dosattr == 0)
1230 dosattr |= ATTR_NORMAL;
1231 dosattr |= ATTR_HIDDEN;
1232
1233 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
Steve French388e57b2008-09-16 23:50:58 +00001234 if (rc != 0)
1235 goto out_reval;
Steve French60502472008-10-07 18:42:52 +00001236
1237 goto retry_std_delete;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238 }
Steve French60502472008-10-07 18:42:52 +00001239
1240 /* undo the setattr if we errored out and it's needed */
1241 if (rc != 0 && dosattr != 0)
1242 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1243
Steve French388e57b2008-09-16 23:50:58 +00001244out_reval:
Jeff Layton5f0319a2008-09-16 14:05:16 -04001245 if (inode) {
Steve Frenchff694522009-04-20 19:45:13 +00001246 cifs_inode = CIFS_I(inode);
1247 cifs_inode->time = 0; /* will force revalidate to get info
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001248 when needed */
Jeff Layton5f0319a2008-09-16 14:05:16 -04001249 inode->i_ctime = current_fs_time(sb);
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001250 }
Jeff Layton5f0319a2008-09-16 14:05:16 -04001251 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
Steve Frenchff694522009-04-20 19:45:13 +00001252 cifs_inode = CIFS_I(dir);
Steve French60502472008-10-07 18:42:52 +00001253 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
Jeff Layton7ffec372010-09-29 19:51:11 -04001254unlink_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 kfree(full_path);
Steve French60502472008-10-07 18:42:52 +00001256 kfree(attrs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 FreeXid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001258 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 return rc;
1260}
1261
1262int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
1263{
Jeff Layton6b37faa2008-10-06 21:54:41 +00001264 int rc = 0, tmprc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 int xid;
1266 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001267 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 struct cifsTconInfo *pTcon;
1269 char *full_path = NULL;
1270 struct inode *newinode = NULL;
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001271 struct cifs_fattr fattr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272
Joe Perchesb6b38f72010-04-21 03:50:45 +00001273 cFYI(1, "In cifs_mkdir, mode = 0x%x inode = 0x%p", mode, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001276 tlink = cifs_sb_tlink(cifs_sb);
1277 if (IS_ERR(tlink))
1278 return PTR_ERR(tlink);
1279 pTcon = tlink_tcon(tlink);
1280
1281 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282
Steve French7f573562005-08-30 11:32:14 -07001283 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301285 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001286 goto mkdir_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 }
Steve French50c2f752007-07-13 00:33:32 +00001288
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001289 if ((pTcon->ses->capabilities & CAP_UNIX) &&
1290 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
Steve French2dd29d32007-04-23 22:07:35 +00001291 le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
1292 u32 oplock = 0;
Steve Frenchf6d09982008-01-08 23:18:22 +00001293 FILE_UNIX_BASIC_INFO *pInfo =
Steve French2dd29d32007-04-23 22:07:35 +00001294 kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001295 if (pInfo == NULL) {
Steve French2dd29d32007-04-23 22:07:35 +00001296 rc = -ENOMEM;
1297 goto mkdir_out;
1298 }
Steve French50c2f752007-07-13 00:33:32 +00001299
Al Viroce3b0f82009-03-29 19:08:22 -04001300 mode &= ~current_umask();
Steve French2dd29d32007-04-23 22:07:35 +00001301 rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
1302 mode, NULL /* netfid */, pInfo, &oplock,
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001303 full_path, cifs_sb->local_nls,
1304 cifs_sb->mnt_cifs_flags &
Steve French2dd29d32007-04-23 22:07:35 +00001305 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve Frenchc45d7072007-09-17 02:04:21 +00001306 if (rc == -EOPNOTSUPP) {
1307 kfree(pInfo);
1308 goto mkdir_retry_old;
1309 } else if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001310 cFYI(1, "posix mkdir returned 0x%x", rc);
Steve French2dd29d32007-04-23 22:07:35 +00001311 d_drop(direntry);
1312 } else {
Cyril Gorcunov8f2376a2007-10-14 17:58:43 +00001313 if (pInfo->Type == cpu_to_le32(-1)) {
1314 /* no return info, go query for it */
Steve French5a07cdf2007-09-16 23:12:47 +00001315 kfree(pInfo);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001316 goto mkdir_get_info;
Steve French5a07cdf2007-09-16 23:12:47 +00001317 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001318/*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
1319 to set uid/gid */
Steve French2dd29d32007-04-23 22:07:35 +00001320 inc_nlink(inode);
1321 if (pTcon->nocase)
Nick Pigginfb045ad2011-01-07 17:49:55 +11001322 d_set_d_op(direntry, &cifs_ci_dentry_ops);
Steve French2dd29d32007-04-23 22:07:35 +00001323 else
Nick Pigginfb045ad2011-01-07 17:49:55 +11001324 d_set_d_op(direntry, &cifs_dentry_ops);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001325
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001326 cifs_unix_basic_to_fattr(&fattr, pInfo, cifs_sb);
Jeff Layton4065c802010-05-17 07:18:58 -04001327 cifs_fill_uniqueid(inode->i_sb, &fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001328 newinode = cifs_iget(inode->i_sb, &fattr);
1329 if (!newinode) {
Steve French5a07cdf2007-09-16 23:12:47 +00001330 kfree(pInfo);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001331 goto mkdir_get_info;
Steve French5a07cdf2007-09-16 23:12:47 +00001332 }
Jeff Layton6b37faa2008-10-06 21:54:41 +00001333
Steve French2dd29d32007-04-23 22:07:35 +00001334 d_instantiate(direntry, newinode);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001335
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001336#ifdef CONFIG_CIFS_DEBUG2
Joe Perchesb6b38f72010-04-21 03:50:45 +00001337 cFYI(1, "instantiated dentry %p %s to inode %p",
1338 direntry, direntry->d_name.name, newinode);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001339
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001340 if (newinode->i_nlink != 2)
Joe Perchesb6b38f72010-04-21 03:50:45 +00001341 cFYI(1, "unexpected number of links %d",
1342 newinode->i_nlink);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001343#endif
Steve French2dd29d32007-04-23 22:07:35 +00001344 }
1345 kfree(pInfo);
1346 goto mkdir_out;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001347 }
Steve Frenchc45d7072007-09-17 02:04:21 +00001348mkdir_retry_old:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349 /* BB add setting the equivalent of mode via CreateX w/ACLs */
Steve French737b7582005-04-28 22:41:06 -07001350 rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
1351 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001353 cFYI(1, "cifs_mkdir returned 0x%x", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354 d_drop(direntry);
1355 } else {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001356mkdir_get_info:
Dave Hansend8c76e62006-09-30 23:29:04 -07001357 inc_nlink(inode);
Steve Frenchc18c8422007-07-18 23:21:09 +00001358 if (pTcon->unix_ext)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 rc = cifs_get_inode_info_unix(&newinode, full_path,
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001360 inode->i_sb, xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361 else
1362 rc = cifs_get_inode_info(&newinode, full_path, NULL,
Steve French8b1327f2008-03-14 22:37:16 +00001363 inode->i_sb, xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364
Steve Frenchb92327f2005-08-22 20:09:43 -07001365 if (pTcon->nocase)
Nick Pigginfb045ad2011-01-07 17:49:55 +11001366 d_set_d_op(direntry, &cifs_ci_dentry_ops);
Steve Frenchb92327f2005-08-22 20:09:43 -07001367 else
Nick Pigginfb045ad2011-01-07 17:49:55 +11001368 d_set_d_op(direntry, &cifs_dentry_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 d_instantiate(direntry, newinode);
Steve French2dd29d32007-04-23 22:07:35 +00001370 /* setting nlink not necessary except in cases where we
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001371 * failed to get it from the server or was set bogus */
Steve French2dd29d32007-04-23 22:07:35 +00001372 if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001373 direntry->d_inode->i_nlink = 2;
Jeff Layton95089912008-08-06 04:39:02 +00001374
Al Viroce3b0f82009-03-29 19:08:22 -04001375 mode &= ~current_umask();
Jeff Layton95089912008-08-06 04:39:02 +00001376 /* must turn on setgid bit if parent dir has it */
1377 if (inode->i_mode & S_ISGID)
1378 mode |= S_ISGID;
1379
Steve Frenchc18c8422007-07-18 23:21:09 +00001380 if (pTcon->unix_ext) {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04001381 struct cifs_unix_set_info_args args = {
1382 .mode = mode,
1383 .ctime = NO_CHANGE_64,
1384 .atime = NO_CHANGE_64,
1385 .mtime = NO_CHANGE_64,
1386 .device = 0,
1387 };
Steve Frenchd0d2f2d2005-06-02 15:12:36 -07001388 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
David Howellsa001e5b2008-11-14 10:38:47 +11001389 args.uid = (__u64)current_fsuid();
Jeff Layton95089912008-08-06 04:39:02 +00001390 if (inode->i_mode & S_ISGID)
1391 args.gid = (__u64)inode->i_gid;
1392 else
David Howellsa001e5b2008-11-14 10:38:47 +11001393 args.gid = (__u64)current_fsgid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 } else {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04001395 args.uid = NO_CHANGE_64;
1396 args.gid = NO_CHANGE_64;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 }
Jeff Layton01ea95e2009-07-09 20:02:49 -04001398 CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
1399 cifs_sb->local_nls,
1400 cifs_sb->mnt_cifs_flags &
1401 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French3ce53fc2007-06-08 14:55:14 +00001402 } else {
Jeff Layton67750fb2008-05-09 22:28:02 +00001403 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1404 (mode & S_IWUGO) == 0) {
1405 FILE_BASIC_INFO pInfo;
Jeff Layton6b37faa2008-10-06 21:54:41 +00001406 struct cifsInodeInfo *cifsInode;
1407 u32 dosattrs;
1408
Jeff Layton67750fb2008-05-09 22:28:02 +00001409 memset(&pInfo, 0, sizeof(pInfo));
Jeff Layton6b37faa2008-10-06 21:54:41 +00001410 cifsInode = CIFS_I(newinode);
1411 dosattrs = cifsInode->cifsAttrs|ATTR_READONLY;
1412 pInfo.Attributes = cpu_to_le32(dosattrs);
1413 tmprc = CIFSSMBSetPathInfo(xid, pTcon,
1414 full_path, &pInfo,
1415 cifs_sb->local_nls,
Jeff Layton67750fb2008-05-09 22:28:02 +00001416 cifs_sb->mnt_cifs_flags &
1417 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton6b37faa2008-10-06 21:54:41 +00001418 if (tmprc == 0)
1419 cifsInode->cifsAttrs = dosattrs;
Jeff Layton67750fb2008-05-09 22:28:02 +00001420 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001421 if (direntry->d_inode) {
Jeff Laytonb0fd30d2008-05-22 09:33:34 -04001422 if (cifs_sb->mnt_cifs_flags &
1423 CIFS_MOUNT_DYNPERM)
1424 direntry->d_inode->i_mode =
1425 (mode | S_IFDIR);
Steve French4e94a102008-05-23 18:22:46 +00001426
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001427 if (cifs_sb->mnt_cifs_flags &
Steve French6473a552005-11-29 20:20:10 -08001428 CIFS_MOUNT_SET_UID) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001429 direntry->d_inode->i_uid =
David Howellsa001e5b2008-11-14 10:38:47 +11001430 current_fsuid();
Jeff Layton95089912008-08-06 04:39:02 +00001431 if (inode->i_mode & S_ISGID)
1432 direntry->d_inode->i_gid =
1433 inode->i_gid;
1434 else
1435 direntry->d_inode->i_gid =
David Howellsa001e5b2008-11-14 10:38:47 +11001436 current_fsgid();
Steve French6473a552005-11-29 20:20:10 -08001437 }
1438 }
Steve French2a138ebb2005-11-29 21:22:19 -08001439 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001441mkdir_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 kfree(full_path);
1443 FreeXid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001444 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445 return rc;
1446}
1447
1448int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1449{
1450 int rc = 0;
1451 int xid;
1452 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001453 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454 struct cifsTconInfo *pTcon;
1455 char *full_path = NULL;
1456 struct cifsInodeInfo *cifsInode;
1457
Joe Perchesb6b38f72010-04-21 03:50:45 +00001458 cFYI(1, "cifs_rmdir, inode = 0x%p", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459
1460 xid = GetXid();
1461
Steve French7f573562005-08-30 11:32:14 -07001462 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301464 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -04001465 goto rmdir_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466 }
1467
Jeff Layton7ffec372010-09-29 19:51:11 -04001468 cifs_sb = CIFS_SB(inode->i_sb);
1469 tlink = cifs_sb_tlink(cifs_sb);
1470 if (IS_ERR(tlink)) {
1471 rc = PTR_ERR(tlink);
1472 goto rmdir_exit;
1473 }
1474 pTcon = tlink_tcon(tlink);
1475
Steve French737b7582005-04-28 22:41:06 -07001476 rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
1477 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton7ffec372010-09-29 19:51:11 -04001478 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479
1480 if (!rc) {
Dave Hansen9a53c3a2006-09-30 23:29:03 -07001481 drop_nlink(inode);
Steve French3677db12007-02-26 16:46:11 +00001482 spin_lock(&direntry->d_inode->i_lock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001483 i_size_write(direntry->d_inode, 0);
Dave Hansence71ec32006-09-30 23:29:06 -07001484 clear_nlink(direntry->d_inode);
Steve French3677db12007-02-26 16:46:11 +00001485 spin_unlock(&direntry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 }
1487
1488 cifsInode = CIFS_I(direntry->d_inode);
1489 cifsInode->time = 0; /* force revalidate to go get info when
1490 needed */
Steve French42c24542009-01-13 22:03:55 +00001491
1492 cifsInode = CIFS_I(inode);
1493 cifsInode->time = 0; /* force revalidate to get parent dir info
1494 since cached search results now invalid */
1495
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1497 current_fs_time(inode->i_sb);
1498
Jeff Layton7ffec372010-09-29 19:51:11 -04001499rmdir_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500 kfree(full_path);
1501 FreeXid(xid);
1502 return rc;
1503}
1504
Steve Frenchee2fd962008-09-23 18:23:33 +00001505static int
1506cifs_do_rename(int xid, struct dentry *from_dentry, const char *fromPath,
1507 struct dentry *to_dentry, const char *toPath)
1508{
1509 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001510 struct tcon_link *tlink;
1511 struct cifsTconInfo *pTcon;
Steve Frenchee2fd962008-09-23 18:23:33 +00001512 __u16 srcfid;
1513 int oplock, rc;
1514
Jeff Layton7ffec372010-09-29 19:51:11 -04001515 tlink = cifs_sb_tlink(cifs_sb);
1516 if (IS_ERR(tlink))
1517 return PTR_ERR(tlink);
1518 pTcon = tlink_tcon(tlink);
1519
Steve Frenchee2fd962008-09-23 18:23:33 +00001520 /* try path-based rename first */
1521 rc = CIFSSMBRename(xid, pTcon, fromPath, toPath, cifs_sb->local_nls,
1522 cifs_sb->mnt_cifs_flags &
1523 CIFS_MOUNT_MAP_SPECIAL_CHR);
1524
1525 /*
1526 * don't bother with rename by filehandle unless file is busy and
1527 * source Note that cross directory moves do not work with
1528 * rename by filehandle to various Windows servers.
1529 */
1530 if (rc == 0 || rc != -ETXTBSY)
Jeff Layton7ffec372010-09-29 19:51:11 -04001531 goto do_rename_exit;
Steve Frenchee2fd962008-09-23 18:23:33 +00001532
Jeff Laytoned0e3ac2010-06-01 16:21:01 -04001533 /* open-file renames don't work across directories */
1534 if (to_dentry->d_parent != from_dentry->d_parent)
Jeff Layton7ffec372010-09-29 19:51:11 -04001535 goto do_rename_exit;
Jeff Laytoned0e3ac2010-06-01 16:21:01 -04001536
Steve Frenchee2fd962008-09-23 18:23:33 +00001537 /* open the file to be renamed -- we need DELETE perms */
1538 rc = CIFSSMBOpen(xid, pTcon, fromPath, FILE_OPEN, DELETE,
1539 CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1540 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1541 CIFS_MOUNT_MAP_SPECIAL_CHR);
1542
1543 if (rc == 0) {
1544 rc = CIFSSMBRenameOpenFile(xid, pTcon, srcfid,
1545 (const char *) to_dentry->d_name.name,
1546 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1547 CIFS_MOUNT_MAP_SPECIAL_CHR);
1548
1549 CIFSSMBClose(xid, pTcon, srcfid);
1550 }
Jeff Layton7ffec372010-09-29 19:51:11 -04001551do_rename_exit:
1552 cifs_put_tlink(tlink);
Steve Frenchee2fd962008-09-23 18:23:33 +00001553 return rc;
1554}
1555
Jeff Layton14121bd2008-10-20 14:45:22 -04001556int cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1557 struct inode *target_dir, struct dentry *target_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558{
Steve Frenchee2fd962008-09-23 18:23:33 +00001559 char *fromName = NULL;
1560 char *toName = NULL;
Jeff Layton639e7a92010-09-03 11:50:09 -04001561 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -04001562 struct tcon_link *tlink;
Jeff Layton14121bd2008-10-20 14:45:22 -04001563 struct cifsTconInfo *tcon;
Steve Frenchee2fd962008-09-23 18:23:33 +00001564 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1565 FILE_UNIX_BASIC_INFO *info_buf_target;
Jeff Layton8d281ef2008-10-22 13:57:01 -04001566 int xid, rc, tmprc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567
Jeff Layton639e7a92010-09-03 11:50:09 -04001568 cifs_sb = CIFS_SB(source_dir->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001569 tlink = cifs_sb_tlink(cifs_sb);
1570 if (IS_ERR(tlink))
1571 return PTR_ERR(tlink);
1572 tcon = tlink_tcon(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573
Steve Frenchee2fd962008-09-23 18:23:33 +00001574 xid = GetXid();
1575
1576 /*
Steve Frenchee2fd962008-09-23 18:23:33 +00001577 * we already have the rename sem so we do not need to
1578 * grab it again here to protect the path integrity
1579 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001580 fromName = build_path_from_dentry(source_dentry);
Steve Frenchee2fd962008-09-23 18:23:33 +00001581 if (fromName == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 rc = -ENOMEM;
1583 goto cifs_rename_exit;
1584 }
1585
Jeff Layton14121bd2008-10-20 14:45:22 -04001586 toName = build_path_from_dentry(target_dentry);
Steve Frenchee2fd962008-09-23 18:23:33 +00001587 if (toName == NULL) {
1588 rc = -ENOMEM;
1589 goto cifs_rename_exit;
1590 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591
Jeff Layton14121bd2008-10-20 14:45:22 -04001592 rc = cifs_do_rename(xid, source_dentry, fromName,
1593 target_dentry, toName);
Steve Frenchee2fd962008-09-23 18:23:33 +00001594
Jeff Layton14121bd2008-10-20 14:45:22 -04001595 if (rc == -EEXIST && tcon->unix_ext) {
Steve Frenchee2fd962008-09-23 18:23:33 +00001596 /*
Jeff Layton14121bd2008-10-20 14:45:22 -04001597 * Are src and dst hardlinks of same inode? We can
1598 * only tell with unix extensions enabled
Steve Frenchee2fd962008-09-23 18:23:33 +00001599 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001600 info_buf_source =
1601 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1602 GFP_KERNEL);
1603 if (info_buf_source == NULL) {
1604 rc = -ENOMEM;
1605 goto cifs_rename_exit;
1606 }
1607
1608 info_buf_target = info_buf_source + 1;
Jeff Layton8d281ef2008-10-22 13:57:01 -04001609 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, fromName,
Jeff Layton14121bd2008-10-20 14:45:22 -04001610 info_buf_source,
Jeff Layton639e7a92010-09-03 11:50:09 -04001611 cifs_sb->local_nls,
1612 cifs_sb->mnt_cifs_flags &
Jeff Layton14121bd2008-10-20 14:45:22 -04001613 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton8d281ef2008-10-22 13:57:01 -04001614 if (tmprc != 0)
Jeff Layton14121bd2008-10-20 14:45:22 -04001615 goto unlink_target;
1616
Jeff Layton639e7a92010-09-03 11:50:09 -04001617 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, toName,
1618 info_buf_target,
1619 cifs_sb->local_nls,
1620 cifs_sb->mnt_cifs_flags &
Jeff Layton14121bd2008-10-20 14:45:22 -04001621 CIFS_MOUNT_MAP_SPECIAL_CHR);
1622
Jeff Layton8d281ef2008-10-22 13:57:01 -04001623 if (tmprc == 0 && (info_buf_source->UniqueId ==
Jeff Laytonae6884a2008-11-03 14:05:08 -05001624 info_buf_target->UniqueId)) {
Jeff Layton14121bd2008-10-20 14:45:22 -04001625 /* same file, POSIX says that this is a noop */
Jeff Laytonae6884a2008-11-03 14:05:08 -05001626 rc = 0;
Jeff Layton14121bd2008-10-20 14:45:22 -04001627 goto cifs_rename_exit;
Jeff Laytonae6884a2008-11-03 14:05:08 -05001628 }
Jeff Layton14121bd2008-10-20 14:45:22 -04001629 } /* else ... BB we could add the same check for Windows by
1630 checking the UniqueId via FILE_INTERNAL_INFO */
1631
Jeff Layton14121bd2008-10-20 14:45:22 -04001632unlink_target:
Jeff Laytonfc6f3942009-04-17 11:45:30 -04001633 /* Try unlinking the target dentry if it's not negative */
1634 if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
Jeff Layton8d281ef2008-10-22 13:57:01 -04001635 tmprc = cifs_unlink(target_dir, target_dentry);
Jeff Layton14121bd2008-10-20 14:45:22 -04001636 if (tmprc)
1637 goto cifs_rename_exit;
1638
Jeff Layton14121bd2008-10-20 14:45:22 -04001639 rc = cifs_do_rename(xid, source_dentry, fromName,
1640 target_dentry, toName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641 }
1642
1643cifs_rename_exit:
Steve Frenchee2fd962008-09-23 18:23:33 +00001644 kfree(info_buf_source);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 kfree(fromName);
1646 kfree(toName);
1647 FreeXid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -04001648 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 return rc;
1650}
1651
Jeff Laytondf2cf172010-02-12 07:44:16 -05001652static bool
1653cifs_inode_needs_reval(struct inode *inode)
1654{
1655 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301656 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Laytondf2cf172010-02-12 07:44:16 -05001657
1658 if (cifs_i->clientCanCacheRead)
1659 return false;
1660
1661 if (!lookupCacheEnabled)
1662 return true;
1663
1664 if (cifs_i->time == 0)
1665 return true;
1666
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301667 if (!time_in_range(jiffies, cifs_i->time,
1668 cifs_i->time + cifs_sb->actimeo))
Jeff Laytondf2cf172010-02-12 07:44:16 -05001669 return true;
1670
Jeff Laytondb192722010-05-17 14:51:49 -04001671 /* hardlinked files w/ noserverino get "special" treatment */
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301672 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
Jeff Laytondb192722010-05-17 14:51:49 -04001673 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1674 return true;
1675
Jeff Laytondf2cf172010-02-12 07:44:16 -05001676 return false;
1677}
1678
Suresh Jayaraman523fb8c2010-11-29 22:39:47 +05301679/*
1680 * Zap the cache. Called when invalid_mapping flag is set.
1681 */
Jeff Laytondf2cf172010-02-12 07:44:16 -05001682static void
1683cifs_invalidate_mapping(struct inode *inode)
1684{
1685 int rc;
1686 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1687
1688 cifs_i->invalid_mapping = false;
1689
1690 /* write back any cached data */
1691 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1692 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoneb4b7562010-10-22 14:52:29 -04001693 mapping_set_error(inode->i_mapping, rc);
Jeff Laytondf2cf172010-02-12 07:44:16 -05001694 }
1695 invalidate_remote_inode(inode);
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +05301696 cifs_fscache_reset_inode_cookie(inode);
Jeff Laytondf2cf172010-02-12 07:44:16 -05001697}
1698
Jeff Laytonabab0952010-02-12 07:44:18 -05001699int cifs_revalidate_file(struct file *filp)
1700{
1701 int rc = 0;
1702 struct inode *inode = filp->f_path.dentry->d_inode;
Jeff Laytonba00ba62010-09-20 16:01:31 -07001703 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
Jeff Laytonabab0952010-02-12 07:44:18 -05001704
1705 if (!cifs_inode_needs_reval(inode))
1706 goto check_inval;
1707
Jeff Layton13cfb732010-09-29 19:51:11 -04001708 if (tlink_tcon(cfile->tlink)->unix_ext)
Jeff Laytonabab0952010-02-12 07:44:18 -05001709 rc = cifs_get_file_info_unix(filp);
1710 else
1711 rc = cifs_get_file_info(filp);
1712
1713check_inval:
1714 if (CIFS_I(inode)->invalid_mapping)
1715 cifs_invalidate_mapping(inode);
1716
1717 return rc;
1718}
1719
Jeff Laytondf2cf172010-02-12 07:44:16 -05001720/* revalidate a dentry's inode attributes */
1721int cifs_revalidate_dentry(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722{
1723 int xid;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001724 int rc = 0;
1725 char *full_path = NULL;
1726 struct inode *inode = dentry->d_inode;
1727 struct super_block *sb = dentry->d_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728
Jeff Laytondf2cf172010-02-12 07:44:16 -05001729 if (inode == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730 return -ENOENT;
1731
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 xid = GetXid();
1733
Jeff Laytondf2cf172010-02-12 07:44:16 -05001734 if (!cifs_inode_needs_reval(inode))
1735 goto check_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736
1737 /* can not safely grab the rename sem here if rename calls revalidate
1738 since that would deadlock */
Jeff Laytondf2cf172010-02-12 07:44:16 -05001739 full_path = build_path_from_dentry(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301741 rc = -ENOMEM;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001742 goto check_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743 }
Jeff Laytondf2cf172010-02-12 07:44:16 -05001744
Steve Frenchf19159d2010-04-21 04:12:10 +00001745 cFYI(1, "Revalidate: %s inode 0x%p count %d dentry: 0x%p d_time %ld "
Jeff Laytondf2cf172010-02-12 07:44:16 -05001746 "jiffies %ld", full_path, inode, inode->i_count.counter,
Steve Frenchf19159d2010-04-21 04:12:10 +00001747 dentry, dentry->d_time, jiffies);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748
Jeff Layton0d424ad2010-09-20 16:01:35 -07001749 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
Jeff Laytondf2cf172010-02-12 07:44:16 -05001750 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1751 else
1752 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1753 xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754
Jeff Laytondf2cf172010-02-12 07:44:16 -05001755check_inval:
1756 if (CIFS_I(inode)->invalid_mapping)
1757 cifs_invalidate_mapping(inode);
Steve French50c2f752007-07-13 00:33:32 +00001758
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759 kfree(full_path);
1760 FreeXid(xid);
1761 return rc;
1762}
1763
1764int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
Jeff Layton1c456012010-10-12 11:32:42 -04001765 struct kstat *stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766{
Jeff Layton3aa1c8c2010-10-07 14:46:28 -04001767 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1768 struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
Jeff Laytondf2cf172010-02-12 07:44:16 -05001769 int err = cifs_revalidate_dentry(dentry);
Jeff Layton3aa1c8c2010-10-07 14:46:28 -04001770
Steve French5fe14c82006-11-07 19:26:33 +00001771 if (!err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772 generic_fillattr(dentry->d_inode, stat);
Steve French5fe14c82006-11-07 19:26:33 +00001773 stat->blksize = CIFS_MAX_MSGSIZE;
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001774 stat->ino = CIFS_I(dentry->d_inode)->uniqueid;
Jeff Layton1c456012010-10-12 11:32:42 -04001775
1776 /*
1777 * If on a multiuser mount without unix extensions, and the
1778 * admin hasn't overridden them, set the ownership to the
1779 * fsuid/fsgid of the current process.
1780 */
Jeff Layton3aa1c8c2010-10-07 14:46:28 -04001781 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
1782 !tcon->unix_ext) {
Jeff Layton1c456012010-10-12 11:32:42 -04001783 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
Jeff Layton3aa1c8c2010-10-07 14:46:28 -04001784 stat->uid = current_fsuid();
Jeff Layton1c456012010-10-12 11:32:42 -04001785 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
Jeff Layton3aa1c8c2010-10-07 14:46:28 -04001786 stat->gid = current_fsgid();
1787 }
Steve French5fe14c82006-11-07 19:26:33 +00001788 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789 return err;
1790}
1791
1792static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1793{
1794 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1795 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1796 struct page *page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797 int rc = 0;
1798
1799 page = grab_cache_page(mapping, index);
1800 if (!page)
1801 return -ENOMEM;
1802
Christoph Lametereebd2aa2008-02-04 22:28:29 -08001803 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804 unlock_page(page);
1805 page_cache_release(page);
1806 return rc;
1807}
1808
Christoph Hellwig1b947462010-07-18 17:51:21 -04001809static void cifs_setsize(struct inode *inode, loff_t offset)
Steve French3677db12007-02-26 16:46:11 +00001810{
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001811 loff_t oldsize;
Steve French3677db12007-02-26 16:46:11 +00001812
Steve Frenchba6a46a2007-02-26 20:06:29 +00001813 spin_lock(&inode->i_lock);
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001814 oldsize = inode->i_size;
Steve French3677db12007-02-26 16:46:11 +00001815 i_size_write(inode, offset);
Steve Frenchba6a46a2007-02-26 20:06:29 +00001816 spin_unlock(&inode->i_lock);
Christoph Hellwig1b947462010-07-18 17:51:21 -04001817
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001818 truncate_pagecache(inode, oldsize, offset);
Steve French3677db12007-02-26 16:46:11 +00001819}
1820
Jeff Layton8efdbde2008-07-23 21:28:12 +00001821static int
1822cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1823 int xid, char *full_path)
1824{
1825 int rc;
1826 struct cifsFileInfo *open_file;
1827 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1828 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001829 struct tcon_link *tlink = NULL;
Jeff Laytonba00ba62010-09-20 16:01:31 -07001830 struct cifsTconInfo *pTcon = NULL;
Jeff Layton8efdbde2008-07-23 21:28:12 +00001831
1832 /*
1833 * To avoid spurious oplock breaks from server, in the case of
1834 * inodes that we already have open, avoid doing path based
1835 * setting of file size if we can do it by handle.
1836 * This keeps our caching token (oplock) and avoids timeouts
1837 * when the local oplock break takes longer to flush
1838 * writebehind data than the SMB timeout for the SetPathInfo
1839 * request would allow
1840 */
Jeff Layton6508d902010-09-29 19:51:11 -04001841 open_file = find_writable_file(cifsInode, true);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001842 if (open_file) {
1843 __u16 nfid = open_file->netfid;
1844 __u32 npid = open_file->pid;
Jeff Layton13cfb732010-09-29 19:51:11 -04001845 pTcon = tlink_tcon(open_file->tlink);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001846 rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size, nfid,
1847 npid, false);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001848 cifsFileInfo_put(open_file);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001849 cFYI(1, "SetFSize for attrs rc = %d", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001850 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1851 unsigned int bytes_written;
1852 rc = CIFSSMBWrite(xid, pTcon, nfid, 0, attrs->ia_size,
1853 &bytes_written, NULL, NULL, 1);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001854 cFYI(1, "Wrt seteof rc %d", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001855 }
1856 } else
1857 rc = -EINVAL;
1858
1859 if (rc != 0) {
Jeff Layton7ffec372010-09-29 19:51:11 -04001860 if (pTcon == NULL) {
1861 tlink = cifs_sb_tlink(cifs_sb);
1862 if (IS_ERR(tlink))
1863 return PTR_ERR(tlink);
1864 pTcon = tlink_tcon(tlink);
1865 }
Jeff Laytonba00ba62010-09-20 16:01:31 -07001866
Jeff Layton8efdbde2008-07-23 21:28:12 +00001867 /* Set file size by pathname rather than by handle
1868 either because no valid, writeable file handle for
1869 it was found or because there was an error setting
1870 it by handle */
1871 rc = CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size,
1872 false, cifs_sb->local_nls,
1873 cifs_sb->mnt_cifs_flags &
1874 CIFS_MOUNT_MAP_SPECIAL_CHR);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001875 cFYI(1, "SetEOF by path (setattrs) rc = %d", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001876 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1877 __u16 netfid;
1878 int oplock = 0;
1879
1880 rc = SMBLegacyOpen(xid, pTcon, full_path,
1881 FILE_OPEN, GENERIC_WRITE,
1882 CREATE_NOT_DIR, &netfid, &oplock, NULL,
1883 cifs_sb->local_nls,
1884 cifs_sb->mnt_cifs_flags &
1885 CIFS_MOUNT_MAP_SPECIAL_CHR);
1886 if (rc == 0) {
1887 unsigned int bytes_written;
1888 rc = CIFSSMBWrite(xid, pTcon, netfid, 0,
1889 attrs->ia_size,
1890 &bytes_written, NULL,
1891 NULL, 1);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001892 cFYI(1, "wrt seteof rc %d", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001893 CIFSSMBClose(xid, pTcon, netfid);
1894 }
1895 }
Jeff Layton7ffec372010-09-29 19:51:11 -04001896 if (tlink)
1897 cifs_put_tlink(tlink);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001898 }
1899
1900 if (rc == 0) {
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001901 cifsInode->server_eof = attrs->ia_size;
Christoph Hellwig1b947462010-07-18 17:51:21 -04001902 cifs_setsize(inode, attrs->ia_size);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001903 cifs_truncate_page(inode->i_mapping, inode->i_size);
1904 }
1905
1906 return rc;
1907}
1908
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001909static int
1910cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1911{
1912 int rc;
1913 int xid;
1914 char *full_path = NULL;
1915 struct inode *inode = direntry->d_inode;
1916 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1917 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -04001918 struct tcon_link *tlink;
Jeff Laytonba00ba62010-09-20 16:01:31 -07001919 struct cifsTconInfo *pTcon;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001920 struct cifs_unix_set_info_args *args = NULL;
Jeff Layton3bbeeb32009-07-09 20:02:50 -04001921 struct cifsFileInfo *open_file;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001922
Joe Perchesb6b38f72010-04-21 03:50:45 +00001923 cFYI(1, "setattr_unix on file %s attrs->ia_valid=0x%x",
1924 direntry->d_name.name, attrs->ia_valid);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001925
1926 xid = GetXid();
1927
Christoph Hellwigdb78b872010-06-04 11:30:03 +02001928 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
1929 attrs->ia_valid |= ATTR_FORCE;
1930
1931 rc = inode_change_ok(inode, attrs);
1932 if (rc < 0)
1933 goto out;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001934
1935 full_path = build_path_from_dentry(direntry);
1936 if (full_path == NULL) {
1937 rc = -ENOMEM;
1938 goto out;
1939 }
1940
Jeff Layton0f4d6342009-03-26 13:35:37 -04001941 /*
1942 * Attempt to flush data before changing attributes. We need to do
1943 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1944 * ownership or mode then we may also need to do this. Here, we take
1945 * the safe way out and just do the flush on all setattr requests. If
1946 * the flush returns error, store it to report later and continue.
1947 *
1948 * BB: This should be smarter. Why bother flushing pages that
1949 * will be truncated anyway? Also, should we error out here if
1950 * the flush returns error?
1951 */
1952 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoneb4b7562010-10-22 14:52:29 -04001953 mapping_set_error(inode->i_mapping, rc);
1954 rc = 0;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001955
1956 if (attrs->ia_valid & ATTR_SIZE) {
1957 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1958 if (rc != 0)
1959 goto out;
1960 }
1961
1962 /* skip mode change if it's just for clearing setuid/setgid */
1963 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1964 attrs->ia_valid &= ~ATTR_MODE;
1965
1966 args = kmalloc(sizeof(*args), GFP_KERNEL);
1967 if (args == NULL) {
1968 rc = -ENOMEM;
1969 goto out;
1970 }
1971
1972 /* set up the struct */
1973 if (attrs->ia_valid & ATTR_MODE)
1974 args->mode = attrs->ia_mode;
1975 else
1976 args->mode = NO_CHANGE_64;
1977
1978 if (attrs->ia_valid & ATTR_UID)
1979 args->uid = attrs->ia_uid;
1980 else
1981 args->uid = NO_CHANGE_64;
1982
1983 if (attrs->ia_valid & ATTR_GID)
1984 args->gid = attrs->ia_gid;
1985 else
1986 args->gid = NO_CHANGE_64;
1987
1988 if (attrs->ia_valid & ATTR_ATIME)
1989 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
1990 else
1991 args->atime = NO_CHANGE_64;
1992
1993 if (attrs->ia_valid & ATTR_MTIME)
1994 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
1995 else
1996 args->mtime = NO_CHANGE_64;
1997
1998 if (attrs->ia_valid & ATTR_CTIME)
1999 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2000 else
2001 args->ctime = NO_CHANGE_64;
2002
2003 args->device = 0;
Jeff Layton6508d902010-09-29 19:51:11 -04002004 open_file = find_writable_file(cifsInode, true);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002005 if (open_file) {
2006 u16 nfid = open_file->netfid;
2007 u32 npid = open_file->pid;
Jeff Layton13cfb732010-09-29 19:51:11 -04002008 pTcon = tlink_tcon(open_file->tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002009 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04002010 cifsFileInfo_put(open_file);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002011 } else {
Jeff Layton7ffec372010-09-29 19:51:11 -04002012 tlink = cifs_sb_tlink(cifs_sb);
2013 if (IS_ERR(tlink)) {
2014 rc = PTR_ERR(tlink);
2015 goto out;
2016 }
2017 pTcon = tlink_tcon(tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002018 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
Jeff Layton01ea95e2009-07-09 20:02:49 -04002019 cifs_sb->local_nls,
2020 cifs_sb->mnt_cifs_flags &
2021 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton7ffec372010-09-29 19:51:11 -04002022 cifs_put_tlink(tlink);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04002023 }
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002024
Christoph Hellwig10257742010-06-04 11:30:02 +02002025 if (rc)
2026 goto out;
Steve Frenchccd4bb12010-02-08 17:39:58 +00002027
Christoph Hellwig10257742010-06-04 11:30:02 +02002028 if ((attrs->ia_valid & ATTR_SIZE) &&
Christoph Hellwig1b947462010-07-18 17:51:21 -04002029 attrs->ia_size != i_size_read(inode))
2030 truncate_setsize(inode, attrs->ia_size);
Christoph Hellwig10257742010-06-04 11:30:02 +02002031
2032 setattr_copy(inode, attrs);
2033 mark_inode_dirty(inode);
2034
2035 /* force revalidate when any of these times are set since some
2036 of the fs types (eg ext3, fat) do not have fine enough
2037 time granularity to match protocol, and we do not have a
2038 a way (yet) to query the server fs's time granularity (and
2039 whether it rounds times down).
2040 */
2041 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2042 cifsInode->time = 0;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002043out:
2044 kfree(args);
2045 kfree(full_path);
2046 FreeXid(xid);
2047 return rc;
2048}
2049
Jeff Layton0510eeb2008-08-02 07:26:12 -04002050static int
2051cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002052{
2053 int xid;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002054 struct inode *inode = direntry->d_inode;
2055 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002056 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002057 char *full_path = NULL;
2058 int rc = -EACCES;
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002059 __u32 dosattr = 0;
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04002060 __u64 mode = NO_CHANGE_64;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002061
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062 xid = GetXid();
2063
Joe Perchesb6b38f72010-04-21 03:50:45 +00002064 cFYI(1, "setattr on file %s attrs->iavalid 0x%x",
2065 direntry->d_name.name, attrs->ia_valid);
Steve French6473a552005-11-29 20:20:10 -08002066
Christoph Hellwigdb78b872010-06-04 11:30:03 +02002067 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2068 attrs->ia_valid |= ATTR_FORCE;
2069
2070 rc = inode_change_ok(inode, attrs);
2071 if (rc < 0) {
2072 FreeXid(xid);
2073 return rc;
Steve French6473a552005-11-29 20:20:10 -08002074 }
Steve French50c2f752007-07-13 00:33:32 +00002075
Steve French7f573562005-08-30 11:32:14 -07002076 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302078 rc = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002079 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302080 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082
Jeff Layton0f4d6342009-03-26 13:35:37 -04002083 /*
2084 * Attempt to flush data before changing attributes. We need to do
2085 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2086 * ownership or mode then we may also need to do this. Here, we take
2087 * the safe way out and just do the flush on all setattr requests. If
2088 * the flush returns error, store it to report later and continue.
2089 *
2090 * BB: This should be smarter. Why bother flushing pages that
2091 * will be truncated anyway? Also, should we error out here if
2092 * the flush returns error?
2093 */
2094 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002095 mapping_set_error(inode->i_mapping, rc);
2096 rc = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +00002097
Steve French50531442008-03-14 19:21:31 +00002098 if (attrs->ia_valid & ATTR_SIZE) {
Jeff Layton8efdbde2008-07-23 21:28:12 +00002099 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2100 if (rc != 0)
Steve Frenche30dcf32005-09-20 20:49:16 -07002101 goto cifs_setattr_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002102 }
Jeff Layton4ca691a2008-05-22 09:33:34 -04002103
2104 /*
2105 * Without unix extensions we can't send ownership changes to the
2106 * server, so silently ignore them. This is consistent with how
2107 * local DOS/Windows filesystems behave (VFAT, NTFS, etc). With
2108 * CIFSACL support + proper Windows to Unix idmapping, we may be
2109 * able to support this in the future.
2110 */
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002111 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
Jeff Layton4ca691a2008-05-22 09:33:34 -04002112 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113
Jeff Laytond32c4f22007-10-18 03:05:22 -07002114 /* skip mode change if it's just for clearing setuid/setgid */
2115 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2116 attrs->ia_valid &= ~ATTR_MODE;
2117
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118 if (attrs->ia_valid & ATTR_MODE) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002119 cFYI(1, "Mode changed to 0%o", attrs->ia_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120 mode = attrs->ia_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121 }
2122
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04002123 if (attrs->ia_valid & ATTR_MODE) {
Steve Frenchcdbce9c2005-11-19 21:04:52 -08002124 rc = 0;
Jeff Layton79df1ba2010-12-06 12:52:08 -05002125#ifdef CONFIG_CIFS_ACL
Shirish Pargaonkar78415d22010-11-27 11:37:26 -06002126 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2127 rc = mode_to_cifs_acl(inode, full_path, mode);
2128 if (rc) {
2129 cFYI(1, "%s: Setting ACL failed with error: %d",
2130 __func__, rc);
2131 goto cifs_setattr_exit;
2132 }
2133 } else
Jeff Layton79df1ba2010-12-06 12:52:08 -05002134#endif /* CONFIG_CIFS_ACL */
Jeff Layton51328612008-05-22 09:33:34 -04002135 if (((mode & S_IWUGO) == 0) &&
2136 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002137
2138 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2139
Jeff Layton51328612008-05-22 09:33:34 -04002140 /* fix up mode if we're not using dynperm */
2141 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2142 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2143 } else if ((mode & S_IWUGO) &&
2144 (cifsInode->cifsAttrs & ATTR_READONLY)) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002145
2146 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2147 /* Attributes of 0 are ignored */
2148 if (dosattr == 0)
2149 dosattr |= ATTR_NORMAL;
Jeff Layton51328612008-05-22 09:33:34 -04002150
2151 /* reset local inode permissions to normal */
2152 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2153 attrs->ia_mode &= ~(S_IALLUGO);
2154 if (S_ISDIR(inode->i_mode))
2155 attrs->ia_mode |=
2156 cifs_sb->mnt_dir_mode;
2157 else
2158 attrs->ia_mode |=
2159 cifs_sb->mnt_file_mode;
2160 }
2161 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2162 /* ignore mode change - ATTR_READONLY hasn't changed */
2163 attrs->ia_valid &= ~ATTR_MODE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002164 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002165 }
2166
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002167 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2168 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2169 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2170 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002171
Steve Frenche30dcf32005-09-20 20:49:16 -07002172 /* Even if error on time set, no sense failing the call if
2173 the server would set the time to a reasonable value anyway,
2174 and this check ensures that we are not being called from
2175 sys_utimes in which case we ought to fail the call back to
2176 the user when the server rejects the call */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002177 if ((rc) && (attrs->ia_valid &
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002178 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
Steve Frenche30dcf32005-09-20 20:49:16 -07002179 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002180 }
2181
2182 /* do not need local check to inode_check_ok since the server does
2183 that */
Christoph Hellwig10257742010-06-04 11:30:02 +02002184 if (rc)
2185 goto cifs_setattr_exit;
2186
2187 if ((attrs->ia_valid & ATTR_SIZE) &&
Christoph Hellwig1b947462010-07-18 17:51:21 -04002188 attrs->ia_size != i_size_read(inode))
2189 truncate_setsize(inode, attrs->ia_size);
Christoph Hellwig10257742010-06-04 11:30:02 +02002190
2191 setattr_copy(inode, attrs);
2192 mark_inode_dirty(inode);
Christoph Hellwig10257742010-06-04 11:30:02 +02002193
Steve Frenche30dcf32005-09-20 20:49:16 -07002194cifs_setattr_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195 kfree(full_path);
2196 FreeXid(xid);
2197 return rc;
2198}
2199
Jeff Layton0510eeb2008-08-02 07:26:12 -04002200int
2201cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2202{
2203 struct inode *inode = direntry->d_inode;
2204 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton0d424ad2010-09-20 16:01:35 -07002205 struct cifsTconInfo *pTcon = cifs_sb_master_tcon(cifs_sb);
Jeff Layton0510eeb2008-08-02 07:26:12 -04002206
2207 if (pTcon->unix_ext)
2208 return cifs_setattr_unix(direntry, attrs);
2209
2210 return cifs_setattr_nounix(direntry, attrs);
2211
2212 /* BB: add cifs_setattr_legacy for really old servers */
2213}
2214
Steve French99ee4db2007-02-27 05:35:17 +00002215#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07002216void cifs_delete_inode(struct inode *inode)
2217{
Joe Perchesb6b38f72010-04-21 03:50:45 +00002218 cFYI(1, "In cifs_delete_inode, inode = 0x%p", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002219 /* may have to add back in if and when safe distributed caching of
2220 directories added e.g. via FindNotify */
2221}
Steve French99ee4db2007-02-27 05:35:17 +00002222#endif