blob: 5a68b92a0f9aebfff069109b3846801764298d54 [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 */
55 if (cifs_sb->tcon->ses->server->maxBuf <
56 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);
291 struct cifsTconInfo *tcon = cifs_sb->tcon;
Joe Perchesc21dfb62010-07-12 13:50:14 -0700292 struct cifsFileInfo *cfile = filp->private_data;
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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400318 tcon = cifs_sb->tcon;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000319 cFYI(1, "Getting info on %s", full_path);
Igor Mammedov79626702008-03-09 03:44:18 +0000320
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 /* could have done a find first instead but this returns more info */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400322 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
Steve French737b7582005-04-28 22:41:06 -0700323 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
324 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400325
326 if (!rc) {
327 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
328 } else if (rc == -EREMOTE) {
329 cifs_create_dfs_fattr(&fattr, sb);
Jeff Laytone911d0c2008-07-12 13:47:59 -0700330 rc = 0;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400331 } else {
332 return rc;
Steve French0e4bbde2008-05-20 19:50:46 +0000333 }
334
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400335 if (*pinode == NULL) {
336 /* get new inode */
Jeff Layton4065c802010-05-17 07:18:58 -0400337 cifs_fill_uniqueid(sb, &fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400338 *pinode = cifs_iget(sb, &fattr);
339 if (!*pinode)
340 rc = -ENOMEM;
341 } else {
342 /* we already have inode, update it */
343 cifs_fattr_to_inode(*pinode, &fattr);
344 }
Steve French0e4bbde2008-05-20 19:50:46 +0000345
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 return rc;
347}
348
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400349static int
350cifs_sfu_type(struct cifs_fattr *fattr, const unsigned char *path,
351 struct cifs_sb_info *cifs_sb, int xid)
Steve Frenchd6e2f2a2005-11-15 16:43:39 -0800352{
353 int rc;
Steve French4b18f2a2008-04-29 00:06:05 +0000354 int oplock = 0;
Steve Frenchd6e2f2a2005-11-15 16:43:39 -0800355 __u16 netfid;
356 struct cifsTconInfo *pTcon = cifs_sb->tcon;
Steve French86c96b42005-11-18 20:25:31 -0800357 char buf[24];
Steve Frenchd6e2f2a2005-11-15 16:43:39 -0800358 unsigned int bytes_read;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000359 char *pbuf;
Steve Frenchd6e2f2a2005-11-15 16:43:39 -0800360
361 pbuf = buf;
362
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400363 fattr->cf_mode &= ~S_IFMT;
364
365 if (fattr->cf_eof == 0) {
366 fattr->cf_mode |= S_IFIFO;
367 fattr->cf_dtype = DT_FIFO;
Steve Frenchd6e2f2a2005-11-15 16:43:39 -0800368 return 0;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400369 } else if (fattr->cf_eof < 8) {
370 fattr->cf_mode |= S_IFREG;
371 fattr->cf_dtype = DT_REG;
Steve Frenchd6e2f2a2005-11-15 16:43:39 -0800372 return -EINVAL; /* EOPNOTSUPP? */
373 }
Steve French50c2f752007-07-13 00:33:32 +0000374
Steve Frenchd6e2f2a2005-11-15 16:43:39 -0800375 rc = CIFSSMBOpen(xid, pTcon, path, FILE_OPEN, GENERIC_READ,
376 CREATE_NOT_DIR, &netfid, &oplock, NULL,
377 cifs_sb->local_nls,
378 cifs_sb->mnt_cifs_flags &
379 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000380 if (rc == 0) {
Steve Frenchec637e32005-12-12 20:53:18 -0800381 int buf_type = CIFS_NO_BUFFER;
Steve Frenchd6e2f2a2005-11-15 16:43:39 -0800382 /* Read header */
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400383 rc = CIFSSMBRead(xid, pTcon, netfid,
Steve French86c96b42005-11-18 20:25:31 -0800384 24 /* length */, 0 /* offset */,
Steve Frenchec637e32005-12-12 20:53:18 -0800385 &bytes_read, &pbuf, &buf_type);
Steve French4523cc32007-04-30 20:13:06 +0000386 if ((rc == 0) && (bytes_read >= 8)) {
387 if (memcmp("IntxBLK", pbuf, 8) == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000388 cFYI(1, "Block device");
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400389 fattr->cf_mode |= S_IFBLK;
390 fattr->cf_dtype = DT_BLK;
Steve French4523cc32007-04-30 20:13:06 +0000391 if (bytes_read == 24) {
Steve French86c96b42005-11-18 20:25:31 -0800392 /* we have enough to decode dev num */
393 __u64 mjr; /* major */
394 __u64 mnr; /* minor */
395 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
396 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400397 fattr->cf_rdev = MKDEV(mjr, mnr);
Steve French86c96b42005-11-18 20:25:31 -0800398 }
Steve French4523cc32007-04-30 20:13:06 +0000399 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000400 cFYI(1, "Char device");
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400401 fattr->cf_mode |= S_IFCHR;
402 fattr->cf_dtype = DT_CHR;
Steve French4523cc32007-04-30 20:13:06 +0000403 if (bytes_read == 24) {
Steve French86c96b42005-11-18 20:25:31 -0800404 /* we have enough to decode dev num */
405 __u64 mjr; /* major */
406 __u64 mnr; /* minor */
407 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
408 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400409 fattr->cf_rdev = MKDEV(mjr, mnr);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000410 }
Steve French4523cc32007-04-30 20:13:06 +0000411 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000412 cFYI(1, "Symlink");
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400413 fattr->cf_mode |= S_IFLNK;
414 fattr->cf_dtype = DT_LNK;
Steve French86c96b42005-11-18 20:25:31 -0800415 } else {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400416 fattr->cf_mode |= S_IFREG; /* file? */
417 fattr->cf_dtype = DT_REG;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000418 rc = -EOPNOTSUPP;
Steve French86c96b42005-11-18 20:25:31 -0800419 }
Steve French3020a1f2005-11-18 11:31:10 -0800420 } else {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400421 fattr->cf_mode |= S_IFREG; /* then it is a file */
422 fattr->cf_dtype = DT_REG;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000423 rc = -EOPNOTSUPP; /* or some unknown SFU type */
424 }
Steve Frenchd6e2f2a2005-11-15 16:43:39 -0800425 CIFSSMBClose(xid, pTcon, netfid);
Steve Frenchd6e2f2a2005-11-15 16:43:39 -0800426 }
427 return rc;
Steve Frenchd6e2f2a2005-11-15 16:43:39 -0800428}
429
Steve French9e294f12005-11-17 16:59:21 -0800430#define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
431
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400432/*
433 * Fetch mode bits as provided by SFU.
434 *
435 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
436 */
437static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
438 struct cifs_sb_info *cifs_sb, int xid)
Steve French9e294f12005-11-17 16:59:21 -0800439{
Steve French3020a1f2005-11-18 11:31:10 -0800440#ifdef CONFIG_CIFS_XATTR
Steve French9e294f12005-11-17 16:59:21 -0800441 ssize_t rc;
442 char ea_value[4];
443 __u32 mode;
444
Jeff Layton31c05192010-02-10 16:18:26 -0500445 rc = CIFSSMBQAllEAs(xid, cifs_sb->tcon, path, "SETFILEBITS",
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400446 ea_value, 4 /* size of buf */, cifs_sb->local_nls,
447 cifs_sb->mnt_cifs_flags &
448 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French4523cc32007-04-30 20:13:06 +0000449 if (rc < 0)
Steve French9e294f12005-11-17 16:59:21 -0800450 return (int)rc;
451 else if (rc > 3) {
452 mode = le32_to_cpu(*((__le32 *)ea_value));
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400453 fattr->cf_mode &= ~SFBITS_MASK;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000454 cFYI(1, "special bits 0%o org mode 0%o", mode,
455 fattr->cf_mode);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400456 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000457 cFYI(1, "special mode bits 0%o", mode);
Steve French9e294f12005-11-17 16:59:21 -0800458 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400459
460 return 0;
Steve French3020a1f2005-11-18 11:31:10 -0800461#else
462 return -EOPNOTSUPP;
463#endif
Steve French9e294f12005-11-17 16:59:21 -0800464}
465
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400466/* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
Steve Frenchf1230c92009-07-22 23:13:01 +0000467static void
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400468cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
469 struct cifs_sb_info *cifs_sb, bool adjust_tz)
Steve Frenchb9a32602008-05-20 21:52:32 +0000470{
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400471 memset(fattr, 0, sizeof(*fattr));
472 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
473 if (info->DeletePending)
474 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
Steve Frenchb9a32602008-05-20 21:52:32 +0000475
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400476 if (info->LastAccessTime)
477 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
478 else
479 fattr->cf_atime = CURRENT_TIME;
480
481 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
482 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
483
484 if (adjust_tz) {
485 fattr->cf_ctime.tv_sec += cifs_sb->tcon->ses->server->timeAdj;
486 fattr->cf_mtime.tv_sec += cifs_sb->tcon->ses->server->timeAdj;
487 }
488
489 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
490 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
491
492 if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
493 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
494 fattr->cf_dtype = DT_DIR;
495 } else {
496 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
497 fattr->cf_dtype = DT_REG;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400498
Jeff Laytond0c280d2009-07-09 01:46:44 -0400499 /* clear write bits if ATTR_READONLY is set */
500 if (fattr->cf_cifsattrs & ATTR_READONLY)
501 fattr->cf_mode &= ~(S_IWUGO);
502 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400503
504 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
505
506 fattr->cf_uid = cifs_sb->mnt_uid;
507 fattr->cf_gid = cifs_sb->mnt_gid;
Steve Frenchb9a32602008-05-20 21:52:32 +0000508}
509
Jeff Laytonabab0952010-02-12 07:44:18 -0500510int cifs_get_file_info(struct file *filp)
511{
512 int rc;
513 int xid;
514 FILE_ALL_INFO find_data;
515 struct cifs_fattr fattr;
516 struct inode *inode = filp->f_path.dentry->d_inode;
517 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
518 struct cifsTconInfo *tcon = cifs_sb->tcon;
Joe Perchesc21dfb62010-07-12 13:50:14 -0700519 struct cifsFileInfo *cfile = filp->private_data;
Jeff Laytonabab0952010-02-12 07:44:18 -0500520
521 xid = GetXid();
522 rc = CIFSSMBQFileInfo(xid, tcon, cfile->netfid, &find_data);
523 if (rc == -EOPNOTSUPP || rc == -EINVAL) {
524 /*
525 * FIXME: legacy server -- fall back to path-based call?
Steve Frenchff2157132010-03-09 20:30:42 +0000526 * for now, just skip revalidating and mark inode for
527 * immediate reval.
528 */
Jeff Laytonabab0952010-02-12 07:44:18 -0500529 rc = 0;
530 CIFS_I(inode)->time = 0;
531 goto cgfi_exit;
532 } else if (rc == -EREMOTE) {
533 cifs_create_dfs_fattr(&fattr, inode->i_sb);
534 rc = 0;
535 } else if (rc)
536 goto cgfi_exit;
537
538 /*
539 * don't bother with SFU junk here -- just mark inode as needing
540 * revalidation.
541 */
542 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false);
543 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
544 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
545 cifs_fattr_to_inode(inode, &fattr);
546cgfi_exit:
547 FreeXid(xid);
548 return rc;
549}
550
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551int cifs_get_inode_info(struct inode **pinode,
Steve French646dd532008-05-15 01:50:56 +0000552 const unsigned char *full_path, FILE_ALL_INFO *pfindData,
Steve French8b1327f2008-03-14 22:37:16 +0000553 struct super_block *sb, int xid, const __u16 *pfid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554{
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400555 int rc = 0, tmprc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 struct cifsTconInfo *pTcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 char *buf = NULL;
Steve French5ade9de2008-05-02 20:56:23 +0000559 bool adjustTZ = false;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400560 struct cifs_fattr fattr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561
562 pTcon = cifs_sb->tcon;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000563 cFYI(1, "Getting info on %s", full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564
Steve Frenchd0d2f2d2005-06-02 15:12:36 -0700565 if ((pfindData == NULL) && (*pinode != NULL)) {
566 if (CIFS_I(*pinode)->clientCanCacheRead) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000567 cFYI(1, "No need to revalidate cached inode sizes");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 return rc;
569 }
570 }
571
572 /* if file info not passed in then get it from server */
Steve Frenchd0d2f2d2005-06-02 15:12:36 -0700573 if (pfindData == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
Steve Frenchd0d2f2d2005-06-02 15:12:36 -0700575 if (buf == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 return -ENOMEM;
577 pfindData = (FILE_ALL_INFO *)buf;
Igor Mammedov79626702008-03-09 03:44:18 +0000578
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 /* could do find first instead but this returns more info */
Igor Mammedov79626702008-03-09 03:44:18 +0000580 rc = CIFSSMBQPathInfo(xid, pTcon, full_path, pfindData,
Steve Frenchacf1a1b2006-10-12 03:28:28 +0000581 0 /* not legacy */,
Steve French6b8edfe2005-08-23 20:26:03 -0700582 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700583 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French6b8edfe2005-08-23 20:26:03 -0700584 /* BB optimize code so we do not make the above call
585 when server claims no NT SMB support and the above call
586 failed at least once - set flag in tcon or mount */
Steve French4523cc32007-04-30 20:13:06 +0000587 if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
Igor Mammedov79626702008-03-09 03:44:18 +0000588 rc = SMBQueryInformation(xid, pTcon, full_path,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000589 pfindData, cifs_sb->local_nls,
Steve French6b8edfe2005-08-23 20:26:03 -0700590 cifs_sb->mnt_cifs_flags &
591 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French4b18f2a2008-04-29 00:06:05 +0000592 adjustTZ = true;
Steve French6b8edfe2005-08-23 20:26:03 -0700593 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400595
596 if (!rc) {
597 cifs_all_info_to_fattr(&fattr, (FILE_ALL_INFO *) pfindData,
598 cifs_sb, adjustTZ);
599 } else if (rc == -EREMOTE) {
600 cifs_create_dfs_fattr(&fattr, sb);
Steve Frenchb9a32602008-05-20 21:52:32 +0000601 rc = 0;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400602 } else {
Igor Mammedov79626702008-03-09 03:44:18 +0000603 goto cgii_exit;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400604 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400606 /*
607 * If an inode wasn't passed in, then get the inode number
608 *
609 * Is an i_ino of zero legal? Can we use that to check if the server
610 * supports returning inode numbers? Are there other sanity checks we
611 * can use to ensure that the server is really filling in that field?
612 *
613 * We can not use the IndexNumber field by default from Windows or
614 * Samba (in ALL_INFO buf) but we can request it explicitly. The SNIA
615 * CIFS spec claims that this value is unique within the scope of a
616 * share, and the windows docs hint that it's actually unique
617 * per-machine.
618 *
619 * There may be higher info levels that work but are there Windows
620 * server or network appliances for which IndexNumber field is not
621 * guaranteed unique?
622 */
Steve Frenchb9a32602008-05-20 21:52:32 +0000623 if (*pinode == NULL) {
Steve Frenchb9a32602008-05-20 21:52:32 +0000624 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
625 int rc1 = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626
Steve Frenchb9a32602008-05-20 21:52:32 +0000627 rc1 = CIFSGetSrvInodeNumber(xid, pTcon,
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400628 full_path, &fattr.cf_uniqueid,
Steve French737b7582005-04-28 22:41:06 -0700629 cifs_sb->local_nls,
630 cifs_sb->mnt_cifs_flags &
631 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Laytonec06aed2009-11-06 14:18:29 -0500632 if (rc1 || !fattr.cf_uniqueid) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000633 cFYI(1, "GetSrvInodeNum rc %d", rc1);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400634 fattr.cf_uniqueid = iunique(sb, ROOT_I);
Jeff Laytonec06aed2009-11-06 14:18:29 -0500635 cifs_autodisable_serverino(cifs_sb);
Jeff Layton132ac7b2009-02-10 07:33:57 -0500636 }
Jeff Layton132ac7b2009-02-10 07:33:57 -0500637 } else {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400638 fattr.cf_uniqueid = iunique(sb, ROOT_I);
Jeff Layton132ac7b2009-02-10 07:33:57 -0500639 }
Steve Frenchb9a32602008-05-20 21:52:32 +0000640 } else {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400641 fattr.cf_uniqueid = CIFS_I(*pinode)->uniqueid;
Steve Frenchb9a32602008-05-20 21:52:32 +0000642 }
643
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400644 /* query for SFU type info if supported and needed */
645 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
646 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
647 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
648 if (tmprc)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000649 cFYI(1, "cifs_sfu_type failed: %d", tmprc);
Steve Frenchb9a32602008-05-20 21:52:32 +0000650 }
Steve Frenchb9a32602008-05-20 21:52:32 +0000651
Steve Frenchb9a32602008-05-20 21:52:32 +0000652#ifdef CONFIG_CIFS_EXPERIMENTAL
653 /* fill in 0777 bits from ACL */
654 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000655 cFYI(1, "Getting mode bits from ACL");
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400656 cifs_acl_to_fattr(cifs_sb, &fattr, *pinode, full_path, pfid);
Steve Frenchb9a32602008-05-20 21:52:32 +0000657 }
658#endif
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400659
660 /* fill in remaining high mode bits e.g. SUID, VTX */
661 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
662 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
663
664 if (!*pinode) {
665 *pinode = cifs_iget(sb, &fattr);
666 if (!*pinode)
667 rc = -ENOMEM;
668 } else {
669 cifs_fattr_to_inode(*pinode, &fattr);
Steve Frenchb9a32602008-05-20 21:52:32 +0000670 }
671
Igor Mammedov79626702008-03-09 03:44:18 +0000672cgii_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 kfree(buf);
674 return rc;
675}
676
Steve French7f8ed422007-09-28 22:28:55 +0000677static const struct inode_operations cifs_ipc_inode_ops = {
678 .lookup = cifs_lookup,
679};
680
Igor Mammedove4cce942009-02-10 14:10:26 +0300681char *cifs_build_path_to_root(struct cifs_sb_info *cifs_sb)
Steve French8be0ed42008-12-05 19:14:12 +0000682{
683 int pplen = cifs_sb->prepathlen;
684 int dfsplen;
685 char *full_path = NULL;
686
687 /* if no prefix path, simply set path to the root of share to "" */
688 if (pplen == 0) {
689 full_path = kmalloc(1, GFP_KERNEL);
690 if (full_path)
691 full_path[0] = 0;
692 return full_path;
693 }
694
695 if (cifs_sb->tcon && (cifs_sb->tcon->Flags & SMB_SHARE_IS_IN_DFS))
696 dfsplen = strnlen(cifs_sb->tcon->treeName, MAX_TREE_SIZE + 1);
697 else
698 dfsplen = 0;
699
700 full_path = kmalloc(dfsplen + pplen + 1, GFP_KERNEL);
701 if (full_path == NULL)
702 return full_path;
703
704 if (dfsplen) {
705 strncpy(full_path, cifs_sb->tcon->treeName, dfsplen);
706 /* switch slash direction in prepath depending on whether
707 * windows or posix style path names
708 */
709 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
710 int i;
711 for (i = 0; i < dfsplen; i++) {
712 if (full_path[i] == '\\')
713 full_path[i] = '/';
714 }
715 }
716 }
717 strncpy(full_path + dfsplen, cifs_sb->prepath, pplen);
718 full_path[dfsplen + pplen] = 0; /* add trailing null */
719 return full_path;
720}
721
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400722static int
723cifs_find_inode(struct inode *inode, void *opaque)
724{
725 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
726
727 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
728 return 0;
729
Jeff Layton3d694382010-05-11 14:59:55 -0400730 /*
731 * uh oh -- it's a directory. We can't use it since hardlinked dirs are
732 * verboten. Disable serverino and return it as if it were found, the
733 * caller can discard it, generate a uniqueid and retry the find
734 */
735 if (S_ISDIR(inode->i_mode) && !list_empty(&inode->i_dentry)) {
736 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
737 cifs_autodisable_serverino(CIFS_SB(inode->i_sb));
738 }
739
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400740 return 1;
741}
742
743static int
744cifs_init_inode(struct inode *inode, void *opaque)
745{
746 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
747
748 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
749 return 0;
750}
751
752/* Given fattrs, get a corresponding inode */
753struct inode *
754cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
755{
756 unsigned long hash;
757 struct inode *inode;
758
Jeff Layton3d694382010-05-11 14:59:55 -0400759retry_iget5_locked:
Joe Perchesb6b38f72010-04-21 03:50:45 +0000760 cFYI(1, "looking for uniqueid=%llu", fattr->cf_uniqueid);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400761
762 /* hash down to 32-bits on 32-bit arch */
763 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
764
765 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400766 if (inode) {
Jeff Layton3d694382010-05-11 14:59:55 -0400767 /* was there a problematic inode number collision? */
768 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
769 iput(inode);
770 fattr->cf_uniqueid = iunique(sb, ROOT_I);
771 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
772 goto retry_iget5_locked;
773 }
774
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400775 cifs_fattr_to_inode(inode, fattr);
776 if (sb->s_flags & MS_NOATIME)
777 inode->i_flags |= S_NOATIME | S_NOCMTIME;
778 if (inode->i_state & I_NEW) {
779 inode->i_ino = hash;
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530780 /* initialize per-inode cache cookie pointer */
781 CIFS_I(inode)->fscache = NULL;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400782 unlock_new_inode(inode);
783 }
784 }
785
786 return inode;
787}
788
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789/* gets root inode */
Jeff Laytonbd433d42009-05-27 09:37:34 -0400790struct inode *cifs_root_iget(struct super_block *sb, unsigned long ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791{
David Howellsce634ab2008-02-07 00:15:33 -0800792 int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 struct cifs_sb_info *cifs_sb;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400794 struct inode *inode = NULL;
David Howellsce634ab2008-02-07 00:15:33 -0800795 long rc;
Steve French8be0ed42008-12-05 19:14:12 +0000796 char *full_path;
David Howellsce634ab2008-02-07 00:15:33 -0800797
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400798 cifs_sb = CIFS_SB(sb);
Igor Mammedove4cce942009-02-10 14:10:26 +0300799 full_path = cifs_build_path_to_root(cifs_sb);
Steve French8be0ed42008-12-05 19:14:12 +0000800 if (full_path == NULL)
801 return ERR_PTR(-ENOMEM);
Steve Frenchc18c8422007-07-18 23:21:09 +0000802
Steve French8be0ed42008-12-05 19:14:12 +0000803 xid = GetXid();
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400804 if (cifs_sb->tcon->unix_ext)
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400805 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400806 else
807 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
Steve French8be0ed42008-12-05 19:14:12 +0000808 xid, NULL);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400809
810 if (!inode)
811 return ERR_PTR(-ENOMEM);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400812
Suresh Jayaramand03382c2010-07-05 18:12:27 +0530813 /* populate tcon->resource_id */
814 cifs_sb->tcon->resource_id = CIFS_I(inode)->uniqueid;
815
Steve French7f8ed422007-09-28 22:28:55 +0000816 if (rc && cifs_sb->tcon->ipc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000817 cFYI(1, "ipc connection - fake read inode");
Steve French7f8ed422007-09-28 22:28:55 +0000818 inode->i_mode |= S_IFDIR;
819 inode->i_nlink = 2;
820 inode->i_op = &cifs_ipc_inode_ops;
821 inode->i_fop = &simple_dir_operations;
822 inode->i_uid = cifs_sb->mnt_uid;
823 inode->i_gid = cifs_sb->mnt_gid;
Steve Frenchad661332008-08-12 14:14:40 +0000824 } else if (rc) {
Steve French8be0ed42008-12-05 19:14:12 +0000825 kfree(full_path);
David Howellsce634ab2008-02-07 00:15:33 -0800826 _FreeXid(xid);
827 iget_failed(inode);
828 return ERR_PTR(rc);
Steve French7f8ed422007-09-28 22:28:55 +0000829 }
830
David Howellsce634ab2008-02-07 00:15:33 -0800831
Steve French8be0ed42008-12-05 19:14:12 +0000832 kfree(full_path);
David Howellsce634ab2008-02-07 00:15:33 -0800833 /* can not call macro FreeXid here since in a void func
834 * TODO: This is no longer true
835 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 _FreeXid(xid);
David Howellsce634ab2008-02-07 00:15:33 -0800837 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838}
839
Steve French388e57b2008-09-16 23:50:58 +0000840static int
841cifs_set_file_info(struct inode *inode, struct iattr *attrs, int xid,
842 char *full_path, __u32 dosattr)
843{
844 int rc;
845 int oplock = 0;
846 __u16 netfid;
847 __u32 netpid;
848 bool set_time = false;
849 struct cifsFileInfo *open_file;
850 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
851 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
852 struct cifsTconInfo *pTcon = cifs_sb->tcon;
853 FILE_BASIC_INFO info_buf;
854
Steve French1adcb712009-02-25 14:19:56 +0000855 if (attrs == NULL)
856 return -EINVAL;
857
Steve French388e57b2008-09-16 23:50:58 +0000858 if (attrs->ia_valid & ATTR_ATIME) {
859 set_time = true;
860 info_buf.LastAccessTime =
861 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
862 } else
863 info_buf.LastAccessTime = 0;
864
865 if (attrs->ia_valid & ATTR_MTIME) {
866 set_time = true;
867 info_buf.LastWriteTime =
868 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
869 } else
870 info_buf.LastWriteTime = 0;
871
872 /*
873 * Samba throws this field away, but windows may actually use it.
874 * Do not set ctime unless other time stamps are changed explicitly
875 * (i.e. by utimes()) since we would then have a mix of client and
876 * server times.
877 */
878 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000879 cFYI(1, "CIFS - CTIME changed");
Steve French388e57b2008-09-16 23:50:58 +0000880 info_buf.ChangeTime =
881 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
882 } else
883 info_buf.ChangeTime = 0;
884
885 info_buf.CreationTime = 0; /* don't change */
886 info_buf.Attributes = cpu_to_le32(dosattr);
887
888 /*
889 * If the file is already open for write, just use that fileid
890 */
891 open_file = find_writable_file(cifsInode);
892 if (open_file) {
893 netfid = open_file->netfid;
894 netpid = open_file->pid;
895 goto set_via_filehandle;
896 }
897
898 /*
899 * NT4 apparently returns success on this call, but it doesn't
900 * really work.
901 */
902 if (!(pTcon->ses->flags & CIFS_SES_NT4)) {
903 rc = CIFSSMBSetPathInfo(xid, pTcon, full_path,
904 &info_buf, cifs_sb->local_nls,
905 cifs_sb->mnt_cifs_flags &
906 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton6b37faa2008-10-06 21:54:41 +0000907 if (rc == 0) {
908 cifsInode->cifsAttrs = dosattr;
909 goto out;
910 } else if (rc != -EOPNOTSUPP && rc != -EINVAL)
Steve French388e57b2008-09-16 23:50:58 +0000911 goto out;
912 }
913
Joe Perchesb6b38f72010-04-21 03:50:45 +0000914 cFYI(1, "calling SetFileInfo since SetPathInfo for "
915 "times not supported by this server");
Steve French388e57b2008-09-16 23:50:58 +0000916 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
917 SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
918 CREATE_NOT_DIR, &netfid, &oplock,
919 NULL, cifs_sb->local_nls,
920 cifs_sb->mnt_cifs_flags &
921 CIFS_MOUNT_MAP_SPECIAL_CHR);
922
923 if (rc != 0) {
924 if (rc == -EIO)
925 rc = -EINVAL;
926 goto out;
927 }
928
929 netpid = current->tgid;
930
931set_via_filehandle:
932 rc = CIFSSMBSetFileInfo(xid, pTcon, &info_buf, netfid, netpid);
Steve Frenchd3889082008-09-24 19:22:52 +0000933 if (!rc)
934 cifsInode->cifsAttrs = dosattr;
935
Steve French388e57b2008-09-16 23:50:58 +0000936 if (open_file == NULL)
937 CIFSSMBClose(xid, pTcon, netfid);
938 else
Dave Kleikamp6ab409b2009-08-31 11:07:12 -0400939 cifsFileInfo_put(open_file);
Steve French388e57b2008-09-16 23:50:58 +0000940out:
941 return rc;
942}
943
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400944/*
945 * open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
946 * and rename it to a random name that hopefully won't conflict with
947 * anything else.
948 */
949static int
Steve French32709582008-10-20 00:44:19 +0000950cifs_rename_pending_delete(char *full_path, struct dentry *dentry, int xid)
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400951{
952 int oplock = 0;
953 int rc;
954 __u16 netfid;
Steve French32709582008-10-20 00:44:19 +0000955 struct inode *inode = dentry->d_inode;
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400956 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
957 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
958 struct cifsTconInfo *tcon = cifs_sb->tcon;
Steve French32709582008-10-20 00:44:19 +0000959 __u32 dosattr, origattr;
960 FILE_BASIC_INFO *info_buf = NULL;
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400961
962 rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
Jeff Laytondd1db2d2008-10-16 19:27:12 -0400963 DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400964 &netfid, &oplock, NULL, cifs_sb->local_nls,
965 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
966 if (rc != 0)
967 goto out;
968
Steve French32709582008-10-20 00:44:19 +0000969 origattr = cifsInode->cifsAttrs;
970 if (origattr == 0)
971 origattr |= ATTR_NORMAL;
972
973 dosattr = origattr & ~ATTR_READONLY;
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400974 if (dosattr == 0)
975 dosattr |= ATTR_NORMAL;
976 dosattr |= ATTR_HIDDEN;
977
Steve French32709582008-10-20 00:44:19 +0000978 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
979 if (dosattr != origattr) {
980 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
981 if (info_buf == NULL) {
982 rc = -ENOMEM;
983 goto out_close;
984 }
985 info_buf->Attributes = cpu_to_le32(dosattr);
986 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
987 current->tgid);
988 /* although we would like to mark the file hidden
989 if that fails we will still try to rename it */
Steve French41346092008-10-20 18:24:42 +0000990 if (rc != 0)
Steve French32709582008-10-20 00:44:19 +0000991 cifsInode->cifsAttrs = dosattr;
992 else
993 dosattr = origattr; /* since not able to change them */
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400994 }
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400995
Jeff Laytondd1db2d2008-10-16 19:27:12 -0400996 /* rename the file */
997 rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400998 cifs_sb->mnt_cifs_flags &
999 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French32709582008-10-20 00:44:19 +00001000 if (rc != 0) {
1001 rc = -ETXTBSY;
1002 goto undo_setattr;
1003 }
Jeff Layton6d22f092008-09-23 11:48:35 -04001004
Steve French32709582008-10-20 00:44:19 +00001005 /* try to set DELETE_ON_CLOSE */
1006 if (!cifsInode->delete_pending) {
1007 rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
1008 current->tgid);
1009 /*
1010 * some samba versions return -ENOENT when we try to set the
1011 * file disposition here. Likely a samba bug, but work around
1012 * it for now. This means that some cifsXXX files may hang
1013 * around after they shouldn't.
1014 *
1015 * BB: remove this hack after more servers have the fix
1016 */
1017 if (rc == -ENOENT)
1018 rc = 0;
1019 else if (rc != 0) {
1020 rc = -ETXTBSY;
1021 goto undo_rename;
1022 }
1023 cifsInode->delete_pending = true;
1024 }
Jeff Layton7ce86d52008-09-24 11:32:59 -04001025
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001026out_close:
1027 CIFSSMBClose(xid, tcon, netfid);
1028out:
Steve French32709582008-10-20 00:44:19 +00001029 kfree(info_buf);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001030 return rc;
Steve French32709582008-10-20 00:44:19 +00001031
1032 /*
1033 * reset everything back to the original state. Don't bother
1034 * dealing with errors here since we can't do anything about
1035 * them anyway.
1036 */
1037undo_rename:
1038 CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
1039 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1040 CIFS_MOUNT_MAP_SPECIAL_CHR);
1041undo_setattr:
1042 if (dosattr != origattr) {
1043 info_buf->Attributes = cpu_to_le32(origattr);
1044 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1045 current->tgid))
1046 cifsInode->cifsAttrs = origattr;
1047 }
1048
1049 goto out_close;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001050}
1051
Steve Frenchff694522009-04-20 19:45:13 +00001052
1053/*
1054 * If dentry->d_inode is null (usually meaning the cached dentry
1055 * is a negative dentry) then we would attempt a standard SMB delete, but
André Goddard Rosaaf901ca2009-11-14 13:09:05 -02001056 * if that fails we can not attempt the fall back mechanisms on EACCESS
1057 * but will return the EACCESS to the caller. Note that the VFS does not call
Steve Frenchff694522009-04-20 19:45:13 +00001058 * unlink on negative dentries currently.
1059 */
Jeff Layton5f0319a2008-09-16 14:05:16 -04001060int cifs_unlink(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061{
1062 int rc = 0;
1063 int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 char *full_path = NULL;
Jeff Layton5f0319a2008-09-16 14:05:16 -04001065 struct inode *inode = dentry->d_inode;
Steve Frenchff694522009-04-20 19:45:13 +00001066 struct cifsInodeInfo *cifs_inode;
Jeff Layton5f0319a2008-09-16 14:05:16 -04001067 struct super_block *sb = dir->i_sb;
1068 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1069 struct cifsTconInfo *tcon = cifs_sb->tcon;
Steve French60502472008-10-07 18:42:52 +00001070 struct iattr *attrs = NULL;
1071 __u32 dosattr = 0, origattr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072
Joe Perchesb6b38f72010-04-21 03:50:45 +00001073 cFYI(1, "cifs_unlink, dir=0x%p, dentry=0x%p", dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074
1075 xid = GetXid();
1076
Jeff Layton5f0319a2008-09-16 14:05:16 -04001077 /* Unlink can be called from rename so we can not take the
1078 * sb->s_vfs_rename_mutex here */
1079 full_path = build_path_from_dentry(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301081 rc = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301083 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 }
Steve French2d785a52007-07-15 01:48:57 +00001085
Jeff Layton5f0319a2008-09-16 14:05:16 -04001086 if ((tcon->ses->capabilities & CAP_UNIX) &&
Steve French2d785a52007-07-15 01:48:57 +00001087 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
Jeff Layton5f0319a2008-09-16 14:05:16 -04001088 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1089 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
Steve French2d785a52007-07-15 01:48:57 +00001090 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1091 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001092 cFYI(1, "posix del rc %d", rc);
Steve French2d785a52007-07-15 01:48:57 +00001093 if ((rc == 0) || (rc == -ENOENT))
1094 goto psx_del_no_retry;
1095 }
1096
Steve French60502472008-10-07 18:42:52 +00001097retry_std_delete:
Jeff Layton5f0319a2008-09-16 14:05:16 -04001098 rc = CIFSSMBDelFile(xid, tcon, full_path, cifs_sb->local_nls,
Steve French737b7582005-04-28 22:41:06 -07001099 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French60502472008-10-07 18:42:52 +00001100
Steve French2d785a52007-07-15 01:48:57 +00001101psx_del_no_retry:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 if (!rc) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001103 if (inode)
1104 drop_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 } else if (rc == -ENOENT) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001106 d_drop(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 } else if (rc == -ETXTBSY) {
Steve French32709582008-10-20 00:44:19 +00001108 rc = cifs_rename_pending_delete(full_path, dentry, xid);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001109 if (rc == 0)
1110 drop_nlink(inode);
Steve Frenchff694522009-04-20 19:45:13 +00001111 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
Steve French388e57b2008-09-16 23:50:58 +00001112 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1113 if (attrs == NULL) {
1114 rc = -ENOMEM;
1115 goto out_reval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 }
Steve French388e57b2008-09-16 23:50:58 +00001117
1118 /* try to reset dos attributes */
Steve Frenchff694522009-04-20 19:45:13 +00001119 cifs_inode = CIFS_I(inode);
1120 origattr = cifs_inode->cifsAttrs;
Steve French60502472008-10-07 18:42:52 +00001121 if (origattr == 0)
1122 origattr |= ATTR_NORMAL;
1123 dosattr = origattr & ~ATTR_READONLY;
Steve French388e57b2008-09-16 23:50:58 +00001124 if (dosattr == 0)
1125 dosattr |= ATTR_NORMAL;
1126 dosattr |= ATTR_HIDDEN;
1127
1128 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
Steve French388e57b2008-09-16 23:50:58 +00001129 if (rc != 0)
1130 goto out_reval;
Steve French60502472008-10-07 18:42:52 +00001131
1132 goto retry_std_delete;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 }
Steve French60502472008-10-07 18:42:52 +00001134
1135 /* undo the setattr if we errored out and it's needed */
1136 if (rc != 0 && dosattr != 0)
1137 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1138
Steve French388e57b2008-09-16 23:50:58 +00001139out_reval:
Jeff Layton5f0319a2008-09-16 14:05:16 -04001140 if (inode) {
Steve Frenchff694522009-04-20 19:45:13 +00001141 cifs_inode = CIFS_I(inode);
1142 cifs_inode->time = 0; /* will force revalidate to get info
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001143 when needed */
Jeff Layton5f0319a2008-09-16 14:05:16 -04001144 inode->i_ctime = current_fs_time(sb);
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001145 }
Jeff Layton5f0319a2008-09-16 14:05:16 -04001146 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
Steve Frenchff694522009-04-20 19:45:13 +00001147 cifs_inode = CIFS_I(dir);
Steve French60502472008-10-07 18:42:52 +00001148 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149
1150 kfree(full_path);
Steve French60502472008-10-07 18:42:52 +00001151 kfree(attrs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 FreeXid(xid);
1153 return rc;
1154}
1155
1156int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
1157{
Jeff Layton6b37faa2008-10-06 21:54:41 +00001158 int rc = 0, tmprc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 int xid;
1160 struct cifs_sb_info *cifs_sb;
1161 struct cifsTconInfo *pTcon;
1162 char *full_path = NULL;
1163 struct inode *newinode = NULL;
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001164 struct cifs_fattr fattr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165
Joe Perchesb6b38f72010-04-21 03:50:45 +00001166 cFYI(1, "In cifs_mkdir, mode = 0x%x inode = 0x%p", mode, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167
1168 xid = GetXid();
1169
1170 cifs_sb = CIFS_SB(inode->i_sb);
1171 pTcon = cifs_sb->tcon;
1172
Steve French7f573562005-08-30 11:32:14 -07001173 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301175 rc = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301177 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178 }
Steve French50c2f752007-07-13 00:33:32 +00001179
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001180 if ((pTcon->ses->capabilities & CAP_UNIX) &&
1181 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
Steve French2dd29d32007-04-23 22:07:35 +00001182 le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
1183 u32 oplock = 0;
Steve Frenchf6d09982008-01-08 23:18:22 +00001184 FILE_UNIX_BASIC_INFO *pInfo =
Steve French2dd29d32007-04-23 22:07:35 +00001185 kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001186 if (pInfo == NULL) {
Steve French2dd29d32007-04-23 22:07:35 +00001187 rc = -ENOMEM;
1188 goto mkdir_out;
1189 }
Steve French50c2f752007-07-13 00:33:32 +00001190
Al Viroce3b0f82009-03-29 19:08:22 -04001191 mode &= ~current_umask();
Steve French2dd29d32007-04-23 22:07:35 +00001192 rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
1193 mode, NULL /* netfid */, pInfo, &oplock,
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001194 full_path, cifs_sb->local_nls,
1195 cifs_sb->mnt_cifs_flags &
Steve French2dd29d32007-04-23 22:07:35 +00001196 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve Frenchc45d7072007-09-17 02:04:21 +00001197 if (rc == -EOPNOTSUPP) {
1198 kfree(pInfo);
1199 goto mkdir_retry_old;
1200 } else if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001201 cFYI(1, "posix mkdir returned 0x%x", rc);
Steve French2dd29d32007-04-23 22:07:35 +00001202 d_drop(direntry);
1203 } else {
Cyril Gorcunov8f2376a2007-10-14 17:58:43 +00001204 if (pInfo->Type == cpu_to_le32(-1)) {
1205 /* no return info, go query for it */
Steve French5a07cdf2007-09-16 23:12:47 +00001206 kfree(pInfo);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001207 goto mkdir_get_info;
Steve French5a07cdf2007-09-16 23:12:47 +00001208 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001209/*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
1210 to set uid/gid */
Steve French2dd29d32007-04-23 22:07:35 +00001211 inc_nlink(inode);
1212 if (pTcon->nocase)
1213 direntry->d_op = &cifs_ci_dentry_ops;
1214 else
1215 direntry->d_op = &cifs_dentry_ops;
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001216
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001217 cifs_unix_basic_to_fattr(&fattr, pInfo, cifs_sb);
Jeff Layton4065c802010-05-17 07:18:58 -04001218 cifs_fill_uniqueid(inode->i_sb, &fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001219 newinode = cifs_iget(inode->i_sb, &fattr);
1220 if (!newinode) {
Steve French5a07cdf2007-09-16 23:12:47 +00001221 kfree(pInfo);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001222 goto mkdir_get_info;
Steve French5a07cdf2007-09-16 23:12:47 +00001223 }
Jeff Layton6b37faa2008-10-06 21:54:41 +00001224
Steve French2dd29d32007-04-23 22:07:35 +00001225 d_instantiate(direntry, newinode);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001226
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001227#ifdef CONFIG_CIFS_DEBUG2
Joe Perchesb6b38f72010-04-21 03:50:45 +00001228 cFYI(1, "instantiated dentry %p %s to inode %p",
1229 direntry, direntry->d_name.name, newinode);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001230
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001231 if (newinode->i_nlink != 2)
Joe Perchesb6b38f72010-04-21 03:50:45 +00001232 cFYI(1, "unexpected number of links %d",
1233 newinode->i_nlink);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001234#endif
Steve French2dd29d32007-04-23 22:07:35 +00001235 }
1236 kfree(pInfo);
1237 goto mkdir_out;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001238 }
Steve Frenchc45d7072007-09-17 02:04:21 +00001239mkdir_retry_old:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240 /* BB add setting the equivalent of mode via CreateX w/ACLs */
Steve French737b7582005-04-28 22:41:06 -07001241 rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
1242 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001244 cFYI(1, "cifs_mkdir returned 0x%x", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 d_drop(direntry);
1246 } else {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001247mkdir_get_info:
Dave Hansend8c76e62006-09-30 23:29:04 -07001248 inc_nlink(inode);
Steve Frenchc18c8422007-07-18 23:21:09 +00001249 if (pTcon->unix_ext)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 rc = cifs_get_inode_info_unix(&newinode, full_path,
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001251 inode->i_sb, xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 else
1253 rc = cifs_get_inode_info(&newinode, full_path, NULL,
Steve French8b1327f2008-03-14 22:37:16 +00001254 inode->i_sb, xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255
Steve Frenchb92327f2005-08-22 20:09:43 -07001256 if (pTcon->nocase)
1257 direntry->d_op = &cifs_ci_dentry_ops;
1258 else
1259 direntry->d_op = &cifs_dentry_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 d_instantiate(direntry, newinode);
Steve French2dd29d32007-04-23 22:07:35 +00001261 /* setting nlink not necessary except in cases where we
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001262 * failed to get it from the server or was set bogus */
Steve French2dd29d32007-04-23 22:07:35 +00001263 if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001264 direntry->d_inode->i_nlink = 2;
Jeff Layton95089912008-08-06 04:39:02 +00001265
Al Viroce3b0f82009-03-29 19:08:22 -04001266 mode &= ~current_umask();
Jeff Layton95089912008-08-06 04:39:02 +00001267 /* must turn on setgid bit if parent dir has it */
1268 if (inode->i_mode & S_ISGID)
1269 mode |= S_ISGID;
1270
Steve Frenchc18c8422007-07-18 23:21:09 +00001271 if (pTcon->unix_ext) {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04001272 struct cifs_unix_set_info_args args = {
1273 .mode = mode,
1274 .ctime = NO_CHANGE_64,
1275 .atime = NO_CHANGE_64,
1276 .mtime = NO_CHANGE_64,
1277 .device = 0,
1278 };
Steve Frenchd0d2f2d2005-06-02 15:12:36 -07001279 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
David Howellsa001e5b2008-11-14 10:38:47 +11001280 args.uid = (__u64)current_fsuid();
Jeff Layton95089912008-08-06 04:39:02 +00001281 if (inode->i_mode & S_ISGID)
1282 args.gid = (__u64)inode->i_gid;
1283 else
David Howellsa001e5b2008-11-14 10:38:47 +11001284 args.gid = (__u64)current_fsgid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 } else {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04001286 args.uid = NO_CHANGE_64;
1287 args.gid = NO_CHANGE_64;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 }
Jeff Layton01ea95e2009-07-09 20:02:49 -04001289 CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
1290 cifs_sb->local_nls,
1291 cifs_sb->mnt_cifs_flags &
1292 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French3ce53fc2007-06-08 14:55:14 +00001293 } else {
Jeff Layton67750fb2008-05-09 22:28:02 +00001294 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1295 (mode & S_IWUGO) == 0) {
1296 FILE_BASIC_INFO pInfo;
Jeff Layton6b37faa2008-10-06 21:54:41 +00001297 struct cifsInodeInfo *cifsInode;
1298 u32 dosattrs;
1299
Jeff Layton67750fb2008-05-09 22:28:02 +00001300 memset(&pInfo, 0, sizeof(pInfo));
Jeff Layton6b37faa2008-10-06 21:54:41 +00001301 cifsInode = CIFS_I(newinode);
1302 dosattrs = cifsInode->cifsAttrs|ATTR_READONLY;
1303 pInfo.Attributes = cpu_to_le32(dosattrs);
1304 tmprc = CIFSSMBSetPathInfo(xid, pTcon,
1305 full_path, &pInfo,
1306 cifs_sb->local_nls,
Jeff Layton67750fb2008-05-09 22:28:02 +00001307 cifs_sb->mnt_cifs_flags &
1308 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton6b37faa2008-10-06 21:54:41 +00001309 if (tmprc == 0)
1310 cifsInode->cifsAttrs = dosattrs;
Jeff Layton67750fb2008-05-09 22:28:02 +00001311 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001312 if (direntry->d_inode) {
Jeff Laytonb0fd30d2008-05-22 09:33:34 -04001313 if (cifs_sb->mnt_cifs_flags &
1314 CIFS_MOUNT_DYNPERM)
1315 direntry->d_inode->i_mode =
1316 (mode | S_IFDIR);
Steve French4e94a102008-05-23 18:22:46 +00001317
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001318 if (cifs_sb->mnt_cifs_flags &
Steve French6473a552005-11-29 20:20:10 -08001319 CIFS_MOUNT_SET_UID) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001320 direntry->d_inode->i_uid =
David Howellsa001e5b2008-11-14 10:38:47 +11001321 current_fsuid();
Jeff Layton95089912008-08-06 04:39:02 +00001322 if (inode->i_mode & S_ISGID)
1323 direntry->d_inode->i_gid =
1324 inode->i_gid;
1325 else
1326 direntry->d_inode->i_gid =
David Howellsa001e5b2008-11-14 10:38:47 +11001327 current_fsgid();
Steve French6473a552005-11-29 20:20:10 -08001328 }
1329 }
Steve French2a138ebb2005-11-29 21:22:19 -08001330 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001332mkdir_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 kfree(full_path);
1334 FreeXid(xid);
1335 return rc;
1336}
1337
1338int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1339{
1340 int rc = 0;
1341 int xid;
1342 struct cifs_sb_info *cifs_sb;
1343 struct cifsTconInfo *pTcon;
1344 char *full_path = NULL;
1345 struct cifsInodeInfo *cifsInode;
1346
Joe Perchesb6b38f72010-04-21 03:50:45 +00001347 cFYI(1, "cifs_rmdir, inode = 0x%p", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348
1349 xid = GetXid();
1350
1351 cifs_sb = CIFS_SB(inode->i_sb);
1352 pTcon = cifs_sb->tcon;
1353
Steve French7f573562005-08-30 11:32:14 -07001354 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301356 rc = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301358 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 }
1360
Steve French737b7582005-04-28 22:41:06 -07001361 rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
1362 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363
1364 if (!rc) {
Dave Hansen9a53c3a2006-09-30 23:29:03 -07001365 drop_nlink(inode);
Steve French3677db12007-02-26 16:46:11 +00001366 spin_lock(&direntry->d_inode->i_lock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001367 i_size_write(direntry->d_inode, 0);
Dave Hansence71ec32006-09-30 23:29:06 -07001368 clear_nlink(direntry->d_inode);
Steve French3677db12007-02-26 16:46:11 +00001369 spin_unlock(&direntry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 }
1371
1372 cifsInode = CIFS_I(direntry->d_inode);
1373 cifsInode->time = 0; /* force revalidate to go get info when
1374 needed */
Steve French42c24542009-01-13 22:03:55 +00001375
1376 cifsInode = CIFS_I(inode);
1377 cifsInode->time = 0; /* force revalidate to get parent dir info
1378 since cached search results now invalid */
1379
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1381 current_fs_time(inode->i_sb);
1382
1383 kfree(full_path);
1384 FreeXid(xid);
1385 return rc;
1386}
1387
Steve Frenchee2fd962008-09-23 18:23:33 +00001388static int
1389cifs_do_rename(int xid, struct dentry *from_dentry, const char *fromPath,
1390 struct dentry *to_dentry, const char *toPath)
1391{
1392 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1393 struct cifsTconInfo *pTcon = cifs_sb->tcon;
1394 __u16 srcfid;
1395 int oplock, rc;
1396
1397 /* try path-based rename first */
1398 rc = CIFSSMBRename(xid, pTcon, fromPath, toPath, cifs_sb->local_nls,
1399 cifs_sb->mnt_cifs_flags &
1400 CIFS_MOUNT_MAP_SPECIAL_CHR);
1401
1402 /*
1403 * don't bother with rename by filehandle unless file is busy and
1404 * source Note that cross directory moves do not work with
1405 * rename by filehandle to various Windows servers.
1406 */
1407 if (rc == 0 || rc != -ETXTBSY)
1408 return rc;
1409
Jeff Laytoned0e3ac2010-06-01 16:21:01 -04001410 /* open-file renames don't work across directories */
1411 if (to_dentry->d_parent != from_dentry->d_parent)
1412 return rc;
1413
Steve Frenchee2fd962008-09-23 18:23:33 +00001414 /* open the file to be renamed -- we need DELETE perms */
1415 rc = CIFSSMBOpen(xid, pTcon, fromPath, FILE_OPEN, DELETE,
1416 CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1417 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1418 CIFS_MOUNT_MAP_SPECIAL_CHR);
1419
1420 if (rc == 0) {
1421 rc = CIFSSMBRenameOpenFile(xid, pTcon, srcfid,
1422 (const char *) to_dentry->d_name.name,
1423 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1424 CIFS_MOUNT_MAP_SPECIAL_CHR);
1425
1426 CIFSSMBClose(xid, pTcon, srcfid);
1427 }
1428
1429 return rc;
1430}
1431
Jeff Layton14121bd2008-10-20 14:45:22 -04001432int cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1433 struct inode *target_dir, struct dentry *target_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434{
Steve Frenchee2fd962008-09-23 18:23:33 +00001435 char *fromName = NULL;
1436 char *toName = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437 struct cifs_sb_info *cifs_sb_source;
1438 struct cifs_sb_info *cifs_sb_target;
Jeff Layton14121bd2008-10-20 14:45:22 -04001439 struct cifsTconInfo *tcon;
Steve Frenchee2fd962008-09-23 18:23:33 +00001440 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1441 FILE_UNIX_BASIC_INFO *info_buf_target;
Jeff Layton8d281ef2008-10-22 13:57:01 -04001442 int xid, rc, tmprc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443
Jeff Layton14121bd2008-10-20 14:45:22 -04001444 cifs_sb_target = CIFS_SB(target_dir->i_sb);
1445 cifs_sb_source = CIFS_SB(source_dir->i_sb);
1446 tcon = cifs_sb_source->tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447
Steve Frenchee2fd962008-09-23 18:23:33 +00001448 xid = GetXid();
1449
1450 /*
1451 * BB: this might be allowed if same server, but different share.
1452 * Consider adding support for this
1453 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001454 if (tcon != cifs_sb_target->tcon) {
Steve Frenchee2fd962008-09-23 18:23:33 +00001455 rc = -EXDEV;
1456 goto cifs_rename_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 }
1458
Steve Frenchee2fd962008-09-23 18:23:33 +00001459 /*
1460 * we already have the rename sem so we do not need to
1461 * grab it again here to protect the path integrity
1462 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001463 fromName = build_path_from_dentry(source_dentry);
Steve Frenchee2fd962008-09-23 18:23:33 +00001464 if (fromName == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465 rc = -ENOMEM;
1466 goto cifs_rename_exit;
1467 }
1468
Jeff Layton14121bd2008-10-20 14:45:22 -04001469 toName = build_path_from_dentry(target_dentry);
Steve Frenchee2fd962008-09-23 18:23:33 +00001470 if (toName == NULL) {
1471 rc = -ENOMEM;
1472 goto cifs_rename_exit;
1473 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474
Jeff Layton14121bd2008-10-20 14:45:22 -04001475 rc = cifs_do_rename(xid, source_dentry, fromName,
1476 target_dentry, toName);
Steve Frenchee2fd962008-09-23 18:23:33 +00001477
Jeff Layton14121bd2008-10-20 14:45:22 -04001478 if (rc == -EEXIST && tcon->unix_ext) {
Steve Frenchee2fd962008-09-23 18:23:33 +00001479 /*
Jeff Layton14121bd2008-10-20 14:45:22 -04001480 * Are src and dst hardlinks of same inode? We can
1481 * only tell with unix extensions enabled
Steve Frenchee2fd962008-09-23 18:23:33 +00001482 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001483 info_buf_source =
1484 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1485 GFP_KERNEL);
1486 if (info_buf_source == NULL) {
1487 rc = -ENOMEM;
1488 goto cifs_rename_exit;
1489 }
1490
1491 info_buf_target = info_buf_source + 1;
Jeff Layton8d281ef2008-10-22 13:57:01 -04001492 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, fromName,
Jeff Layton14121bd2008-10-20 14:45:22 -04001493 info_buf_source,
1494 cifs_sb_source->local_nls,
1495 cifs_sb_source->mnt_cifs_flags &
1496 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton8d281ef2008-10-22 13:57:01 -04001497 if (tmprc != 0)
Jeff Layton14121bd2008-10-20 14:45:22 -04001498 goto unlink_target;
1499
Jeff Layton8d281ef2008-10-22 13:57:01 -04001500 tmprc = CIFSSMBUnixQPathInfo(xid, tcon,
Jeff Layton14121bd2008-10-20 14:45:22 -04001501 toName, info_buf_target,
1502 cifs_sb_target->local_nls,
1503 /* remap based on source sb */
1504 cifs_sb_source->mnt_cifs_flags &
1505 CIFS_MOUNT_MAP_SPECIAL_CHR);
1506
Jeff Layton8d281ef2008-10-22 13:57:01 -04001507 if (tmprc == 0 && (info_buf_source->UniqueId ==
Jeff Laytonae6884a2008-11-03 14:05:08 -05001508 info_buf_target->UniqueId)) {
Jeff Layton14121bd2008-10-20 14:45:22 -04001509 /* same file, POSIX says that this is a noop */
Jeff Laytonae6884a2008-11-03 14:05:08 -05001510 rc = 0;
Jeff Layton14121bd2008-10-20 14:45:22 -04001511 goto cifs_rename_exit;
Jeff Laytonae6884a2008-11-03 14:05:08 -05001512 }
Jeff Layton14121bd2008-10-20 14:45:22 -04001513 } /* else ... BB we could add the same check for Windows by
1514 checking the UniqueId via FILE_INTERNAL_INFO */
1515
Jeff Layton14121bd2008-10-20 14:45:22 -04001516unlink_target:
Jeff Laytonfc6f3942009-04-17 11:45:30 -04001517 /* Try unlinking the target dentry if it's not negative */
1518 if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
Jeff Layton8d281ef2008-10-22 13:57:01 -04001519 tmprc = cifs_unlink(target_dir, target_dentry);
Jeff Layton14121bd2008-10-20 14:45:22 -04001520 if (tmprc)
1521 goto cifs_rename_exit;
1522
Jeff Layton14121bd2008-10-20 14:45:22 -04001523 rc = cifs_do_rename(xid, source_dentry, fromName,
1524 target_dentry, toName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525 }
1526
1527cifs_rename_exit:
Steve Frenchee2fd962008-09-23 18:23:33 +00001528 kfree(info_buf_source);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 kfree(fromName);
1530 kfree(toName);
1531 FreeXid(xid);
1532 return rc;
1533}
1534
Jeff Laytondf2cf172010-02-12 07:44:16 -05001535static bool
1536cifs_inode_needs_reval(struct inode *inode)
1537{
1538 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1539
1540 if (cifs_i->clientCanCacheRead)
1541 return false;
1542
1543 if (!lookupCacheEnabled)
1544 return true;
1545
1546 if (cifs_i->time == 0)
1547 return true;
1548
1549 /* FIXME: the actimeo should be tunable */
1550 if (time_after_eq(jiffies, cifs_i->time + HZ))
1551 return true;
1552
Jeff Laytondb192722010-05-17 14:51:49 -04001553 /* hardlinked files w/ noserverino get "special" treatment */
1554 if (!(CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1555 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1556 return true;
1557
Jeff Laytondf2cf172010-02-12 07:44:16 -05001558 return false;
1559}
1560
1561/* check invalid_mapping flag and zap the cache if it's set */
1562static void
1563cifs_invalidate_mapping(struct inode *inode)
1564{
1565 int rc;
1566 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1567
1568 cifs_i->invalid_mapping = false;
1569
1570 /* write back any cached data */
1571 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1572 rc = filemap_write_and_wait(inode->i_mapping);
1573 if (rc)
1574 cifs_i->write_behind_rc = rc;
1575 }
1576 invalidate_remote_inode(inode);
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +05301577 cifs_fscache_reset_inode_cookie(inode);
Jeff Laytondf2cf172010-02-12 07:44:16 -05001578}
1579
Jeff Laytonabab0952010-02-12 07:44:18 -05001580int cifs_revalidate_file(struct file *filp)
1581{
1582 int rc = 0;
1583 struct inode *inode = filp->f_path.dentry->d_inode;
1584
1585 if (!cifs_inode_needs_reval(inode))
1586 goto check_inval;
1587
1588 if (CIFS_SB(inode->i_sb)->tcon->unix_ext)
1589 rc = cifs_get_file_info_unix(filp);
1590 else
1591 rc = cifs_get_file_info(filp);
1592
1593check_inval:
1594 if (CIFS_I(inode)->invalid_mapping)
1595 cifs_invalidate_mapping(inode);
1596
1597 return rc;
1598}
1599
Jeff Laytondf2cf172010-02-12 07:44:16 -05001600/* revalidate a dentry's inode attributes */
1601int cifs_revalidate_dentry(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602{
1603 int xid;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001604 int rc = 0;
1605 char *full_path = NULL;
1606 struct inode *inode = dentry->d_inode;
1607 struct super_block *sb = dentry->d_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608
Jeff Laytondf2cf172010-02-12 07:44:16 -05001609 if (inode == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610 return -ENOENT;
1611
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612 xid = GetXid();
1613
Jeff Laytondf2cf172010-02-12 07:44:16 -05001614 if (!cifs_inode_needs_reval(inode))
1615 goto check_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616
1617 /* can not safely grab the rename sem here if rename calls revalidate
1618 since that would deadlock */
Jeff Laytondf2cf172010-02-12 07:44:16 -05001619 full_path = build_path_from_dentry(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301621 rc = -ENOMEM;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001622 goto check_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 }
Jeff Laytondf2cf172010-02-12 07:44:16 -05001624
Steve Frenchf19159d2010-04-21 04:12:10 +00001625 cFYI(1, "Revalidate: %s inode 0x%p count %d dentry: 0x%p d_time %ld "
Jeff Laytondf2cf172010-02-12 07:44:16 -05001626 "jiffies %ld", full_path, inode, inode->i_count.counter,
Steve Frenchf19159d2010-04-21 04:12:10 +00001627 dentry, dentry->d_time, jiffies);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628
Jeff Laytondf2cf172010-02-12 07:44:16 -05001629 if (CIFS_SB(sb)->tcon->unix_ext)
1630 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1631 else
1632 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1633 xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634
Jeff Laytondf2cf172010-02-12 07:44:16 -05001635check_inval:
1636 if (CIFS_I(inode)->invalid_mapping)
1637 cifs_invalidate_mapping(inode);
Steve French50c2f752007-07-13 00:33:32 +00001638
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639 kfree(full_path);
1640 FreeXid(xid);
1641 return rc;
1642}
1643
1644int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1645 struct kstat *stat)
1646{
Jeff Laytondf2cf172010-02-12 07:44:16 -05001647 int err = cifs_revalidate_dentry(dentry);
Steve French5fe14c82006-11-07 19:26:33 +00001648 if (!err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 generic_fillattr(dentry->d_inode, stat);
Steve French5fe14c82006-11-07 19:26:33 +00001650 stat->blksize = CIFS_MAX_MSGSIZE;
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001651 stat->ino = CIFS_I(dentry->d_inode)->uniqueid;
Steve French5fe14c82006-11-07 19:26:33 +00001652 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653 return err;
1654}
1655
1656static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1657{
1658 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1659 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1660 struct page *page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661 int rc = 0;
1662
1663 page = grab_cache_page(mapping, index);
1664 if (!page)
1665 return -ENOMEM;
1666
Christoph Lametereebd2aa2008-02-04 22:28:29 -08001667 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 unlock_page(page);
1669 page_cache_release(page);
1670 return rc;
1671}
1672
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001673static int cifs_vmtruncate(struct inode *inode, loff_t offset)
Steve French3677db12007-02-26 16:46:11 +00001674{
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001675 loff_t oldsize;
1676 int err;
Steve French3677db12007-02-26 16:46:11 +00001677
Steve Frenchba6a46a2007-02-26 20:06:29 +00001678 spin_lock(&inode->i_lock);
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001679 err = inode_newsize_ok(inode, offset);
1680 if (err) {
Steve Frenchba6a46a2007-02-26 20:06:29 +00001681 spin_unlock(&inode->i_lock);
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001682 goto out;
Steve Frenchba6a46a2007-02-26 20:06:29 +00001683 }
Steve French3677db12007-02-26 16:46:11 +00001684
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001685 oldsize = inode->i_size;
Steve French3677db12007-02-26 16:46:11 +00001686 i_size_write(inode, offset);
Steve Frenchba6a46a2007-02-26 20:06:29 +00001687 spin_unlock(&inode->i_lock);
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001688 truncate_pagecache(inode, oldsize, offset);
Al Viroacfa4382008-12-04 10:06:33 -05001689 if (inode->i_op->truncate)
Steve French3677db12007-02-26 16:46:11 +00001690 inode->i_op->truncate(inode);
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001691out:
1692 return err;
Steve French3677db12007-02-26 16:46:11 +00001693}
1694
Jeff Layton8efdbde2008-07-23 21:28:12 +00001695static int
1696cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1697 int xid, char *full_path)
1698{
1699 int rc;
1700 struct cifsFileInfo *open_file;
1701 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1702 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1703 struct cifsTconInfo *pTcon = cifs_sb->tcon;
1704
1705 /*
1706 * To avoid spurious oplock breaks from server, in the case of
1707 * inodes that we already have open, avoid doing path based
1708 * setting of file size if we can do it by handle.
1709 * This keeps our caching token (oplock) and avoids timeouts
1710 * when the local oplock break takes longer to flush
1711 * writebehind data than the SMB timeout for the SetPathInfo
1712 * request would allow
1713 */
1714 open_file = find_writable_file(cifsInode);
1715 if (open_file) {
1716 __u16 nfid = open_file->netfid;
1717 __u32 npid = open_file->pid;
1718 rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size, nfid,
1719 npid, false);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001720 cifsFileInfo_put(open_file);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001721 cFYI(1, "SetFSize for attrs rc = %d", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001722 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1723 unsigned int bytes_written;
1724 rc = CIFSSMBWrite(xid, pTcon, nfid, 0, attrs->ia_size,
1725 &bytes_written, NULL, NULL, 1);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001726 cFYI(1, "Wrt seteof rc %d", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001727 }
1728 } else
1729 rc = -EINVAL;
1730
1731 if (rc != 0) {
1732 /* Set file size by pathname rather than by handle
1733 either because no valid, writeable file handle for
1734 it was found or because there was an error setting
1735 it by handle */
1736 rc = CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size,
1737 false, cifs_sb->local_nls,
1738 cifs_sb->mnt_cifs_flags &
1739 CIFS_MOUNT_MAP_SPECIAL_CHR);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001740 cFYI(1, "SetEOF by path (setattrs) rc = %d", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001741 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1742 __u16 netfid;
1743 int oplock = 0;
1744
1745 rc = SMBLegacyOpen(xid, pTcon, full_path,
1746 FILE_OPEN, GENERIC_WRITE,
1747 CREATE_NOT_DIR, &netfid, &oplock, NULL,
1748 cifs_sb->local_nls,
1749 cifs_sb->mnt_cifs_flags &
1750 CIFS_MOUNT_MAP_SPECIAL_CHR);
1751 if (rc == 0) {
1752 unsigned int bytes_written;
1753 rc = CIFSSMBWrite(xid, pTcon, netfid, 0,
1754 attrs->ia_size,
1755 &bytes_written, NULL,
1756 NULL, 1);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001757 cFYI(1, "wrt seteof rc %d", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001758 CIFSSMBClose(xid, pTcon, netfid);
1759 }
1760 }
1761 }
1762
1763 if (rc == 0) {
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001764 cifsInode->server_eof = attrs->ia_size;
Jeff Layton8efdbde2008-07-23 21:28:12 +00001765 rc = cifs_vmtruncate(inode, attrs->ia_size);
1766 cifs_truncate_page(inode->i_mapping, inode->i_size);
1767 }
1768
1769 return rc;
1770}
1771
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001772static int
1773cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1774{
1775 int rc;
1776 int xid;
1777 char *full_path = NULL;
1778 struct inode *inode = direntry->d_inode;
1779 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1780 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1781 struct cifsTconInfo *pTcon = cifs_sb->tcon;
1782 struct cifs_unix_set_info_args *args = NULL;
Jeff Layton3bbeeb32009-07-09 20:02:50 -04001783 struct cifsFileInfo *open_file;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001784
Joe Perchesb6b38f72010-04-21 03:50:45 +00001785 cFYI(1, "setattr_unix on file %s attrs->ia_valid=0x%x",
1786 direntry->d_name.name, attrs->ia_valid);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001787
1788 xid = GetXid();
1789
1790 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) == 0) {
1791 /* check if we have permission to change attrs */
1792 rc = inode_change_ok(inode, attrs);
1793 if (rc < 0)
1794 goto out;
1795 else
1796 rc = 0;
1797 }
1798
1799 full_path = build_path_from_dentry(direntry);
1800 if (full_path == NULL) {
1801 rc = -ENOMEM;
1802 goto out;
1803 }
1804
Jeff Layton0f4d6342009-03-26 13:35:37 -04001805 /*
1806 * Attempt to flush data before changing attributes. We need to do
1807 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1808 * ownership or mode then we may also need to do this. Here, we take
1809 * the safe way out and just do the flush on all setattr requests. If
1810 * the flush returns error, store it to report later and continue.
1811 *
1812 * BB: This should be smarter. Why bother flushing pages that
1813 * will be truncated anyway? Also, should we error out here if
1814 * the flush returns error?
1815 */
1816 rc = filemap_write_and_wait(inode->i_mapping);
1817 if (rc != 0) {
1818 cifsInode->write_behind_rc = rc;
1819 rc = 0;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001820 }
1821
1822 if (attrs->ia_valid & ATTR_SIZE) {
1823 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1824 if (rc != 0)
1825 goto out;
1826 }
1827
1828 /* skip mode change if it's just for clearing setuid/setgid */
1829 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1830 attrs->ia_valid &= ~ATTR_MODE;
1831
1832 args = kmalloc(sizeof(*args), GFP_KERNEL);
1833 if (args == NULL) {
1834 rc = -ENOMEM;
1835 goto out;
1836 }
1837
1838 /* set up the struct */
1839 if (attrs->ia_valid & ATTR_MODE)
1840 args->mode = attrs->ia_mode;
1841 else
1842 args->mode = NO_CHANGE_64;
1843
1844 if (attrs->ia_valid & ATTR_UID)
1845 args->uid = attrs->ia_uid;
1846 else
1847 args->uid = NO_CHANGE_64;
1848
1849 if (attrs->ia_valid & ATTR_GID)
1850 args->gid = attrs->ia_gid;
1851 else
1852 args->gid = NO_CHANGE_64;
1853
1854 if (attrs->ia_valid & ATTR_ATIME)
1855 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
1856 else
1857 args->atime = NO_CHANGE_64;
1858
1859 if (attrs->ia_valid & ATTR_MTIME)
1860 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
1861 else
1862 args->mtime = NO_CHANGE_64;
1863
1864 if (attrs->ia_valid & ATTR_CTIME)
1865 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
1866 else
1867 args->ctime = NO_CHANGE_64;
1868
1869 args->device = 0;
Jeff Layton3bbeeb32009-07-09 20:02:50 -04001870 open_file = find_writable_file(cifsInode);
1871 if (open_file) {
1872 u16 nfid = open_file->netfid;
1873 u32 npid = open_file->pid;
1874 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001875 cifsFileInfo_put(open_file);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04001876 } else {
1877 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
Jeff Layton01ea95e2009-07-09 20:02:49 -04001878 cifs_sb->local_nls,
1879 cifs_sb->mnt_cifs_flags &
1880 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04001881 }
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001882
Steve Frenchccd4bb12010-02-08 17:39:58 +00001883 if (!rc) {
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001884 rc = inode_setattr(inode, attrs);
Steve Frenchccd4bb12010-02-08 17:39:58 +00001885
1886 /* force revalidate when any of these times are set since some
1887 of the fs types (eg ext3, fat) do not have fine enough
1888 time granularity to match protocol, and we do not have a
1889 a way (yet) to query the server fs's time granularity (and
1890 whether it rounds times down).
1891 */
1892 if (!rc && (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME)))
1893 cifsInode->time = 0;
1894 }
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001895out:
1896 kfree(args);
1897 kfree(full_path);
1898 FreeXid(xid);
1899 return rc;
1900}
1901
Jeff Layton0510eeb2008-08-02 07:26:12 -04001902static int
1903cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904{
1905 int xid;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001906 struct inode *inode = direntry->d_inode;
1907 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001908 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 char *full_path = NULL;
1910 int rc = -EACCES;
Jeff Laytonfeb3e202008-08-02 07:26:12 -04001911 __u32 dosattr = 0;
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04001912 __u64 mode = NO_CHANGE_64;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001913
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914 xid = GetXid();
1915
Joe Perchesb6b38f72010-04-21 03:50:45 +00001916 cFYI(1, "setattr on file %s attrs->iavalid 0x%x",
1917 direntry->d_name.name, attrs->ia_valid);
Steve French6473a552005-11-29 20:20:10 -08001918
Steve French2a138ebb2005-11-29 21:22:19 -08001919 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) == 0) {
Steve French6473a552005-11-29 20:20:10 -08001920 /* check if we have permission to change attrs */
Jeff Layton02eadef2008-05-09 21:26:11 +00001921 rc = inode_change_ok(inode, attrs);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001922 if (rc < 0) {
Steve French6473a552005-11-29 20:20:10 -08001923 FreeXid(xid);
1924 return rc;
1925 } else
1926 rc = 0;
1927 }
Steve French50c2f752007-07-13 00:33:32 +00001928
Steve French7f573562005-08-30 11:32:14 -07001929 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301931 rc = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301933 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935
Jeff Layton0f4d6342009-03-26 13:35:37 -04001936 /*
1937 * Attempt to flush data before changing attributes. We need to do
1938 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1939 * ownership or mode then we may also need to do this. Here, we take
1940 * the safe way out and just do the flush on all setattr requests. If
1941 * the flush returns error, store it to report later and continue.
1942 *
1943 * BB: This should be smarter. Why bother flushing pages that
1944 * will be truncated anyway? Also, should we error out here if
1945 * the flush returns error?
1946 */
1947 rc = filemap_write_and_wait(inode->i_mapping);
1948 if (rc != 0) {
1949 cifsInode->write_behind_rc = rc;
1950 rc = 0;
Steve French50531442008-03-14 19:21:31 +00001951 }
Jeff Laytoncea21802007-11-20 23:19:03 +00001952
Steve French50531442008-03-14 19:21:31 +00001953 if (attrs->ia_valid & ATTR_SIZE) {
Jeff Layton8efdbde2008-07-23 21:28:12 +00001954 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1955 if (rc != 0)
Steve Frenche30dcf32005-09-20 20:49:16 -07001956 goto cifs_setattr_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957 }
Jeff Layton4ca691a2008-05-22 09:33:34 -04001958
1959 /*
1960 * Without unix extensions we can't send ownership changes to the
1961 * server, so silently ignore them. This is consistent with how
1962 * local DOS/Windows filesystems behave (VFAT, NTFS, etc). With
1963 * CIFSACL support + proper Windows to Unix idmapping, we may be
1964 * able to support this in the future.
1965 */
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001966 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
Jeff Layton4ca691a2008-05-22 09:33:34 -04001967 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968
Jeff Laytond32c4f22007-10-18 03:05:22 -07001969 /* skip mode change if it's just for clearing setuid/setgid */
1970 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1971 attrs->ia_valid &= ~ATTR_MODE;
1972
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973 if (attrs->ia_valid & ATTR_MODE) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001974 cFYI(1, "Mode changed to 0%o", attrs->ia_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975 mode = attrs->ia_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976 }
1977
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001978 if (attrs->ia_valid & ATTR_MODE) {
Steve Frenchcdbce9c2005-11-19 21:04:52 -08001979 rc = 0;
Steve French97837582007-12-31 07:47:21 +00001980#ifdef CONFIG_CIFS_EXPERIMENTAL
1981 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
Jeff Layton02eadef2008-05-09 21:26:11 +00001982 rc = mode_to_acl(inode, full_path, mode);
Jeff Layton51328612008-05-22 09:33:34 -04001983 else
Steve French97837582007-12-31 07:47:21 +00001984#endif
Jeff Layton51328612008-05-22 09:33:34 -04001985 if (((mode & S_IWUGO) == 0) &&
1986 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04001987
1988 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
1989
Jeff Layton51328612008-05-22 09:33:34 -04001990 /* fix up mode if we're not using dynperm */
1991 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
1992 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
1993 } else if ((mode & S_IWUGO) &&
1994 (cifsInode->cifsAttrs & ATTR_READONLY)) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04001995
1996 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
1997 /* Attributes of 0 are ignored */
1998 if (dosattr == 0)
1999 dosattr |= ATTR_NORMAL;
Jeff Layton51328612008-05-22 09:33:34 -04002000
2001 /* reset local inode permissions to normal */
2002 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2003 attrs->ia_mode &= ~(S_IALLUGO);
2004 if (S_ISDIR(inode->i_mode))
2005 attrs->ia_mode |=
2006 cifs_sb->mnt_dir_mode;
2007 else
2008 attrs->ia_mode |=
2009 cifs_sb->mnt_file_mode;
2010 }
2011 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2012 /* ignore mode change - ATTR_READONLY hasn't changed */
2013 attrs->ia_valid &= ~ATTR_MODE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002014 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015 }
2016
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002017 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2018 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2019 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2020 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002021
Steve Frenche30dcf32005-09-20 20:49:16 -07002022 /* Even if error on time set, no sense failing the call if
2023 the server would set the time to a reasonable value anyway,
2024 and this check ensures that we are not being called from
2025 sys_utimes in which case we ought to fail the call back to
2026 the user when the server rejects the call */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002027 if ((rc) && (attrs->ia_valid &
Jeff Laytonfeb3e202008-08-02 07:26:12 -04002028 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
Steve Frenche30dcf32005-09-20 20:49:16 -07002029 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030 }
2031
2032 /* do not need local check to inode_check_ok since the server does
2033 that */
2034 if (!rc)
Jeff Layton02eadef2008-05-09 21:26:11 +00002035 rc = inode_setattr(inode, attrs);
Steve Frenche30dcf32005-09-20 20:49:16 -07002036cifs_setattr_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002037 kfree(full_path);
2038 FreeXid(xid);
2039 return rc;
2040}
2041
Jeff Layton0510eeb2008-08-02 07:26:12 -04002042int
2043cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2044{
2045 struct inode *inode = direntry->d_inode;
2046 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2047 struct cifsTconInfo *pTcon = cifs_sb->tcon;
2048
2049 if (pTcon->unix_ext)
2050 return cifs_setattr_unix(direntry, attrs);
2051
2052 return cifs_setattr_nounix(direntry, attrs);
2053
2054 /* BB: add cifs_setattr_legacy for really old servers */
2055}
2056
Steve French99ee4db2007-02-27 05:35:17 +00002057#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058void cifs_delete_inode(struct inode *inode)
2059{
Joe Perchesb6b38f72010-04-21 03:50:45 +00002060 cFYI(1, "In cifs_delete_inode, inode = 0x%p", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002061 /* may have to add back in if and when safe distributed caching of
2062 directories added e.g. via FindNotify */
2063}
Steve French99ee4db2007-02-27 05:35:17 +00002064#endif