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