]> git.ipfire.org Git - thirdparty/kernel/stable.git/blame - fs/cifs/inode.c
cifs: fallback to older infolevels on findfirst queryinfo retry
[thirdparty/kernel/stable.git] / fs / cifs / inode.c
CommitLineData
1da177e4
LT
1/*
2 * fs/cifs/inode.c
3 *
f19159dc 4 * Copyright (C) International Business Machines Corp., 2002,2010
1da177e4
LT
5 * 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>
1da177e4 22#include <linux/stat.h>
5a0e3ad6 23#include <linux/slab.h>
1da177e4 24#include <linux/pagemap.h>
4f73c7d3 25#include <linux/freezer.h>
174cd4b1 26#include <linux/sched/signal.h>
5dd43ce2 27#include <linux/wait_bit.h>
174cd4b1 28
1da177e4
LT
29#include <asm/div64.h>
30#include "cifsfs.h"
31#include "cifspdu.h"
32#include "cifsglob.h"
33#include "cifsproto.h"
34#include "cifs_debug.h"
35#include "cifs_fs_sb.h"
2baa2682 36#include "cifs_unicode.h"
9451a9a5 37#include "fscache.h"
1da177e4 38
70eff55d 39
01c64fea 40static void cifs_set_ops(struct inode *inode)
70eff55d
CH
41{
42 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
43
44 switch (inode->i_mode & S_IFMT) {
45 case S_IFREG:
46 inode->i_op = &cifs_file_inode_ops;
47 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
48 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
49 inode->i_fop = &cifs_file_direct_nobrl_ops;
50 else
51 inode->i_fop = &cifs_file_direct_ops;
8be7e6ba
PS
52 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
53 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
54 inode->i_fop = &cifs_file_strict_nobrl_ops;
55 else
56 inode->i_fop = &cifs_file_strict_ops;
70eff55d
CH
57 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
58 inode->i_fop = &cifs_file_nobrl_ops;
59 else { /* not direct, send byte range locks */
60 inode->i_fop = &cifs_file_ops;
61 }
62
70eff55d 63 /* check if server can support readpages */
0d424ad0 64 if (cifs_sb_master_tcon(cifs_sb)->ses->server->maxBuf <
09cbfeaf 65 PAGE_SIZE + MAX_CIFS_HDR_SIZE)
70eff55d
CH
66 inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
67 else
68 inode->i_data.a_ops = &cifs_addr_ops;
69 break;
70 case S_IFDIR:
bc5b6e24 71#ifdef CONFIG_CIFS_DFS_UPCALL
01c64fea 72 if (IS_AUTOMOUNT(inode)) {
7962670e
IM
73 inode->i_op = &cifs_dfs_referral_inode_operations;
74 } else {
bc5b6e24
SF
75#else /* NO DFS support, treat as a directory */
76 {
77#endif
7962670e
IM
78 inode->i_op = &cifs_dir_inode_ops;
79 inode->i_fop = &cifs_dir_ops;
80 }
70eff55d
CH
81 break;
82 case S_IFLNK:
83 inode->i_op = &cifs_symlink_inode_ops;
84 break;
85 default:
86 init_special_inode(inode, inode->i_mode, inode->i_rdev);
87 break;
88 }
89}
90
df2cf170
JL
91/* check inode attributes against fattr. If they don't match, tag the
92 * inode for cache invalidation
93 */
94static void
95cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
96{
97 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
98
f96637be
JP
99 cifs_dbg(FYI, "%s: revalidating inode %llu\n",
100 __func__, cifs_i->uniqueid);
df2cf170
JL
101
102 if (inode->i_state & I_NEW) {
f96637be
JP
103 cifs_dbg(FYI, "%s: inode %llu is new\n",
104 __func__, cifs_i->uniqueid);
df2cf170
JL
105 return;
106 }
107
108 /* don't bother with revalidation if we have an oplock */
18cceb6a 109 if (CIFS_CACHE_READ(cifs_i)) {
f96637be
JP
110 cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
111 __func__, cifs_i->uniqueid);
df2cf170
JL
112 return;
113 }
114
115 /* revalidate if mtime or size have changed */
116 if (timespec_equal(&inode->i_mtime, &fattr->cf_mtime) &&
117 cifs_i->server_eof == fattr->cf_eof) {
f96637be
JP
118 cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
119 __func__, cifs_i->uniqueid);
df2cf170
JL
120 return;
121 }
122
f96637be
JP
123 cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
124 __func__, cifs_i->uniqueid);
aff8d5ca 125 set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags);
df2cf170
JL
126}
127
74d290da
JM
128/*
129 * copy nlink to the inode, unless it wasn't provided. Provide
130 * sane values if we don't have an existing one and none was provided
131 */
132static void
133cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
134{
135 /*
136 * if we're in a situation where we can't trust what we
137 * got from the server (readdir, some non-unix cases)
138 * fake reasonable values
139 */
140 if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
141 /* only provide fake values on a new inode */
142 if (inode->i_state & I_NEW) {
143 if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
144 set_nlink(inode, 2);
145 else
146 set_nlink(inode, 1);
147 }
148 return;
149 }
150
151 /* we trust the server, so update it */
152 set_nlink(inode, fattr->cf_nlink);
153}
154
cc0bad75
JL
155/* populate an inode with info from a cifs_fattr struct */
156void
157cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
75f12983 158{
cc0bad75 159 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
0b8f18e3 160 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
cc0bad75 161
df2cf170
JL
162 cifs_revalidate_cache(inode, fattr);
163
b7ca6928 164 spin_lock(&inode->i_lock);
cc0bad75
JL
165 inode->i_atime = fattr->cf_atime;
166 inode->i_mtime = fattr->cf_mtime;
167 inode->i_ctime = fattr->cf_ctime;
cc0bad75 168 inode->i_rdev = fattr->cf_rdev;
74d290da 169 cifs_nlink_fattr_to_inode(inode, fattr);
cc0bad75
JL
170 inode->i_uid = fattr->cf_uid;
171 inode->i_gid = fattr->cf_gid;
172
0b8f18e3
JL
173 /* if dynperm is set, don't clobber existing mode */
174 if (inode->i_state & I_NEW ||
175 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
176 inode->i_mode = fattr->cf_mode;
177
cc0bad75 178 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
75f12983 179
0b8f18e3
JL
180 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
181 cifs_i->time = 0;
182 else
183 cifs_i->time = jiffies;
184
aff8d5ca
JL
185 if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING)
186 set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
187 else
188 clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
cc0bad75 189
835a36ca 190 cifs_i->server_eof = fattr->cf_eof;
cc0bad75
JL
191 /*
192 * Can't safely change the file size here if the client is writing to
193 * it due to potential races.
194 */
cc0bad75
JL
195 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
196 i_size_write(inode, fattr->cf_eof);
197
198 /*
199 * i_blocks is not related to (i_size / i_blksize),
200 * but instead 512 byte (2**9) size is required for
201 * calculating num blocks.
202 */
203 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
204 }
205 spin_unlock(&inode->i_lock);
206
01c64fea
DH
207 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
208 inode->i_flags |= S_AUTOMOUNT;
c2b93e06
JL
209 if (inode->i_state & I_NEW)
210 cifs_set_ops(inode);
cc0bad75
JL
211}
212
4065c802
JL
213void
214cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
215{
216 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
217
218 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
219 return;
220
221 fattr->cf_uniqueid = iunique(sb, ROOT_I);
222}
223
cc0bad75
JL
224/* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
225void
226cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
227 struct cifs_sb_info *cifs_sb)
228{
229 memset(fattr, 0, sizeof(*fattr));
230 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
231 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
232 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
233
234 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
235 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
236 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
6e70e26d
SF
237 /* old POSIX extensions don't get create time */
238
cc0bad75 239 fattr->cf_mode = le64_to_cpu(info->Permissions);
75f12983
CH
240
241 /*
242 * Since we set the inode type below we need to mask off
243 * to avoid strange results if bits set above.
244 */
cc0bad75 245 fattr->cf_mode &= ~S_IFMT;
75f12983
CH
246 switch (le32_to_cpu(info->Type)) {
247 case UNIX_FILE:
cc0bad75
JL
248 fattr->cf_mode |= S_IFREG;
249 fattr->cf_dtype = DT_REG;
75f12983
CH
250 break;
251 case UNIX_SYMLINK:
cc0bad75
JL
252 fattr->cf_mode |= S_IFLNK;
253 fattr->cf_dtype = DT_LNK;
75f12983
CH
254 break;
255 case UNIX_DIR:
cc0bad75
JL
256 fattr->cf_mode |= S_IFDIR;
257 fattr->cf_dtype = DT_DIR;
75f12983
CH
258 break;
259 case UNIX_CHARDEV:
cc0bad75
JL
260 fattr->cf_mode |= S_IFCHR;
261 fattr->cf_dtype = DT_CHR;
262 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
263 le64_to_cpu(info->DevMinor) & MINORMASK);
75f12983
CH
264 break;
265 case UNIX_BLOCKDEV:
cc0bad75
JL
266 fattr->cf_mode |= S_IFBLK;
267 fattr->cf_dtype = DT_BLK;
268 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
269 le64_to_cpu(info->DevMinor) & MINORMASK);
75f12983
CH
270 break;
271 case UNIX_FIFO:
cc0bad75
JL
272 fattr->cf_mode |= S_IFIFO;
273 fattr->cf_dtype = DT_FIFO;
75f12983
CH
274 break;
275 case UNIX_SOCKET:
cc0bad75
JL
276 fattr->cf_mode |= S_IFSOCK;
277 fattr->cf_dtype = DT_SOCK;
75f12983
CH
278 break;
279 default:
280 /* safest to call it a file if we do not know */
cc0bad75
JL
281 fattr->cf_mode |= S_IFREG;
282 fattr->cf_dtype = DT_REG;
f96637be 283 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
75f12983
CH
284 break;
285 }
286
46bbc25f
EB
287 fattr->cf_uid = cifs_sb->mnt_uid;
288 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
289 u64 id = le64_to_cpu(info->Uid);
4a2c8cf5
EB
290 if (id < ((uid_t)-1)) {
291 kuid_t uid = make_kuid(&init_user_ns, id);
292 if (uid_valid(uid))
293 fattr->cf_uid = uid;
294 }
46bbc25f
EB
295 }
296
297 fattr->cf_gid = cifs_sb->mnt_gid;
298 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
299 u64 id = le64_to_cpu(info->Gid);
4a2c8cf5
EB
300 if (id < ((gid_t)-1)) {
301 kgid_t gid = make_kgid(&init_user_ns, id);
302 if (gid_valid(gid))
303 fattr->cf_gid = gid;
304 }
46bbc25f 305 }
75f12983 306
cc0bad75 307 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
75f12983
CH
308}
309
b9a3260f 310/*
cc0bad75
JL
311 * Fill a cifs_fattr struct with fake inode info.
312 *
313 * Needed to setup cifs_fattr data for the directory which is the
314 * junction to the new submount (ie to setup the fake directory
315 * which represents a DFS referral).
b9a3260f 316 */
f1230c97 317static void
cc0bad75 318cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
0e4bbde9 319{
cc0bad75 320 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
0e4bbde9 321
f96637be 322 cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
cc0bad75
JL
323
324 memset(fattr, 0, sizeof(*fattr));
325 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
326 fattr->cf_uid = cifs_sb->mnt_uid;
327 fattr->cf_gid = cifs_sb->mnt_gid;
e37fea58
DD
328 ktime_get_real_ts(&fattr->cf_mtime);
329 fattr->cf_mtime = timespec_trunc(fattr->cf_mtime, sb->s_time_gran);
330 fattr->cf_atime = fattr->cf_ctime = fattr->cf_mtime;
cc0bad75
JL
331 fattr->cf_nlink = 2;
332 fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
0e4bbde9
SF
333}
334
4ad65044
PS
335static int
336cifs_get_file_info_unix(struct file *filp)
abab095d
JL
337{
338 int rc;
6d5786a3 339 unsigned int xid;
abab095d
JL
340 FILE_UNIX_BASIC_INFO find_data;
341 struct cifs_fattr fattr;
496ad9aa 342 struct inode *inode = file_inode(filp);
abab095d 343 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
c21dfb69 344 struct cifsFileInfo *cfile = filp->private_data;
96daf2b0 345 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
abab095d 346
6d5786a3 347 xid = get_xid();
4b4de76e 348 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
abab095d
JL
349 if (!rc) {
350 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
351 } else if (rc == -EREMOTE) {
352 cifs_create_dfs_fattr(&fattr, inode->i_sb);
353 rc = 0;
354 }
355
356 cifs_fattr_to_inode(inode, &fattr);
6d5786a3 357 free_xid(xid);
abab095d
JL
358 return rc;
359}
360
1da177e4 361int cifs_get_inode_info_unix(struct inode **pinode,
cc0bad75 362 const unsigned char *full_path,
6d5786a3 363 struct super_block *sb, unsigned int xid)
1da177e4 364{
cc0bad75 365 int rc;
0e4bbde9 366 FILE_UNIX_BASIC_INFO find_data;
cc0bad75 367 struct cifs_fattr fattr;
96daf2b0 368 struct cifs_tcon *tcon;
7ffec372 369 struct tcon_link *tlink;
1da177e4 370 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1da177e4 371
f96637be 372 cifs_dbg(FYI, "Getting info on %s\n", full_path);
7962670e 373
7ffec372
JL
374 tlink = cifs_sb_tlink(cifs_sb);
375 if (IS_ERR(tlink))
376 return PTR_ERR(tlink);
377 tcon = tlink_tcon(tlink);
378
1da177e4 379 /* could have done a find first instead but this returns more info */
cc0bad75 380 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
bc8ebdc4 381 cifs_sb->local_nls, cifs_remap(cifs_sb));
7ffec372 382 cifs_put_tlink(tlink);
e911d0cc 383
cc0bad75
JL
384 if (!rc) {
385 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
386 } else if (rc == -EREMOTE) {
387 cifs_create_dfs_fattr(&fattr, sb);
388 rc = 0;
389 } else {
390 return rc;
391 }
1da177e4 392
1b12b9c1
SM
393 /* check for Minshall+French symlinks */
394 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
cb084b1a
SP
395 int tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
396 full_path);
1b12b9c1 397 if (tmprc)
cb084b1a 398 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
1b12b9c1
SM
399 }
400
0e4bbde9 401 if (*pinode == NULL) {
cc0bad75 402 /* get new inode */
4065c802 403 cifs_fill_uniqueid(sb, &fattr);
cc0bad75
JL
404 *pinode = cifs_iget(sb, &fattr);
405 if (!*pinode)
0e4bbde9 406 rc = -ENOMEM;
cc0bad75
JL
407 } else {
408 /* we already have inode, update it */
7196ac11
NA
409
410 /* if uniqueid is different, return error */
411 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
412 CIFS_I(*pinode)->uniqueid != fattr.cf_uniqueid)) {
413 rc = -ESTALE;
414 goto cgiiu_exit;
415 }
416
417 /* if filetype is different, return error */
418 if (unlikely(((*pinode)->i_mode & S_IFMT) !=
419 (fattr.cf_mode & S_IFMT))) {
420 rc = -ESTALE;
421 goto cgiiu_exit;
422 }
423
cc0bad75 424 cifs_fattr_to_inode(*pinode, &fattr);
0e4bbde9 425 }
1da177e4 426
7196ac11 427cgiiu_exit:
1da177e4
LT
428 return rc;
429}
430
0b8f18e3 431static int
0360d605 432cifs_sfu_type(struct cifs_fattr *fattr, const char *path,
6d5786a3 433 struct cifs_sb_info *cifs_sb, unsigned int xid)
d6e2f2a4
SF
434{
435 int rc;
db8b631d 436 __u32 oplock;
7ffec372 437 struct tcon_link *tlink;
96daf2b0 438 struct cifs_tcon *tcon;
d81b8a40
PS
439 struct cifs_fid fid;
440 struct cifs_open_parms oparms;
d4ffff1f 441 struct cifs_io_parms io_parms;
86c96b4b 442 char buf[24];
d6e2f2a4 443 unsigned int bytes_read;
fb8c4b14 444 char *pbuf;
0360d605 445 int buf_type = CIFS_NO_BUFFER;
d6e2f2a4
SF
446
447 pbuf = buf;
448
0b8f18e3
JL
449 fattr->cf_mode &= ~S_IFMT;
450
451 if (fattr->cf_eof == 0) {
452 fattr->cf_mode |= S_IFIFO;
453 fattr->cf_dtype = DT_FIFO;
d6e2f2a4 454 return 0;
0b8f18e3
JL
455 } else if (fattr->cf_eof < 8) {
456 fattr->cf_mode |= S_IFREG;
457 fattr->cf_dtype = DT_REG;
d6e2f2a4
SF
458 return -EINVAL; /* EOPNOTSUPP? */
459 }
50c2f753 460
7ffec372
JL
461 tlink = cifs_sb_tlink(cifs_sb);
462 if (IS_ERR(tlink))
463 return PTR_ERR(tlink);
464 tcon = tlink_tcon(tlink);
465
d81b8a40
PS
466 oparms.tcon = tcon;
467 oparms.cifs_sb = cifs_sb;
468 oparms.desired_access = GENERIC_READ;
469 oparms.create_options = CREATE_NOT_DIR;
b0b69369
SF
470 if (backup_cred(cifs_sb))
471 oparms.create_options |= CREATE_OPEN_BACKUP_INTENT;
d81b8a40
PS
472 oparms.disposition = FILE_OPEN;
473 oparms.path = path;
474 oparms.fid = &fid;
475 oparms.reconnect = false;
476
db8b631d
SF
477 if (tcon->ses->server->oplocks)
478 oplock = REQ_OPLOCK;
479 else
480 oplock = 0;
481 rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);
0360d605 482 if (rc) {
db8b631d 483 cifs_dbg(FYI, "check sfu type of %s, open rc = %d\n", path, rc);
0360d605
PS
484 cifs_put_tlink(tlink);
485 return rc;
486 }
487
488 /* Read header */
d81b8a40 489 io_parms.netfid = fid.netfid;
0360d605
PS
490 io_parms.pid = current->tgid;
491 io_parms.tcon = tcon;
492 io_parms.offset = 0;
493 io_parms.length = 24;
494
db8b631d
SF
495 rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,
496 &bytes_read, &pbuf, &buf_type);
0360d605
PS
497 if ((rc == 0) && (bytes_read >= 8)) {
498 if (memcmp("IntxBLK", pbuf, 8) == 0) {
499 cifs_dbg(FYI, "Block device\n");
500 fattr->cf_mode |= S_IFBLK;
501 fattr->cf_dtype = DT_BLK;
502 if (bytes_read == 24) {
503 /* we have enough to decode dev num */
504 __u64 mjr; /* major */
505 __u64 mnr; /* minor */
506 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
507 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
508 fattr->cf_rdev = MKDEV(mjr, mnr);
86c96b4b 509 }
0360d605
PS
510 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
511 cifs_dbg(FYI, "Char device\n");
512 fattr->cf_mode |= S_IFCHR;
513 fattr->cf_dtype = DT_CHR;
514 if (bytes_read == 24) {
515 /* we have enough to decode dev num */
516 __u64 mjr; /* major */
517 __u64 mnr; /* minor */
518 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
519 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
520 fattr->cf_rdev = MKDEV(mjr, mnr);
521 }
522 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
523 cifs_dbg(FYI, "Symlink\n");
524 fattr->cf_mode |= S_IFLNK;
525 fattr->cf_dtype = DT_LNK;
3020a1f5 526 } else {
0360d605 527 fattr->cf_mode |= S_IFREG; /* file? */
0b8f18e3 528 fattr->cf_dtype = DT_REG;
0360d605 529 rc = -EOPNOTSUPP;
fb8c4b14 530 }
0360d605
PS
531 } else {
532 fattr->cf_mode |= S_IFREG; /* then it is a file */
533 fattr->cf_dtype = DT_REG;
534 rc = -EOPNOTSUPP; /* or some unknown SFU type */
d6e2f2a4 535 }
db8b631d
SF
536
537 tcon->ses->server->ops->close(xid, tcon, &fid);
7ffec372 538 cifs_put_tlink(tlink);
d6e2f2a4 539 return rc;
d6e2f2a4
SF
540}
541
9e294f1c
SF
542#define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
543
0b8f18e3
JL
544/*
545 * Fetch mode bits as provided by SFU.
546 *
547 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
548 */
549static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
6d5786a3 550 struct cifs_sb_info *cifs_sb, unsigned int xid)
9e294f1c 551{
3020a1f5 552#ifdef CONFIG_CIFS_XATTR
9e294f1c
SF
553 ssize_t rc;
554 char ea_value[4];
555 __u32 mode;
7ffec372 556 struct tcon_link *tlink;
96daf2b0 557 struct cifs_tcon *tcon;
7ffec372
JL
558
559 tlink = cifs_sb_tlink(cifs_sb);
560 if (IS_ERR(tlink))
561 return PTR_ERR(tlink);
562 tcon = tlink_tcon(tlink);
9e294f1c 563
d979f3b0
SF
564 if (tcon->ses->server->ops->query_all_EAs == NULL) {
565 cifs_put_tlink(tlink);
566 return -EOPNOTSUPP;
567 }
568
569 rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
570 "SETFILEBITS", ea_value, 4 /* size of buf */,
67b4c889 571 cifs_sb);
7ffec372 572 cifs_put_tlink(tlink);
4523cc30 573 if (rc < 0)
9e294f1c
SF
574 return (int)rc;
575 else if (rc > 3) {
576 mode = le32_to_cpu(*((__le32 *)ea_value));
0b8f18e3 577 fattr->cf_mode &= ~SFBITS_MASK;
f96637be
JP
578 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
579 mode, fattr->cf_mode);
0b8f18e3 580 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
f96637be 581 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
9e294f1c 582 }
0b8f18e3
JL
583
584 return 0;
3020a1f5
SF
585#else
586 return -EOPNOTSUPP;
587#endif
9e294f1c
SF
588}
589
0b8f18e3 590/* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
f1230c97 591static void
0b8f18e3 592cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
e37fea58 593 struct super_block *sb, bool adjust_tz,
eb85d94b 594 bool symlink)
b9a3260f 595{
e37fea58 596 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
96daf2b0 597 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
0d424ad0 598
0b8f18e3
JL
599 memset(fattr, 0, sizeof(*fattr));
600 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
601 if (info->DeletePending)
602 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
603
604 if (info->LastAccessTime)
605 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
e37fea58
DD
606 else {
607 ktime_get_real_ts(&fattr->cf_atime);
608 fattr->cf_atime = timespec_trunc(fattr->cf_atime, sb->s_time_gran);
609 }
0b8f18e3
JL
610
611 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
612 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
613
614 if (adjust_tz) {
0d424ad0
JL
615 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
616 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
0b8f18e3
JL
617 }
618
619 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
620 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
20054bd6 621 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
0b8f18e3 622
74d290da 623 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
eb85d94b
PS
624
625 if (symlink) {
626 fattr->cf_mode = S_IFLNK;
627 fattr->cf_dtype = DT_LNK;
628 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
0b8f18e3
JL
629 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
630 fattr->cf_dtype = DT_DIR;
6de2ce42
PS
631 /*
632 * Server can return wrong NumberOfLinks value for directories
633 * when Unix extensions are disabled - fake it.
634 */
74d290da
JM
635 if (!tcon->unix_ext)
636 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
0b8f18e3
JL
637 } else {
638 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
639 fattr->cf_dtype = DT_REG;
0b8f18e3 640
d0c280d2
JL
641 /* clear write bits if ATTR_READONLY is set */
642 if (fattr->cf_cifsattrs & ATTR_READONLY)
643 fattr->cf_mode &= ~(S_IWUGO);
0b8f18e3 644
74d290da
JM
645 /*
646 * Don't accept zero nlink from non-unix servers unless
647 * delete is pending. Instead mark it as unknown.
648 */
649 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
650 !info->DeletePending) {
651 cifs_dbg(1, "bogus file nlink value %u\n",
6658b9f7 652 fattr->cf_nlink);
74d290da 653 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
6658b9f7 654 }
6de2ce42 655 }
0b8f18e3
JL
656
657 fattr->cf_uid = cifs_sb->mnt_uid;
658 fattr->cf_gid = cifs_sb->mnt_gid;
b9a3260f
SF
659}
660
4ad65044
PS
661static int
662cifs_get_file_info(struct file *filp)
abab095d
JL
663{
664 int rc;
6d5786a3 665 unsigned int xid;
abab095d
JL
666 FILE_ALL_INFO find_data;
667 struct cifs_fattr fattr;
496ad9aa 668 struct inode *inode = file_inode(filp);
c21dfb69 669 struct cifsFileInfo *cfile = filp->private_data;
96daf2b0 670 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
4ad65044
PS
671 struct TCP_Server_Info *server = tcon->ses->server;
672
673 if (!server->ops->query_file_info)
674 return -ENOSYS;
abab095d 675
6d5786a3 676 xid = get_xid();
4ad65044 677 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
42274bb2
PS
678 switch (rc) {
679 case 0:
e37fea58 680 cifs_all_info_to_fattr(&fattr, &find_data, inode->i_sb, false,
eb85d94b 681 false);
42274bb2
PS
682 break;
683 case -EREMOTE:
684 cifs_create_dfs_fattr(&fattr, inode->i_sb);
685 rc = 0;
686 break;
687 case -EOPNOTSUPP:
688 case -EINVAL:
abab095d
JL
689 /*
690 * FIXME: legacy server -- fall back to path-based call?
ff215713
SF
691 * for now, just skip revalidating and mark inode for
692 * immediate reval.
693 */
abab095d
JL
694 rc = 0;
695 CIFS_I(inode)->time = 0;
42274bb2 696 default:
abab095d 697 goto cgfi_exit;
42274bb2 698 }
abab095d
JL
699
700 /*
701 * don't bother with SFU junk here -- just mark inode as needing
702 * revalidation.
703 */
abab095d
JL
704 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
705 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
706 cifs_fattr_to_inode(inode, &fattr);
707cgfi_exit:
6d5786a3 708 free_xid(xid);
abab095d
JL
709 return rc;
710}
711
70dbed63
SF
712/* Simple function to return a 64 bit hash of string. Rarely called */
713static __u64 simple_hashstr(const char *str)
714{
8f041940 715 const __u64 hash_mult = 1125899906842597ULL; /* a big enough prime */
70dbed63
SF
716 __u64 hash = 0;
717
718 while (*str)
719 hash = (hash + (__u64) *str++) * hash_mult;
720
721 return hash;
722}
723
1208ef1f
PS
724int
725cifs_get_inode_info(struct inode **inode, const char *full_path,
726 FILE_ALL_INFO *data, struct super_block *sb, int xid,
42eacf9e 727 const struct cifs_fid *fid)
1da177e4 728{
c052e2b4
SP
729 bool validinum = false;
730 __u16 srchflgs;
731 int rc = 0, tmprc = ENOSYS;
1208ef1f
PS
732 struct cifs_tcon *tcon;
733 struct TCP_Server_Info *server;
7ffec372 734 struct tcon_link *tlink;
1da177e4 735 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1da177e4 736 char *buf = NULL;
1208ef1f 737 bool adjust_tz = false;
0b8f18e3 738 struct cifs_fattr fattr;
c052e2b4 739 struct cifs_search_info *srchinf = NULL;
eb85d94b 740 bool symlink = false;
1da177e4 741
7ffec372
JL
742 tlink = cifs_sb_tlink(cifs_sb);
743 if (IS_ERR(tlink))
744 return PTR_ERR(tlink);
1208ef1f
PS
745 tcon = tlink_tcon(tlink);
746 server = tcon->ses->server;
7ffec372 747
f96637be 748 cifs_dbg(FYI, "Getting info on %s\n", full_path);
1da177e4 749
1208ef1f 750 if ((data == NULL) && (*inode != NULL)) {
18cceb6a 751 if (CIFS_CACHE_READ(CIFS_I(*inode))) {
f96637be 752 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
7ffec372 753 goto cgii_exit;
1da177e4
LT
754 }
755 }
756
1208ef1f
PS
757 /* if inode info is not passed, get it from server */
758 if (data == NULL) {
759 if (!server->ops->query_path_info) {
760 rc = -ENOSYS;
761 goto cgii_exit;
762 }
1da177e4 763 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
7ffec372
JL
764 if (buf == NULL) {
765 rc = -ENOMEM;
766 goto cgii_exit;
767 }
1208ef1f
PS
768 data = (FILE_ALL_INFO *)buf;
769 rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path,
eb85d94b 770 data, &adjust_tz, &symlink);
1da177e4 771 }
0b8f18e3
JL
772
773 if (!rc) {
e37fea58 774 cifs_all_info_to_fattr(&fattr, data, sb, adjust_tz,
eb85d94b 775 symlink);
0b8f18e3
JL
776 } else if (rc == -EREMOTE) {
777 cifs_create_dfs_fattr(&fattr, sb);
b9a3260f 778 rc = 0;
122f2bd8
SF
779 } else if ((rc == -EACCES) && backup_cred(cifs_sb) &&
780 (strcmp(server->vals->version_string, SMB1_VERSION_STRING)
781 == 0)) {
1d41cd12
SF
782 /*
783 * For SMB2 and later the backup intent flag is already
784 * sent if needed on open and there is no path based
785 * FindFirst operation to use to retry with
786 */
787
788 srchinf = kzalloc(sizeof(struct cifs_search_info),
789 GFP_KERNEL);
790 if (srchinf == NULL) {
791 rc = -ENOMEM;
792 goto cgii_exit;
793 }
c052e2b4 794
1d41cd12
SF
795 srchinf->endOfSearch = false;
796 if (tcon->unix_ext)
797 srchinf->info_level = SMB_FIND_FILE_UNIX;
798 else if ((tcon->ses->capabilities &
799 tcon->ses->server->vals->cap_nt_find) == 0)
800 srchinf->info_level = SMB_FIND_FILE_INFO_STANDARD;
801 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
c052e2b4 802 srchinf->info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
1d41cd12
SF
803 else /* no srvino useful for fallback to some netapp */
804 srchinf->info_level = SMB_FIND_FILE_DIRECTORY_INFO;
c052e2b4 805
1d41cd12
SF
806 srchflgs = CIFS_SEARCH_CLOSE_ALWAYS |
807 CIFS_SEARCH_CLOSE_AT_END |
808 CIFS_SEARCH_BACKUP_SEARCH;
c052e2b4 809
1d41cd12
SF
810 rc = CIFSFindFirst(xid, tcon, full_path,
811 cifs_sb, NULL, srchflgs, srchinf, false);
812 if (!rc) {
813 data = (FILE_ALL_INFO *)srchinf->srch_entries_start;
c052e2b4 814
1d41cd12
SF
815 cifs_dir_info_to_fattr(&fattr,
816 (FILE_DIRECTORY_INFO *)data, cifs_sb);
817 fattr.cf_uniqueid = le64_to_cpu(
818 ((SEARCH_ID_FULL_DIR_INFO *)data)->UniqueId);
819 validinum = true;
c052e2b4 820
1d41cd12
SF
821 cifs_buf_release(srchinf->ntwrk_buf_start);
822 }
823 kfree(srchinf);
824 if (rc)
825 goto cgii_exit;
c052e2b4 826 } else
7962670e 827 goto cgii_exit;
1da177e4 828
0b8f18e3
JL
829 /*
830 * If an inode wasn't passed in, then get the inode number
831 *
832 * Is an i_ino of zero legal? Can we use that to check if the server
833 * supports returning inode numbers? Are there other sanity checks we
834 * can use to ensure that the server is really filling in that field?
0b8f18e3 835 */
1208ef1f 836 if (*inode == NULL) {
b9a3260f 837 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
c052e2b4
SP
838 if (validinum == false) {
839 if (server->ops->get_srv_inum)
840 tmprc = server->ops->get_srv_inum(xid,
841 tcon, cifs_sb, full_path,
842 &fattr.cf_uniqueid, data);
843 if (tmprc) {
f96637be
JP
844 cifs_dbg(FYI, "GetSrvInodeNum rc %d\n",
845 tmprc);
c052e2b4
SP
846 fattr.cf_uniqueid = iunique(sb, ROOT_I);
847 cifs_autodisable_serverino(cifs_sb);
70dbed63
SF
848 } else if ((fattr.cf_uniqueid == 0) &&
849 strlen(full_path) == 0) {
850 /* some servers ret bad root ino ie 0 */
851 cifs_dbg(FYI, "Invalid (0) inodenum\n");
852 fattr.cf_flags |=
853 CIFS_FATTR_FAKE_ROOT_INO;
854 fattr.cf_uniqueid =
855 simple_hashstr(tcon->treeName);
c052e2b4 856 }
132ac7b7 857 }
c052e2b4 858 } else
0b8f18e3 859 fattr.cf_uniqueid = iunique(sb, ROOT_I);
a108471b
RL
860 } else {
861 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
862 validinum == false && server->ops->get_srv_inum) {
863 /*
864 * Pass a NULL tcon to ensure we don't make a round
865 * trip to the server. This only works for SMB2+.
866 */
867 tmprc = server->ops->get_srv_inum(xid,
868 NULL, cifs_sb, full_path,
869 &fattr.cf_uniqueid, data);
870 if (tmprc)
871 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
70dbed63
SF
872 else if ((fattr.cf_uniqueid == 0) &&
873 strlen(full_path) == 0) {
874 /*
875 * Reuse existing root inode num since
876 * inum zero for root causes ls of . and .. to
877 * not be returned
878 */
879 cifs_dbg(FYI, "Srv ret 0 inode num for root\n");
880 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
881 }
a108471b
RL
882 } else
883 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
884 }
b9a3260f 885
0b8f18e3
JL
886 /* query for SFU type info if supported and needed */
887 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
888 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
889 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
890 if (tmprc)
f96637be 891 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
b9a3260f 892 }
1da177e4 893
79df1bae 894#ifdef CONFIG_CIFS_ACL
b9a3260f
SF
895 /* fill in 0777 bits from ACL */
896 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
1208ef1f 897 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, full_path, fid);
78415d2d 898 if (rc) {
f96637be
JP
899 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
900 __func__, rc);
78415d2d
SP
901 goto cgii_exit;
902 }
b9a3260f 903 }
79df1bae 904#endif /* CONFIG_CIFS_ACL */
b9a3260f 905
0b8f18e3
JL
906 /* fill in remaining high mode bits e.g. SUID, VTX */
907 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
908 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
b9a3260f 909
1b12b9c1
SM
910 /* check for Minshall+French symlinks */
911 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
cb084b1a
SP
912 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
913 full_path);
1b12b9c1 914 if (tmprc)
cb084b1a 915 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
1b12b9c1
SM
916 }
917
1208ef1f
PS
918 if (!*inode) {
919 *inode = cifs_iget(sb, &fattr);
920 if (!*inode)
0b8f18e3
JL
921 rc = -ENOMEM;
922 } else {
7196ac11
NA
923 /* we already have inode, update it */
924
a108471b
RL
925 /* if uniqueid is different, return error */
926 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
927 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
928 rc = -ESTALE;
929 goto cgii_exit;
930 }
931
7196ac11
NA
932 /* if filetype is different, return error */
933 if (unlikely(((*inode)->i_mode & S_IFMT) !=
934 (fattr.cf_mode & S_IFMT))) {
935 rc = -ESTALE;
936 goto cgii_exit;
937 }
938
1208ef1f 939 cifs_fattr_to_inode(*inode, &fattr);
0b8f18e3 940 }
b9a3260f 941
7962670e 942cgii_exit:
70dbed63
SF
943 if ((*inode) && ((*inode)->i_ino == 0))
944 cifs_dbg(FYI, "inode number of zero returned\n");
945
1da177e4 946 kfree(buf);
7ffec372 947 cifs_put_tlink(tlink);
1da177e4
LT
948 return rc;
949}
950
7f8ed420
SF
951static const struct inode_operations cifs_ipc_inode_ops = {
952 .lookup = cifs_lookup,
953};
954
cc0bad75
JL
955static int
956cifs_find_inode(struct inode *inode, void *opaque)
957{
958 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
959
f30b9c11 960 /* don't match inode with different uniqueid */
cc0bad75
JL
961 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
962 return 0;
963
20054bd6
JL
964 /* use createtime like an i_generation field */
965 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
966 return 0;
967
f30b9c11
JL
968 /* don't match inode of different type */
969 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
970 return 0;
971
5acfec25 972 /* if it's not a directory or has no dentries, then flag it */
b3d9b7a3 973 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
3d694380 974 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
3d694380 975
cc0bad75
JL
976 return 1;
977}
978
979static int
980cifs_init_inode(struct inode *inode, void *opaque)
981{
982 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
983
984 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
20054bd6 985 CIFS_I(inode)->createtime = fattr->cf_createtime;
cc0bad75
JL
986 return 0;
987}
988
5acfec25
JL
989/*
990 * walk dentry list for an inode and report whether it has aliases that
991 * are hashed. We use this to determine if a directory inode can actually
992 * be used.
993 */
994static bool
995inode_has_hashed_dentries(struct inode *inode)
996{
997 struct dentry *dentry;
998
873feea0 999 spin_lock(&inode->i_lock);
946e51f2 1000 hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
5acfec25 1001 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
873feea0 1002 spin_unlock(&inode->i_lock);
5acfec25
JL
1003 return true;
1004 }
1005 }
873feea0 1006 spin_unlock(&inode->i_lock);
5acfec25
JL
1007 return false;
1008}
1009
cc0bad75
JL
1010/* Given fattrs, get a corresponding inode */
1011struct inode *
1012cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
1013{
1014 unsigned long hash;
1015 struct inode *inode;
1016
3d694380 1017retry_iget5_locked:
f96637be 1018 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
cc0bad75
JL
1019
1020 /* hash down to 32-bits on 32-bit arch */
1021 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
1022
1023 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
cc0bad75 1024 if (inode) {
5acfec25 1025 /* was there a potentially problematic inode collision? */
3d694380 1026 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
3d694380 1027 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
5acfec25
JL
1028
1029 if (inode_has_hashed_dentries(inode)) {
1030 cifs_autodisable_serverino(CIFS_SB(sb));
1031 iput(inode);
1032 fattr->cf_uniqueid = iunique(sb, ROOT_I);
1033 goto retry_iget5_locked;
1034 }
3d694380
JL
1035 }
1036
cc0bad75
JL
1037 cifs_fattr_to_inode(inode, fattr);
1038 if (sb->s_flags & MS_NOATIME)
1039 inode->i_flags |= S_NOATIME | S_NOCMTIME;
1040 if (inode->i_state & I_NEW) {
1041 inode->i_ino = hash;
0ccd4802 1042#ifdef CONFIG_CIFS_FSCACHE
9451a9a5
SJ
1043 /* initialize per-inode cache cookie pointer */
1044 CIFS_I(inode)->fscache = NULL;
0ccd4802 1045#endif
cc0bad75
JL
1046 unlock_new_inode(inode);
1047 }
1048 }
1049
1050 return inode;
1051}
1052
1da177e4 1053/* gets root inode */
9b6763e0 1054struct inode *cifs_root_iget(struct super_block *sb)
1da177e4 1055{
6d5786a3 1056 unsigned int xid;
0d424ad0 1057 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
cc0bad75 1058 struct inode *inode = NULL;
ce634ab2 1059 long rc;
96daf2b0 1060 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
a6b5058f
AA
1061 char *path = NULL;
1062 int len;
1063
1064 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
1065 && cifs_sb->prepath) {
1066 len = strlen(cifs_sb->prepath);
1067 path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
1068 if (path == NULL)
1069 return ERR_PTR(-ENOMEM);
1070 path[0] = '/';
1071 memcpy(path+1, cifs_sb->prepath, len);
1072 } else {
1073 path = kstrdup("", GFP_KERNEL);
1074 if (path == NULL)
1075 return ERR_PTR(-ENOMEM);
1076 }
ce634ab2 1077
6d5786a3 1078 xid = get_xid();
b5b374ea 1079 if (tcon->unix_ext) {
a6b5058f 1080 rc = cifs_get_inode_info_unix(&inode, path, sb, xid);
b5b374ea
SF
1081 /* some servers mistakenly claim POSIX support */
1082 if (rc != -EOPNOTSUPP)
1083 goto iget_no_retry;
1084 cifs_dbg(VFS, "server does not support POSIX extensions");
1085 tcon->unix_ext = false;
1086 }
1087
a6b5058f
AA
1088 convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
1089 rc = cifs_get_inode_info(&inode, path, NULL, sb, xid, NULL);
0b8f18e3 1090
b5b374ea 1091iget_no_retry:
a7851ce7
OS
1092 if (!inode) {
1093 inode = ERR_PTR(rc);
1094 goto out;
1095 }
cc0bad75 1096
0ccd4802 1097#ifdef CONFIG_CIFS_FSCACHE
d03382ce 1098 /* populate tcon->resource_id */
0d424ad0 1099 tcon->resource_id = CIFS_I(inode)->uniqueid;
0ccd4802 1100#endif
d03382ce 1101
0d424ad0 1102 if (rc && tcon->ipc) {
f96637be 1103 cifs_dbg(FYI, "ipc connection - fake read inode\n");
b7ca6928 1104 spin_lock(&inode->i_lock);
7f8ed420 1105 inode->i_mode |= S_IFDIR;
bfe86848 1106 set_nlink(inode, 2);
7f8ed420
SF
1107 inode->i_op = &cifs_ipc_inode_ops;
1108 inode->i_fop = &simple_dir_operations;
1109 inode->i_uid = cifs_sb->mnt_uid;
1110 inode->i_gid = cifs_sb->mnt_gid;
b7ca6928 1111 spin_unlock(&inode->i_lock);
ad661334 1112 } else if (rc) {
ce634ab2 1113 iget_failed(inode);
a7851ce7 1114 inode = ERR_PTR(rc);
7f8ed420
SF
1115 }
1116
a7851ce7 1117out:
a6b5058f 1118 kfree(path);
6d5786a3 1119 /* can not call macro free_xid here since in a void func
ce634ab2
DH
1120 * TODO: This is no longer true
1121 */
6d5786a3 1122 _free_xid(xid);
ce634ab2 1123 return inode;
1da177e4
LT
1124}
1125
ed6875e0 1126int
6d5786a3 1127cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
ed6875e0 1128 char *full_path, __u32 dosattr)
388e57b2 1129{
388e57b2 1130 bool set_time = false;
388e57b2 1131 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
6bdf6dbd 1132 struct TCP_Server_Info *server;
388e57b2
SF
1133 FILE_BASIC_INFO info_buf;
1134
1adcb710
SF
1135 if (attrs == NULL)
1136 return -EINVAL;
1137
6bdf6dbd
PS
1138 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1139 if (!server->ops->set_file_info)
1140 return -ENOSYS;
1141
be1210c7
SF
1142 info_buf.Pad = 0;
1143
388e57b2
SF
1144 if (attrs->ia_valid & ATTR_ATIME) {
1145 set_time = true;
1146 info_buf.LastAccessTime =
1147 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1148 } else
1149 info_buf.LastAccessTime = 0;
1150
1151 if (attrs->ia_valid & ATTR_MTIME) {
1152 set_time = true;
1153 info_buf.LastWriteTime =
1154 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1155 } else
1156 info_buf.LastWriteTime = 0;
1157
1158 /*
1159 * Samba throws this field away, but windows may actually use it.
1160 * Do not set ctime unless other time stamps are changed explicitly
1161 * (i.e. by utimes()) since we would then have a mix of client and
1162 * server times.
1163 */
1164 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
f96637be 1165 cifs_dbg(FYI, "CIFS - CTIME changed\n");
388e57b2
SF
1166 info_buf.ChangeTime =
1167 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1168 } else
1169 info_buf.ChangeTime = 0;
1170
1171 info_buf.CreationTime = 0; /* don't change */
1172 info_buf.Attributes = cpu_to_le32(dosattr);
1173
6bdf6dbd 1174 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
388e57b2
SF
1175}
1176
a12a1ac7 1177/*
ed6875e0 1178 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
a12a1ac7
JL
1179 * and rename it to a random name that hopefully won't conflict with
1180 * anything else.
1181 */
ed6875e0
PS
1182int
1183cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1184 const unsigned int xid)
a12a1ac7
JL
1185{
1186 int oplock = 0;
1187 int rc;
d81b8a40
PS
1188 struct cifs_fid fid;
1189 struct cifs_open_parms oparms;
2b0143b5 1190 struct inode *inode = d_inode(dentry);
a12a1ac7
JL
1191 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1192 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
7ffec372 1193 struct tcon_link *tlink;
96daf2b0 1194 struct cifs_tcon *tcon;
3270958b
SF
1195 __u32 dosattr, origattr;
1196 FILE_BASIC_INFO *info_buf = NULL;
a12a1ac7 1197
7ffec372
JL
1198 tlink = cifs_sb_tlink(cifs_sb);
1199 if (IS_ERR(tlink))
1200 return PTR_ERR(tlink);
1201 tcon = tlink_tcon(tlink);
1202
c483a984
SP
1203 /*
1204 * We cannot rename the file if the server doesn't support
1205 * CAP_INFOLEVEL_PASSTHRU
1206 */
1207 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1208 rc = -EBUSY;
1209 goto out;
1210 }
1211
d81b8a40
PS
1212 oparms.tcon = tcon;
1213 oparms.cifs_sb = cifs_sb;
1214 oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1215 oparms.create_options = CREATE_NOT_DIR;
1216 oparms.disposition = FILE_OPEN;
1217 oparms.path = full_path;
1218 oparms.fid = &fid;
1219 oparms.reconnect = false;
1220
1221 rc = CIFS_open(xid, &oparms, &oplock, NULL);
a12a1ac7
JL
1222 if (rc != 0)
1223 goto out;
1224
3270958b
SF
1225 origattr = cifsInode->cifsAttrs;
1226 if (origattr == 0)
1227 origattr |= ATTR_NORMAL;
1228
1229 dosattr = origattr & ~ATTR_READONLY;
a12a1ac7
JL
1230 if (dosattr == 0)
1231 dosattr |= ATTR_NORMAL;
1232 dosattr |= ATTR_HIDDEN;
1233
3270958b
SF
1234 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1235 if (dosattr != origattr) {
1236 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1237 if (info_buf == NULL) {
1238 rc = -ENOMEM;
1239 goto out_close;
1240 }
1241 info_buf->Attributes = cpu_to_le32(dosattr);
d81b8a40 1242 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
3270958b
SF
1243 current->tgid);
1244 /* although we would like to mark the file hidden
1245 if that fails we will still try to rename it */
72d282dc 1246 if (!rc)
3270958b
SF
1247 cifsInode->cifsAttrs = dosattr;
1248 else
1249 dosattr = origattr; /* since not able to change them */
a12a1ac7 1250 }
a12a1ac7 1251
dd1db2de 1252 /* rename the file */
d81b8a40
PS
1253 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1254 cifs_sb->local_nls,
2baa2682 1255 cifs_remap(cifs_sb));
3270958b 1256 if (rc != 0) {
47c78f4a 1257 rc = -EBUSY;
3270958b
SF
1258 goto undo_setattr;
1259 }
6d22f098 1260
3270958b 1261 /* try to set DELETE_ON_CLOSE */
aff8d5ca 1262 if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
d81b8a40 1263 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
3270958b
SF
1264 current->tgid);
1265 /*
1266 * some samba versions return -ENOENT when we try to set the
1267 * file disposition here. Likely a samba bug, but work around
1268 * it for now. This means that some cifsXXX files may hang
1269 * around after they shouldn't.
1270 *
1271 * BB: remove this hack after more servers have the fix
1272 */
1273 if (rc == -ENOENT)
1274 rc = 0;
1275 else if (rc != 0) {
47c78f4a 1276 rc = -EBUSY;
3270958b
SF
1277 goto undo_rename;
1278 }
aff8d5ca 1279 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
3270958b 1280 }
7ce86d5a 1281
a12a1ac7 1282out_close:
d81b8a40 1283 CIFSSMBClose(xid, tcon, fid.netfid);
a12a1ac7 1284out:
3270958b 1285 kfree(info_buf);
7ffec372 1286 cifs_put_tlink(tlink);
a12a1ac7 1287 return rc;
3270958b
SF
1288
1289 /*
1290 * reset everything back to the original state. Don't bother
1291 * dealing with errors here since we can't do anything about
1292 * them anyway.
1293 */
1294undo_rename:
d81b8a40 1295 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
2baa2682 1296 cifs_sb->local_nls, cifs_remap(cifs_sb));
3270958b
SF
1297undo_setattr:
1298 if (dosattr != origattr) {
1299 info_buf->Attributes = cpu_to_le32(origattr);
d81b8a40 1300 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
3270958b
SF
1301 current->tgid))
1302 cifsInode->cifsAttrs = origattr;
1303 }
1304
1305 goto out_close;
a12a1ac7
JL
1306}
1307
b7ca6928
SF
1308/* copied from fs/nfs/dir.c with small changes */
1309static void
1310cifs_drop_nlink(struct inode *inode)
1311{
1312 spin_lock(&inode->i_lock);
1313 if (inode->i_nlink > 0)
1314 drop_nlink(inode);
1315 spin_unlock(&inode->i_lock);
1316}
ff694527
SF
1317
1318/*
2b0143b5 1319 * If d_inode(dentry) is null (usually meaning the cached dentry
ff694527 1320 * is a negative dentry) then we would attempt a standard SMB delete, but
af901ca1
AGR
1321 * if that fails we can not attempt the fall back mechanisms on EACCESS
1322 * but will return the EACCESS to the caller. Note that the VFS does not call
ff694527
SF
1323 * unlink on negative dentries currently.
1324 */
5f0319a7 1325int cifs_unlink(struct inode *dir, struct dentry *dentry)
1da177e4
LT
1326{
1327 int rc = 0;
6d5786a3 1328 unsigned int xid;
1da177e4 1329 char *full_path = NULL;
2b0143b5 1330 struct inode *inode = d_inode(dentry);
ff694527 1331 struct cifsInodeInfo *cifs_inode;
5f0319a7
JL
1332 struct super_block *sb = dir->i_sb;
1333 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
7ffec372 1334 struct tcon_link *tlink;
96daf2b0 1335 struct cifs_tcon *tcon;
ed6875e0 1336 struct TCP_Server_Info *server;
6050247d
SF
1337 struct iattr *attrs = NULL;
1338 __u32 dosattr = 0, origattr = 0;
1da177e4 1339
f96637be 1340 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1da177e4 1341
7ffec372
JL
1342 tlink = cifs_sb_tlink(cifs_sb);
1343 if (IS_ERR(tlink))
1344 return PTR_ERR(tlink);
1345 tcon = tlink_tcon(tlink);
ed6875e0 1346 server = tcon->ses->server;
7ffec372 1347
6d5786a3 1348 xid = get_xid();
1da177e4 1349
5f0319a7
JL
1350 /* Unlink can be called from rename so we can not take the
1351 * sb->s_vfs_rename_mutex here */
1352 full_path = build_path_from_dentry(dentry);
1da177e4 1353 if (full_path == NULL) {
0f3bc09e 1354 rc = -ENOMEM;
7ffec372 1355 goto unlink_out;
1da177e4 1356 }
2d785a50 1357
29e20f9c
PS
1358 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1359 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
5f0319a7 1360 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
2d785a50 1361 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
2baa2682 1362 cifs_remap(cifs_sb));
f96637be 1363 cifs_dbg(FYI, "posix del rc %d\n", rc);
2d785a50
SF
1364 if ((rc == 0) || (rc == -ENOENT))
1365 goto psx_del_no_retry;
1366 }
1da177e4 1367
6050247d 1368retry_std_delete:
ed6875e0
PS
1369 if (!server->ops->unlink) {
1370 rc = -ENOSYS;
1371 goto psx_del_no_retry;
1372 }
1373
1374 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
6050247d 1375
2d785a50 1376psx_del_no_retry:
1da177e4 1377 if (!rc) {
5f0319a7 1378 if (inode)
b7ca6928 1379 cifs_drop_nlink(inode);
1da177e4 1380 } else if (rc == -ENOENT) {
5f0319a7 1381 d_drop(dentry);
47c78f4a 1382 } else if (rc == -EBUSY) {
ed6875e0
PS
1383 if (server->ops->rename_pending_delete) {
1384 rc = server->ops->rename_pending_delete(full_path,
1385 dentry, xid);
1386 if (rc == 0)
1387 cifs_drop_nlink(inode);
1388 }
ff694527 1389 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
388e57b2
SF
1390 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1391 if (attrs == NULL) {
1392 rc = -ENOMEM;
1393 goto out_reval;
1da177e4 1394 }
388e57b2
SF
1395
1396 /* try to reset dos attributes */
ff694527
SF
1397 cifs_inode = CIFS_I(inode);
1398 origattr = cifs_inode->cifsAttrs;
6050247d
SF
1399 if (origattr == 0)
1400 origattr |= ATTR_NORMAL;
1401 dosattr = origattr & ~ATTR_READONLY;
388e57b2
SF
1402 if (dosattr == 0)
1403 dosattr |= ATTR_NORMAL;
1404 dosattr |= ATTR_HIDDEN;
1405
1406 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
388e57b2
SF
1407 if (rc != 0)
1408 goto out_reval;
6050247d
SF
1409
1410 goto retry_std_delete;
1da177e4 1411 }
6050247d
SF
1412
1413 /* undo the setattr if we errored out and it's needed */
1414 if (rc != 0 && dosattr != 0)
1415 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1416
388e57b2 1417out_reval:
4523cc30 1418 if (inode) {
ff694527
SF
1419 cifs_inode = CIFS_I(inode);
1420 cifs_inode->time = 0; /* will force revalidate to get info
5f0319a7 1421 when needed */
e37fea58 1422 inode->i_ctime = current_time(inode);
06bcfedd 1423 }
e37fea58 1424 dir->i_ctime = dir->i_mtime = current_time(dir);
ff694527 1425 cifs_inode = CIFS_I(dir);
6050247d 1426 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
7ffec372 1427unlink_out:
1da177e4 1428 kfree(full_path);
6050247d 1429 kfree(attrs);
6d5786a3 1430 free_xid(xid);
7ffec372 1431 cifs_put_tlink(tlink);
1da177e4
LT
1432 return rc;
1433}
1434
ff691e96 1435static int
101b92d9 1436cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
ff691e96
PS
1437 const char *full_path, struct cifs_sb_info *cifs_sb,
1438 struct cifs_tcon *tcon, const unsigned int xid)
1439{
1440 int rc = 0;
101b92d9 1441 struct inode *inode = NULL;
ff691e96
PS
1442
1443 if (tcon->unix_ext)
101b92d9 1444 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
ff691e96
PS
1445 xid);
1446 else
101b92d9
JL
1447 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1448 xid, NULL);
1449
ff691e96
PS
1450 if (rc)
1451 return rc;
1452
ff691e96
PS
1453 /*
1454 * setting nlink not necessary except in cases where we failed to get it
101b92d9
JL
1455 * from the server or was set bogus. Also, since this is a brand new
1456 * inode, no need to grab the i_lock before setting the i_nlink.
ff691e96 1457 */
101b92d9
JL
1458 if (inode->i_nlink < 2)
1459 set_nlink(inode, 2);
ff691e96
PS
1460 mode &= ~current_umask();
1461 /* must turn on setgid bit if parent dir has it */
101b92d9 1462 if (parent->i_mode & S_ISGID)
ff691e96
PS
1463 mode |= S_ISGID;
1464
1465 if (tcon->unix_ext) {
1466 struct cifs_unix_set_info_args args = {
1467 .mode = mode,
1468 .ctime = NO_CHANGE_64,
1469 .atime = NO_CHANGE_64,
1470 .mtime = NO_CHANGE_64,
1471 .device = 0,
1472 };
1473 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
49418b2c 1474 args.uid = current_fsuid();
101b92d9 1475 if (parent->i_mode & S_ISGID)
49418b2c 1476 args.gid = parent->i_gid;
ff691e96 1477 else
49418b2c 1478 args.gid = current_fsgid();
ff691e96 1479 } else {
49418b2c
EB
1480 args.uid = INVALID_UID; /* no change */
1481 args.gid = INVALID_GID; /* no change */
ff691e96
PS
1482 }
1483 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1484 cifs_sb->local_nls,
2baa2682 1485 cifs_remap(cifs_sb));
ff691e96 1486 } else {
f436720e 1487 struct TCP_Server_Info *server = tcon->ses->server;
ff691e96 1488 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
f436720e 1489 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
101b92d9 1490 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
f436720e 1491 tcon, xid);
101b92d9
JL
1492 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1493 inode->i_mode = (mode | S_IFDIR);
1494
1495 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1496 inode->i_uid = current_fsuid();
1497 if (inode->i_mode & S_ISGID)
1498 inode->i_gid = parent->i_gid;
1499 else
1500 inode->i_gid = current_fsgid();
ff691e96
PS
1501 }
1502 }
101b92d9 1503 d_instantiate(dentry, inode);
ff691e96
PS
1504 return rc;
1505}
1506
1507static int
1508cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1509 const char *full_path, struct cifs_sb_info *cifs_sb,
1510 struct cifs_tcon *tcon, const unsigned int xid)
1511{
1512 int rc = 0;
1513 u32 oplock = 0;
1514 FILE_UNIX_BASIC_INFO *info = NULL;
1515 struct inode *newinode = NULL;
1516 struct cifs_fattr fattr;
1517
1518 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1519 if (info == NULL) {
1520 rc = -ENOMEM;
1521 goto posix_mkdir_out;
1522 }
1523
1524 mode &= ~current_umask();
1525 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1526 NULL /* netfid */, info, &oplock, full_path,
2baa2682 1527 cifs_sb->local_nls, cifs_remap(cifs_sb));
ff691e96
PS
1528 if (rc == -EOPNOTSUPP)
1529 goto posix_mkdir_out;
1530 else if (rc) {
f96637be 1531 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
ff691e96
PS
1532 d_drop(dentry);
1533 goto posix_mkdir_out;
1534 }
1535
1536 if (info->Type == cpu_to_le32(-1))
1537 /* no return info, go query for it */
1538 goto posix_mkdir_get_info;
1539 /*
1540 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1541 * need to set uid/gid.
1542 */
1543
1544 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1545 cifs_fill_uniqueid(inode->i_sb, &fattr);
1546 newinode = cifs_iget(inode->i_sb, &fattr);
1547 if (!newinode)
1548 goto posix_mkdir_get_info;
1549
1550 d_instantiate(dentry, newinode);
1551
1552#ifdef CONFIG_CIFS_DEBUG2
35c265e0
AV
1553 cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1554 dentry, dentry, newinode);
ff691e96
PS
1555
1556 if (newinode->i_nlink != 2)
f96637be
JP
1557 cifs_dbg(FYI, "unexpected number of links %d\n",
1558 newinode->i_nlink);
ff691e96
PS
1559#endif
1560
1561posix_mkdir_out:
1562 kfree(info);
1563 return rc;
1564posix_mkdir_get_info:
1565 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1566 xid);
1567 goto posix_mkdir_out;
1568}
1569
18bb1db3 1570int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1da177e4 1571{
ff691e96 1572 int rc = 0;
6d5786a3 1573 unsigned int xid;
1da177e4 1574 struct cifs_sb_info *cifs_sb;
7ffec372 1575 struct tcon_link *tlink;
29e20f9c 1576 struct cifs_tcon *tcon;
f436720e 1577 struct TCP_Server_Info *server;
ff691e96 1578 char *full_path;
1da177e4 1579
f96637be
JP
1580 cifs_dbg(FYI, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1581 mode, inode);
1da177e4 1582
1da177e4 1583 cifs_sb = CIFS_SB(inode->i_sb);
7ffec372
JL
1584 tlink = cifs_sb_tlink(cifs_sb);
1585 if (IS_ERR(tlink))
1586 return PTR_ERR(tlink);
29e20f9c 1587 tcon = tlink_tcon(tlink);
7ffec372 1588
6d5786a3 1589 xid = get_xid();
1da177e4 1590
7f57356b 1591 full_path = build_path_from_dentry(direntry);
1da177e4 1592 if (full_path == NULL) {
0f3bc09e 1593 rc = -ENOMEM;
7ffec372 1594 goto mkdir_out;
1da177e4 1595 }
50c2f753 1596
29e20f9c
PS
1597 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1598 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
ff691e96
PS
1599 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1600 tcon, xid);
1601 if (rc != -EOPNOTSUPP)
2dd29d31 1602 goto mkdir_out;
fb8c4b14 1603 }
ff691e96 1604
f436720e
PS
1605 server = tcon->ses->server;
1606
1607 if (!server->ops->mkdir) {
1608 rc = -ENOSYS;
1609 goto mkdir_out;
1610 }
1611
1da177e4 1612 /* BB add setting the equivalent of mode via CreateX w/ACLs */
f436720e 1613 rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
1da177e4 1614 if (rc) {
f96637be 1615 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1da177e4 1616 d_drop(direntry);
ff691e96 1617 goto mkdir_out;
1da177e4 1618 }
ff691e96
PS
1619
1620 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1621 xid);
fb8c4b14 1622mkdir_out:
6de2ce42
PS
1623 /*
1624 * Force revalidate to get parent dir info when needed since cached
1625 * attributes are invalid now.
1626 */
1627 CIFS_I(inode)->time = 0;
1da177e4 1628 kfree(full_path);
6d5786a3 1629 free_xid(xid);
7ffec372 1630 cifs_put_tlink(tlink);
1da177e4
LT
1631 return rc;
1632}
1633
1634int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1635{
1636 int rc = 0;
6d5786a3 1637 unsigned int xid;
1da177e4 1638 struct cifs_sb_info *cifs_sb;
7ffec372 1639 struct tcon_link *tlink;
f958ca5d
PS
1640 struct cifs_tcon *tcon;
1641 struct TCP_Server_Info *server;
1da177e4
LT
1642 char *full_path = NULL;
1643 struct cifsInodeInfo *cifsInode;
1644
f96637be 1645 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1da177e4 1646
6d5786a3 1647 xid = get_xid();
1da177e4 1648
7f57356b 1649 full_path = build_path_from_dentry(direntry);
1da177e4 1650 if (full_path == NULL) {
0f3bc09e 1651 rc = -ENOMEM;
7ffec372 1652 goto rmdir_exit;
1da177e4
LT
1653 }
1654
7ffec372
JL
1655 cifs_sb = CIFS_SB(inode->i_sb);
1656 tlink = cifs_sb_tlink(cifs_sb);
1657 if (IS_ERR(tlink)) {
1658 rc = PTR_ERR(tlink);
1659 goto rmdir_exit;
1660 }
f958ca5d
PS
1661 tcon = tlink_tcon(tlink);
1662 server = tcon->ses->server;
1663
1664 if (!server->ops->rmdir) {
1665 rc = -ENOSYS;
1666 cifs_put_tlink(tlink);
1667 goto rmdir_exit;
1668 }
7ffec372 1669
f958ca5d 1670 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
7ffec372 1671 cifs_put_tlink(tlink);
1da177e4
LT
1672
1673 if (!rc) {
2b0143b5
DH
1674 spin_lock(&d_inode(direntry)->i_lock);
1675 i_size_write(d_inode(direntry), 0);
1676 clear_nlink(d_inode(direntry));
1677 spin_unlock(&d_inode(direntry)->i_lock);
1da177e4
LT
1678 }
1679
2b0143b5 1680 cifsInode = CIFS_I(d_inode(direntry));
6de2ce42
PS
1681 /* force revalidate to go get info when needed */
1682 cifsInode->time = 0;
42c24544
SF
1683
1684 cifsInode = CIFS_I(inode);
6de2ce42
PS
1685 /*
1686 * Force revalidate to get parent dir info when needed since cached
1687 * attributes are invalid now.
1688 */
1689 cifsInode->time = 0;
42c24544 1690
2b0143b5 1691 d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
e37fea58 1692 current_time(inode);
1da177e4 1693
7ffec372 1694rmdir_exit:
1da177e4 1695 kfree(full_path);
6d5786a3 1696 free_xid(xid);
1da177e4
LT
1697 return rc;
1698}
1699
ee2fd967 1700static int
8ceb9843
PS
1701cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1702 const char *from_path, struct dentry *to_dentry,
1703 const char *to_path)
ee2fd967
SF
1704{
1705 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
7ffec372 1706 struct tcon_link *tlink;
8ceb9843
PS
1707 struct cifs_tcon *tcon;
1708 struct TCP_Server_Info *server;
d81b8a40
PS
1709 struct cifs_fid fid;
1710 struct cifs_open_parms oparms;
ee2fd967
SF
1711 int oplock, rc;
1712
7ffec372
JL
1713 tlink = cifs_sb_tlink(cifs_sb);
1714 if (IS_ERR(tlink))
1715 return PTR_ERR(tlink);
8ceb9843
PS
1716 tcon = tlink_tcon(tlink);
1717 server = tcon->ses->server;
1718
1719 if (!server->ops->rename)
1720 return -ENOSYS;
7ffec372 1721
ee2fd967 1722 /* try path-based rename first */
8ceb9843 1723 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
ee2fd967
SF
1724
1725 /*
8ceb9843
PS
1726 * Don't bother with rename by filehandle unless file is busy and
1727 * source. Note that cross directory moves do not work with
ee2fd967
SF
1728 * rename by filehandle to various Windows servers.
1729 */
47c78f4a 1730 if (rc == 0 || rc != -EBUSY)
7ffec372 1731 goto do_rename_exit;
ee2fd967 1732
ed0e3ace
JL
1733 /* open-file renames don't work across directories */
1734 if (to_dentry->d_parent != from_dentry->d_parent)
7ffec372 1735 goto do_rename_exit;
ed0e3ace 1736
d81b8a40
PS
1737 oparms.tcon = tcon;
1738 oparms.cifs_sb = cifs_sb;
ee2fd967 1739 /* open the file to be renamed -- we need DELETE perms */
d81b8a40
PS
1740 oparms.desired_access = DELETE;
1741 oparms.create_options = CREATE_NOT_DIR;
1742 oparms.disposition = FILE_OPEN;
1743 oparms.path = from_path;
1744 oparms.fid = &fid;
1745 oparms.reconnect = false;
1746
1747 rc = CIFS_open(xid, &oparms, &oplock, NULL);
ee2fd967 1748 if (rc == 0) {
d81b8a40 1749 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
ee2fd967 1750 (const char *) to_dentry->d_name.name,
2baa2682 1751 cifs_sb->local_nls, cifs_remap(cifs_sb));
d81b8a40 1752 CIFSSMBClose(xid, tcon, fid.netfid);
ee2fd967 1753 }
7ffec372
JL
1754do_rename_exit:
1755 cifs_put_tlink(tlink);
ee2fd967
SF
1756 return rc;
1757}
1758
8ceb9843 1759int
7c33d597
MS
1760cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
1761 struct inode *target_dir, struct dentry *target_dentry,
1762 unsigned int flags)
1da177e4 1763{
8ceb9843
PS
1764 char *from_name = NULL;
1765 char *to_name = NULL;
639e7a91 1766 struct cifs_sb_info *cifs_sb;
7ffec372 1767 struct tcon_link *tlink;
96daf2b0 1768 struct cifs_tcon *tcon;
ee2fd967
SF
1769 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1770 FILE_UNIX_BASIC_INFO *info_buf_target;
6d5786a3
PS
1771 unsigned int xid;
1772 int rc, tmprc;
1da177e4 1773
7c33d597
MS
1774 if (flags & ~RENAME_NOREPLACE)
1775 return -EINVAL;
1776
639e7a91 1777 cifs_sb = CIFS_SB(source_dir->i_sb);
7ffec372
JL
1778 tlink = cifs_sb_tlink(cifs_sb);
1779 if (IS_ERR(tlink))
1780 return PTR_ERR(tlink);
1781 tcon = tlink_tcon(tlink);
1da177e4 1782
6d5786a3 1783 xid = get_xid();
ee2fd967 1784
ee2fd967
SF
1785 /*
1786 * we already have the rename sem so we do not need to
1787 * grab it again here to protect the path integrity
1788 */
8ceb9843
PS
1789 from_name = build_path_from_dentry(source_dentry);
1790 if (from_name == NULL) {
ee2fd967
SF
1791 rc = -ENOMEM;
1792 goto cifs_rename_exit;
1793 }
1794
8ceb9843
PS
1795 to_name = build_path_from_dentry(target_dentry);
1796 if (to_name == NULL) {
1da177e4
LT
1797 rc = -ENOMEM;
1798 goto cifs_rename_exit;
1799 }
1800
8ceb9843
PS
1801 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1802 to_name);
ee2fd967 1803
7c33d597
MS
1804 /*
1805 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1806 */
1807 if (flags & RENAME_NOREPLACE)
1808 goto cifs_rename_exit;
1809
14121bdc
JL
1810 if (rc == -EEXIST && tcon->unix_ext) {
1811 /*
8ceb9843
PS
1812 * Are src and dst hardlinks of same inode? We can only tell
1813 * with unix extensions enabled.
14121bdc
JL
1814 */
1815 info_buf_source =
1816 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1817 GFP_KERNEL);
1818 if (info_buf_source == NULL) {
1819 rc = -ENOMEM;
1820 goto cifs_rename_exit;
1821 }
1822
1823 info_buf_target = info_buf_source + 1;
8ceb9843
PS
1824 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1825 info_buf_source,
1826 cifs_sb->local_nls,
2baa2682 1827 cifs_remap(cifs_sb));
8d281efb 1828 if (tmprc != 0)
14121bdc 1829 goto unlink_target;
ee2fd967 1830
8ceb9843
PS
1831 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1832 info_buf_target,
1833 cifs_sb->local_nls,
2baa2682 1834 cifs_remap(cifs_sb));
14121bdc 1835
8d281efb 1836 if (tmprc == 0 && (info_buf_source->UniqueId ==
ae6884a9 1837 info_buf_target->UniqueId)) {
14121bdc 1838 /* same file, POSIX says that this is a noop */
ae6884a9 1839 rc = 0;
14121bdc 1840 goto cifs_rename_exit;
ae6884a9 1841 }
8ceb9843
PS
1842 }
1843 /*
1844 * else ... BB we could add the same check for Windows by
1845 * checking the UniqueId via FILE_INTERNAL_INFO
1846 */
14121bdc 1847
ee2fd967 1848unlink_target:
fc6f3943 1849 /* Try unlinking the target dentry if it's not negative */
2b0143b5 1850 if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
a07d3220
PS
1851 if (d_is_dir(target_dentry))
1852 tmprc = cifs_rmdir(target_dir, target_dentry);
1853 else
1854 tmprc = cifs_unlink(target_dir, target_dentry);
14121bdc
JL
1855 if (tmprc)
1856 goto cifs_rename_exit;
8ceb9843
PS
1857 rc = cifs_do_rename(xid, source_dentry, from_name,
1858 target_dentry, to_name);
1da177e4
LT
1859 }
1860
b46799a8
PS
1861 /* force revalidate to go get info when needed */
1862 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
1863
1864 source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
e37fea58 1865 target_dir->i_mtime = current_time(source_dir);
b46799a8 1866
1da177e4 1867cifs_rename_exit:
ee2fd967 1868 kfree(info_buf_source);
8ceb9843
PS
1869 kfree(from_name);
1870 kfree(to_name);
6d5786a3 1871 free_xid(xid);
7ffec372 1872 cifs_put_tlink(tlink);
1da177e4
LT
1873 return rc;
1874}
1875
df2cf170
JL
1876static bool
1877cifs_inode_needs_reval(struct inode *inode)
1da177e4 1878{
df2cf170 1879 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
6d20e840 1880 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1da177e4 1881
18cceb6a 1882 if (CIFS_CACHE_READ(cifs_i))
df2cf170 1883 return false;
1da177e4 1884
df2cf170
JL
1885 if (!lookupCacheEnabled)
1886 return true;
1da177e4 1887
df2cf170
JL
1888 if (cifs_i->time == 0)
1889 return true;
1da177e4 1890
a87c9ad9
JL
1891 if (!cifs_sb->actimeo)
1892 return true;
1893
6d20e840
SJ
1894 if (!time_in_range(jiffies, cifs_i->time,
1895 cifs_i->time + cifs_sb->actimeo))
df2cf170
JL
1896 return true;
1897
db19272e 1898 /* hardlinked files w/ noserverino get "special" treatment */
6d20e840 1899 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
db19272e
JL
1900 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1901 return true;
1902
df2cf170
JL
1903 return false;
1904}
1905
523fb8c8
SJ
1906/*
1907 * Zap the cache. Called when invalid_mapping flag is set.
1908 */
6feb9891 1909int
df2cf170
JL
1910cifs_invalidate_mapping(struct inode *inode)
1911{
6feb9891 1912 int rc = 0;
df2cf170 1913
df2cf170 1914 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
257fb1f1 1915 rc = invalidate_inode_pages2(inode->i_mapping);
4f73c7d3 1916 if (rc)
f96637be
JP
1917 cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1918 __func__, inode);
df2cf170 1919 }
257fb1f1 1920
9451a9a5 1921 cifs_fscache_reset_inode_cookie(inode);
6feb9891 1922 return rc;
df2cf170
JL
1923}
1924
4f73c7d3
JL
1925/**
1926 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
1927 * @word: long word containing the bit lock
1928 */
1929static int
dfd01f02 1930cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
4f73c7d3 1931{
4f73c7d3 1932 freezable_schedule_unsafe();
dfd01f02
PZ
1933 if (signal_pending_state(mode, current))
1934 return -ERESTARTSYS;
4f73c7d3
JL
1935 return 0;
1936}
1937
e284e53f
JL
1938int
1939cifs_revalidate_mapping(struct inode *inode)
1940{
4f73c7d3
JL
1941 int rc;
1942 unsigned long *flags = &CIFS_I(inode)->flags;
1943
74316201
N
1944 rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
1945 TASK_KILLABLE);
4f73c7d3
JL
1946 if (rc)
1947 return rc;
1948
1949 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
1950 rc = cifs_invalidate_mapping(inode);
1951 if (rc)
1952 set_bit(CIFS_INO_INVALID_MAPPING, flags);
1953 }
1954
1955 clear_bit_unlock(CIFS_INO_LOCK, flags);
b1cce803 1956 smp_mb__after_atomic();
4f73c7d3
JL
1957 wake_up_bit(flags, CIFS_INO_LOCK);
1958
1959 return rc;
1960}
1961
1962int
1963cifs_zap_mapping(struct inode *inode)
1964{
1965 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
1966 return cifs_revalidate_mapping(inode);
e284e53f
JL
1967}
1968
6feb9891 1969int cifs_revalidate_file_attr(struct file *filp)
abab095d
JL
1970{
1971 int rc = 0;
496ad9aa 1972 struct inode *inode = file_inode(filp);
ba00ba64 1973 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
abab095d
JL
1974
1975 if (!cifs_inode_needs_reval(inode))
6feb9891 1976 return rc;
abab095d 1977
13cfb733 1978 if (tlink_tcon(cfile->tlink)->unix_ext)
abab095d
JL
1979 rc = cifs_get_file_info_unix(filp);
1980 else
1981 rc = cifs_get_file_info(filp);
1982
abab095d
JL
1983 return rc;
1984}
1985
6feb9891 1986int cifs_revalidate_dentry_attr(struct dentry *dentry)
df2cf170 1987{
6d5786a3 1988 unsigned int xid;
df2cf170 1989 int rc = 0;
2b0143b5 1990 struct inode *inode = d_inode(dentry);
df2cf170 1991 struct super_block *sb = dentry->d_sb;
6feb9891 1992 char *full_path = NULL;
df2cf170
JL
1993
1994 if (inode == NULL)
1995 return -ENOENT;
1da177e4 1996
df2cf170 1997 if (!cifs_inode_needs_reval(inode))
6feb9891
PS
1998 return rc;
1999
6d5786a3 2000 xid = get_xid();
1da177e4
LT
2001
2002 /* can not safely grab the rename sem here if rename calls revalidate
2003 since that would deadlock */
df2cf170 2004 full_path = build_path_from_dentry(dentry);
1da177e4 2005 if (full_path == NULL) {
0f3bc09e 2006 rc = -ENOMEM;
6feb9891 2007 goto out;
1da177e4
LT
2008 }
2009
f96637be
JP
2010 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2011 full_path, inode, inode->i_count.counter,
a00be0e3 2012 dentry, cifs_get_time(dentry), jiffies);
1da177e4 2013
0d424ad0 2014 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
df2cf170
JL
2015 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2016 else
2017 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2018 xid, NULL);
1da177e4 2019
6feb9891 2020out:
1da177e4 2021 kfree(full_path);
6d5786a3 2022 free_xid(xid);
1da177e4
LT
2023 return rc;
2024}
2025
6feb9891
PS
2026int cifs_revalidate_file(struct file *filp)
2027{
2028 int rc;
496ad9aa 2029 struct inode *inode = file_inode(filp);
6feb9891
PS
2030
2031 rc = cifs_revalidate_file_attr(filp);
2032 if (rc)
2033 return rc;
2034
e284e53f 2035 return cifs_revalidate_mapping(inode);
6feb9891
PS
2036}
2037
2038/* revalidate a dentry's inode attributes */
2039int cifs_revalidate_dentry(struct dentry *dentry)
2040{
2041 int rc;
2b0143b5 2042 struct inode *inode = d_inode(dentry);
6feb9891
PS
2043
2044 rc = cifs_revalidate_dentry_attr(dentry);
2045 if (rc)
2046 return rc;
2047
e284e53f 2048 return cifs_revalidate_mapping(inode);
6feb9891
PS
2049}
2050
a528d35e
DH
2051int cifs_getattr(const struct path *path, struct kstat *stat,
2052 u32 request_mask, unsigned int flags)
1da177e4 2053{
a528d35e 2054 struct dentry *dentry = path->dentry;
3aa1c8c2 2055 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
96daf2b0 2056 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2b0143b5 2057 struct inode *inode = d_inode(dentry);
6feb9891 2058 int rc;
3aa1c8c2 2059
6feb9891
PS
2060 /*
2061 * We need to be sure that all dirty pages are written and the server
2062 * has actual ctime, mtime and file length.
2063 */
18cceb6a 2064 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
6feb9891
PS
2065 inode->i_mapping->nrpages != 0) {
2066 rc = filemap_fdatawait(inode->i_mapping);
156ecb2d
SF
2067 if (rc) {
2068 mapping_set_error(inode->i_mapping, rc);
2069 return rc;
2070 }
6feb9891 2071 }
1c456013 2072
6feb9891
PS
2073 rc = cifs_revalidate_dentry_attr(dentry);
2074 if (rc)
2075 return rc;
2076
2077 generic_fillattr(inode, stat);
2078 stat->blksize = CIFS_MAX_MSGSIZE;
2079 stat->ino = CIFS_I(inode)->uniqueid;
2080
6e70e26d
SF
2081 /* old CIFS Unix Extensions doesn't return create time */
2082 if (CIFS_I(inode)->createtime) {
2083 stat->result_mask |= STATX_BTIME;
2084 stat->btime =
2085 cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
2086 }
2087
2088 stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2089 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2090 stat->attributes |= STATX_ATTR_COMPRESSED;
2091 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2092 stat->attributes |= STATX_ATTR_ENCRYPTED;
2093
6feb9891 2094 /*
d3d1fce1
JL
2095 * If on a multiuser mount without unix extensions or cifsacl being
2096 * enabled, and the admin hasn't overridden them, set the ownership
2097 * to the fsuid/fsgid of the current process.
6feb9891
PS
2098 */
2099 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
d3d1fce1 2100 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
6feb9891
PS
2101 !tcon->unix_ext) {
2102 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2103 stat->uid = current_fsuid();
2104 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2105 stat->gid = current_fsgid();
5fe14c85 2106 }
6feb9891 2107 return rc;
1da177e4
LT
2108}
2109
2110static int cifs_truncate_page(struct address_space *mapping, loff_t from)
2111{
09cbfeaf
KS
2112 pgoff_t index = from >> PAGE_SHIFT;
2113 unsigned offset = from & (PAGE_SIZE - 1);
1da177e4 2114 struct page *page;
1da177e4
LT
2115 int rc = 0;
2116
2117 page = grab_cache_page(mapping, index);
2118 if (!page)
2119 return -ENOMEM;
2120
09cbfeaf 2121 zero_user_segment(page, offset, PAGE_SIZE);
1da177e4 2122 unlock_page(page);
09cbfeaf 2123 put_page(page);
1da177e4
LT
2124 return rc;
2125}
2126
1b947463 2127static void cifs_setsize(struct inode *inode, loff_t offset)
3677db10 2128{
ba6a46a0 2129 spin_lock(&inode->i_lock);
3677db10 2130 i_size_write(inode, offset);
ba6a46a0 2131 spin_unlock(&inode->i_lock);
1b947463 2132
7caef267 2133 truncate_pagecache(inode, offset);
3677db10
SF
2134}
2135
8efdbde6
JL
2136static int
2137cifs_set_file_size(struct inode *inode, struct iattr *attrs,
6d5786a3 2138 unsigned int xid, char *full_path)
8efdbde6
JL
2139{
2140 int rc;
2141 struct cifsFileInfo *open_file;
2142 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2143 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
7ffec372 2144 struct tcon_link *tlink = NULL;
d1433418
PS
2145 struct cifs_tcon *tcon = NULL;
2146 struct TCP_Server_Info *server;
8efdbde6
JL
2147
2148 /*
2149 * To avoid spurious oplock breaks from server, in the case of
2150 * inodes that we already have open, avoid doing path based
2151 * setting of file size if we can do it by handle.
2152 * This keeps our caching token (oplock) and avoids timeouts
2153 * when the local oplock break takes longer to flush
2154 * writebehind data than the SMB timeout for the SetPathInfo
2155 * request would allow
2156 */
6508d904 2157 open_file = find_writable_file(cifsInode, true);
8efdbde6 2158 if (open_file) {
d1433418
PS
2159 tcon = tlink_tcon(open_file->tlink);
2160 server = tcon->ses->server;
2161 if (server->ops->set_file_size)
2162 rc = server->ops->set_file_size(xid, tcon, open_file,
2163 attrs->ia_size, false);
2164 else
2165 rc = -ENOSYS;
6ab409b5 2166 cifsFileInfo_put(open_file);
f96637be 2167 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
8efdbde6
JL
2168 } else
2169 rc = -EINVAL;
2170
d1433418
PS
2171 if (!rc)
2172 goto set_size_out;
2173
2174 if (tcon == NULL) {
2175 tlink = cifs_sb_tlink(cifs_sb);
2176 if (IS_ERR(tlink))
2177 return PTR_ERR(tlink);
2178 tcon = tlink_tcon(tlink);
2179 server = tcon->ses->server;
2180 }
ba00ba64 2181
d1433418
PS
2182 /*
2183 * Set file size by pathname rather than by handle either because no
2184 * valid, writeable file handle for it was found or because there was
2185 * an error setting it by handle.
2186 */
2187 if (server->ops->set_path_size)
2188 rc = server->ops->set_path_size(xid, tcon, full_path,
2189 attrs->ia_size, cifs_sb, false);
2190 else
2191 rc = -ENOSYS;
f96637be 2192 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
d1433418 2193
d1433418
PS
2194 if (tlink)
2195 cifs_put_tlink(tlink);
8efdbde6 2196
d1433418 2197set_size_out:
8efdbde6 2198 if (rc == 0) {
fbec9ab9 2199 cifsInode->server_eof = attrs->ia_size;
1b947463 2200 cifs_setsize(inode, attrs->ia_size);
8efdbde6
JL
2201 cifs_truncate_page(inode->i_mapping, inode->i_size);
2202 }
2203
2204 return rc;
2205}
2206
3fe5c1dd
JL
2207static int
2208cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2209{
2210 int rc;
6d5786a3 2211 unsigned int xid;
3fe5c1dd 2212 char *full_path = NULL;
2b0143b5 2213 struct inode *inode = d_inode(direntry);
3fe5c1dd
JL
2214 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2215 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
7ffec372 2216 struct tcon_link *tlink;
96daf2b0 2217 struct cifs_tcon *pTcon;
3fe5c1dd 2218 struct cifs_unix_set_info_args *args = NULL;
3bbeeb3c 2219 struct cifsFileInfo *open_file;
3fe5c1dd 2220
35c265e0
AV
2221 cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2222 direntry, attrs->ia_valid);
3fe5c1dd 2223
6d5786a3 2224 xid = get_xid();
3fe5c1dd 2225
db78b877
CH
2226 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2227 attrs->ia_valid |= ATTR_FORCE;
2228
31051c85 2229 rc = setattr_prepare(direntry, attrs);
db78b877
CH
2230 if (rc < 0)
2231 goto out;
3fe5c1dd
JL
2232
2233 full_path = build_path_from_dentry(direntry);
2234 if (full_path == NULL) {
2235 rc = -ENOMEM;
2236 goto out;
2237 }
2238
0f4d634c
JL
2239 /*
2240 * Attempt to flush data before changing attributes. We need to do
2241 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2242 * ownership or mode then we may also need to do this. Here, we take
2243 * the safe way out and just do the flush on all setattr requests. If
2244 * the flush returns error, store it to report later and continue.
2245 *
2246 * BB: This should be smarter. Why bother flushing pages that
2247 * will be truncated anyway? Also, should we error out here if
2248 * the flush returns error?
2249 */
2250 rc = filemap_write_and_wait(inode->i_mapping);
eb4b756b
JL
2251 mapping_set_error(inode->i_mapping, rc);
2252 rc = 0;
3fe5c1dd
JL
2253
2254 if (attrs->ia_valid & ATTR_SIZE) {
2255 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2256 if (rc != 0)
2257 goto out;
2258 }
2259
2260 /* skip mode change if it's just for clearing setuid/setgid */
2261 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2262 attrs->ia_valid &= ~ATTR_MODE;
2263
2264 args = kmalloc(sizeof(*args), GFP_KERNEL);
2265 if (args == NULL) {
2266 rc = -ENOMEM;
2267 goto out;
2268 }
2269
2270 /* set up the struct */
2271 if (attrs->ia_valid & ATTR_MODE)
2272 args->mode = attrs->ia_mode;
2273 else
2274 args->mode = NO_CHANGE_64;
2275
2276 if (attrs->ia_valid & ATTR_UID)
2277 args->uid = attrs->ia_uid;
2278 else
49418b2c 2279 args->uid = INVALID_UID; /* no change */
3fe5c1dd
JL
2280
2281 if (attrs->ia_valid & ATTR_GID)
2282 args->gid = attrs->ia_gid;
2283 else
49418b2c 2284 args->gid = INVALID_GID; /* no change */
3fe5c1dd
JL
2285
2286 if (attrs->ia_valid & ATTR_ATIME)
2287 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2288 else
2289 args->atime = NO_CHANGE_64;
2290
2291 if (attrs->ia_valid & ATTR_MTIME)
2292 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2293 else
2294 args->mtime = NO_CHANGE_64;
2295
2296 if (attrs->ia_valid & ATTR_CTIME)
2297 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2298 else
2299 args->ctime = NO_CHANGE_64;
2300
2301 args->device = 0;
6508d904 2302 open_file = find_writable_file(cifsInode, true);
3bbeeb3c 2303 if (open_file) {
4b4de76e 2304 u16 nfid = open_file->fid.netfid;
3bbeeb3c 2305 u32 npid = open_file->pid;
13cfb733 2306 pTcon = tlink_tcon(open_file->tlink);
3bbeeb3c 2307 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
6ab409b5 2308 cifsFileInfo_put(open_file);
3bbeeb3c 2309 } else {
7ffec372
JL
2310 tlink = cifs_sb_tlink(cifs_sb);
2311 if (IS_ERR(tlink)) {
2312 rc = PTR_ERR(tlink);
2313 goto out;
2314 }
2315 pTcon = tlink_tcon(tlink);
3bbeeb3c 2316 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
01ea95e3 2317 cifs_sb->local_nls,
bc8ebdc4 2318 cifs_remap(cifs_sb));
7ffec372 2319 cifs_put_tlink(tlink);
3bbeeb3c 2320 }
3fe5c1dd 2321
1025774c
CH
2322 if (rc)
2323 goto out;
ccd4bb1b 2324
1025774c 2325 if ((attrs->ia_valid & ATTR_SIZE) &&
1b947463
CH
2326 attrs->ia_size != i_size_read(inode))
2327 truncate_setsize(inode, attrs->ia_size);
1025774c
CH
2328
2329 setattr_copy(inode, attrs);
2330 mark_inode_dirty(inode);
2331
2332 /* force revalidate when any of these times are set since some
2333 of the fs types (eg ext3, fat) do not have fine enough
2334 time granularity to match protocol, and we do not have a
2335 a way (yet) to query the server fs's time granularity (and
2336 whether it rounds times down).
2337 */
2338 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2339 cifsInode->time = 0;
3fe5c1dd
JL
2340out:
2341 kfree(args);
2342 kfree(full_path);
6d5786a3 2343 free_xid(xid);
3fe5c1dd
JL
2344 return rc;
2345}
2346
0510eeb7
JL
2347static int
2348cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
1da177e4 2349{
6d5786a3 2350 unsigned int xid;
8abf2775
EB
2351 kuid_t uid = INVALID_UID;
2352 kgid_t gid = INVALID_GID;
2b0143b5 2353 struct inode *inode = d_inode(direntry);
3fe5c1dd 2354 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3fe5c1dd 2355 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1da177e4
LT
2356 char *full_path = NULL;
2357 int rc = -EACCES;
feb3e20c 2358 __u32 dosattr = 0;
4e1e7fb9 2359 __u64 mode = NO_CHANGE_64;
3fe5c1dd 2360
6d5786a3 2361 xid = get_xid();
1da177e4 2362
35c265e0
AV
2363 cifs_dbg(FYI, "setattr on file %pd attrs->iavalid 0x%x\n",
2364 direntry, attrs->ia_valid);
6473a559 2365
db78b877
CH
2366 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2367 attrs->ia_valid |= ATTR_FORCE;
2368
31051c85 2369 rc = setattr_prepare(direntry, attrs);
db78b877 2370 if (rc < 0) {
6d5786a3 2371 free_xid(xid);
db78b877 2372 return rc;
6473a559 2373 }
50c2f753 2374
7f57356b 2375 full_path = build_path_from_dentry(direntry);
1da177e4 2376 if (full_path == NULL) {
0f3bc09e 2377 rc = -ENOMEM;
6d5786a3 2378 free_xid(xid);
0f3bc09e 2379 return rc;
1da177e4 2380 }
1da177e4 2381
0f4d634c
JL
2382 /*
2383 * Attempt to flush data before changing attributes. We need to do
2384 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2385 * ownership or mode then we may also need to do this. Here, we take
2386 * the safe way out and just do the flush on all setattr requests. If
2387 * the flush returns error, store it to report later and continue.
2388 *
2389 * BB: This should be smarter. Why bother flushing pages that
2390 * will be truncated anyway? Also, should we error out here if
2391 * the flush returns error?
2392 */
2393 rc = filemap_write_and_wait(inode->i_mapping);
eb4b756b
JL
2394 mapping_set_error(inode->i_mapping, rc);
2395 rc = 0;
cea21805 2396
50531444 2397 if (attrs->ia_valid & ATTR_SIZE) {
8efdbde6
JL
2398 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2399 if (rc != 0)
e30dcf3a 2400 goto cifs_setattr_exit;
1da177e4 2401 }
4ca691a8 2402
a5ff3769
SP
2403 if (attrs->ia_valid & ATTR_UID)
2404 uid = attrs->ia_uid;
2405
2406 if (attrs->ia_valid & ATTR_GID)
2407 gid = attrs->ia_gid;
2408
2409#ifdef CONFIG_CIFS_ACL
2410 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
8abf2775 2411 if (uid_valid(uid) || gid_valid(gid)) {
a5ff3769
SP
2412 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2413 uid, gid);
2414 if (rc) {
f96637be
JP
2415 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2416 __func__, rc);
a5ff3769
SP
2417 goto cifs_setattr_exit;
2418 }
2419 }
2420 } else
2421#endif /* CONFIG_CIFS_ACL */
3fe5c1dd 2422 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
4ca691a8 2423 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
1da177e4 2424
d32c4f26
JL
2425 /* skip mode change if it's just for clearing setuid/setgid */
2426 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2427 attrs->ia_valid &= ~ATTR_MODE;
2428
1da177e4 2429 if (attrs->ia_valid & ATTR_MODE) {
1da177e4 2430 mode = attrs->ia_mode;
cdbce9c8 2431 rc = 0;
79df1bae 2432#ifdef CONFIG_CIFS_ACL
78415d2d 2433 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
a5ff3769 2434 rc = id_mode_to_cifs_acl(inode, full_path, mode,
8abf2775 2435 INVALID_UID, INVALID_GID);
78415d2d 2436 if (rc) {
f96637be
JP
2437 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2438 __func__, rc);
78415d2d
SP
2439 goto cifs_setattr_exit;
2440 }
2441 } else
79df1bae 2442#endif /* CONFIG_CIFS_ACL */
5132861a
JL
2443 if (((mode & S_IWUGO) == 0) &&
2444 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
feb3e20c
JL
2445
2446 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2447
5132861a
JL
2448 /* fix up mode if we're not using dynperm */
2449 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2450 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2451 } else if ((mode & S_IWUGO) &&
2452 (cifsInode->cifsAttrs & ATTR_READONLY)) {
feb3e20c
JL
2453
2454 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2455 /* Attributes of 0 are ignored */
2456 if (dosattr == 0)
2457 dosattr |= ATTR_NORMAL;
5132861a
JL
2458
2459 /* reset local inode permissions to normal */
2460 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2461 attrs->ia_mode &= ~(S_IALLUGO);
2462 if (S_ISDIR(inode->i_mode))
2463 attrs->ia_mode |=
2464 cifs_sb->mnt_dir_mode;
2465 else
2466 attrs->ia_mode |=
2467 cifs_sb->mnt_file_mode;
2468 }
2469 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2470 /* ignore mode change - ATTR_READONLY hasn't changed */
2471 attrs->ia_valid &= ~ATTR_MODE;
1da177e4 2472 }
1da177e4
LT
2473 }
2474
feb3e20c
JL
2475 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2476 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2477 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2478 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
1da177e4 2479
e30dcf3a
SF
2480 /* Even if error on time set, no sense failing the call if
2481 the server would set the time to a reasonable value anyway,
2482 and this check ensures that we are not being called from
2483 sys_utimes in which case we ought to fail the call back to
2484 the user when the server rejects the call */
fb8c4b14 2485 if ((rc) && (attrs->ia_valid &
feb3e20c 2486 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
e30dcf3a 2487 rc = 0;
1da177e4
LT
2488 }
2489
2490 /* do not need local check to inode_check_ok since the server does
2491 that */
1025774c
CH
2492 if (rc)
2493 goto cifs_setattr_exit;
2494
2495 if ((attrs->ia_valid & ATTR_SIZE) &&
1b947463
CH
2496 attrs->ia_size != i_size_read(inode))
2497 truncate_setsize(inode, attrs->ia_size);
1025774c
CH
2498
2499 setattr_copy(inode, attrs);
2500 mark_inode_dirty(inode);
1025774c 2501
e30dcf3a 2502cifs_setattr_exit:
1da177e4 2503 kfree(full_path);
6d5786a3 2504 free_xid(xid);
1da177e4
LT
2505 return rc;
2506}
2507
0510eeb7
JL
2508int
2509cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2510{
fc64005c 2511 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
96daf2b0 2512 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
0510eeb7
JL
2513
2514 if (pTcon->unix_ext)
2515 return cifs_setattr_unix(direntry, attrs);
2516
2517 return cifs_setattr_nounix(direntry, attrs);
2518
2519 /* BB: add cifs_setattr_legacy for really old servers */
2520}
2521
99ee4dbd 2522#if 0
1da177e4
LT
2523void cifs_delete_inode(struct inode *inode)
2524{
f96637be 2525 cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
1da177e4
LT
2526 /* may have to add back in if and when safe distributed caching of
2527 directories added e.g. via FindNotify */
2528}
99ee4dbd 2529#endif