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