blob: b35cb031c20cbd965b036c4ce2c4dafd4f84d487 [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"
32
Christoph Hellwig70eff552008-02-15 20:55:05 +000033
Igor Mammedov79626702008-03-09 03:44:18 +000034static void cifs_set_ops(struct inode *inode, const bool is_dfs_referral)
Christoph Hellwig70eff552008-02-15 20:55:05 +000035{
36 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
37
38 switch (inode->i_mode & S_IFMT) {
39 case S_IFREG:
40 inode->i_op = &cifs_file_inode_ops;
41 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
42 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
43 inode->i_fop = &cifs_file_direct_nobrl_ops;
44 else
45 inode->i_fop = &cifs_file_direct_ops;
46 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
47 inode->i_fop = &cifs_file_nobrl_ops;
48 else { /* not direct, send byte range locks */
49 inode->i_fop = &cifs_file_ops;
50 }
51
52
53 /* check if server can support readpages */
54 if (cifs_sb->tcon->ses->server->maxBuf <
55 PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
56 inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
57 else
58 inode->i_data.a_ops = &cifs_addr_ops;
59 break;
60 case S_IFDIR:
Steve Frenchbc5b6e22008-03-11 21:07:48 +000061#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov79626702008-03-09 03:44:18 +000062 if (is_dfs_referral) {
63 inode->i_op = &cifs_dfs_referral_inode_operations;
64 } else {
Steve Frenchbc5b6e22008-03-11 21:07:48 +000065#else /* NO DFS support, treat as a directory */
66 {
67#endif
Igor Mammedov79626702008-03-09 03:44:18 +000068 inode->i_op = &cifs_dir_inode_ops;
69 inode->i_fop = &cifs_dir_ops;
70 }
Christoph Hellwig70eff552008-02-15 20:55:05 +000071 break;
72 case S_IFLNK:
73 inode->i_op = &cifs_symlink_inode_ops;
74 break;
75 default:
76 init_special_inode(inode, inode->i_mode, inode->i_rdev);
77 break;
78 }
79}
80
Jeff Laytondf2cf172010-02-12 07:44:16 -050081/* check inode attributes against fattr. If they don't match, tag the
82 * inode for cache invalidation
83 */
84static void
85cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
86{
87 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
88
Steve Frenchf19159d2010-04-21 04:12:10 +000089 cFYI(1, "%s: revalidating inode %llu", __func__, cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -050090
91 if (inode->i_state & I_NEW) {
Steve Frenchf19159d2010-04-21 04:12:10 +000092 cFYI(1, "%s: inode %llu is new", __func__, cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -050093 return;
94 }
95
96 /* don't bother with revalidation if we have an oplock */
97 if (cifs_i->clientCanCacheRead) {
Steve Frenchf19159d2010-04-21 04:12:10 +000098 cFYI(1, "%s: inode %llu is oplocked", __func__,
99 cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -0500100 return;
101 }
102
103 /* revalidate if mtime or size have changed */
104 if (timespec_equal(&inode->i_mtime, &fattr->cf_mtime) &&
105 cifs_i->server_eof == fattr->cf_eof) {
Steve Frenchf19159d2010-04-21 04:12:10 +0000106 cFYI(1, "%s: inode %llu is unchanged", __func__,
107 cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -0500108 return;
109 }
110
Steve Frenchf19159d2010-04-21 04:12:10 +0000111 cFYI(1, "%s: invalidating inode %llu mapping", __func__,
112 cifs_i->uniqueid);
Jeff Laytondf2cf172010-02-12 07:44:16 -0500113 cifs_i->invalid_mapping = true;
114}
115
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400116/* populate an inode with info from a cifs_fattr struct */
117void
118cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
Christoph Hellwig75f12982008-02-25 20:25:21 +0000119{
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400120 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400121 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
122 unsigned long oldtime = cifs_i->time;
Christoph Hellwig75f12982008-02-25 20:25:21 +0000123
Jeff Laytondf2cf172010-02-12 07:44:16 -0500124 cifs_revalidate_cache(inode, fattr);
125
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400126 inode->i_atime = fattr->cf_atime;
127 inode->i_mtime = fattr->cf_mtime;
128 inode->i_ctime = fattr->cf_ctime;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400129 inode->i_rdev = fattr->cf_rdev;
130 inode->i_nlink = fattr->cf_nlink;
131 inode->i_uid = fattr->cf_uid;
132 inode->i_gid = fattr->cf_gid;
133
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400134 /* if dynperm is set, don't clobber existing mode */
135 if (inode->i_state & I_NEW ||
136 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
137 inode->i_mode = fattr->cf_mode;
138
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400139 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
140 cifs_i->uniqueid = fattr->cf_uniqueid;
141
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 Laytoncc0bad72009-06-25 00:56:52 -0400173/* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
174void
175cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
176 struct cifs_sb_info *cifs_sb)
177{
178 memset(fattr, 0, sizeof(*fattr));
179 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
180 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
181 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
182
183 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
184 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
185 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
186 fattr->cf_mode = le64_to_cpu(info->Permissions);
187
188 /*
189 * Since we set the inode type below we need to mask off
190 * to avoid strange results if bits set above.
191 */
192 fattr->cf_mode &= ~S_IFMT;
193 switch (le32_to_cpu(info->Type)) {
194 case UNIX_FILE:
195 fattr->cf_mode |= S_IFREG;
196 fattr->cf_dtype = DT_REG;
197 break;
198 case UNIX_SYMLINK:
199 fattr->cf_mode |= S_IFLNK;
200 fattr->cf_dtype = DT_LNK;
201 break;
202 case UNIX_DIR:
203 fattr->cf_mode |= S_IFDIR;
204 fattr->cf_dtype = DT_DIR;
205 break;
206 case UNIX_CHARDEV:
207 fattr->cf_mode |= S_IFCHR;
208 fattr->cf_dtype = DT_CHR;
209 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
210 le64_to_cpu(info->DevMinor) & MINORMASK);
211 break;
212 case UNIX_BLOCKDEV:
213 fattr->cf_mode |= S_IFBLK;
214 fattr->cf_dtype = DT_BLK;
215 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
216 le64_to_cpu(info->DevMinor) & MINORMASK);
217 break;
218 case UNIX_FIFO:
219 fattr->cf_mode |= S_IFIFO;
220 fattr->cf_dtype = DT_FIFO;
221 break;
222 case UNIX_SOCKET:
223 fattr->cf_mode |= S_IFSOCK;
224 fattr->cf_dtype = DT_SOCK;
225 break;
226 default:
227 /* safest to call it a file if we do not know */
228 fattr->cf_mode |= S_IFREG;
229 fattr->cf_dtype = DT_REG;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000230 cFYI(1, "unknown type %d", le32_to_cpu(info->Type));
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400231 break;
232 }
233
234 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
235 fattr->cf_uid = cifs_sb->mnt_uid;
236 else
237 fattr->cf_uid = le64_to_cpu(info->Uid);
238
239 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
240 fattr->cf_gid = cifs_sb->mnt_gid;
241 else
242 fattr->cf_gid = le64_to_cpu(info->Gid);
243
244 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
245}
Steve Frenchb9a32602008-05-20 21:52:32 +0000246
247/*
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400248 * Fill a cifs_fattr struct with fake inode info.
249 *
250 * Needed to setup cifs_fattr data for the directory which is the
251 * junction to the new submount (ie to setup the fake directory
252 * which represents a DFS referral).
Steve Frenchb9a32602008-05-20 21:52:32 +0000253 */
Steve Frenchf1230c92009-07-22 23:13:01 +0000254static void
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400255cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
Steve French0e4bbde2008-05-20 19:50:46 +0000256{
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400257 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Steve French0e4bbde2008-05-20 19:50:46 +0000258
Joe Perchesb6b38f72010-04-21 03:50:45 +0000259 cFYI(1, "creating fake fattr for DFS referral");
Steve French0e4bbde2008-05-20 19:50:46 +0000260
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400261 memset(fattr, 0, sizeof(*fattr));
262 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
263 fattr->cf_uid = cifs_sb->mnt_uid;
264 fattr->cf_gid = cifs_sb->mnt_gid;
265 fattr->cf_atime = CURRENT_TIME;
266 fattr->cf_ctime = CURRENT_TIME;
267 fattr->cf_mtime = CURRENT_TIME;
268 fattr->cf_nlink = 2;
269 fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
Steve French0e4bbde2008-05-20 19:50:46 +0000270}
271
Jeff Laytonabab0952010-02-12 07:44:18 -0500272int cifs_get_file_info_unix(struct file *filp)
273{
274 int rc;
275 int xid;
276 FILE_UNIX_BASIC_INFO find_data;
277 struct cifs_fattr fattr;
278 struct inode *inode = filp->f_path.dentry->d_inode;
279 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
280 struct cifsTconInfo *tcon = cifs_sb->tcon;
281 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
282
283 xid = GetXid();
284 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->netfid, &find_data);
285 if (!rc) {
286 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
287 } else if (rc == -EREMOTE) {
288 cifs_create_dfs_fattr(&fattr, inode->i_sb);
289 rc = 0;
290 }
291
292 cifs_fattr_to_inode(inode, &fattr);
293 FreeXid(xid);
294 return rc;
295}
296
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297int cifs_get_inode_info_unix(struct inode **pinode,
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400298 const unsigned char *full_path,
299 struct super_block *sb, int xid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300{
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400301 int rc;
Steve French0e4bbde2008-05-20 19:50:46 +0000302 FILE_UNIX_BASIC_INFO find_data;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400303 struct cifs_fattr fattr;
304 struct cifsTconInfo *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400307 tcon = cifs_sb->tcon;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000308 cFYI(1, "Getting info on %s", full_path);
Igor Mammedov79626702008-03-09 03:44:18 +0000309
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 /* could have done a find first instead but this returns more info */
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400311 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
Steve French737b7582005-04-28 22:41:06 -0700312 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
313 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400314
315 if (!rc) {
316 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
317 } else if (rc == -EREMOTE) {
318 cifs_create_dfs_fattr(&fattr, sb);
Jeff Laytone911d0c2008-07-12 13:47:59 -0700319 rc = 0;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400320 } else {
321 return rc;
Steve French0e4bbde2008-05-20 19:50:46 +0000322 }
323
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400324 if (*pinode == NULL) {
325 /* get new inode */
326 *pinode = cifs_iget(sb, &fattr);
327 if (!*pinode)
328 rc = -ENOMEM;
329 } else {
330 /* we already have inode, update it */
331 cifs_fattr_to_inode(*pinode, &fattr);
332 }
Steve French0e4bbde2008-05-20 19:50:46 +0000333
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 return rc;
335}
336
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400337static int
338cifs_sfu_type(struct cifs_fattr *fattr, const unsigned char *path,
339 struct cifs_sb_info *cifs_sb, int xid)
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800340{
341 int rc;
Steve French4b18f2a2008-04-29 00:06:05 +0000342 int oplock = 0;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800343 __u16 netfid;
344 struct cifsTconInfo *pTcon = cifs_sb->tcon;
Steve French86c96b42005-11-18 20:25:31 -0800345 char buf[24];
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800346 unsigned int bytes_read;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000347 char *pbuf;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800348
349 pbuf = buf;
350
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400351 fattr->cf_mode &= ~S_IFMT;
352
353 if (fattr->cf_eof == 0) {
354 fattr->cf_mode |= S_IFIFO;
355 fattr->cf_dtype = DT_FIFO;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800356 return 0;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400357 } else if (fattr->cf_eof < 8) {
358 fattr->cf_mode |= S_IFREG;
359 fattr->cf_dtype = DT_REG;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800360 return -EINVAL; /* EOPNOTSUPP? */
361 }
Steve French50c2f752007-07-13 00:33:32 +0000362
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800363 rc = CIFSSMBOpen(xid, pTcon, path, FILE_OPEN, GENERIC_READ,
364 CREATE_NOT_DIR, &netfid, &oplock, NULL,
365 cifs_sb->local_nls,
366 cifs_sb->mnt_cifs_flags &
367 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000368 if (rc == 0) {
Steve Frenchec637e32005-12-12 20:53:18 -0800369 int buf_type = CIFS_NO_BUFFER;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800370 /* Read header */
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400371 rc = CIFSSMBRead(xid, pTcon, netfid,
Steve French86c96b42005-11-18 20:25:31 -0800372 24 /* length */, 0 /* offset */,
Steve Frenchec637e32005-12-12 20:53:18 -0800373 &bytes_read, &pbuf, &buf_type);
Steve French4523cc32007-04-30 20:13:06 +0000374 if ((rc == 0) && (bytes_read >= 8)) {
375 if (memcmp("IntxBLK", pbuf, 8) == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000376 cFYI(1, "Block device");
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400377 fattr->cf_mode |= S_IFBLK;
378 fattr->cf_dtype = DT_BLK;
Steve French4523cc32007-04-30 20:13:06 +0000379 if (bytes_read == 24) {
Steve French86c96b42005-11-18 20:25:31 -0800380 /* we have enough to decode dev num */
381 __u64 mjr; /* major */
382 __u64 mnr; /* minor */
383 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
384 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400385 fattr->cf_rdev = MKDEV(mjr, mnr);
Steve French86c96b42005-11-18 20:25:31 -0800386 }
Steve French4523cc32007-04-30 20:13:06 +0000387 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000388 cFYI(1, "Char device");
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400389 fattr->cf_mode |= S_IFCHR;
390 fattr->cf_dtype = DT_CHR;
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 Frenchfb8c4b12007-07-10 01:16:18 +0000398 }
Steve French4523cc32007-04-30 20:13:06 +0000399 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000400 cFYI(1, "Symlink");
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400401 fattr->cf_mode |= S_IFLNK;
402 fattr->cf_dtype = DT_LNK;
Steve French86c96b42005-11-18 20:25:31 -0800403 } else {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400404 fattr->cf_mode |= S_IFREG; /* file? */
405 fattr->cf_dtype = DT_REG;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000406 rc = -EOPNOTSUPP;
Steve French86c96b42005-11-18 20:25:31 -0800407 }
Steve French3020a1f2005-11-18 11:31:10 -0800408 } else {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400409 fattr->cf_mode |= S_IFREG; /* then it is a file */
410 fattr->cf_dtype = DT_REG;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000411 rc = -EOPNOTSUPP; /* or some unknown SFU type */
412 }
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800413 CIFSSMBClose(xid, pTcon, netfid);
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800414 }
415 return rc;
Steve Frenchd6e2f2a42005-11-15 16:43:39 -0800416}
417
Steve French9e294f12005-11-17 16:59:21 -0800418#define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
419
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400420/*
421 * Fetch mode bits as provided by SFU.
422 *
423 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
424 */
425static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
426 struct cifs_sb_info *cifs_sb, int xid)
Steve French9e294f12005-11-17 16:59:21 -0800427{
Steve French3020a1f2005-11-18 11:31:10 -0800428#ifdef CONFIG_CIFS_XATTR
Steve French9e294f12005-11-17 16:59:21 -0800429 ssize_t rc;
430 char ea_value[4];
431 __u32 mode;
432
Jeff Layton31c05192010-02-10 16:18:26 -0500433 rc = CIFSSMBQAllEAs(xid, cifs_sb->tcon, path, "SETFILEBITS",
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400434 ea_value, 4 /* size of buf */, cifs_sb->local_nls,
435 cifs_sb->mnt_cifs_flags &
436 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French4523cc32007-04-30 20:13:06 +0000437 if (rc < 0)
Steve French9e294f12005-11-17 16:59:21 -0800438 return (int)rc;
439 else if (rc > 3) {
440 mode = le32_to_cpu(*((__le32 *)ea_value));
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400441 fattr->cf_mode &= ~SFBITS_MASK;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000442 cFYI(1, "special bits 0%o org mode 0%o", mode,
443 fattr->cf_mode);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400444 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000445 cFYI(1, "special mode bits 0%o", mode);
Steve French9e294f12005-11-17 16:59:21 -0800446 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400447
448 return 0;
Steve French3020a1f2005-11-18 11:31:10 -0800449#else
450 return -EOPNOTSUPP;
451#endif
Steve French9e294f12005-11-17 16:59:21 -0800452}
453
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400454/* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
Steve Frenchf1230c92009-07-22 23:13:01 +0000455static void
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400456cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
457 struct cifs_sb_info *cifs_sb, bool adjust_tz)
Steve Frenchb9a32602008-05-20 21:52:32 +0000458{
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400459 memset(fattr, 0, sizeof(*fattr));
460 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
461 if (info->DeletePending)
462 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
Steve Frenchb9a32602008-05-20 21:52:32 +0000463
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400464 if (info->LastAccessTime)
465 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
466 else
467 fattr->cf_atime = CURRENT_TIME;
468
469 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
470 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
471
472 if (adjust_tz) {
473 fattr->cf_ctime.tv_sec += cifs_sb->tcon->ses->server->timeAdj;
474 fattr->cf_mtime.tv_sec += cifs_sb->tcon->ses->server->timeAdj;
475 }
476
477 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
478 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
479
480 if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
481 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
482 fattr->cf_dtype = DT_DIR;
483 } else {
484 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
485 fattr->cf_dtype = DT_REG;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400486
Jeff Laytond0c280d2009-07-09 01:46:44 -0400487 /* clear write bits if ATTR_READONLY is set */
488 if (fattr->cf_cifsattrs & ATTR_READONLY)
489 fattr->cf_mode &= ~(S_IWUGO);
490 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400491
492 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
493
494 fattr->cf_uid = cifs_sb->mnt_uid;
495 fattr->cf_gid = cifs_sb->mnt_gid;
Steve Frenchb9a32602008-05-20 21:52:32 +0000496}
497
Jeff Laytonabab0952010-02-12 07:44:18 -0500498int cifs_get_file_info(struct file *filp)
499{
500 int rc;
501 int xid;
502 FILE_ALL_INFO find_data;
503 struct cifs_fattr fattr;
504 struct inode *inode = filp->f_path.dentry->d_inode;
505 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
506 struct cifsTconInfo *tcon = cifs_sb->tcon;
507 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
508
509 xid = GetXid();
510 rc = CIFSSMBQFileInfo(xid, tcon, cfile->netfid, &find_data);
511 if (rc == -EOPNOTSUPP || rc == -EINVAL) {
512 /*
513 * FIXME: legacy server -- fall back to path-based call?
Steve Frenchff2157132010-03-09 20:30:42 +0000514 * for now, just skip revalidating and mark inode for
515 * immediate reval.
516 */
Jeff Laytonabab0952010-02-12 07:44:18 -0500517 rc = 0;
518 CIFS_I(inode)->time = 0;
519 goto cgfi_exit;
520 } else if (rc == -EREMOTE) {
521 cifs_create_dfs_fattr(&fattr, inode->i_sb);
522 rc = 0;
523 } else if (rc)
524 goto cgfi_exit;
525
526 /*
527 * don't bother with SFU junk here -- just mark inode as needing
528 * revalidation.
529 */
530 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false);
531 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
532 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
533 cifs_fattr_to_inode(inode, &fattr);
534cgfi_exit:
535 FreeXid(xid);
536 return rc;
537}
538
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539int cifs_get_inode_info(struct inode **pinode,
Steve French646dd532008-05-15 01:50:56 +0000540 const unsigned char *full_path, FILE_ALL_INFO *pfindData,
Steve French8b1327f2008-03-14 22:37:16 +0000541 struct super_block *sb, int xid, const __u16 *pfid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542{
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400543 int rc = 0, tmprc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 struct cifsTconInfo *pTcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 char *buf = NULL;
Steve French5ade9de2008-05-02 20:56:23 +0000547 bool adjustTZ = false;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400548 struct cifs_fattr fattr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549
550 pTcon = cifs_sb->tcon;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000551 cFYI(1, "Getting info on %s", full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552
Steve Frenchd0d2f2d2005-06-02 15:12:36 -0700553 if ((pfindData == NULL) && (*pinode != NULL)) {
554 if (CIFS_I(*pinode)->clientCanCacheRead) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000555 cFYI(1, "No need to revalidate cached inode sizes");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 return rc;
557 }
558 }
559
560 /* if file info not passed in then get it from server */
Steve Frenchd0d2f2d2005-06-02 15:12:36 -0700561 if (pfindData == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
Steve Frenchd0d2f2d2005-06-02 15:12:36 -0700563 if (buf == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 return -ENOMEM;
565 pfindData = (FILE_ALL_INFO *)buf;
Igor Mammedov79626702008-03-09 03:44:18 +0000566
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 /* could do find first instead but this returns more info */
Igor Mammedov79626702008-03-09 03:44:18 +0000568 rc = CIFSSMBQPathInfo(xid, pTcon, full_path, pfindData,
Steve Frenchacf1a1b2006-10-12 03:28:28 +0000569 0 /* not legacy */,
Steve French6b8edfe2005-08-23 20:26:03 -0700570 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700571 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French6b8edfe2005-08-23 20:26:03 -0700572 /* BB optimize code so we do not make the above call
573 when server claims no NT SMB support and the above call
574 failed at least once - set flag in tcon or mount */
Steve French4523cc32007-04-30 20:13:06 +0000575 if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
Igor Mammedov79626702008-03-09 03:44:18 +0000576 rc = SMBQueryInformation(xid, pTcon, full_path,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000577 pfindData, cifs_sb->local_nls,
Steve French6b8edfe2005-08-23 20:26:03 -0700578 cifs_sb->mnt_cifs_flags &
579 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French4b18f2a2008-04-29 00:06:05 +0000580 adjustTZ = true;
Steve French6b8edfe2005-08-23 20:26:03 -0700581 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 }
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400583
584 if (!rc) {
585 cifs_all_info_to_fattr(&fattr, (FILE_ALL_INFO *) pfindData,
586 cifs_sb, adjustTZ);
587 } else if (rc == -EREMOTE) {
588 cifs_create_dfs_fattr(&fattr, sb);
Steve Frenchb9a32602008-05-20 21:52:32 +0000589 rc = 0;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400590 } else {
Igor Mammedov79626702008-03-09 03:44:18 +0000591 goto cgii_exit;
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400592 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400594 /*
595 * If an inode wasn't passed in, then get the inode number
596 *
597 * Is an i_ino of zero legal? Can we use that to check if the server
598 * supports returning inode numbers? Are there other sanity checks we
599 * can use to ensure that the server is really filling in that field?
600 *
601 * We can not use the IndexNumber field by default from Windows or
602 * Samba (in ALL_INFO buf) but we can request it explicitly. The SNIA
603 * CIFS spec claims that this value is unique within the scope of a
604 * share, and the windows docs hint that it's actually unique
605 * per-machine.
606 *
607 * There may be higher info levels that work but are there Windows
608 * server or network appliances for which IndexNumber field is not
609 * guaranteed unique?
610 */
Steve Frenchb9a32602008-05-20 21:52:32 +0000611 if (*pinode == NULL) {
Steve Frenchb9a32602008-05-20 21:52:32 +0000612 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
613 int rc1 = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614
Steve Frenchb9a32602008-05-20 21:52:32 +0000615 rc1 = CIFSGetSrvInodeNumber(xid, pTcon,
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400616 full_path, &fattr.cf_uniqueid,
Steve French737b7582005-04-28 22:41:06 -0700617 cifs_sb->local_nls,
618 cifs_sb->mnt_cifs_flags &
619 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Laytonec06aed2009-11-06 14:18:29 -0500620 if (rc1 || !fattr.cf_uniqueid) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000621 cFYI(1, "GetSrvInodeNum rc %d", rc1);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400622 fattr.cf_uniqueid = iunique(sb, ROOT_I);
Jeff Laytonec06aed2009-11-06 14:18:29 -0500623 cifs_autodisable_serverino(cifs_sb);
Jeff Layton132ac7b2009-02-10 07:33:57 -0500624 }
Jeff Layton132ac7b2009-02-10 07:33:57 -0500625 } else {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400626 fattr.cf_uniqueid = iunique(sb, ROOT_I);
Jeff Layton132ac7b2009-02-10 07:33:57 -0500627 }
Steve Frenchb9a32602008-05-20 21:52:32 +0000628 } else {
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400629 fattr.cf_uniqueid = CIFS_I(*pinode)->uniqueid;
Steve Frenchb9a32602008-05-20 21:52:32 +0000630 }
631
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400632 /* query for SFU type info if supported and needed */
633 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
634 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
635 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
636 if (tmprc)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000637 cFYI(1, "cifs_sfu_type failed: %d", tmprc);
Steve Frenchb9a32602008-05-20 21:52:32 +0000638 }
Steve Frenchb9a32602008-05-20 21:52:32 +0000639
Steve Frenchb9a32602008-05-20 21:52:32 +0000640#ifdef CONFIG_CIFS_EXPERIMENTAL
641 /* fill in 0777 bits from ACL */
642 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000643 cFYI(1, "Getting mode bits from ACL");
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400644 cifs_acl_to_fattr(cifs_sb, &fattr, *pinode, full_path, pfid);
Steve Frenchb9a32602008-05-20 21:52:32 +0000645 }
646#endif
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400647
648 /* fill in remaining high mode bits e.g. SUID, VTX */
649 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
650 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
651
652 if (!*pinode) {
653 *pinode = cifs_iget(sb, &fattr);
654 if (!*pinode)
655 rc = -ENOMEM;
656 } else {
657 cifs_fattr_to_inode(*pinode, &fattr);
Steve Frenchb9a32602008-05-20 21:52:32 +0000658 }
659
Igor Mammedov79626702008-03-09 03:44:18 +0000660cgii_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 kfree(buf);
662 return rc;
663}
664
Steve French7f8ed422007-09-28 22:28:55 +0000665static const struct inode_operations cifs_ipc_inode_ops = {
666 .lookup = cifs_lookup,
667};
668
Igor Mammedove4cce942009-02-10 14:10:26 +0300669char *cifs_build_path_to_root(struct cifs_sb_info *cifs_sb)
Steve French8be0ed42008-12-05 19:14:12 +0000670{
671 int pplen = cifs_sb->prepathlen;
672 int dfsplen;
673 char *full_path = NULL;
674
675 /* if no prefix path, simply set path to the root of share to "" */
676 if (pplen == 0) {
677 full_path = kmalloc(1, GFP_KERNEL);
678 if (full_path)
679 full_path[0] = 0;
680 return full_path;
681 }
682
683 if (cifs_sb->tcon && (cifs_sb->tcon->Flags & SMB_SHARE_IS_IN_DFS))
684 dfsplen = strnlen(cifs_sb->tcon->treeName, MAX_TREE_SIZE + 1);
685 else
686 dfsplen = 0;
687
688 full_path = kmalloc(dfsplen + pplen + 1, GFP_KERNEL);
689 if (full_path == NULL)
690 return full_path;
691
692 if (dfsplen) {
693 strncpy(full_path, cifs_sb->tcon->treeName, dfsplen);
694 /* switch slash direction in prepath depending on whether
695 * windows or posix style path names
696 */
697 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
698 int i;
699 for (i = 0; i < dfsplen; i++) {
700 if (full_path[i] == '\\')
701 full_path[i] = '/';
702 }
703 }
704 }
705 strncpy(full_path + dfsplen, cifs_sb->prepath, pplen);
706 full_path[dfsplen + pplen] = 0; /* add trailing null */
707 return full_path;
708}
709
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400710static int
711cifs_find_inode(struct inode *inode, void *opaque)
712{
713 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
714
715 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
716 return 0;
717
718 return 1;
719}
720
721static int
722cifs_init_inode(struct inode *inode, void *opaque)
723{
724 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
725
726 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
727 return 0;
728}
729
730/* Given fattrs, get a corresponding inode */
731struct inode *
732cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
733{
734 unsigned long hash;
735 struct inode *inode;
736
Joe Perchesb6b38f72010-04-21 03:50:45 +0000737 cFYI(1, "looking for uniqueid=%llu", fattr->cf_uniqueid);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400738
739 /* hash down to 32-bits on 32-bit arch */
740 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
741
742 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
743
744 /* we have fattrs in hand, update the inode */
745 if (inode) {
746 cifs_fattr_to_inode(inode, fattr);
747 if (sb->s_flags & MS_NOATIME)
748 inode->i_flags |= S_NOATIME | S_NOCMTIME;
749 if (inode->i_state & I_NEW) {
750 inode->i_ino = hash;
751 unlock_new_inode(inode);
752 }
753 }
754
755 return inode;
756}
757
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758/* gets root inode */
Jeff Laytonbd433d42009-05-27 09:37:34 -0400759struct inode *cifs_root_iget(struct super_block *sb, unsigned long ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760{
David Howellsce634ab2008-02-07 00:15:33 -0800761 int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 struct cifs_sb_info *cifs_sb;
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400763 struct inode *inode = NULL;
David Howellsce634ab2008-02-07 00:15:33 -0800764 long rc;
Steve French8be0ed42008-12-05 19:14:12 +0000765 char *full_path;
David Howellsce634ab2008-02-07 00:15:33 -0800766
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400767 cifs_sb = CIFS_SB(sb);
Igor Mammedove4cce942009-02-10 14:10:26 +0300768 full_path = cifs_build_path_to_root(cifs_sb);
Steve French8be0ed42008-12-05 19:14:12 +0000769 if (full_path == NULL)
770 return ERR_PTR(-ENOMEM);
Steve Frenchc18c8422007-07-18 23:21:09 +0000771
Steve French8be0ed42008-12-05 19:14:12 +0000772 xid = GetXid();
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400773 if (cifs_sb->tcon->unix_ext)
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400774 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400775 else
776 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
Steve French8be0ed42008-12-05 19:14:12 +0000777 xid, NULL);
Jeff Layton0b8f18e2009-07-09 01:46:37 -0400778
779 if (!inode)
780 return ERR_PTR(-ENOMEM);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400781
Steve French7f8ed422007-09-28 22:28:55 +0000782 if (rc && cifs_sb->tcon->ipc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000783 cFYI(1, "ipc connection - fake read inode");
Steve French7f8ed422007-09-28 22:28:55 +0000784 inode->i_mode |= S_IFDIR;
785 inode->i_nlink = 2;
786 inode->i_op = &cifs_ipc_inode_ops;
787 inode->i_fop = &simple_dir_operations;
788 inode->i_uid = cifs_sb->mnt_uid;
789 inode->i_gid = cifs_sb->mnt_gid;
Steve Frenchad661332008-08-12 14:14:40 +0000790 } else if (rc) {
Steve French8be0ed42008-12-05 19:14:12 +0000791 kfree(full_path);
David Howellsce634ab2008-02-07 00:15:33 -0800792 _FreeXid(xid);
793 iget_failed(inode);
794 return ERR_PTR(rc);
Steve French7f8ed422007-09-28 22:28:55 +0000795 }
796
David Howellsce634ab2008-02-07 00:15:33 -0800797
Steve French8be0ed42008-12-05 19:14:12 +0000798 kfree(full_path);
David Howellsce634ab2008-02-07 00:15:33 -0800799 /* can not call macro FreeXid here since in a void func
800 * TODO: This is no longer true
801 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 _FreeXid(xid);
David Howellsce634ab2008-02-07 00:15:33 -0800803 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804}
805
Steve French388e57b2008-09-16 23:50:58 +0000806static int
807cifs_set_file_info(struct inode *inode, struct iattr *attrs, int xid,
808 char *full_path, __u32 dosattr)
809{
810 int rc;
811 int oplock = 0;
812 __u16 netfid;
813 __u32 netpid;
814 bool set_time = false;
815 struct cifsFileInfo *open_file;
816 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
817 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
818 struct cifsTconInfo *pTcon = cifs_sb->tcon;
819 FILE_BASIC_INFO info_buf;
820
Steve French1adcb712009-02-25 14:19:56 +0000821 if (attrs == NULL)
822 return -EINVAL;
823
Steve French388e57b2008-09-16 23:50:58 +0000824 if (attrs->ia_valid & ATTR_ATIME) {
825 set_time = true;
826 info_buf.LastAccessTime =
827 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
828 } else
829 info_buf.LastAccessTime = 0;
830
831 if (attrs->ia_valid & ATTR_MTIME) {
832 set_time = true;
833 info_buf.LastWriteTime =
834 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
835 } else
836 info_buf.LastWriteTime = 0;
837
838 /*
839 * Samba throws this field away, but windows may actually use it.
840 * Do not set ctime unless other time stamps are changed explicitly
841 * (i.e. by utimes()) since we would then have a mix of client and
842 * server times.
843 */
844 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000845 cFYI(1, "CIFS - CTIME changed");
Steve French388e57b2008-09-16 23:50:58 +0000846 info_buf.ChangeTime =
847 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
848 } else
849 info_buf.ChangeTime = 0;
850
851 info_buf.CreationTime = 0; /* don't change */
852 info_buf.Attributes = cpu_to_le32(dosattr);
853
854 /*
855 * If the file is already open for write, just use that fileid
856 */
857 open_file = find_writable_file(cifsInode);
858 if (open_file) {
859 netfid = open_file->netfid;
860 netpid = open_file->pid;
861 goto set_via_filehandle;
862 }
863
864 /*
865 * NT4 apparently returns success on this call, but it doesn't
866 * really work.
867 */
868 if (!(pTcon->ses->flags & CIFS_SES_NT4)) {
869 rc = CIFSSMBSetPathInfo(xid, pTcon, full_path,
870 &info_buf, cifs_sb->local_nls,
871 cifs_sb->mnt_cifs_flags &
872 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton6b37faa2008-10-06 21:54:41 +0000873 if (rc == 0) {
874 cifsInode->cifsAttrs = dosattr;
875 goto out;
876 } else if (rc != -EOPNOTSUPP && rc != -EINVAL)
Steve French388e57b2008-09-16 23:50:58 +0000877 goto out;
878 }
879
Joe Perchesb6b38f72010-04-21 03:50:45 +0000880 cFYI(1, "calling SetFileInfo since SetPathInfo for "
881 "times not supported by this server");
Steve French388e57b2008-09-16 23:50:58 +0000882 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
883 SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
884 CREATE_NOT_DIR, &netfid, &oplock,
885 NULL, cifs_sb->local_nls,
886 cifs_sb->mnt_cifs_flags &
887 CIFS_MOUNT_MAP_SPECIAL_CHR);
888
889 if (rc != 0) {
890 if (rc == -EIO)
891 rc = -EINVAL;
892 goto out;
893 }
894
895 netpid = current->tgid;
896
897set_via_filehandle:
898 rc = CIFSSMBSetFileInfo(xid, pTcon, &info_buf, netfid, netpid);
Steve Frenchd3889082008-09-24 19:22:52 +0000899 if (!rc)
900 cifsInode->cifsAttrs = dosattr;
901
Steve French388e57b2008-09-16 23:50:58 +0000902 if (open_file == NULL)
903 CIFSSMBClose(xid, pTcon, netfid);
904 else
Dave Kleikamp6ab409b2009-08-31 11:07:12 -0400905 cifsFileInfo_put(open_file);
Steve French388e57b2008-09-16 23:50:58 +0000906out:
907 return rc;
908}
909
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400910/*
911 * open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
912 * and rename it to a random name that hopefully won't conflict with
913 * anything else.
914 */
915static int
Steve French32709582008-10-20 00:44:19 +0000916cifs_rename_pending_delete(char *full_path, struct dentry *dentry, int xid)
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400917{
918 int oplock = 0;
919 int rc;
920 __u16 netfid;
Steve French32709582008-10-20 00:44:19 +0000921 struct inode *inode = dentry->d_inode;
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400922 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
923 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
924 struct cifsTconInfo *tcon = cifs_sb->tcon;
Steve French32709582008-10-20 00:44:19 +0000925 __u32 dosattr, origattr;
926 FILE_BASIC_INFO *info_buf = NULL;
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400927
928 rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
Jeff Laytondd1db2d2008-10-16 19:27:12 -0400929 DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400930 &netfid, &oplock, NULL, cifs_sb->local_nls,
931 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
932 if (rc != 0)
933 goto out;
934
Steve French32709582008-10-20 00:44:19 +0000935 origattr = cifsInode->cifsAttrs;
936 if (origattr == 0)
937 origattr |= ATTR_NORMAL;
938
939 dosattr = origattr & ~ATTR_READONLY;
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400940 if (dosattr == 0)
941 dosattr |= ATTR_NORMAL;
942 dosattr |= ATTR_HIDDEN;
943
Steve French32709582008-10-20 00:44:19 +0000944 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
945 if (dosattr != origattr) {
946 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
947 if (info_buf == NULL) {
948 rc = -ENOMEM;
949 goto out_close;
950 }
951 info_buf->Attributes = cpu_to_le32(dosattr);
952 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
953 current->tgid);
954 /* although we would like to mark the file hidden
955 if that fails we will still try to rename it */
Steve French41346092008-10-20 18:24:42 +0000956 if (rc != 0)
Steve French32709582008-10-20 00:44:19 +0000957 cifsInode->cifsAttrs = dosattr;
958 else
959 dosattr = origattr; /* since not able to change them */
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400960 }
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400961
Jeff Laytondd1db2d2008-10-16 19:27:12 -0400962 /* rename the file */
963 rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400964 cifs_sb->mnt_cifs_flags &
965 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French32709582008-10-20 00:44:19 +0000966 if (rc != 0) {
967 rc = -ETXTBSY;
968 goto undo_setattr;
969 }
Jeff Layton6d22f092008-09-23 11:48:35 -0400970
Steve French32709582008-10-20 00:44:19 +0000971 /* try to set DELETE_ON_CLOSE */
972 if (!cifsInode->delete_pending) {
973 rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
974 current->tgid);
975 /*
976 * some samba versions return -ENOENT when we try to set the
977 * file disposition here. Likely a samba bug, but work around
978 * it for now. This means that some cifsXXX files may hang
979 * around after they shouldn't.
980 *
981 * BB: remove this hack after more servers have the fix
982 */
983 if (rc == -ENOENT)
984 rc = 0;
985 else if (rc != 0) {
986 rc = -ETXTBSY;
987 goto undo_rename;
988 }
989 cifsInode->delete_pending = true;
990 }
Jeff Layton7ce86d52008-09-24 11:32:59 -0400991
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400992out_close:
993 CIFSSMBClose(xid, tcon, netfid);
994out:
Steve French32709582008-10-20 00:44:19 +0000995 kfree(info_buf);
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400996 return rc;
Steve French32709582008-10-20 00:44:19 +0000997
998 /*
999 * reset everything back to the original state. Don't bother
1000 * dealing with errors here since we can't do anything about
1001 * them anyway.
1002 */
1003undo_rename:
1004 CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
1005 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1006 CIFS_MOUNT_MAP_SPECIAL_CHR);
1007undo_setattr:
1008 if (dosattr != origattr) {
1009 info_buf->Attributes = cpu_to_le32(origattr);
1010 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1011 current->tgid))
1012 cifsInode->cifsAttrs = origattr;
1013 }
1014
1015 goto out_close;
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001016}
1017
Steve Frenchff694522009-04-20 19:45:13 +00001018
1019/*
1020 * If dentry->d_inode is null (usually meaning the cached dentry
1021 * is a negative dentry) then we would attempt a standard SMB delete, but
André Goddard Rosaaf901ca2009-11-14 13:09:05 -02001022 * if that fails we can not attempt the fall back mechanisms on EACCESS
1023 * but will return the EACCESS to the caller. Note that the VFS does not call
Steve Frenchff694522009-04-20 19:45:13 +00001024 * unlink on negative dentries currently.
1025 */
Jeff Layton5f0319a2008-09-16 14:05:16 -04001026int cifs_unlink(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027{
1028 int rc = 0;
1029 int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 char *full_path = NULL;
Jeff Layton5f0319a2008-09-16 14:05:16 -04001031 struct inode *inode = dentry->d_inode;
Steve Frenchff694522009-04-20 19:45:13 +00001032 struct cifsInodeInfo *cifs_inode;
Jeff Layton5f0319a2008-09-16 14:05:16 -04001033 struct super_block *sb = dir->i_sb;
1034 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1035 struct cifsTconInfo *tcon = cifs_sb->tcon;
Steve French60502472008-10-07 18:42:52 +00001036 struct iattr *attrs = NULL;
1037 __u32 dosattr = 0, origattr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038
Joe Perchesb6b38f72010-04-21 03:50:45 +00001039 cFYI(1, "cifs_unlink, dir=0x%p, dentry=0x%p", dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040
1041 xid = GetXid();
1042
Jeff Layton5f0319a2008-09-16 14:05:16 -04001043 /* Unlink can be called from rename so we can not take the
1044 * sb->s_vfs_rename_mutex here */
1045 full_path = build_path_from_dentry(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301047 rc = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301049 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 }
Steve French2d785a52007-07-15 01:48:57 +00001051
Jeff Layton5f0319a2008-09-16 14:05:16 -04001052 if ((tcon->ses->capabilities & CAP_UNIX) &&
Steve French2d785a52007-07-15 01:48:57 +00001053 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
Jeff Layton5f0319a2008-09-16 14:05:16 -04001054 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1055 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
Steve French2d785a52007-07-15 01:48:57 +00001056 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1057 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001058 cFYI(1, "posix del rc %d", rc);
Steve French2d785a52007-07-15 01:48:57 +00001059 if ((rc == 0) || (rc == -ENOENT))
1060 goto psx_del_no_retry;
1061 }
1062
Steve French60502472008-10-07 18:42:52 +00001063retry_std_delete:
Jeff Layton5f0319a2008-09-16 14:05:16 -04001064 rc = CIFSSMBDelFile(xid, tcon, full_path, cifs_sb->local_nls,
Steve French737b7582005-04-28 22:41:06 -07001065 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French60502472008-10-07 18:42:52 +00001066
Steve French2d785a52007-07-15 01:48:57 +00001067psx_del_no_retry:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 if (!rc) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001069 if (inode)
1070 drop_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 } else if (rc == -ENOENT) {
Jeff Layton5f0319a2008-09-16 14:05:16 -04001072 d_drop(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 } else if (rc == -ETXTBSY) {
Steve French32709582008-10-20 00:44:19 +00001074 rc = cifs_rename_pending_delete(full_path, dentry, xid);
Jeff Laytona12a1ac2008-09-23 11:48:35 -04001075 if (rc == 0)
1076 drop_nlink(inode);
Steve Frenchff694522009-04-20 19:45:13 +00001077 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
Steve French388e57b2008-09-16 23:50:58 +00001078 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1079 if (attrs == NULL) {
1080 rc = -ENOMEM;
1081 goto out_reval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 }
Steve French388e57b2008-09-16 23:50:58 +00001083
1084 /* try to reset dos attributes */
Steve Frenchff694522009-04-20 19:45:13 +00001085 cifs_inode = CIFS_I(inode);
1086 origattr = cifs_inode->cifsAttrs;
Steve French60502472008-10-07 18:42:52 +00001087 if (origattr == 0)
1088 origattr |= ATTR_NORMAL;
1089 dosattr = origattr & ~ATTR_READONLY;
Steve French388e57b2008-09-16 23:50:58 +00001090 if (dosattr == 0)
1091 dosattr |= ATTR_NORMAL;
1092 dosattr |= ATTR_HIDDEN;
1093
1094 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
Steve French388e57b2008-09-16 23:50:58 +00001095 if (rc != 0)
1096 goto out_reval;
Steve French60502472008-10-07 18:42:52 +00001097
1098 goto retry_std_delete;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 }
Steve French60502472008-10-07 18:42:52 +00001100
1101 /* undo the setattr if we errored out and it's needed */
1102 if (rc != 0 && dosattr != 0)
1103 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1104
Steve French388e57b2008-09-16 23:50:58 +00001105out_reval:
Jeff Layton5f0319a2008-09-16 14:05:16 -04001106 if (inode) {
Steve Frenchff694522009-04-20 19:45:13 +00001107 cifs_inode = CIFS_I(inode);
1108 cifs_inode->time = 0; /* will force revalidate to get info
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001109 when needed */
Jeff Layton5f0319a2008-09-16 14:05:16 -04001110 inode->i_ctime = current_fs_time(sb);
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001111 }
Jeff Layton5f0319a2008-09-16 14:05:16 -04001112 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
Steve Frenchff694522009-04-20 19:45:13 +00001113 cifs_inode = CIFS_I(dir);
Steve French60502472008-10-07 18:42:52 +00001114 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115
1116 kfree(full_path);
Steve French60502472008-10-07 18:42:52 +00001117 kfree(attrs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 FreeXid(xid);
1119 return rc;
1120}
1121
1122int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
1123{
Jeff Layton6b37faa2008-10-06 21:54:41 +00001124 int rc = 0, tmprc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 int xid;
1126 struct cifs_sb_info *cifs_sb;
1127 struct cifsTconInfo *pTcon;
1128 char *full_path = NULL;
1129 struct inode *newinode = NULL;
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001130 struct cifs_fattr fattr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131
Joe Perchesb6b38f72010-04-21 03:50:45 +00001132 cFYI(1, "In cifs_mkdir, mode = 0x%x inode = 0x%p", mode, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133
1134 xid = GetXid();
1135
1136 cifs_sb = CIFS_SB(inode->i_sb);
1137 pTcon = cifs_sb->tcon;
1138
Steve French7f573562005-08-30 11:32:14 -07001139 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301141 rc = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301143 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 }
Steve French50c2f752007-07-13 00:33:32 +00001145
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001146 if ((pTcon->ses->capabilities & CAP_UNIX) &&
1147 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
Steve French2dd29d32007-04-23 22:07:35 +00001148 le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
1149 u32 oplock = 0;
Steve Frenchf6d09982008-01-08 23:18:22 +00001150 FILE_UNIX_BASIC_INFO *pInfo =
Steve French2dd29d32007-04-23 22:07:35 +00001151 kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001152 if (pInfo == NULL) {
Steve French2dd29d32007-04-23 22:07:35 +00001153 rc = -ENOMEM;
1154 goto mkdir_out;
1155 }
Steve French50c2f752007-07-13 00:33:32 +00001156
Al Viroce3b0f82009-03-29 19:08:22 -04001157 mode &= ~current_umask();
Steve French2dd29d32007-04-23 22:07:35 +00001158 rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
1159 mode, NULL /* netfid */, pInfo, &oplock,
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001160 full_path, cifs_sb->local_nls,
1161 cifs_sb->mnt_cifs_flags &
Steve French2dd29d32007-04-23 22:07:35 +00001162 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve Frenchc45d7072007-09-17 02:04:21 +00001163 if (rc == -EOPNOTSUPP) {
1164 kfree(pInfo);
1165 goto mkdir_retry_old;
1166 } else if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001167 cFYI(1, "posix mkdir returned 0x%x", rc);
Steve French2dd29d32007-04-23 22:07:35 +00001168 d_drop(direntry);
1169 } else {
Cyril Gorcunov8f2376a2007-10-14 17:58:43 +00001170 if (pInfo->Type == cpu_to_le32(-1)) {
1171 /* no return info, go query for it */
Steve French5a07cdf2007-09-16 23:12:47 +00001172 kfree(pInfo);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001173 goto mkdir_get_info;
Steve French5a07cdf2007-09-16 23:12:47 +00001174 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001175/*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
1176 to set uid/gid */
Steve French2dd29d32007-04-23 22:07:35 +00001177 inc_nlink(inode);
1178 if (pTcon->nocase)
1179 direntry->d_op = &cifs_ci_dentry_ops;
1180 else
1181 direntry->d_op = &cifs_dentry_ops;
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001182
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001183 cifs_unix_basic_to_fattr(&fattr, pInfo, cifs_sb);
1184 newinode = cifs_iget(inode->i_sb, &fattr);
1185 if (!newinode) {
Steve French5a07cdf2007-09-16 23:12:47 +00001186 kfree(pInfo);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001187 goto mkdir_get_info;
Steve French5a07cdf2007-09-16 23:12:47 +00001188 }
Jeff Layton6b37faa2008-10-06 21:54:41 +00001189
Steve French2dd29d32007-04-23 22:07:35 +00001190 d_instantiate(direntry, newinode);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001191
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001192#ifdef CONFIG_CIFS_DEBUG2
Joe Perchesb6b38f72010-04-21 03:50:45 +00001193 cFYI(1, "instantiated dentry %p %s to inode %p",
1194 direntry, direntry->d_name.name, newinode);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001195
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001196 if (newinode->i_nlink != 2)
Joe Perchesb6b38f72010-04-21 03:50:45 +00001197 cFYI(1, "unexpected number of links %d",
1198 newinode->i_nlink);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001199#endif
Steve French2dd29d32007-04-23 22:07:35 +00001200 }
1201 kfree(pInfo);
1202 goto mkdir_out;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001203 }
Steve Frenchc45d7072007-09-17 02:04:21 +00001204mkdir_retry_old:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 /* BB add setting the equivalent of mode via CreateX w/ACLs */
Steve French737b7582005-04-28 22:41:06 -07001206 rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
1207 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001209 cFYI(1, "cifs_mkdir returned 0x%x", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 d_drop(direntry);
1211 } else {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001212mkdir_get_info:
Dave Hansend8c76e62006-09-30 23:29:04 -07001213 inc_nlink(inode);
Steve Frenchc18c8422007-07-18 23:21:09 +00001214 if (pTcon->unix_ext)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 rc = cifs_get_inode_info_unix(&newinode, full_path,
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001216 inode->i_sb, xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217 else
1218 rc = cifs_get_inode_info(&newinode, full_path, NULL,
Steve French8b1327f2008-03-14 22:37:16 +00001219 inode->i_sb, xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220
Steve Frenchb92327f2005-08-22 20:09:43 -07001221 if (pTcon->nocase)
1222 direntry->d_op = &cifs_ci_dentry_ops;
1223 else
1224 direntry->d_op = &cifs_dentry_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 d_instantiate(direntry, newinode);
Steve French2dd29d32007-04-23 22:07:35 +00001226 /* setting nlink not necessary except in cases where we
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001227 * failed to get it from the server or was set bogus */
Steve French2dd29d32007-04-23 22:07:35 +00001228 if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001229 direntry->d_inode->i_nlink = 2;
Jeff Layton95089912008-08-06 04:39:02 +00001230
Al Viroce3b0f82009-03-29 19:08:22 -04001231 mode &= ~current_umask();
Jeff Layton95089912008-08-06 04:39:02 +00001232 /* must turn on setgid bit if parent dir has it */
1233 if (inode->i_mode & S_ISGID)
1234 mode |= S_ISGID;
1235
Steve Frenchc18c8422007-07-18 23:21:09 +00001236 if (pTcon->unix_ext) {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04001237 struct cifs_unix_set_info_args args = {
1238 .mode = mode,
1239 .ctime = NO_CHANGE_64,
1240 .atime = NO_CHANGE_64,
1241 .mtime = NO_CHANGE_64,
1242 .device = 0,
1243 };
Steve Frenchd0d2f2d2005-06-02 15:12:36 -07001244 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
David Howellsa001e5b2008-11-14 10:38:47 +11001245 args.uid = (__u64)current_fsuid();
Jeff Layton95089912008-08-06 04:39:02 +00001246 if (inode->i_mode & S_ISGID)
1247 args.gid = (__u64)inode->i_gid;
1248 else
David Howellsa001e5b2008-11-14 10:38:47 +11001249 args.gid = (__u64)current_fsgid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 } else {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04001251 args.uid = NO_CHANGE_64;
1252 args.gid = NO_CHANGE_64;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 }
Jeff Layton01ea95e2009-07-09 20:02:49 -04001254 CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
1255 cifs_sb->local_nls,
1256 cifs_sb->mnt_cifs_flags &
1257 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French3ce53fc2007-06-08 14:55:14 +00001258 } else {
Jeff Layton67750fb2008-05-09 22:28:02 +00001259 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1260 (mode & S_IWUGO) == 0) {
1261 FILE_BASIC_INFO pInfo;
Jeff Layton6b37faa2008-10-06 21:54:41 +00001262 struct cifsInodeInfo *cifsInode;
1263 u32 dosattrs;
1264
Jeff Layton67750fb2008-05-09 22:28:02 +00001265 memset(&pInfo, 0, sizeof(pInfo));
Jeff Layton6b37faa2008-10-06 21:54:41 +00001266 cifsInode = CIFS_I(newinode);
1267 dosattrs = cifsInode->cifsAttrs|ATTR_READONLY;
1268 pInfo.Attributes = cpu_to_le32(dosattrs);
1269 tmprc = CIFSSMBSetPathInfo(xid, pTcon,
1270 full_path, &pInfo,
1271 cifs_sb->local_nls,
Jeff Layton67750fb2008-05-09 22:28:02 +00001272 cifs_sb->mnt_cifs_flags &
1273 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton6b37faa2008-10-06 21:54:41 +00001274 if (tmprc == 0)
1275 cifsInode->cifsAttrs = dosattrs;
Jeff Layton67750fb2008-05-09 22:28:02 +00001276 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001277 if (direntry->d_inode) {
Jeff Laytonb0fd30d2008-05-22 09:33:34 -04001278 if (cifs_sb->mnt_cifs_flags &
1279 CIFS_MOUNT_DYNPERM)
1280 direntry->d_inode->i_mode =
1281 (mode | S_IFDIR);
Steve French4e94a102008-05-23 18:22:46 +00001282
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001283 if (cifs_sb->mnt_cifs_flags &
Steve French6473a552005-11-29 20:20:10 -08001284 CIFS_MOUNT_SET_UID) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001285 direntry->d_inode->i_uid =
David Howellsa001e5b2008-11-14 10:38:47 +11001286 current_fsuid();
Jeff Layton95089912008-08-06 04:39:02 +00001287 if (inode->i_mode & S_ISGID)
1288 direntry->d_inode->i_gid =
1289 inode->i_gid;
1290 else
1291 direntry->d_inode->i_gid =
David Howellsa001e5b2008-11-14 10:38:47 +11001292 current_fsgid();
Steve French6473a552005-11-29 20:20:10 -08001293 }
1294 }
Steve French2a138ebb2005-11-29 21:22:19 -08001295 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001297mkdir_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 kfree(full_path);
1299 FreeXid(xid);
1300 return rc;
1301}
1302
1303int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1304{
1305 int rc = 0;
1306 int xid;
1307 struct cifs_sb_info *cifs_sb;
1308 struct cifsTconInfo *pTcon;
1309 char *full_path = NULL;
1310 struct cifsInodeInfo *cifsInode;
1311
Joe Perchesb6b38f72010-04-21 03:50:45 +00001312 cFYI(1, "cifs_rmdir, inode = 0x%p", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313
1314 xid = GetXid();
1315
1316 cifs_sb = CIFS_SB(inode->i_sb);
1317 pTcon = cifs_sb->tcon;
1318
Steve French7f573562005-08-30 11:32:14 -07001319 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301321 rc = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301323 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 }
1325
Steve French737b7582005-04-28 22:41:06 -07001326 rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
1327 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328
1329 if (!rc) {
Dave Hansen9a53c3a2006-09-30 23:29:03 -07001330 drop_nlink(inode);
Steve French3677db12007-02-26 16:46:11 +00001331 spin_lock(&direntry->d_inode->i_lock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001332 i_size_write(direntry->d_inode, 0);
Dave Hansence71ec32006-09-30 23:29:06 -07001333 clear_nlink(direntry->d_inode);
Steve French3677db12007-02-26 16:46:11 +00001334 spin_unlock(&direntry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 }
1336
1337 cifsInode = CIFS_I(direntry->d_inode);
1338 cifsInode->time = 0; /* force revalidate to go get info when
1339 needed */
Steve French42c24542009-01-13 22:03:55 +00001340
1341 cifsInode = CIFS_I(inode);
1342 cifsInode->time = 0; /* force revalidate to get parent dir info
1343 since cached search results now invalid */
1344
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1346 current_fs_time(inode->i_sb);
1347
1348 kfree(full_path);
1349 FreeXid(xid);
1350 return rc;
1351}
1352
Steve Frenchee2fd962008-09-23 18:23:33 +00001353static int
1354cifs_do_rename(int xid, struct dentry *from_dentry, const char *fromPath,
1355 struct dentry *to_dentry, const char *toPath)
1356{
1357 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1358 struct cifsTconInfo *pTcon = cifs_sb->tcon;
1359 __u16 srcfid;
1360 int oplock, rc;
1361
1362 /* try path-based rename first */
1363 rc = CIFSSMBRename(xid, pTcon, fromPath, toPath, cifs_sb->local_nls,
1364 cifs_sb->mnt_cifs_flags &
1365 CIFS_MOUNT_MAP_SPECIAL_CHR);
1366
1367 /*
1368 * don't bother with rename by filehandle unless file is busy and
1369 * source Note that cross directory moves do not work with
1370 * rename by filehandle to various Windows servers.
1371 */
1372 if (rc == 0 || rc != -ETXTBSY)
1373 return rc;
1374
1375 /* open the file to be renamed -- we need DELETE perms */
1376 rc = CIFSSMBOpen(xid, pTcon, fromPath, FILE_OPEN, DELETE,
1377 CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1378 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1379 CIFS_MOUNT_MAP_SPECIAL_CHR);
1380
1381 if (rc == 0) {
1382 rc = CIFSSMBRenameOpenFile(xid, pTcon, srcfid,
1383 (const char *) to_dentry->d_name.name,
1384 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1385 CIFS_MOUNT_MAP_SPECIAL_CHR);
1386
1387 CIFSSMBClose(xid, pTcon, srcfid);
1388 }
1389
1390 return rc;
1391}
1392
Jeff Layton14121bd2008-10-20 14:45:22 -04001393int cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1394 struct inode *target_dir, struct dentry *target_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395{
Steve Frenchee2fd962008-09-23 18:23:33 +00001396 char *fromName = NULL;
1397 char *toName = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398 struct cifs_sb_info *cifs_sb_source;
1399 struct cifs_sb_info *cifs_sb_target;
Jeff Layton14121bd2008-10-20 14:45:22 -04001400 struct cifsTconInfo *tcon;
Steve Frenchee2fd962008-09-23 18:23:33 +00001401 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1402 FILE_UNIX_BASIC_INFO *info_buf_target;
Jeff Layton8d281ef2008-10-22 13:57:01 -04001403 int xid, rc, tmprc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404
Jeff Layton14121bd2008-10-20 14:45:22 -04001405 cifs_sb_target = CIFS_SB(target_dir->i_sb);
1406 cifs_sb_source = CIFS_SB(source_dir->i_sb);
1407 tcon = cifs_sb_source->tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408
Steve Frenchee2fd962008-09-23 18:23:33 +00001409 xid = GetXid();
1410
1411 /*
1412 * BB: this might be allowed if same server, but different share.
1413 * Consider adding support for this
1414 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001415 if (tcon != cifs_sb_target->tcon) {
Steve Frenchee2fd962008-09-23 18:23:33 +00001416 rc = -EXDEV;
1417 goto cifs_rename_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418 }
1419
Steve Frenchee2fd962008-09-23 18:23:33 +00001420 /*
1421 * we already have the rename sem so we do not need to
1422 * grab it again here to protect the path integrity
1423 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001424 fromName = build_path_from_dentry(source_dentry);
Steve Frenchee2fd962008-09-23 18:23:33 +00001425 if (fromName == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 rc = -ENOMEM;
1427 goto cifs_rename_exit;
1428 }
1429
Jeff Layton14121bd2008-10-20 14:45:22 -04001430 toName = build_path_from_dentry(target_dentry);
Steve Frenchee2fd962008-09-23 18:23:33 +00001431 if (toName == NULL) {
1432 rc = -ENOMEM;
1433 goto cifs_rename_exit;
1434 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435
Jeff Layton14121bd2008-10-20 14:45:22 -04001436 rc = cifs_do_rename(xid, source_dentry, fromName,
1437 target_dentry, toName);
Steve Frenchee2fd962008-09-23 18:23:33 +00001438
Jeff Layton14121bd2008-10-20 14:45:22 -04001439 if (rc == -EEXIST && tcon->unix_ext) {
Steve Frenchee2fd962008-09-23 18:23:33 +00001440 /*
Jeff Layton14121bd2008-10-20 14:45:22 -04001441 * Are src and dst hardlinks of same inode? We can
1442 * only tell with unix extensions enabled
Steve Frenchee2fd962008-09-23 18:23:33 +00001443 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001444 info_buf_source =
1445 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1446 GFP_KERNEL);
1447 if (info_buf_source == NULL) {
1448 rc = -ENOMEM;
1449 goto cifs_rename_exit;
1450 }
1451
1452 info_buf_target = info_buf_source + 1;
Jeff Layton8d281ef2008-10-22 13:57:01 -04001453 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, fromName,
Jeff Layton14121bd2008-10-20 14:45:22 -04001454 info_buf_source,
1455 cifs_sb_source->local_nls,
1456 cifs_sb_source->mnt_cifs_flags &
1457 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton8d281ef2008-10-22 13:57:01 -04001458 if (tmprc != 0)
Jeff Layton14121bd2008-10-20 14:45:22 -04001459 goto unlink_target;
1460
Jeff Layton8d281ef2008-10-22 13:57:01 -04001461 tmprc = CIFSSMBUnixQPathInfo(xid, tcon,
Jeff Layton14121bd2008-10-20 14:45:22 -04001462 toName, info_buf_target,
1463 cifs_sb_target->local_nls,
1464 /* remap based on source sb */
1465 cifs_sb_source->mnt_cifs_flags &
1466 CIFS_MOUNT_MAP_SPECIAL_CHR);
1467
Jeff Layton8d281ef2008-10-22 13:57:01 -04001468 if (tmprc == 0 && (info_buf_source->UniqueId ==
Jeff Laytonae6884a2008-11-03 14:05:08 -05001469 info_buf_target->UniqueId)) {
Jeff Layton14121bd2008-10-20 14:45:22 -04001470 /* same file, POSIX says that this is a noop */
Jeff Laytonae6884a2008-11-03 14:05:08 -05001471 rc = 0;
Jeff Layton14121bd2008-10-20 14:45:22 -04001472 goto cifs_rename_exit;
Jeff Laytonae6884a2008-11-03 14:05:08 -05001473 }
Jeff Layton14121bd2008-10-20 14:45:22 -04001474 } /* else ... BB we could add the same check for Windows by
1475 checking the UniqueId via FILE_INTERNAL_INFO */
1476
Jeff Layton14121bd2008-10-20 14:45:22 -04001477unlink_target:
Jeff Laytonfc6f3942009-04-17 11:45:30 -04001478 /* Try unlinking the target dentry if it's not negative */
1479 if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
Jeff Layton8d281ef2008-10-22 13:57:01 -04001480 tmprc = cifs_unlink(target_dir, target_dentry);
Jeff Layton14121bd2008-10-20 14:45:22 -04001481 if (tmprc)
1482 goto cifs_rename_exit;
1483
Jeff Layton14121bd2008-10-20 14:45:22 -04001484 rc = cifs_do_rename(xid, source_dentry, fromName,
1485 target_dentry, toName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 }
1487
1488cifs_rename_exit:
Steve Frenchee2fd962008-09-23 18:23:33 +00001489 kfree(info_buf_source);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490 kfree(fromName);
1491 kfree(toName);
1492 FreeXid(xid);
1493 return rc;
1494}
1495
Jeff Laytondf2cf172010-02-12 07:44:16 -05001496static bool
1497cifs_inode_needs_reval(struct inode *inode)
1498{
1499 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1500
1501 if (cifs_i->clientCanCacheRead)
1502 return false;
1503
1504 if (!lookupCacheEnabled)
1505 return true;
1506
1507 if (cifs_i->time == 0)
1508 return true;
1509
1510 /* FIXME: the actimeo should be tunable */
1511 if (time_after_eq(jiffies, cifs_i->time + HZ))
1512 return true;
1513
1514 return false;
1515}
1516
1517/* check invalid_mapping flag and zap the cache if it's set */
1518static void
1519cifs_invalidate_mapping(struct inode *inode)
1520{
1521 int rc;
1522 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1523
1524 cifs_i->invalid_mapping = false;
1525
1526 /* write back any cached data */
1527 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1528 rc = filemap_write_and_wait(inode->i_mapping);
1529 if (rc)
1530 cifs_i->write_behind_rc = rc;
1531 }
1532 invalidate_remote_inode(inode);
1533}
1534
Jeff Laytonabab0952010-02-12 07:44:18 -05001535int cifs_revalidate_file(struct file *filp)
1536{
1537 int rc = 0;
1538 struct inode *inode = filp->f_path.dentry->d_inode;
1539
1540 if (!cifs_inode_needs_reval(inode))
1541 goto check_inval;
1542
1543 if (CIFS_SB(inode->i_sb)->tcon->unix_ext)
1544 rc = cifs_get_file_info_unix(filp);
1545 else
1546 rc = cifs_get_file_info(filp);
1547
1548check_inval:
1549 if (CIFS_I(inode)->invalid_mapping)
1550 cifs_invalidate_mapping(inode);
1551
1552 return rc;
1553}
1554
Jeff Laytondf2cf172010-02-12 07:44:16 -05001555/* revalidate a dentry's inode attributes */
1556int cifs_revalidate_dentry(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557{
1558 int xid;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001559 int rc = 0;
1560 char *full_path = NULL;
1561 struct inode *inode = dentry->d_inode;
1562 struct super_block *sb = dentry->d_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563
Jeff Laytondf2cf172010-02-12 07:44:16 -05001564 if (inode == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 return -ENOENT;
1566
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567 xid = GetXid();
1568
Jeff Laytondf2cf172010-02-12 07:44:16 -05001569 if (!cifs_inode_needs_reval(inode))
1570 goto check_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571
1572 /* can not safely grab the rename sem here if rename calls revalidate
1573 since that would deadlock */
Jeff Laytondf2cf172010-02-12 07:44:16 -05001574 full_path = build_path_from_dentry(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301576 rc = -ENOMEM;
Jeff Laytondf2cf172010-02-12 07:44:16 -05001577 goto check_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578 }
Jeff Laytondf2cf172010-02-12 07:44:16 -05001579
Steve Frenchf19159d2010-04-21 04:12:10 +00001580 cFYI(1, "Revalidate: %s inode 0x%p count %d dentry: 0x%p d_time %ld "
Jeff Laytondf2cf172010-02-12 07:44:16 -05001581 "jiffies %ld", full_path, inode, inode->i_count.counter,
Steve Frenchf19159d2010-04-21 04:12:10 +00001582 dentry, dentry->d_time, jiffies);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583
Jeff Laytondf2cf172010-02-12 07:44:16 -05001584 if (CIFS_SB(sb)->tcon->unix_ext)
1585 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1586 else
1587 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1588 xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589
Jeff Laytondf2cf172010-02-12 07:44:16 -05001590check_inval:
1591 if (CIFS_I(inode)->invalid_mapping)
1592 cifs_invalidate_mapping(inode);
Steve French50c2f752007-07-13 00:33:32 +00001593
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594 kfree(full_path);
1595 FreeXid(xid);
1596 return rc;
1597}
1598
1599int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1600 struct kstat *stat)
1601{
Jeff Laytondf2cf172010-02-12 07:44:16 -05001602 int err = cifs_revalidate_dentry(dentry);
Steve French5fe14c82006-11-07 19:26:33 +00001603 if (!err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604 generic_fillattr(dentry->d_inode, stat);
Steve French5fe14c82006-11-07 19:26:33 +00001605 stat->blksize = CIFS_MAX_MSGSIZE;
Jeff Laytoncc0bad72009-06-25 00:56:52 -04001606 stat->ino = CIFS_I(dentry->d_inode)->uniqueid;
Steve French5fe14c82006-11-07 19:26:33 +00001607 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608 return err;
1609}
1610
1611static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1612{
1613 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1614 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1615 struct page *page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616 int rc = 0;
1617
1618 page = grab_cache_page(mapping, index);
1619 if (!page)
1620 return -ENOMEM;
1621
Christoph Lametereebd2aa2008-02-04 22:28:29 -08001622 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 unlock_page(page);
1624 page_cache_release(page);
1625 return rc;
1626}
1627
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001628static int cifs_vmtruncate(struct inode *inode, loff_t offset)
Steve French3677db12007-02-26 16:46:11 +00001629{
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001630 loff_t oldsize;
1631 int err;
Steve French3677db12007-02-26 16:46:11 +00001632
Steve Frenchba6a46a2007-02-26 20:06:29 +00001633 spin_lock(&inode->i_lock);
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001634 err = inode_newsize_ok(inode, offset);
1635 if (err) {
Steve Frenchba6a46a2007-02-26 20:06:29 +00001636 spin_unlock(&inode->i_lock);
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001637 goto out;
Steve Frenchba6a46a2007-02-26 20:06:29 +00001638 }
Steve French3677db12007-02-26 16:46:11 +00001639
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001640 oldsize = inode->i_size;
Steve French3677db12007-02-26 16:46:11 +00001641 i_size_write(inode, offset);
Steve Frenchba6a46a2007-02-26 20:06:29 +00001642 spin_unlock(&inode->i_lock);
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001643 truncate_pagecache(inode, oldsize, offset);
Al Viroacfa4382008-12-04 10:06:33 -05001644 if (inode->i_op->truncate)
Steve French3677db12007-02-26 16:46:11 +00001645 inode->i_op->truncate(inode);
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001646out:
1647 return err;
Steve French3677db12007-02-26 16:46:11 +00001648}
1649
Jeff Layton8efdbde2008-07-23 21:28:12 +00001650static int
1651cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1652 int xid, char *full_path)
1653{
1654 int rc;
1655 struct cifsFileInfo *open_file;
1656 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1657 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1658 struct cifsTconInfo *pTcon = cifs_sb->tcon;
1659
1660 /*
1661 * To avoid spurious oplock breaks from server, in the case of
1662 * inodes that we already have open, avoid doing path based
1663 * setting of file size if we can do it by handle.
1664 * This keeps our caching token (oplock) and avoids timeouts
1665 * when the local oplock break takes longer to flush
1666 * writebehind data than the SMB timeout for the SetPathInfo
1667 * request would allow
1668 */
1669 open_file = find_writable_file(cifsInode);
1670 if (open_file) {
1671 __u16 nfid = open_file->netfid;
1672 __u32 npid = open_file->pid;
1673 rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size, nfid,
1674 npid, false);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001675 cifsFileInfo_put(open_file);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001676 cFYI(1, "SetFSize for attrs rc = %d", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001677 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1678 unsigned int bytes_written;
1679 rc = CIFSSMBWrite(xid, pTcon, nfid, 0, attrs->ia_size,
1680 &bytes_written, NULL, NULL, 1);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001681 cFYI(1, "Wrt seteof rc %d", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001682 }
1683 } else
1684 rc = -EINVAL;
1685
1686 if (rc != 0) {
1687 /* Set file size by pathname rather than by handle
1688 either because no valid, writeable file handle for
1689 it was found or because there was an error setting
1690 it by handle */
1691 rc = CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size,
1692 false, cifs_sb->local_nls,
1693 cifs_sb->mnt_cifs_flags &
1694 CIFS_MOUNT_MAP_SPECIAL_CHR);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001695 cFYI(1, "SetEOF by path (setattrs) rc = %d", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001696 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1697 __u16 netfid;
1698 int oplock = 0;
1699
1700 rc = SMBLegacyOpen(xid, pTcon, full_path,
1701 FILE_OPEN, GENERIC_WRITE,
1702 CREATE_NOT_DIR, &netfid, &oplock, NULL,
1703 cifs_sb->local_nls,
1704 cifs_sb->mnt_cifs_flags &
1705 CIFS_MOUNT_MAP_SPECIAL_CHR);
1706 if (rc == 0) {
1707 unsigned int bytes_written;
1708 rc = CIFSSMBWrite(xid, pTcon, netfid, 0,
1709 attrs->ia_size,
1710 &bytes_written, NULL,
1711 NULL, 1);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001712 cFYI(1, "wrt seteof rc %d", rc);
Jeff Layton8efdbde2008-07-23 21:28:12 +00001713 CIFSSMBClose(xid, pTcon, netfid);
1714 }
1715 }
1716 }
1717
1718 if (rc == 0) {
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001719 cifsInode->server_eof = attrs->ia_size;
Jeff Layton8efdbde2008-07-23 21:28:12 +00001720 rc = cifs_vmtruncate(inode, attrs->ia_size);
1721 cifs_truncate_page(inode->i_mapping, inode->i_size);
1722 }
1723
1724 return rc;
1725}
1726
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001727static int
1728cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1729{
1730 int rc;
1731 int xid;
1732 char *full_path = NULL;
1733 struct inode *inode = direntry->d_inode;
1734 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1735 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1736 struct cifsTconInfo *pTcon = cifs_sb->tcon;
1737 struct cifs_unix_set_info_args *args = NULL;
Jeff Layton3bbeeb32009-07-09 20:02:50 -04001738 struct cifsFileInfo *open_file;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001739
Joe Perchesb6b38f72010-04-21 03:50:45 +00001740 cFYI(1, "setattr_unix on file %s attrs->ia_valid=0x%x",
1741 direntry->d_name.name, attrs->ia_valid);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001742
1743 xid = GetXid();
1744
1745 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) == 0) {
1746 /* check if we have permission to change attrs */
1747 rc = inode_change_ok(inode, attrs);
1748 if (rc < 0)
1749 goto out;
1750 else
1751 rc = 0;
1752 }
1753
1754 full_path = build_path_from_dentry(direntry);
1755 if (full_path == NULL) {
1756 rc = -ENOMEM;
1757 goto out;
1758 }
1759
Jeff Layton0f4d6342009-03-26 13:35:37 -04001760 /*
1761 * Attempt to flush data before changing attributes. We need to do
1762 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1763 * ownership or mode then we may also need to do this. Here, we take
1764 * the safe way out and just do the flush on all setattr requests. If
1765 * the flush returns error, store it to report later and continue.
1766 *
1767 * BB: This should be smarter. Why bother flushing pages that
1768 * will be truncated anyway? Also, should we error out here if
1769 * the flush returns error?
1770 */
1771 rc = filemap_write_and_wait(inode->i_mapping);
1772 if (rc != 0) {
1773 cifsInode->write_behind_rc = rc;
1774 rc = 0;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001775 }
1776
1777 if (attrs->ia_valid & ATTR_SIZE) {
1778 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1779 if (rc != 0)
1780 goto out;
1781 }
1782
1783 /* skip mode change if it's just for clearing setuid/setgid */
1784 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1785 attrs->ia_valid &= ~ATTR_MODE;
1786
1787 args = kmalloc(sizeof(*args), GFP_KERNEL);
1788 if (args == NULL) {
1789 rc = -ENOMEM;
1790 goto out;
1791 }
1792
1793 /* set up the struct */
1794 if (attrs->ia_valid & ATTR_MODE)
1795 args->mode = attrs->ia_mode;
1796 else
1797 args->mode = NO_CHANGE_64;
1798
1799 if (attrs->ia_valid & ATTR_UID)
1800 args->uid = attrs->ia_uid;
1801 else
1802 args->uid = NO_CHANGE_64;
1803
1804 if (attrs->ia_valid & ATTR_GID)
1805 args->gid = attrs->ia_gid;
1806 else
1807 args->gid = NO_CHANGE_64;
1808
1809 if (attrs->ia_valid & ATTR_ATIME)
1810 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
1811 else
1812 args->atime = NO_CHANGE_64;
1813
1814 if (attrs->ia_valid & ATTR_MTIME)
1815 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
1816 else
1817 args->mtime = NO_CHANGE_64;
1818
1819 if (attrs->ia_valid & ATTR_CTIME)
1820 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
1821 else
1822 args->ctime = NO_CHANGE_64;
1823
1824 args->device = 0;
Jeff Layton3bbeeb32009-07-09 20:02:50 -04001825 open_file = find_writable_file(cifsInode);
1826 if (open_file) {
1827 u16 nfid = open_file->netfid;
1828 u32 npid = open_file->pid;
1829 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001830 cifsFileInfo_put(open_file);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04001831 } else {
1832 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
Jeff Layton01ea95e2009-07-09 20:02:49 -04001833 cifs_sb->local_nls,
1834 cifs_sb->mnt_cifs_flags &
1835 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04001836 }
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001837
Steve Frenchccd4bb12010-02-08 17:39:58 +00001838 if (!rc) {
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001839 rc = inode_setattr(inode, attrs);
Steve Frenchccd4bb12010-02-08 17:39:58 +00001840
1841 /* force revalidate when any of these times are set since some
1842 of the fs types (eg ext3, fat) do not have fine enough
1843 time granularity to match protocol, and we do not have a
1844 a way (yet) to query the server fs's time granularity (and
1845 whether it rounds times down).
1846 */
1847 if (!rc && (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME)))
1848 cifsInode->time = 0;
1849 }
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001850out:
1851 kfree(args);
1852 kfree(full_path);
1853 FreeXid(xid);
1854 return rc;
1855}
1856
Jeff Layton0510eeb2008-08-02 07:26:12 -04001857static int
1858cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859{
1860 int xid;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001861 struct inode *inode = direntry->d_inode;
1862 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001863 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864 char *full_path = NULL;
1865 int rc = -EACCES;
Jeff Laytonfeb3e202008-08-02 07:26:12 -04001866 __u32 dosattr = 0;
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04001867 __u64 mode = NO_CHANGE_64;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001868
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869 xid = GetXid();
1870
Joe Perchesb6b38f72010-04-21 03:50:45 +00001871 cFYI(1, "setattr on file %s attrs->iavalid 0x%x",
1872 direntry->d_name.name, attrs->ia_valid);
Steve French6473a552005-11-29 20:20:10 -08001873
Steve French2a138ebb2005-11-29 21:22:19 -08001874 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) == 0) {
Steve French6473a552005-11-29 20:20:10 -08001875 /* check if we have permission to change attrs */
Jeff Layton02eadef2008-05-09 21:26:11 +00001876 rc = inode_change_ok(inode, attrs);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001877 if (rc < 0) {
Steve French6473a552005-11-29 20:20:10 -08001878 FreeXid(xid);
1879 return rc;
1880 } else
1881 rc = 0;
1882 }
Steve French50c2f752007-07-13 00:33:32 +00001883
Steve French7f573562005-08-30 11:32:14 -07001884 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301886 rc = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301888 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890
Jeff Layton0f4d6342009-03-26 13:35:37 -04001891 /*
1892 * Attempt to flush data before changing attributes. We need to do
1893 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1894 * ownership or mode then we may also need to do this. Here, we take
1895 * the safe way out and just do the flush on all setattr requests. If
1896 * the flush returns error, store it to report later and continue.
1897 *
1898 * BB: This should be smarter. Why bother flushing pages that
1899 * will be truncated anyway? Also, should we error out here if
1900 * the flush returns error?
1901 */
1902 rc = filemap_write_and_wait(inode->i_mapping);
1903 if (rc != 0) {
1904 cifsInode->write_behind_rc = rc;
1905 rc = 0;
Steve French50531442008-03-14 19:21:31 +00001906 }
Jeff Laytoncea21802007-11-20 23:19:03 +00001907
Steve French50531442008-03-14 19:21:31 +00001908 if (attrs->ia_valid & ATTR_SIZE) {
Jeff Layton8efdbde2008-07-23 21:28:12 +00001909 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1910 if (rc != 0)
Steve Frenche30dcf32005-09-20 20:49:16 -07001911 goto cifs_setattr_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912 }
Jeff Layton4ca691a2008-05-22 09:33:34 -04001913
1914 /*
1915 * Without unix extensions we can't send ownership changes to the
1916 * server, so silently ignore them. This is consistent with how
1917 * local DOS/Windows filesystems behave (VFAT, NTFS, etc). With
1918 * CIFSACL support + proper Windows to Unix idmapping, we may be
1919 * able to support this in the future.
1920 */
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001921 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
Jeff Layton4ca691a2008-05-22 09:33:34 -04001922 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923
Jeff Laytond32c4f22007-10-18 03:05:22 -07001924 /* skip mode change if it's just for clearing setuid/setgid */
1925 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1926 attrs->ia_valid &= ~ATTR_MODE;
1927
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928 if (attrs->ia_valid & ATTR_MODE) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001929 cFYI(1, "Mode changed to 0%o", attrs->ia_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930 mode = attrs->ia_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931 }
1932
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001933 if (attrs->ia_valid & ATTR_MODE) {
Steve Frenchcdbce9c2005-11-19 21:04:52 -08001934 rc = 0;
Steve French97837582007-12-31 07:47:21 +00001935#ifdef CONFIG_CIFS_EXPERIMENTAL
1936 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
Jeff Layton02eadef2008-05-09 21:26:11 +00001937 rc = mode_to_acl(inode, full_path, mode);
Jeff Layton51328612008-05-22 09:33:34 -04001938 else
Steve French97837582007-12-31 07:47:21 +00001939#endif
Jeff Layton51328612008-05-22 09:33:34 -04001940 if (((mode & S_IWUGO) == 0) &&
1941 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04001942
1943 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
1944
Jeff Layton51328612008-05-22 09:33:34 -04001945 /* fix up mode if we're not using dynperm */
1946 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
1947 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
1948 } else if ((mode & S_IWUGO) &&
1949 (cifsInode->cifsAttrs & ATTR_READONLY)) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04001950
1951 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
1952 /* Attributes of 0 are ignored */
1953 if (dosattr == 0)
1954 dosattr |= ATTR_NORMAL;
Jeff Layton51328612008-05-22 09:33:34 -04001955
1956 /* reset local inode permissions to normal */
1957 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
1958 attrs->ia_mode &= ~(S_IALLUGO);
1959 if (S_ISDIR(inode->i_mode))
1960 attrs->ia_mode |=
1961 cifs_sb->mnt_dir_mode;
1962 else
1963 attrs->ia_mode |=
1964 cifs_sb->mnt_file_mode;
1965 }
1966 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
1967 /* ignore mode change - ATTR_READONLY hasn't changed */
1968 attrs->ia_valid &= ~ATTR_MODE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970 }
1971
Jeff Laytonfeb3e202008-08-02 07:26:12 -04001972 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
1973 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
1974 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1975 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976
Steve Frenche30dcf32005-09-20 20:49:16 -07001977 /* Even if error on time set, no sense failing the call if
1978 the server would set the time to a reasonable value anyway,
1979 and this check ensures that we are not being called from
1980 sys_utimes in which case we ought to fail the call back to
1981 the user when the server rejects the call */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001982 if ((rc) && (attrs->ia_valid &
Jeff Laytonfeb3e202008-08-02 07:26:12 -04001983 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
Steve Frenche30dcf32005-09-20 20:49:16 -07001984 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985 }
1986
1987 /* do not need local check to inode_check_ok since the server does
1988 that */
1989 if (!rc)
Jeff Layton02eadef2008-05-09 21:26:11 +00001990 rc = inode_setattr(inode, attrs);
Steve Frenche30dcf32005-09-20 20:49:16 -07001991cifs_setattr_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992 kfree(full_path);
1993 FreeXid(xid);
1994 return rc;
1995}
1996
Jeff Layton0510eeb2008-08-02 07:26:12 -04001997int
1998cifs_setattr(struct dentry *direntry, struct iattr *attrs)
1999{
2000 struct inode *inode = direntry->d_inode;
2001 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2002 struct cifsTconInfo *pTcon = cifs_sb->tcon;
2003
2004 if (pTcon->unix_ext)
2005 return cifs_setattr_unix(direntry, attrs);
2006
2007 return cifs_setattr_nounix(direntry, attrs);
2008
2009 /* BB: add cifs_setattr_legacy for really old servers */
2010}
2011
Steve French99ee4db2007-02-27 05:35:17 +00002012#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013void cifs_delete_inode(struct inode *inode)
2014{
Joe Perchesb6b38f72010-04-21 03:50:45 +00002015 cFYI(1, "In cifs_delete_inode, inode = 0x%p", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002016 /* may have to add back in if and when safe distributed caching of
2017 directories added e.g. via FindNotify */
2018}
Steve French99ee4db2007-02-27 05:35:17 +00002019#endif