1 // SPDX-License-Identifier: LGPL-2.1
2 /*
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2010
5 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 */
8 #include <linux/fs.h>
9 #include <linux/stat.h>
10 #include <linux/slab.h>
11 #include <linux/pagemap.h>
12 #include <linux/freezer.h>
13 #include <linux/sched/signal.h>
14 #include <linux/wait_bit.h>
15 #include <linux/fiemap.h>
16 #include <asm/div64.h>
17 #include "cifsfs.h"
18 #include "cifspdu.h"
19 #include "cifsglob.h"
20 #include "cifsproto.h"
21 #include "smb2proto.h"
22 #include "cifs_debug.h"
23 #include "cifs_fs_sb.h"
24 #include "cifs_unicode.h"
25 #include "fscache.h"
26 #include "fs_context.h"
27 #include "cifs_ioctl.h"
28 #include "cached_dir.h"
29 #include "reparse.h"
30
31 /*
32 * Set parameters for the netfs library
33 */
cifs_set_netfs_context(struct inode * inode)34 static void cifs_set_netfs_context(struct inode *inode)
35 {
36 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
37
38 netfs_inode_init(&cifs_i->netfs, &cifs_req_ops, true);
39 }
40
cifs_set_ops(struct inode * inode)41 static void cifs_set_ops(struct inode *inode)
42 {
43 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
44 struct netfs_inode *ictx = netfs_inode(inode);
45
46 switch (inode->i_mode & S_IFMT) {
47 case S_IFREG:
48 inode->i_op = &cifs_file_inode_ops;
49 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
50 set_bit(NETFS_ICTX_UNBUFFERED, &ictx->flags);
51 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
52 inode->i_fop = &cifs_file_direct_nobrl_ops;
53 else
54 inode->i_fop = &cifs_file_direct_ops;
55 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
56 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
57 inode->i_fop = &cifs_file_strict_nobrl_ops;
58 else
59 inode->i_fop = &cifs_file_strict_ops;
60 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
61 inode->i_fop = &cifs_file_nobrl_ops;
62 else { /* not direct, send byte range locks */
63 inode->i_fop = &cifs_file_ops;
64 }
65
66 /* check if server can support readahead */
67 if (cifs_sb_master_tcon(cifs_sb)->ses->server->max_read <
68 PAGE_SIZE + MAX_CIFS_HDR_SIZE)
69 inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
70 else
71 inode->i_data.a_ops = &cifs_addr_ops;
72 mapping_set_large_folios(inode->i_mapping);
73 break;
74 case S_IFDIR:
75 if (IS_AUTOMOUNT(inode)) {
76 inode->i_op = &cifs_namespace_inode_operations;
77 } else {
78 inode->i_op = &cifs_dir_inode_ops;
79 inode->i_fop = &cifs_dir_ops;
80 }
81 break;
82 case S_IFLNK:
83 inode->i_op = &cifs_symlink_inode_ops;
84 break;
85 default:
86 init_special_inode(inode, inode->i_mode, inode->i_rdev);
87 break;
88 }
89 }
90
91 /* check inode attributes against fattr. If they don't match, tag the
92 * inode for cache invalidation
93 */
94 static void
cifs_revalidate_cache(struct inode * inode,struct cifs_fattr * fattr)95 cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
96 {
97 struct cifs_fscache_inode_coherency_data cd;
98 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
99 struct timespec64 mtime;
100
101 cifs_dbg(FYI, "%s: revalidating inode %llu\n",
102 __func__, cifs_i->uniqueid);
103
104 if (inode->i_state & I_NEW) {
105 cifs_dbg(FYI, "%s: inode %llu is new\n",
106 __func__, cifs_i->uniqueid);
107 return;
108 }
109
110 /* don't bother with revalidation if we have an oplock */
111 if (CIFS_CACHE_READ(cifs_i)) {
112 cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
113 __func__, cifs_i->uniqueid);
114 return;
115 }
116
117 /* revalidate if mtime or size have changed */
118 fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);
119 mtime = inode_get_mtime(inode);
120 if (timespec64_equal(&mtime, &fattr->cf_mtime) &&
121 cifs_i->netfs.remote_i_size == fattr->cf_eof) {
122 cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
123 __func__, cifs_i->uniqueid);
124 return;
125 }
126
127 cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
128 __func__, cifs_i->uniqueid);
129 set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags);
130 /* Invalidate fscache cookie */
131 cifs_fscache_fill_coherency(&cifs_i->netfs.inode, &cd);
132 fscache_invalidate(cifs_inode_cookie(inode), &cd, i_size_read(inode), 0);
133 }
134
135 /*
136 * copy nlink to the inode, unless it wasn't provided. Provide
137 * sane values if we don't have an existing one and none was provided
138 */
139 static void
cifs_nlink_fattr_to_inode(struct inode * inode,struct cifs_fattr * fattr)140 cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
141 {
142 /*
143 * if we're in a situation where we can't trust what we
144 * got from the server (readdir, some non-unix cases)
145 * fake reasonable values
146 */
147 if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
148 /* only provide fake values on a new inode */
149 if (inode->i_state & I_NEW) {
150 if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
151 set_nlink(inode, 2);
152 else
153 set_nlink(inode, 1);
154 }
155 return;
156 }
157
158 /* we trust the server, so update it */
159 set_nlink(inode, fattr->cf_nlink);
160 }
161
162 /* populate an inode with info from a cifs_fattr struct */
163 int
cifs_fattr_to_inode(struct inode * inode,struct cifs_fattr * fattr,bool from_readdir)164 cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr,
165 bool from_readdir)
166 {
167 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
168 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
169
170 if (!(inode->i_state & I_NEW) &&
171 unlikely(inode_wrong_type(inode, fattr->cf_mode))) {
172 CIFS_I(inode)->time = 0; /* force reval */
173 return -ESTALE;
174 }
175 if (inode->i_state & I_NEW)
176 CIFS_I(inode)->netfs.zero_point = fattr->cf_eof;
177
178 cifs_revalidate_cache(inode, fattr);
179
180 spin_lock(&inode->i_lock);
181 fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);
182 fattr->cf_atime = timestamp_truncate(fattr->cf_atime, inode);
183 fattr->cf_ctime = timestamp_truncate(fattr->cf_ctime, inode);
184 /* we do not want atime to be less than mtime, it broke some apps */
185 if (timespec64_compare(&fattr->cf_atime, &fattr->cf_mtime) < 0)
186 inode_set_atime_to_ts(inode, fattr->cf_mtime);
187 else
188 inode_set_atime_to_ts(inode, fattr->cf_atime);
189 inode_set_mtime_to_ts(inode, fattr->cf_mtime);
190 inode_set_ctime_to_ts(inode, fattr->cf_ctime);
191 inode->i_rdev = fattr->cf_rdev;
192 cifs_nlink_fattr_to_inode(inode, fattr);
193 inode->i_uid = fattr->cf_uid;
194 inode->i_gid = fattr->cf_gid;
195
196 /* if dynperm is set, don't clobber existing mode */
197 if (inode->i_state & I_NEW ||
198 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
199 inode->i_mode = fattr->cf_mode;
200
201 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
202 cifs_i->reparse_tag = fattr->cf_cifstag;
203
204 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
205 cifs_i->time = 0;
206 else
207 cifs_i->time = jiffies;
208
209 if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING)
210 set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
211 else
212 clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
213
214 cifs_i->netfs.remote_i_size = fattr->cf_eof;
215 /*
216 * Can't safely change the file size here if the client is writing to
217 * it due to potential races.
218 */
219 if (is_size_safe_to_change(cifs_i, fattr->cf_eof, from_readdir)) {
220 i_size_write(inode, fattr->cf_eof);
221
222 /*
223 * i_blocks is not related to (i_size / i_blksize),
224 * but instead 512 byte (2**9) size is required for
225 * calculating num blocks.
226 */
227 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
228 }
229
230 if (S_ISLNK(fattr->cf_mode) && fattr->cf_symlink_target) {
231 kfree(cifs_i->symlink_target);
232 cifs_i->symlink_target = fattr->cf_symlink_target;
233 fattr->cf_symlink_target = NULL;
234 }
235 spin_unlock(&inode->i_lock);
236
237 if (fattr->cf_flags & CIFS_FATTR_JUNCTION)
238 inode->i_flags |= S_AUTOMOUNT;
239 if (inode->i_state & I_NEW) {
240 cifs_set_netfs_context(inode);
241 cifs_set_ops(inode);
242 }
243 return 0;
244 }
245
246 void
cifs_fill_uniqueid(struct super_block * sb,struct cifs_fattr * fattr)247 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
248 {
249 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
250
251 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
252 return;
253
254 fattr->cf_uniqueid = iunique(sb, ROOT_I);
255 }
256
257 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
258 void
cifs_unix_basic_to_fattr(struct cifs_fattr * fattr,FILE_UNIX_BASIC_INFO * info,struct cifs_sb_info * cifs_sb)259 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
260 struct cifs_sb_info *cifs_sb)
261 {
262 memset(fattr, 0, sizeof(*fattr));
263 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
264 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
265 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
266
267 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
268 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
269 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
270 /* old POSIX extensions don't get create time */
271
272 fattr->cf_mode = le64_to_cpu(info->Permissions);
273
274 /*
275 * Since we set the inode type below we need to mask off
276 * to avoid strange results if bits set above.
277 */
278 fattr->cf_mode &= ~S_IFMT;
279 switch (le32_to_cpu(info->Type)) {
280 case UNIX_FILE:
281 fattr->cf_mode |= S_IFREG;
282 fattr->cf_dtype = DT_REG;
283 break;
284 case UNIX_SYMLINK:
285 fattr->cf_mode |= S_IFLNK;
286 fattr->cf_dtype = DT_LNK;
287 break;
288 case UNIX_DIR:
289 fattr->cf_mode |= S_IFDIR;
290 fattr->cf_dtype = DT_DIR;
291 break;
292 case UNIX_CHARDEV:
293 fattr->cf_mode |= S_IFCHR;
294 fattr->cf_dtype = DT_CHR;
295 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
296 le64_to_cpu(info->DevMinor) & MINORMASK);
297 break;
298 case UNIX_BLOCKDEV:
299 fattr->cf_mode |= S_IFBLK;
300 fattr->cf_dtype = DT_BLK;
301 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
302 le64_to_cpu(info->DevMinor) & MINORMASK);
303 break;
304 case UNIX_FIFO:
305 fattr->cf_mode |= S_IFIFO;
306 fattr->cf_dtype = DT_FIFO;
307 break;
308 case UNIX_SOCKET:
309 fattr->cf_mode |= S_IFSOCK;
310 fattr->cf_dtype = DT_SOCK;
311 break;
312 default:
313 /* safest to call it a file if we do not know */
314 fattr->cf_mode |= S_IFREG;
315 fattr->cf_dtype = DT_REG;
316 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
317 break;
318 }
319
320 fattr->cf_uid = cifs_sb->ctx->linux_uid;
321 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
322 u64 id = le64_to_cpu(info->Uid);
323 if (id < ((uid_t)-1)) {
324 kuid_t uid = make_kuid(&init_user_ns, id);
325 if (uid_valid(uid))
326 fattr->cf_uid = uid;
327 }
328 }
329
330 fattr->cf_gid = cifs_sb->ctx->linux_gid;
331 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
332 u64 id = le64_to_cpu(info->Gid);
333 if (id < ((gid_t)-1)) {
334 kgid_t gid = make_kgid(&init_user_ns, id);
335 if (gid_valid(gid))
336 fattr->cf_gid = gid;
337 }
338 }
339
340 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
341 }
342
343 /*
344 * Fill a cifs_fattr struct with fake inode info.
345 *
346 * Needed to setup cifs_fattr data for the directory which is the
347 * junction to the new submount (ie to setup the fake directory
348 * which represents a DFS referral or reparse mount point).
349 */
cifs_create_junction_fattr(struct cifs_fattr * fattr,struct super_block * sb)350 static void cifs_create_junction_fattr(struct cifs_fattr *fattr,
351 struct super_block *sb)
352 {
353 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
354
355 cifs_dbg(FYI, "%s: creating fake fattr\n", __func__);
356
357 memset(fattr, 0, sizeof(*fattr));
358 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
359 fattr->cf_uid = cifs_sb->ctx->linux_uid;
360 fattr->cf_gid = cifs_sb->ctx->linux_gid;
361 ktime_get_coarse_real_ts64(&fattr->cf_mtime);
362 fattr->cf_atime = fattr->cf_ctime = fattr->cf_mtime;
363 fattr->cf_nlink = 2;
364 fattr->cf_flags = CIFS_FATTR_JUNCTION;
365 }
366
367 /* Update inode with final fattr data */
update_inode_info(struct super_block * sb,struct cifs_fattr * fattr,struct inode ** inode)368 static int update_inode_info(struct super_block *sb,
369 struct cifs_fattr *fattr,
370 struct inode **inode)
371 {
372 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
373 int rc = 0;
374
375 if (!*inode) {
376 *inode = cifs_iget(sb, fattr);
377 if (!*inode)
378 rc = -ENOMEM;
379 return rc;
380 }
381 /* We already have inode, update it.
382 *
383 * If file type or uniqueid is different, return error.
384 */
385 if (unlikely((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
386 CIFS_I(*inode)->uniqueid != fattr->cf_uniqueid)) {
387 CIFS_I(*inode)->time = 0; /* force reval */
388 return -ESTALE;
389 }
390 return cifs_fattr_to_inode(*inode, fattr, false);
391 }
392
393 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
394 static int
cifs_get_file_info_unix(struct file * filp)395 cifs_get_file_info_unix(struct file *filp)
396 {
397 int rc;
398 unsigned int xid;
399 FILE_UNIX_BASIC_INFO find_data;
400 struct cifs_fattr fattr = {};
401 struct inode *inode = file_inode(filp);
402 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
403 struct cifsFileInfo *cfile = filp->private_data;
404 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
405
406 xid = get_xid();
407
408 if (cfile->symlink_target) {
409 fattr.cf_symlink_target = kstrdup(cfile->symlink_target, GFP_KERNEL);
410 if (!fattr.cf_symlink_target) {
411 rc = -ENOMEM;
412 goto cifs_gfiunix_out;
413 }
414 }
415
416 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
417 if (!rc) {
418 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
419 } else if (rc == -EREMOTE) {
420 cifs_create_junction_fattr(&fattr, inode->i_sb);
421 } else
422 goto cifs_gfiunix_out;
423
424 rc = cifs_fattr_to_inode(inode, &fattr, false);
425
426 cifs_gfiunix_out:
427 free_xid(xid);
428 return rc;
429 }
430
cifs_get_unix_fattr(const unsigned char * full_path,struct super_block * sb,struct cifs_fattr * fattr,struct inode ** pinode,const unsigned int xid)431 static int cifs_get_unix_fattr(const unsigned char *full_path,
432 struct super_block *sb,
433 struct cifs_fattr *fattr,
434 struct inode **pinode,
435 const unsigned int xid)
436 {
437 struct TCP_Server_Info *server;
438 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
439 FILE_UNIX_BASIC_INFO find_data;
440 struct cifs_tcon *tcon;
441 struct tcon_link *tlink;
442 int rc, tmprc;
443
444 cifs_dbg(FYI, "Getting info on %s\n", full_path);
445
446 tlink = cifs_sb_tlink(cifs_sb);
447 if (IS_ERR(tlink))
448 return PTR_ERR(tlink);
449 tcon = tlink_tcon(tlink);
450 server = tcon->ses->server;
451
452 /* could have done a find first instead but this returns more info */
453 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
454 cifs_sb->local_nls, cifs_remap(cifs_sb));
455 cifs_dbg(FYI, "%s: query path info: rc = %d\n", __func__, rc);
456 cifs_put_tlink(tlink);
457
458 if (!rc) {
459 cifs_unix_basic_to_fattr(fattr, &find_data, cifs_sb);
460 } else if (rc == -EREMOTE) {
461 cifs_create_junction_fattr(fattr, sb);
462 rc = 0;
463 } else {
464 return rc;
465 }
466
467 if (!*pinode)
468 cifs_fill_uniqueid(sb, fattr);
469
470 /* check for Minshall+French symlinks */
471 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
472 tmprc = check_mf_symlink(xid, tcon, cifs_sb, fattr, full_path);
473 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
474 }
475
476 if (S_ISLNK(fattr->cf_mode) && !fattr->cf_symlink_target) {
477 if (!server->ops->query_symlink)
478 return -EOPNOTSUPP;
479 rc = server->ops->query_symlink(xid, tcon,
480 cifs_sb, full_path,
481 &fattr->cf_symlink_target);
482 cifs_dbg(FYI, "%s: query_symlink: %d\n", __func__, rc);
483 }
484 return rc;
485 }
486
cifs_get_inode_info_unix(struct inode ** pinode,const unsigned char * full_path,struct super_block * sb,unsigned int xid)487 int cifs_get_inode_info_unix(struct inode **pinode,
488 const unsigned char *full_path,
489 struct super_block *sb, unsigned int xid)
490 {
491 struct cifs_fattr fattr = {};
492 int rc;
493
494 rc = cifs_get_unix_fattr(full_path, sb, &fattr, pinode, xid);
495 if (rc)
496 goto out;
497
498 rc = update_inode_info(sb, &fattr, pinode);
499 out:
500 kfree(fattr.cf_symlink_target);
501 return rc;
502 }
503 #else
cifs_get_unix_fattr(const unsigned char * full_path,struct super_block * sb,struct cifs_fattr * fattr,struct inode ** pinode,const unsigned int xid)504 static inline int cifs_get_unix_fattr(const unsigned char *full_path,
505 struct super_block *sb,
506 struct cifs_fattr *fattr,
507 struct inode **pinode,
508 const unsigned int xid)
509 {
510 return -EOPNOTSUPP;
511 }
512
cifs_get_inode_info_unix(struct inode ** pinode,const unsigned char * full_path,struct super_block * sb,unsigned int xid)513 int cifs_get_inode_info_unix(struct inode **pinode,
514 const unsigned char *full_path,
515 struct super_block *sb, unsigned int xid)
516 {
517 return -EOPNOTSUPP;
518 }
519 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
520
521 static int
cifs_sfu_type(struct cifs_fattr * fattr,const char * path,struct cifs_sb_info * cifs_sb,unsigned int xid)522 cifs_sfu_type(struct cifs_fattr *fattr, const char *path,
523 struct cifs_sb_info *cifs_sb, unsigned int xid)
524 {
525 int rc;
526 __u32 oplock;
527 struct tcon_link *tlink;
528 struct cifs_tcon *tcon;
529 struct cifs_fid fid;
530 struct cifs_open_parms oparms;
531 struct cifs_io_parms io_parms = {0};
532 char *symlink_buf_utf16;
533 unsigned int symlink_len_utf16;
534 char buf[24];
535 unsigned int bytes_read;
536 char *pbuf;
537 int buf_type = CIFS_NO_BUFFER;
538
539 pbuf = buf;
540
541 fattr->cf_mode &= ~S_IFMT;
542
543 if (fattr->cf_eof == 0) {
544 cifs_dbg(FYI, "Fifo\n");
545 fattr->cf_mode |= S_IFIFO;
546 fattr->cf_dtype = DT_FIFO;
547 return 0;
548 } else if (fattr->cf_eof > 1 && fattr->cf_eof < 8) {
549 fattr->cf_mode |= S_IFREG;
550 fattr->cf_dtype = DT_REG;
551 return -EINVAL; /* EOPNOTSUPP? */
552 }
553
554 tlink = cifs_sb_tlink(cifs_sb);
555 if (IS_ERR(tlink))
556 return PTR_ERR(tlink);
557 tcon = tlink_tcon(tlink);
558
559 oparms = (struct cifs_open_parms) {
560 .tcon = tcon,
561 .cifs_sb = cifs_sb,
562 .desired_access = GENERIC_READ,
563 .create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR),
564 .disposition = FILE_OPEN,
565 .path = path,
566 .fid = &fid,
567 };
568
569 if (tcon->ses->server->oplocks)
570 oplock = REQ_OPLOCK;
571 else
572 oplock = 0;
573 rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);
574 if (rc) {
575 cifs_dbg(FYI, "check sfu type of %s, open rc = %d\n", path, rc);
576 cifs_put_tlink(tlink);
577 return rc;
578 }
579
580 /* Read header */
581 io_parms.netfid = fid.netfid;
582 io_parms.pid = current->tgid;
583 io_parms.tcon = tcon;
584 io_parms.offset = 0;
585 io_parms.length = 24;
586
587 rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,
588 &bytes_read, &pbuf, &buf_type);
589 if ((rc == 0) && (bytes_read >= 8)) {
590 if (memcmp("IntxBLK\0", pbuf, 8) == 0) {
591 cifs_dbg(FYI, "Block device\n");
592 fattr->cf_mode |= S_IFBLK;
593 fattr->cf_dtype = DT_BLK;
594 if (bytes_read == 24) {
595 /* we have enough to decode dev num */
596 __u64 mjr; /* major */
597 __u64 mnr; /* minor */
598 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
599 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
600 fattr->cf_rdev = MKDEV(mjr, mnr);
601 } else if (bytes_read == 16) {
602 /*
603 * Windows NFS server before Windows Server 2012
604 * stores major and minor number in SFU-modified
605 * style, just as 32-bit numbers. Recognize it.
606 */
607 __u32 mjr; /* major */
608 __u32 mnr; /* minor */
609 mjr = le32_to_cpu(*(__le32 *)(pbuf+8));
610 mnr = le32_to_cpu(*(__le32 *)(pbuf+12));
611 fattr->cf_rdev = MKDEV(mjr, mnr);
612 }
613 } else if (memcmp("IntxCHR\0", pbuf, 8) == 0) {
614 cifs_dbg(FYI, "Char device\n");
615 fattr->cf_mode |= S_IFCHR;
616 fattr->cf_dtype = DT_CHR;
617 if (bytes_read == 24) {
618 /* we have enough to decode dev num */
619 __u64 mjr; /* major */
620 __u64 mnr; /* minor */
621 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
622 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
623 fattr->cf_rdev = MKDEV(mjr, mnr);
624 } else if (bytes_read == 16) {
625 /*
626 * Windows NFS server before Windows Server 2012
627 * stores major and minor number in SFU-modified
628 * style, just as 32-bit numbers. Recognize it.
629 */
630 __u32 mjr; /* major */
631 __u32 mnr; /* minor */
632 mjr = le32_to_cpu(*(__le32 *)(pbuf+8));
633 mnr = le32_to_cpu(*(__le32 *)(pbuf+12));
634 fattr->cf_rdev = MKDEV(mjr, mnr);
635 }
636 } else if (memcmp("LnxSOCK", pbuf, 8) == 0) {
637 cifs_dbg(FYI, "Socket\n");
638 fattr->cf_mode |= S_IFSOCK;
639 fattr->cf_dtype = DT_SOCK;
640 } else if (memcmp("IntxLNK\1", pbuf, 8) == 0) {
641 cifs_dbg(FYI, "Symlink\n");
642 fattr->cf_mode |= S_IFLNK;
643 fattr->cf_dtype = DT_LNK;
644 if ((fattr->cf_eof > 8) && (fattr->cf_eof % 2 == 0)) {
645 symlink_buf_utf16 = kmalloc(fattr->cf_eof-8 + 1, GFP_KERNEL);
646 if (symlink_buf_utf16) {
647 io_parms.offset = 8;
648 io_parms.length = fattr->cf_eof-8 + 1;
649 buf_type = CIFS_NO_BUFFER;
650 rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,
651 &symlink_len_utf16,
652 &symlink_buf_utf16,
653 &buf_type);
654 /*
655 * Check that read buffer has valid length and does not
656 * contain UTF-16 null codepoint (via UniStrnlen() call)
657 * because Linux cannot process symlink with null byte.
658 */
659 if ((rc == 0) &&
660 (symlink_len_utf16 > 0) &&
661 (symlink_len_utf16 < fattr->cf_eof-8 + 1) &&
662 (symlink_len_utf16 % 2 == 0) &&
663 (UniStrnlen((wchar_t *)symlink_buf_utf16, symlink_len_utf16/2) == symlink_len_utf16/2)) {
664 fattr->cf_symlink_target =
665 cifs_strndup_from_utf16(symlink_buf_utf16,
666 symlink_len_utf16,
667 true,
668 cifs_sb->local_nls);
669 if (!fattr->cf_symlink_target)
670 rc = -ENOMEM;
671 }
672 kfree(symlink_buf_utf16);
673 } else {
674 rc = -ENOMEM;
675 }
676 }
677 } else if (memcmp("LnxFIFO", pbuf, 8) == 0) {
678 cifs_dbg(FYI, "FIFO\n");
679 fattr->cf_mode |= S_IFIFO;
680 fattr->cf_dtype = DT_FIFO;
681 } else {
682 fattr->cf_mode |= S_IFREG; /* file? */
683 fattr->cf_dtype = DT_REG;
684 rc = -EOPNOTSUPP;
685 }
686 } else if ((rc == 0) && (bytes_read == 1) && (pbuf[0] == '\0')) {
687 cifs_dbg(FYI, "Socket\n");
688 fattr->cf_mode |= S_IFSOCK;
689 fattr->cf_dtype = DT_SOCK;
690 } else {
691 fattr->cf_mode |= S_IFREG; /* then it is a file */
692 fattr->cf_dtype = DT_REG;
693 rc = -EOPNOTSUPP; /* or some unknown SFU type */
694 }
695
696 tcon->ses->server->ops->close(xid, tcon, &fid);
697 cifs_put_tlink(tlink);
698 return rc;
699 }
700
701 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
702
703 /*
704 * Fetch mode bits as provided by SFU.
705 *
706 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
707 */
cifs_sfu_mode(struct cifs_fattr * fattr,const unsigned char * path,struct cifs_sb_info * cifs_sb,unsigned int xid)708 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
709 struct cifs_sb_info *cifs_sb, unsigned int xid)
710 {
711 #ifdef CONFIG_CIFS_XATTR
712 ssize_t rc;
713 char ea_value[4];
714 __u32 mode;
715 struct tcon_link *tlink;
716 struct cifs_tcon *tcon;
717
718 tlink = cifs_sb_tlink(cifs_sb);
719 if (IS_ERR(tlink))
720 return PTR_ERR(tlink);
721 tcon = tlink_tcon(tlink);
722
723 if (tcon->ses->server->ops->query_all_EAs == NULL) {
724 cifs_put_tlink(tlink);
725 return -EOPNOTSUPP;
726 }
727
728 rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
729 "SETFILEBITS", ea_value, 4 /* size of buf */,
730 cifs_sb);
731 cifs_put_tlink(tlink);
732 if (rc < 0)
733 return (int)rc;
734 else if (rc > 3) {
735 mode = le32_to_cpu(*((__le32 *)ea_value));
736 fattr->cf_mode &= ~SFBITS_MASK;
737 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
738 mode, fattr->cf_mode);
739 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
740 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
741 }
742
743 return 0;
744 #else
745 return -EOPNOTSUPP;
746 #endif
747 }
748
749 #define POSIX_TYPE_FILE 0
750 #define POSIX_TYPE_DIR 1
751 #define POSIX_TYPE_SYMLINK 2
752 #define POSIX_TYPE_CHARDEV 3
753 #define POSIX_TYPE_BLKDEV 4
754 #define POSIX_TYPE_FIFO 5
755 #define POSIX_TYPE_SOCKET 6
756
757 #define POSIX_X_OTH 0000001
758 #define POSIX_W_OTH 0000002
759 #define POSIX_R_OTH 0000004
760 #define POSIX_X_GRP 0000010
761 #define POSIX_W_GRP 0000020
762 #define POSIX_R_GRP 0000040
763 #define POSIX_X_USR 0000100
764 #define POSIX_W_USR 0000200
765 #define POSIX_R_USR 0000400
766 #define POSIX_STICKY 0001000
767 #define POSIX_SET_GID 0002000
768 #define POSIX_SET_UID 0004000
769
770 #define POSIX_OTH_MASK 0000007
771 #define POSIX_GRP_MASK 0000070
772 #define POSIX_USR_MASK 0000700
773 #define POSIX_PERM_MASK 0000777
774 #define POSIX_FILETYPE_MASK 0070000
775
776 #define POSIX_FILETYPE_SHIFT 12
777
wire_perms_to_posix(u32 wire)778 static u32 wire_perms_to_posix(u32 wire)
779 {
780 u32 mode = 0;
781
782 mode |= (wire & POSIX_X_OTH) ? S_IXOTH : 0;
783 mode |= (wire & POSIX_W_OTH) ? S_IWOTH : 0;
784 mode |= (wire & POSIX_R_OTH) ? S_IROTH : 0;
785 mode |= (wire & POSIX_X_GRP) ? S_IXGRP : 0;
786 mode |= (wire & POSIX_W_GRP) ? S_IWGRP : 0;
787 mode |= (wire & POSIX_R_GRP) ? S_IRGRP : 0;
788 mode |= (wire & POSIX_X_USR) ? S_IXUSR : 0;
789 mode |= (wire & POSIX_W_USR) ? S_IWUSR : 0;
790 mode |= (wire & POSIX_R_USR) ? S_IRUSR : 0;
791 mode |= (wire & POSIX_STICKY) ? S_ISVTX : 0;
792 mode |= (wire & POSIX_SET_GID) ? S_ISGID : 0;
793 mode |= (wire & POSIX_SET_UID) ? S_ISUID : 0;
794
795 return mode;
796 }
797
798 static u32 posix_filetypes[] = {
799 S_IFREG,
800 S_IFDIR,
801 S_IFLNK,
802 S_IFCHR,
803 S_IFBLK,
804 S_IFIFO,
805 S_IFSOCK
806 };
807
wire_filetype_to_posix(u32 wire_type)808 static u32 wire_filetype_to_posix(u32 wire_type)
809 {
810 if (wire_type >= ARRAY_SIZE(posix_filetypes)) {
811 pr_warn("Unexpected type %u", wire_type);
812 return 0;
813 }
814 return posix_filetypes[wire_type];
815 }
816
wire_mode_to_posix(u32 wire,bool is_dir)817 umode_t wire_mode_to_posix(u32 wire, bool is_dir)
818 {
819 u32 wire_type;
820 u32 mode;
821
822 wire_type = (wire & POSIX_FILETYPE_MASK) >> POSIX_FILETYPE_SHIFT;
823 /* older servers do not set POSIX file type in the mode field in the response */
824 if ((wire_type == 0) && is_dir)
825 mode = wire_perms_to_posix(wire) | S_IFDIR;
826 else
827 mode = (wire_perms_to_posix(wire) | wire_filetype_to_posix(wire_type));
828 return (umode_t)mode;
829 }
830
831 /* Fill a cifs_fattr struct with info from POSIX info struct */
smb311_posix_info_to_fattr(struct cifs_fattr * fattr,struct cifs_open_info_data * data,struct super_block * sb)832 static void smb311_posix_info_to_fattr(struct cifs_fattr *fattr,
833 struct cifs_open_info_data *data,
834 struct super_block *sb)
835 {
836 struct smb311_posix_qinfo *info = &data->posix_fi;
837 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
838 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
839
840 memset(fattr, 0, sizeof(*fattr));
841
842 /* no fattr->flags to set */
843 fattr->cf_cifsattrs = le32_to_cpu(info->DosAttributes);
844 fattr->cf_uniqueid = le64_to_cpu(info->Inode);
845
846 if (info->LastAccessTime)
847 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
848 else
849 ktime_get_coarse_real_ts64(&fattr->cf_atime);
850
851 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
852 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
853
854 if (data->adjust_tz) {
855 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
856 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
857 }
858
859 /*
860 * The srv fs device id is overridden on network mount so setting
861 * @fattr->cf_rdev isn't needed here.
862 */
863 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
864 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
865 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
866 fattr->cf_nlink = le32_to_cpu(info->HardLinks);
867 fattr->cf_mode = wire_mode_to_posix(le32_to_cpu(info->Mode),
868 fattr->cf_cifsattrs & ATTR_DIRECTORY);
869
870 if (cifs_open_data_reparse(data) &&
871 cifs_reparse_point_to_fattr(cifs_sb, fattr, data))
872 goto out_reparse;
873
874 fattr->cf_dtype = S_DT(fattr->cf_mode);
875
876 out_reparse:
877 if (S_ISLNK(fattr->cf_mode)) {
878 if (likely(data->symlink_target))
879 fattr->cf_eof = strnlen(data->symlink_target, PATH_MAX);
880 fattr->cf_symlink_target = data->symlink_target;
881 data->symlink_target = NULL;
882 }
883 sid_to_id(cifs_sb, &data->posix_owner, fattr, SIDOWNER);
884 sid_to_id(cifs_sb, &data->posix_group, fattr, SIDGROUP);
885
886 cifs_dbg(FYI, "POSIX query info: mode 0x%x uniqueid 0x%llx nlink %d\n",
887 fattr->cf_mode, fattr->cf_uniqueid, fattr->cf_nlink);
888 }
889
cifs_open_info_to_fattr(struct cifs_fattr * fattr,struct cifs_open_info_data * data,struct super_block * sb)890 static void cifs_open_info_to_fattr(struct cifs_fattr *fattr,
891 struct cifs_open_info_data *data,
892 struct super_block *sb)
893 {
894 struct smb2_file_all_info *info = &data->fi;
895 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
896 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
897
898 memset(fattr, 0, sizeof(*fattr));
899 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
900 if (info->DeletePending)
901 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
902
903 if (info->LastAccessTime)
904 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
905 else
906 ktime_get_coarse_real_ts64(&fattr->cf_atime);
907
908 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
909 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
910
911 if (data->adjust_tz) {
912 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
913 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
914 }
915
916 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
917 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
918 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
919 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
920 fattr->cf_uid = cifs_sb->ctx->linux_uid;
921 fattr->cf_gid = cifs_sb->ctx->linux_gid;
922
923 fattr->cf_mode = cifs_sb->ctx->file_mode;
924 if (cifs_open_data_reparse(data) &&
925 cifs_reparse_point_to_fattr(cifs_sb, fattr, data))
926 goto out_reparse;
927
928 if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
929 fattr->cf_mode = S_IFDIR | cifs_sb->ctx->dir_mode;
930 fattr->cf_dtype = DT_DIR;
931 /*
932 * Server can return wrong NumberOfLinks value for directories
933 * when Unix extensions are disabled - fake it.
934 */
935 if (!tcon->unix_ext)
936 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
937 } else {
938 fattr->cf_mode = S_IFREG | cifs_sb->ctx->file_mode;
939 fattr->cf_dtype = DT_REG;
940
941 /*
942 * Don't accept zero nlink from non-unix servers unless
943 * delete is pending. Instead mark it as unknown.
944 */
945 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
946 !info->DeletePending) {
947 cifs_dbg(VFS, "bogus file nlink value %u\n",
948 fattr->cf_nlink);
949 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
950 }
951 }
952
953 /* clear write bits if ATTR_READONLY is set */
954 if (fattr->cf_cifsattrs & ATTR_READONLY)
955 fattr->cf_mode &= ~(S_IWUGO);
956
957 out_reparse:
958 if (S_ISLNK(fattr->cf_mode)) {
959 if (likely(data->symlink_target))
960 fattr->cf_eof = strnlen(data->symlink_target, PATH_MAX);
961 fattr->cf_symlink_target = data->symlink_target;
962 data->symlink_target = NULL;
963 }
964 }
965
966 static int
cifs_get_file_info(struct file * filp)967 cifs_get_file_info(struct file *filp)
968 {
969 int rc;
970 unsigned int xid;
971 struct cifs_open_info_data data = {};
972 struct cifs_fattr fattr;
973 struct inode *inode = file_inode(filp);
974 struct cifsFileInfo *cfile = filp->private_data;
975 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
976 struct TCP_Server_Info *server = tcon->ses->server;
977 struct dentry *dentry = filp->f_path.dentry;
978 void *page = alloc_dentry_path();
979 const unsigned char *path;
980
981 if (!server->ops->query_file_info) {
982 free_dentry_path(page);
983 return -ENOSYS;
984 }
985
986 xid = get_xid();
987 rc = server->ops->query_file_info(xid, tcon, cfile, &data);
988 switch (rc) {
989 case 0:
990 /* TODO: add support to query reparse tag */
991 data.adjust_tz = false;
992 if (data.symlink_target) {
993 data.reparse_point = true;
994 data.reparse.tag = IO_REPARSE_TAG_SYMLINK;
995 }
996 path = build_path_from_dentry(dentry, page);
997 if (IS_ERR(path)) {
998 rc = PTR_ERR(path);
999 goto cgfi_exit;
1000 }
1001 cifs_open_info_to_fattr(&fattr, &data, inode->i_sb);
1002 if (fattr.cf_flags & CIFS_FATTR_DELETE_PENDING)
1003 cifs_mark_open_handles_for_deleted_file(inode, path);
1004 break;
1005 case -EREMOTE:
1006 cifs_create_junction_fattr(&fattr, inode->i_sb);
1007 break;
1008 case -EOPNOTSUPP:
1009 case -EINVAL:
1010 /*
1011 * FIXME: legacy server -- fall back to path-based call?
1012 * for now, just skip revalidating and mark inode for
1013 * immediate reval.
1014 */
1015 rc = 0;
1016 CIFS_I(inode)->time = 0;
1017 goto cgfi_exit;
1018 default:
1019 goto cgfi_exit;
1020 }
1021
1022 /*
1023 * don't bother with SFU junk here -- just mark inode as needing
1024 * revalidation.
1025 */
1026 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
1027 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
1028 /* if filetype is different, return error */
1029 rc = cifs_fattr_to_inode(inode, &fattr, false);
1030 cgfi_exit:
1031 cifs_free_open_info(&data);
1032 free_dentry_path(page);
1033 free_xid(xid);
1034 return rc;
1035 }
1036
1037 /* Simple function to return a 64 bit hash of string. Rarely called */
simple_hashstr(const char * str)1038 static __u64 simple_hashstr(const char *str)
1039 {
1040 const __u64 hash_mult = 1125899906842597ULL; /* a big enough prime */
1041 __u64 hash = 0;
1042
1043 while (*str)
1044 hash = (hash + (__u64) *str++) * hash_mult;
1045
1046 return hash;
1047 }
1048
1049 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1050 /**
1051 * cifs_backup_query_path_info - SMB1 fallback code to get ino
1052 *
1053 * Fallback code to get file metadata when we don't have access to
1054 * full_path (EACCES) and have backup creds.
1055 *
1056 * @xid: transaction id used to identify original request in logs
1057 * @tcon: information about the server share we have mounted
1058 * @sb: the superblock stores info such as disk space available
1059 * @full_path: name of the file we are getting the metadata for
1060 * @resp_buf: will be set to cifs resp buf and needs to be freed with
1061 * cifs_buf_release() when done with @data
1062 * @data: will be set to search info result buffer
1063 */
1064 static int
cifs_backup_query_path_info(int xid,struct cifs_tcon * tcon,struct super_block * sb,const char * full_path,void ** resp_buf,FILE_ALL_INFO ** data)1065 cifs_backup_query_path_info(int xid,
1066 struct cifs_tcon *tcon,
1067 struct super_block *sb,
1068 const char *full_path,
1069 void **resp_buf,
1070 FILE_ALL_INFO **data)
1071 {
1072 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1073 struct cifs_search_info info = {0};
1074 u16 flags;
1075 int rc;
1076
1077 *resp_buf = NULL;
1078 info.endOfSearch = false;
1079 if (tcon->unix_ext)
1080 info.info_level = SMB_FIND_FILE_UNIX;
1081 else if ((tcon->ses->capabilities &
1082 tcon->ses->server->vals->cap_nt_find) == 0)
1083 info.info_level = SMB_FIND_FILE_INFO_STANDARD;
1084 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
1085 info.info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
1086 else /* no srvino useful for fallback to some netapp */
1087 info.info_level = SMB_FIND_FILE_DIRECTORY_INFO;
1088
1089 flags = CIFS_SEARCH_CLOSE_ALWAYS |
1090 CIFS_SEARCH_CLOSE_AT_END |
1091 CIFS_SEARCH_BACKUP_SEARCH;
1092
1093 rc = CIFSFindFirst(xid, tcon, full_path,
1094 cifs_sb, NULL, flags, &info, false);
1095 if (rc)
1096 return rc;
1097
1098 *resp_buf = (void *)info.ntwrk_buf_start;
1099 *data = (FILE_ALL_INFO *)info.srch_entries_start;
1100 return 0;
1101 }
1102 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1103
cifs_set_fattr_ino(int xid,struct cifs_tcon * tcon,struct super_block * sb,struct inode ** inode,const char * full_path,struct cifs_open_info_data * data,struct cifs_fattr * fattr)1104 static void cifs_set_fattr_ino(int xid, struct cifs_tcon *tcon, struct super_block *sb,
1105 struct inode **inode, const char *full_path,
1106 struct cifs_open_info_data *data, struct cifs_fattr *fattr)
1107 {
1108 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1109 struct TCP_Server_Info *server = tcon->ses->server;
1110 int rc;
1111
1112 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
1113 if (*inode)
1114 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
1115 else
1116 fattr->cf_uniqueid = iunique(sb, ROOT_I);
1117 return;
1118 }
1119
1120 /*
1121 * If we have an inode pass a NULL tcon to ensure we don't
1122 * make a round trip to the server. This only works for SMB2+.
1123 */
1124 rc = server->ops->get_srv_inum(xid, *inode ? NULL : tcon, cifs_sb, full_path,
1125 &fattr->cf_uniqueid, data);
1126 if (rc) {
1127 /*
1128 * If that fails reuse existing ino or generate one
1129 * and disable server ones
1130 */
1131 if (*inode)
1132 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
1133 else {
1134 fattr->cf_uniqueid = iunique(sb, ROOT_I);
1135 cifs_autodisable_serverino(cifs_sb);
1136 }
1137 return;
1138 }
1139
1140 /* If no errors, check for zero root inode (invalid) */
1141 if (fattr->cf_uniqueid == 0 && strlen(full_path) == 0) {
1142 cifs_dbg(FYI, "Invalid (0) inodenum\n");
1143 if (*inode) {
1144 /* reuse */
1145 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
1146 } else {
1147 /* make an ino by hashing the UNC */
1148 fattr->cf_flags |= CIFS_FATTR_FAKE_ROOT_INO;
1149 fattr->cf_uniqueid = simple_hashstr(tcon->tree_name);
1150 }
1151 }
1152 }
1153
is_inode_cache_good(struct inode * ino)1154 static inline bool is_inode_cache_good(struct inode *ino)
1155 {
1156 return ino && CIFS_CACHE_READ(CIFS_I(ino)) && CIFS_I(ino)->time != 0;
1157 }
1158
reparse_info_to_fattr(struct cifs_open_info_data * data,struct super_block * sb,const unsigned int xid,struct cifs_tcon * tcon,const char * full_path,struct cifs_fattr * fattr)1159 static int reparse_info_to_fattr(struct cifs_open_info_data *data,
1160 struct super_block *sb,
1161 const unsigned int xid,
1162 struct cifs_tcon *tcon,
1163 const char *full_path,
1164 struct cifs_fattr *fattr)
1165 {
1166 struct TCP_Server_Info *server = tcon->ses->server;
1167 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1168 struct kvec rsp_iov, *iov = NULL;
1169 int rsp_buftype = CIFS_NO_BUFFER;
1170 u32 tag = data->reparse.tag;
1171 int rc = 0;
1172
1173 if (!tag && server->ops->query_reparse_point) {
1174 rc = server->ops->query_reparse_point(xid, tcon, cifs_sb,
1175 full_path, &tag,
1176 &rsp_iov, &rsp_buftype);
1177 if (!rc)
1178 iov = &rsp_iov;
1179 } else if (data->reparse.io.buftype != CIFS_NO_BUFFER &&
1180 data->reparse.io.iov.iov_base) {
1181 iov = &data->reparse.io.iov;
1182 }
1183
1184 rc = -EOPNOTSUPP;
1185 data->reparse.tag = tag;
1186 if (!data->reparse.tag) {
1187 if (server->ops->query_symlink) {
1188 rc = server->ops->query_symlink(xid, tcon,
1189 cifs_sb, full_path,
1190 &data->symlink_target);
1191 }
1192 if (rc == -EOPNOTSUPP)
1193 data->reparse.tag = IO_REPARSE_TAG_INTERNAL;
1194 }
1195
1196 switch (data->reparse.tag) {
1197 case 0: /* SMB1 symlink */
1198 break;
1199 case IO_REPARSE_TAG_INTERNAL:
1200 rc = 0;
1201 if (le32_to_cpu(data->fi.Attributes) & ATTR_DIRECTORY) {
1202 cifs_create_junction_fattr(fattr, sb);
1203 goto out;
1204 }
1205 break;
1206 default:
1207 /* Check for cached reparse point data */
1208 if (data->symlink_target || data->reparse.buf) {
1209 rc = 0;
1210 } else if (iov && server->ops->get_reparse_point_buffer) {
1211 struct reparse_data_buffer *reparse_buf;
1212 u32 reparse_len;
1213
1214 reparse_buf = server->ops->get_reparse_point_buffer(iov, &reparse_len);
1215 rc = parse_reparse_point(reparse_buf, reparse_len,
1216 cifs_sb, full_path, data);
1217 /*
1218 * If the reparse point was not handled but it is the
1219 * name surrogate which points to directory, then treat
1220 * is as a new mount point. Name surrogate reparse point
1221 * represents another named entity in the system.
1222 */
1223 if (rc == -EOPNOTSUPP &&
1224 IS_REPARSE_TAG_NAME_SURROGATE(data->reparse.tag) &&
1225 (le32_to_cpu(data->fi.Attributes) & ATTR_DIRECTORY)) {
1226 rc = 0;
1227 cifs_create_junction_fattr(fattr, sb);
1228 goto out;
1229 }
1230 /*
1231 * If the reparse point is unsupported by the Linux SMB
1232 * client then let it process by the SMB server. So mask
1233 * the -EOPNOTSUPP error code. This will allow Linux SMB
1234 * client to send SMB OPEN request to server. If server
1235 * does not support this reparse point too then server
1236 * will return error during open the path.
1237 */
1238 if (rc == -EOPNOTSUPP)
1239 rc = 0;
1240 }
1241
1242 if (data->reparse.tag == IO_REPARSE_TAG_SYMLINK && !rc) {
1243 bool directory = le32_to_cpu(data->fi.Attributes) & ATTR_DIRECTORY;
1244 rc = smb2_fix_symlink_target_type(&data->symlink_target, directory, cifs_sb);
1245 }
1246 break;
1247 }
1248
1249 if (tcon->posix_extensions)
1250 smb311_posix_info_to_fattr(fattr, data, sb);
1251 else
1252 cifs_open_info_to_fattr(fattr, data, sb);
1253 out:
1254 fattr->cf_cifstag = data->reparse.tag;
1255 free_rsp_buf(rsp_buftype, rsp_iov.iov_base);
1256 return rc;
1257 }
1258
cifs_get_fattr(struct cifs_open_info_data * data,struct super_block * sb,int xid,const struct cifs_fid * fid,struct cifs_fattr * fattr,struct inode ** inode,const char * full_path)1259 static int cifs_get_fattr(struct cifs_open_info_data *data,
1260 struct super_block *sb, int xid,
1261 const struct cifs_fid *fid,
1262 struct cifs_fattr *fattr,
1263 struct inode **inode,
1264 const char *full_path)
1265 {
1266 struct cifs_open_info_data tmp_data = {};
1267 struct cifs_tcon *tcon;
1268 struct TCP_Server_Info *server;
1269 struct tcon_link *tlink;
1270 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1271 void *smb1_backup_rsp_buf = NULL;
1272 int rc = 0;
1273 int tmprc = 0;
1274
1275 tlink = cifs_sb_tlink(cifs_sb);
1276 if (IS_ERR(tlink))
1277 return PTR_ERR(tlink);
1278 tcon = tlink_tcon(tlink);
1279 server = tcon->ses->server;
1280
1281 /*
1282 * 1. Fetch file metadata if not provided (data)
1283 */
1284
1285 if (!data) {
1286 rc = server->ops->query_path_info(xid, tcon, cifs_sb,
1287 full_path, &tmp_data);
1288 data = &tmp_data;
1289 }
1290
1291 /*
1292 * 2. Convert it to internal cifs metadata (fattr)
1293 */
1294
1295 switch (rc) {
1296 case 0:
1297 /*
1298 * If the file is a reparse point, it is more complicated
1299 * since we have to check if its reparse tag matches a known
1300 * special file type e.g. symlink or fifo or char etc.
1301 */
1302 if (cifs_open_data_reparse(data)) {
1303 rc = reparse_info_to_fattr(data, sb, xid, tcon,
1304 full_path, fattr);
1305 } else {
1306 cifs_open_info_to_fattr(fattr, data, sb);
1307 }
1308 if (!rc && *inode &&
1309 (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING))
1310 cifs_mark_open_handles_for_deleted_file(*inode, full_path);
1311 break;
1312 case -EREMOTE:
1313 /* DFS link, no metadata available on this server */
1314 cifs_create_junction_fattr(fattr, sb);
1315 rc = 0;
1316 break;
1317 case -EACCES:
1318 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1319 /*
1320 * perm errors, try again with backup flags if possible
1321 *
1322 * For SMB2 and later the backup intent flag
1323 * is already sent if needed on open and there
1324 * is no path based FindFirst operation to use
1325 * to retry with
1326 */
1327 if (backup_cred(cifs_sb) && is_smb1_server(server)) {
1328 /* for easier reading */
1329 FILE_ALL_INFO *fi;
1330 FILE_DIRECTORY_INFO *fdi;
1331 SEARCH_ID_FULL_DIR_INFO *si;
1332
1333 rc = cifs_backup_query_path_info(xid, tcon, sb,
1334 full_path,
1335 &smb1_backup_rsp_buf,
1336 &fi);
1337 if (rc)
1338 goto out;
1339
1340 move_cifs_info_to_smb2(&data->fi, fi);
1341 fdi = (FILE_DIRECTORY_INFO *)fi;
1342 si = (SEARCH_ID_FULL_DIR_INFO *)fi;
1343
1344 cifs_dir_info_to_fattr(fattr, fdi, cifs_sb);
1345 fattr->cf_uniqueid = le64_to_cpu(si->UniqueId);
1346 /* uniqueid set, skip get inum step */
1347 goto handle_mnt_opt;
1348 } else {
1349 /* nothing we can do, bail out */
1350 goto out;
1351 }
1352 #else
1353 goto out;
1354 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1355 break;
1356 default:
1357 cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc);
1358 goto out;
1359 }
1360
1361 /*
1362 * 3. Get or update inode number (fattr->cf_uniqueid)
1363 */
1364
1365 cifs_set_fattr_ino(xid, tcon, sb, inode, full_path, data, fattr);
1366
1367 /*
1368 * 4. Tweak fattr based on mount options
1369 */
1370 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1371 handle_mnt_opt:
1372 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1373 /* query for SFU type info if supported and needed */
1374 if ((fattr->cf_cifsattrs & ATTR_SYSTEM) &&
1375 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)) {
1376 tmprc = cifs_sfu_type(fattr, full_path, cifs_sb, xid);
1377 if (tmprc)
1378 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
1379 }
1380
1381 /* fill in 0777 bits from ACL */
1382 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID) {
1383 rc = cifs_acl_to_fattr(cifs_sb, fattr, *inode,
1384 true, full_path, fid);
1385 if (rc == -EREMOTE)
1386 rc = 0;
1387 if (rc) {
1388 cifs_dbg(FYI, "%s: Get mode from SID failed. rc=%d\n",
1389 __func__, rc);
1390 goto out;
1391 }
1392 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
1393 rc = cifs_acl_to_fattr(cifs_sb, fattr, *inode,
1394 false, full_path, fid);
1395 if (rc == -EREMOTE)
1396 rc = 0;
1397 if (rc) {
1398 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
1399 __func__, rc);
1400 goto out;
1401 }
1402 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
1403 /* fill in remaining high mode bits e.g. SUID, VTX */
1404 cifs_sfu_mode(fattr, full_path, cifs_sb, xid);
1405 else if (!(tcon->posix_extensions))
1406 /* clear write bits if ATTR_READONLY is set */
1407 if (fattr->cf_cifsattrs & ATTR_READONLY)
1408 fattr->cf_mode &= ~(S_IWUGO);
1409
1410
1411 /* check for Minshall+French symlinks */
1412 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
1413 tmprc = check_mf_symlink(xid, tcon, cifs_sb, fattr, full_path);
1414 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
1415 }
1416
1417 out:
1418 cifs_buf_release(smb1_backup_rsp_buf);
1419 cifs_put_tlink(tlink);
1420 cifs_free_open_info(&tmp_data);
1421 return rc;
1422 }
1423
cifs_get_inode_info(struct inode ** inode,const char * full_path,struct cifs_open_info_data * data,struct super_block * sb,int xid,const struct cifs_fid * fid)1424 int cifs_get_inode_info(struct inode **inode,
1425 const char *full_path,
1426 struct cifs_open_info_data *data,
1427 struct super_block *sb, int xid,
1428 const struct cifs_fid *fid)
1429 {
1430 struct cifs_fattr fattr = {};
1431 int rc;
1432
1433 if (!data && is_inode_cache_good(*inode)) {
1434 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
1435 return 0;
1436 }
1437
1438 rc = cifs_get_fattr(data, sb, xid, fid, &fattr, inode, full_path);
1439 if (rc)
1440 goto out;
1441
1442 rc = update_inode_info(sb, &fattr, inode);
1443 out:
1444 kfree(fattr.cf_symlink_target);
1445 return rc;
1446 }
1447
smb311_posix_get_fattr(struct cifs_open_info_data * data,struct cifs_fattr * fattr,const char * full_path,struct super_block * sb,const unsigned int xid)1448 static int smb311_posix_get_fattr(struct cifs_open_info_data *data,
1449 struct cifs_fattr *fattr,
1450 const char *full_path,
1451 struct super_block *sb,
1452 const unsigned int xid)
1453 {
1454 struct cifs_open_info_data tmp_data = {};
1455 struct TCP_Server_Info *server;
1456 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1457 struct cifs_tcon *tcon;
1458 struct tcon_link *tlink;
1459 int tmprc;
1460 int rc = 0;
1461
1462 tlink = cifs_sb_tlink(cifs_sb);
1463 if (IS_ERR(tlink))
1464 return PTR_ERR(tlink);
1465 tcon = tlink_tcon(tlink);
1466 server = tcon->ses->server;
1467
1468 /*
1469 * 1. Fetch file metadata if not provided (data)
1470 */
1471 if (!data) {
1472 rc = server->ops->query_path_info(xid, tcon, cifs_sb,
1473 full_path, &tmp_data);
1474 data = &tmp_data;
1475 }
1476
1477 /*
1478 * 2. Convert it to internal cifs metadata (fattr)
1479 */
1480
1481 switch (rc) {
1482 case 0:
1483 if (cifs_open_data_reparse(data)) {
1484 rc = reparse_info_to_fattr(data, sb, xid, tcon,
1485 full_path, fattr);
1486 } else {
1487 smb311_posix_info_to_fattr(fattr, data, sb);
1488 }
1489 break;
1490 case -EREMOTE:
1491 /* DFS link, no metadata available on this server */
1492 cifs_create_junction_fattr(fattr, sb);
1493 rc = 0;
1494 break;
1495 case -EACCES:
1496 /*
1497 * For SMB2 and later the backup intent flag
1498 * is already sent if needed on open and there
1499 * is no path based FindFirst operation to use
1500 * to retry with so nothing we can do, bail out
1501 */
1502 goto out;
1503 default:
1504 cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc);
1505 goto out;
1506 }
1507
1508 /*
1509 * 3. Tweak fattr based on mount options
1510 */
1511 /* check for Minshall+French symlinks */
1512 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
1513 tmprc = check_mf_symlink(xid, tcon, cifs_sb, fattr, full_path);
1514 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
1515 }
1516
1517 out:
1518 cifs_put_tlink(tlink);
1519 cifs_free_open_info(data);
1520 return rc;
1521 }
1522
smb311_posix_get_inode_info(struct inode ** inode,const char * full_path,struct cifs_open_info_data * data,struct super_block * sb,const unsigned int xid)1523 int smb311_posix_get_inode_info(struct inode **inode,
1524 const char *full_path,
1525 struct cifs_open_info_data *data,
1526 struct super_block *sb,
1527 const unsigned int xid)
1528 {
1529 struct cifs_fattr fattr = {};
1530 int rc;
1531
1532 if (!data && is_inode_cache_good(*inode)) {
1533 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
1534 return 0;
1535 }
1536
1537 rc = smb311_posix_get_fattr(data, &fattr, full_path, sb, xid);
1538 if (rc)
1539 goto out;
1540
1541 rc = update_inode_info(sb, &fattr, inode);
1542 if (!rc && fattr.cf_flags & CIFS_FATTR_DELETE_PENDING)
1543 cifs_mark_open_handles_for_deleted_file(*inode, full_path);
1544 out:
1545 kfree(fattr.cf_symlink_target);
1546 return rc;
1547 }
1548
1549 static const struct inode_operations cifs_ipc_inode_ops = {
1550 .lookup = cifs_lookup,
1551 };
1552
1553 static int
cifs_find_inode(struct inode * inode,void * opaque)1554 cifs_find_inode(struct inode *inode, void *opaque)
1555 {
1556 struct cifs_fattr *fattr = opaque;
1557
1558 /* [!] The compared values must be the same in struct cifs_fscache_inode_key. */
1559
1560 /* don't match inode with different uniqueid */
1561 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
1562 return 0;
1563
1564 /* use createtime like an i_generation field */
1565 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
1566 return 0;
1567
1568 /* don't match inode of different type */
1569 if (inode_wrong_type(inode, fattr->cf_mode))
1570 return 0;
1571
1572 /* if it's not a directory or has no dentries, then flag it */
1573 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
1574 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
1575
1576 return 1;
1577 }
1578
1579 static int
cifs_init_inode(struct inode * inode,void * opaque)1580 cifs_init_inode(struct inode *inode, void *opaque)
1581 {
1582 struct cifs_fattr *fattr = opaque;
1583
1584 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
1585 CIFS_I(inode)->createtime = fattr->cf_createtime;
1586 return 0;
1587 }
1588
1589 /*
1590 * walk dentry list for an inode and report whether it has aliases that
1591 * are hashed. We use this to determine if a directory inode can actually
1592 * be used.
1593 */
1594 static bool
inode_has_hashed_dentries(struct inode * inode)1595 inode_has_hashed_dentries(struct inode *inode)
1596 {
1597 struct dentry *dentry;
1598
1599 spin_lock(&inode->i_lock);
1600 hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
1601 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
1602 spin_unlock(&inode->i_lock);
1603 return true;
1604 }
1605 }
1606 spin_unlock(&inode->i_lock);
1607 return false;
1608 }
1609
1610 /* Given fattrs, get a corresponding inode */
1611 struct inode *
cifs_iget(struct super_block * sb,struct cifs_fattr * fattr)1612 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
1613 {
1614 unsigned long hash;
1615 struct inode *inode;
1616
1617 retry_iget5_locked:
1618 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
1619
1620 /* hash down to 32-bits on 32-bit arch */
1621 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
1622
1623 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
1624 if (inode) {
1625 /* was there a potentially problematic inode collision? */
1626 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
1627 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
1628
1629 if (inode_has_hashed_dentries(inode)) {
1630 cifs_autodisable_serverino(CIFS_SB(sb));
1631 iput(inode);
1632 fattr->cf_uniqueid = iunique(sb, ROOT_I);
1633 goto retry_iget5_locked;
1634 }
1635 }
1636
1637 /* can't fail - see cifs_find_inode() */
1638 cifs_fattr_to_inode(inode, fattr, false);
1639 if (sb->s_flags & SB_NOATIME)
1640 inode->i_flags |= S_NOATIME | S_NOCMTIME;
1641 if (inode->i_state & I_NEW) {
1642 inode->i_ino = hash;
1643 cifs_fscache_get_inode_cookie(inode);
1644 unlock_new_inode(inode);
1645 }
1646 }
1647
1648 return inode;
1649 }
1650
1651 /* gets root inode */
cifs_root_iget(struct super_block * sb)1652 struct inode *cifs_root_iget(struct super_block *sb)
1653 {
1654 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1655 struct cifs_fattr fattr = {};
1656 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1657 struct inode *inode = NULL;
1658 unsigned int xid;
1659 char *path = NULL;
1660 int len;
1661 int rc;
1662
1663 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
1664 && cifs_sb->prepath) {
1665 len = strlen(cifs_sb->prepath);
1666 path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
1667 if (path == NULL)
1668 return ERR_PTR(-ENOMEM);
1669 path[0] = '/';
1670 memcpy(path+1, cifs_sb->prepath, len);
1671 } else {
1672 path = kstrdup("", GFP_KERNEL);
1673 if (path == NULL)
1674 return ERR_PTR(-ENOMEM);
1675 }
1676
1677 xid = get_xid();
1678 if (tcon->unix_ext) {
1679 rc = cifs_get_unix_fattr(path, sb, &fattr, &inode, xid);
1680 /* some servers mistakenly claim POSIX support */
1681 if (rc != -EOPNOTSUPP)
1682 goto iget_root;
1683 cifs_dbg(VFS, "server does not support POSIX extensions\n");
1684 tcon->unix_ext = false;
1685 }
1686
1687 convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
1688 if (tcon->posix_extensions)
1689 rc = smb311_posix_get_fattr(NULL, &fattr, path, sb, xid);
1690 else
1691 rc = cifs_get_fattr(NULL, sb, xid, NULL, &fattr, &inode, path);
1692
1693 iget_root:
1694 if (!rc) {
1695 if (fattr.cf_flags & CIFS_FATTR_JUNCTION) {
1696 fattr.cf_flags &= ~CIFS_FATTR_JUNCTION;
1697 cifs_autodisable_serverino(cifs_sb);
1698 }
1699 inode = cifs_iget(sb, &fattr);
1700 }
1701
1702 if (!inode) {
1703 inode = ERR_PTR(rc);
1704 goto out;
1705 }
1706
1707 if (!rc && fattr.cf_flags & CIFS_FATTR_DELETE_PENDING)
1708 cifs_mark_open_handles_for_deleted_file(inode, path);
1709
1710 if (rc && tcon->pipe) {
1711 cifs_dbg(FYI, "ipc connection - fake read inode\n");
1712 spin_lock(&inode->i_lock);
1713 inode->i_mode |= S_IFDIR;
1714 set_nlink(inode, 2);
1715 inode->i_op = &cifs_ipc_inode_ops;
1716 inode->i_fop = &simple_dir_operations;
1717 inode->i_uid = cifs_sb->ctx->linux_uid;
1718 inode->i_gid = cifs_sb->ctx->linux_gid;
1719 spin_unlock(&inode->i_lock);
1720 } else if (rc) {
1721 iget_failed(inode);
1722 inode = ERR_PTR(rc);
1723 }
1724
1725 out:
1726 kfree(path);
1727 free_xid(xid);
1728 kfree(fattr.cf_symlink_target);
1729 return inode;
1730 }
1731
1732 int
cifs_set_file_info(struct inode * inode,struct iattr * attrs,unsigned int xid,const char * full_path,__u32 dosattr)1733 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1734 const char *full_path, __u32 dosattr)
1735 {
1736 bool set_time = false;
1737 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1738 struct TCP_Server_Info *server;
1739 FILE_BASIC_INFO info_buf;
1740
1741 if (attrs == NULL)
1742 return -EINVAL;
1743
1744 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1745 if (!server->ops->set_file_info)
1746 return -ENOSYS;
1747
1748 info_buf.Pad = 0;
1749
1750 if (attrs->ia_valid & ATTR_ATIME) {
1751 set_time = true;
1752 info_buf.LastAccessTime =
1753 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1754 } else
1755 info_buf.LastAccessTime = 0;
1756
1757 if (attrs->ia_valid & ATTR_MTIME) {
1758 set_time = true;
1759 info_buf.LastWriteTime =
1760 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1761 } else
1762 info_buf.LastWriteTime = 0;
1763
1764 /*
1765 * Samba throws this field away, but windows may actually use it.
1766 * Do not set ctime unless other time stamps are changed explicitly
1767 * (i.e. by utimes()) since we would then have a mix of client and
1768 * server times.
1769 */
1770 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1771 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1772 info_buf.ChangeTime =
1773 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1774 } else
1775 info_buf.ChangeTime = 0;
1776
1777 info_buf.CreationTime = 0; /* don't change */
1778 info_buf.Attributes = cpu_to_le32(dosattr);
1779
1780 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1781 }
1782
1783 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1784 /*
1785 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1786 * and rename it to a random name that hopefully won't conflict with
1787 * anything else.
1788 */
1789 int
cifs_rename_pending_delete(const char * full_path,struct dentry * dentry,const unsigned int xid)1790 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1791 const unsigned int xid)
1792 {
1793 int oplock = 0;
1794 int rc;
1795 struct cifs_fid fid;
1796 struct cifs_open_parms oparms;
1797 struct inode *inode = d_inode(dentry);
1798 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1799 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1800 struct tcon_link *tlink;
1801 struct cifs_tcon *tcon;
1802 __u32 dosattr, origattr;
1803 FILE_BASIC_INFO *info_buf = NULL;
1804
1805 tlink = cifs_sb_tlink(cifs_sb);
1806 if (IS_ERR(tlink))
1807 return PTR_ERR(tlink);
1808 tcon = tlink_tcon(tlink);
1809
1810 /*
1811 * We cannot rename the file if the server doesn't support
1812 * CAP_INFOLEVEL_PASSTHRU
1813 */
1814 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1815 rc = -EBUSY;
1816 goto out;
1817 }
1818
1819 oparms = (struct cifs_open_parms) {
1820 .tcon = tcon,
1821 .cifs_sb = cifs_sb,
1822 .desired_access = DELETE | FILE_WRITE_ATTRIBUTES,
1823 .create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR),
1824 .disposition = FILE_OPEN,
1825 .path = full_path,
1826 .fid = &fid,
1827 };
1828
1829 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1830 if (rc != 0)
1831 goto out;
1832
1833 origattr = cifsInode->cifsAttrs;
1834 if (origattr == 0)
1835 origattr |= ATTR_NORMAL;
1836
1837 dosattr = origattr & ~ATTR_READONLY;
1838 if (dosattr == 0)
1839 dosattr |= ATTR_NORMAL;
1840 dosattr |= ATTR_HIDDEN;
1841
1842 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1843 if (dosattr != origattr) {
1844 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1845 if (info_buf == NULL) {
1846 rc = -ENOMEM;
1847 goto out_close;
1848 }
1849 info_buf->Attributes = cpu_to_le32(dosattr);
1850 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1851 current->tgid);
1852 /* although we would like to mark the file hidden
1853 if that fails we will still try to rename it */
1854 if (!rc)
1855 cifsInode->cifsAttrs = dosattr;
1856 else
1857 dosattr = origattr; /* since not able to change them */
1858 }
1859
1860 /* rename the file */
1861 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1862 cifs_sb->local_nls,
1863 cifs_remap(cifs_sb));
1864 if (rc != 0) {
1865 rc = -EBUSY;
1866 goto undo_setattr;
1867 }
1868
1869 /* try to set DELETE_ON_CLOSE */
1870 if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1871 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1872 current->tgid);
1873 /*
1874 * some samba versions return -ENOENT when we try to set the
1875 * file disposition here. Likely a samba bug, but work around
1876 * it for now. This means that some cifsXXX files may hang
1877 * around after they shouldn't.
1878 *
1879 * BB: remove this hack after more servers have the fix
1880 */
1881 if (rc == -ENOENT)
1882 rc = 0;
1883 else if (rc != 0) {
1884 rc = -EBUSY;
1885 goto undo_rename;
1886 }
1887 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1888 }
1889
1890 out_close:
1891 CIFSSMBClose(xid, tcon, fid.netfid);
1892 out:
1893 kfree(info_buf);
1894 cifs_put_tlink(tlink);
1895 return rc;
1896
1897 /*
1898 * reset everything back to the original state. Don't bother
1899 * dealing with errors here since we can't do anything about
1900 * them anyway.
1901 */
1902 undo_rename:
1903 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1904 cifs_sb->local_nls, cifs_remap(cifs_sb));
1905 undo_setattr:
1906 if (dosattr != origattr) {
1907 info_buf->Attributes = cpu_to_le32(origattr);
1908 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1909 current->tgid))
1910 cifsInode->cifsAttrs = origattr;
1911 }
1912
1913 goto out_close;
1914 }
1915 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1916
1917 /* copied from fs/nfs/dir.c with small changes */
1918 static void
cifs_drop_nlink(struct inode * inode)1919 cifs_drop_nlink(struct inode *inode)
1920 {
1921 spin_lock(&inode->i_lock);
1922 if (inode->i_nlink > 0)
1923 drop_nlink(inode);
1924 spin_unlock(&inode->i_lock);
1925 }
1926
1927 /*
1928 * If d_inode(dentry) is null (usually meaning the cached dentry
1929 * is a negative dentry) then we would attempt a standard SMB delete, but
1930 * if that fails we can not attempt the fall back mechanisms on EACCES
1931 * but will return the EACCES to the caller. Note that the VFS does not call
1932 * unlink on negative dentries currently.
1933 */
__cifs_unlink(struct inode * dir,struct dentry * dentry,bool sillyrename)1934 static int __cifs_unlink(struct inode *dir, struct dentry *dentry, bool sillyrename)
1935 {
1936 int rc = 0;
1937 unsigned int xid;
1938 const char *full_path;
1939 void *page;
1940 struct inode *inode = d_inode(dentry);
1941 struct cifsInodeInfo *cifs_inode;
1942 struct super_block *sb = dir->i_sb;
1943 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1944 struct tcon_link *tlink;
1945 struct cifs_tcon *tcon;
1946 __u32 dosattr = 0, origattr = 0;
1947 struct TCP_Server_Info *server;
1948 struct iattr *attrs = NULL;
1949 bool rehash = false;
1950
1951 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1952
1953 if (unlikely(cifs_forced_shutdown(cifs_sb)))
1954 return -EIO;
1955
1956 /* Unhash dentry in advance to prevent any concurrent opens */
1957 spin_lock(&dentry->d_lock);
1958 if (!d_unhashed(dentry)) {
1959 __d_drop(dentry);
1960 rehash = true;
1961 }
1962 spin_unlock(&dentry->d_lock);
1963
1964 tlink = cifs_sb_tlink(cifs_sb);
1965 if (IS_ERR(tlink))
1966 return PTR_ERR(tlink);
1967 tcon = tlink_tcon(tlink);
1968 server = tcon->ses->server;
1969
1970 xid = get_xid();
1971 page = alloc_dentry_path();
1972
1973 if (tcon->nodelete) {
1974 rc = -EACCES;
1975 goto unlink_out;
1976 }
1977
1978 /* Unlink can be called from rename so we can not take the
1979 * sb->s_vfs_rename_mutex here */
1980 full_path = build_path_from_dentry(dentry, page);
1981 if (IS_ERR(full_path)) {
1982 rc = PTR_ERR(full_path);
1983 goto unlink_out;
1984 }
1985
1986 netfs_wait_for_outstanding_io(inode);
1987 cifs_close_deferred_file_under_dentry(tcon, dentry);
1988 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1989 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1990 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1991 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1992 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1993 cifs_remap(cifs_sb));
1994 cifs_dbg(FYI, "posix del rc %d\n", rc);
1995 if ((rc == 0) || (rc == -ENOENT))
1996 goto psx_del_no_retry;
1997 }
1998 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1999
2000 retry_std_delete:
2001 if (!server->ops->unlink) {
2002 rc = -ENOSYS;
2003 goto psx_del_no_retry;
2004 }
2005
2006 /* For SMB2+, if the file is open, we always perform a silly rename.
2007 *
2008 * We check for d_count() right after calling
2009 * cifs_close_deferred_file_under_dentry() to make sure that the
2010 * dentry's refcount gets dropped in case the file had any deferred
2011 * close.
2012 */
2013 if (!sillyrename && server->vals->protocol_id > SMB10_PROT_ID) {
2014 spin_lock(&dentry->d_lock);
2015 if (d_count(dentry) > 1)
2016 sillyrename = true;
2017 spin_unlock(&dentry->d_lock);
2018 }
2019
2020 if (sillyrename)
2021 rc = -EBUSY;
2022 else
2023 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb, dentry);
2024
2025 psx_del_no_retry:
2026 if (!rc) {
2027 if (inode) {
2028 cifs_mark_open_handles_for_deleted_file(inode, full_path);
2029 cifs_drop_nlink(inode);
2030 }
2031 } else if (rc == -ENOENT) {
2032 if (simple_positive(dentry))
2033 d_delete(dentry);
2034 } else if (rc == -EBUSY) {
2035 if (server->ops->rename_pending_delete) {
2036 rc = server->ops->rename_pending_delete(full_path,
2037 dentry, xid);
2038 if (rc == 0) {
2039 cifs_mark_open_handles_for_deleted_file(inode, full_path);
2040 cifs_drop_nlink(inode);
2041 }
2042 }
2043 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
2044 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
2045 if (attrs == NULL) {
2046 rc = -ENOMEM;
2047 goto out_reval;
2048 }
2049
2050 /* try to reset dos attributes */
2051 cifs_inode = CIFS_I(inode);
2052 origattr = cifs_inode->cifsAttrs;
2053 if (origattr == 0)
2054 origattr |= ATTR_NORMAL;
2055 dosattr = origattr & ~ATTR_READONLY;
2056 if (dosattr == 0)
2057 dosattr |= ATTR_NORMAL;
2058 dosattr |= ATTR_HIDDEN;
2059
2060 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2061 if (rc != 0)
2062 goto out_reval;
2063
2064 goto retry_std_delete;
2065 }
2066
2067 /* undo the setattr if we errored out and it's needed */
2068 if (rc != 0 && dosattr != 0)
2069 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
2070
2071 out_reval:
2072 if (inode) {
2073 cifs_inode = CIFS_I(inode);
2074 cifs_inode->time = 0; /* will force revalidate to get info
2075 when needed */
2076 inode_set_ctime_current(inode);
2077 }
2078 inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
2079 cifs_inode = CIFS_I(dir);
2080 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
2081 unlink_out:
2082 free_dentry_path(page);
2083 kfree(attrs);
2084 free_xid(xid);
2085 cifs_put_tlink(tlink);
2086 if (rehash)
2087 d_rehash(dentry);
2088 return rc;
2089 }
2090
cifs_unlink(struct inode * dir,struct dentry * dentry)2091 int cifs_unlink(struct inode *dir, struct dentry *dentry)
2092 {
2093 return __cifs_unlink(dir, dentry, false);
2094 }
2095
2096 static int
cifs_mkdir_qinfo(struct inode * parent,struct dentry * dentry,umode_t mode,const char * full_path,struct cifs_sb_info * cifs_sb,struct cifs_tcon * tcon,const unsigned int xid)2097 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
2098 const char *full_path, struct cifs_sb_info *cifs_sb,
2099 struct cifs_tcon *tcon, const unsigned int xid)
2100 {
2101 int rc = 0;
2102 struct inode *inode = NULL;
2103
2104 if (tcon->posix_extensions) {
2105 rc = smb311_posix_get_inode_info(&inode, full_path,
2106 NULL, parent->i_sb, xid);
2107 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2108 } else if (tcon->unix_ext) {
2109 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
2110 xid);
2111 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2112 } else {
2113 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
2114 xid, NULL);
2115 }
2116
2117 if (rc)
2118 return rc;
2119
2120 if (!S_ISDIR(inode->i_mode)) {
2121 /*
2122 * mkdir succeeded, but another client has managed to remove the
2123 * sucker and replace it with non-directory. Return success,
2124 * but don't leave the child in dcache.
2125 */
2126 iput(inode);
2127 d_drop(dentry);
2128 return 0;
2129 }
2130 /*
2131 * setting nlink not necessary except in cases where we failed to get it
2132 * from the server or was set bogus. Also, since this is a brand new
2133 * inode, no need to grab the i_lock before setting the i_nlink.
2134 */
2135 if (inode->i_nlink < 2)
2136 set_nlink(inode, 2);
2137 mode &= ~current_umask();
2138 /* must turn on setgid bit if parent dir has it */
2139 if (parent->i_mode & S_ISGID)
2140 mode |= S_ISGID;
2141
2142 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2143 if (tcon->unix_ext) {
2144 struct cifs_unix_set_info_args args = {
2145 .mode = mode,
2146 .ctime = NO_CHANGE_64,
2147 .atime = NO_CHANGE_64,
2148 .mtime = NO_CHANGE_64,
2149 .device = 0,
2150 };
2151 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
2152 args.uid = current_fsuid();
2153 if (parent->i_mode & S_ISGID)
2154 args.gid = parent->i_gid;
2155 else
2156 args.gid = current_fsgid();
2157 } else {
2158 args.uid = INVALID_UID; /* no change */
2159 args.gid = INVALID_GID; /* no change */
2160 }
2161 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
2162 cifs_sb->local_nls,
2163 cifs_remap(cifs_sb));
2164 } else {
2165 #else
2166 {
2167 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2168 struct TCP_Server_Info *server = tcon->ses->server;
2169 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2170 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
2171 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
2172 tcon, xid);
2173 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
2174 inode->i_mode = (mode | S_IFDIR);
2175
2176 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
2177 inode->i_uid = current_fsuid();
2178 if (inode->i_mode & S_ISGID)
2179 inode->i_gid = parent->i_gid;
2180 else
2181 inode->i_gid = current_fsgid();
2182 }
2183 }
2184 d_instantiate(dentry, inode);
2185 return 0;
2186 }
2187
2188 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2189 static int
2190 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
2191 const char *full_path, struct cifs_sb_info *cifs_sb,
2192 struct cifs_tcon *tcon, const unsigned int xid)
2193 {
2194 int rc = 0;
2195 u32 oplock = 0;
2196 FILE_UNIX_BASIC_INFO *info = NULL;
2197 struct inode *newinode = NULL;
2198 struct cifs_fattr fattr;
2199
2200 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
2201 if (info == NULL) {
2202 rc = -ENOMEM;
2203 goto posix_mkdir_out;
2204 }
2205
2206 mode &= ~current_umask();
2207 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
2208 NULL /* netfid */, info, &oplock, full_path,
2209 cifs_sb->local_nls, cifs_remap(cifs_sb));
2210 if (rc == -EOPNOTSUPP)
2211 goto posix_mkdir_out;
2212 else if (rc) {
2213 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
2214 d_drop(dentry);
2215 goto posix_mkdir_out;
2216 }
2217
2218 if (info->Type == cpu_to_le32(-1))
2219 /* no return info, go query for it */
2220 goto posix_mkdir_get_info;
2221 /*
2222 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
2223 * need to set uid/gid.
2224 */
2225
2226 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
2227 cifs_fill_uniqueid(inode->i_sb, &fattr);
2228 newinode = cifs_iget(inode->i_sb, &fattr);
2229 if (!newinode)
2230 goto posix_mkdir_get_info;
2231
2232 d_instantiate(dentry, newinode);
2233
2234 #ifdef CONFIG_CIFS_DEBUG2
2235 cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
2236 dentry, dentry, newinode);
2237
2238 if (newinode->i_nlink != 2)
2239 cifs_dbg(FYI, "unexpected number of links %d\n",
2240 newinode->i_nlink);
2241 #endif
2242
2243 posix_mkdir_out:
2244 kfree(info);
2245 return rc;
2246 posix_mkdir_get_info:
2247 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
2248 xid);
2249 goto posix_mkdir_out;
2250 }
2251 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2252
2253 struct dentry *cifs_mkdir(struct mnt_idmap *idmap, struct inode *inode,
2254 struct dentry *direntry, umode_t mode)
2255 {
2256 int rc = 0;
2257 unsigned int xid;
2258 struct cifs_sb_info *cifs_sb;
2259 struct tcon_link *tlink;
2260 struct cifs_tcon *tcon;
2261 struct TCP_Server_Info *server;
2262 const char *full_path;
2263 void *page;
2264
2265 cifs_dbg(FYI, "In cifs_mkdir, mode = %04ho inode = 0x%p\n",
2266 mode, inode);
2267
2268 cifs_sb = CIFS_SB(inode->i_sb);
2269 if (unlikely(cifs_forced_shutdown(cifs_sb)))
2270 return ERR_PTR(-EIO);
2271 tlink = cifs_sb_tlink(cifs_sb);
2272 if (IS_ERR(tlink))
2273 return ERR_CAST(tlink);
2274 tcon = tlink_tcon(tlink);
2275
2276 xid = get_xid();
2277
2278 page = alloc_dentry_path();
2279 full_path = build_path_from_dentry(direntry, page);
2280 if (IS_ERR(full_path)) {
2281 rc = PTR_ERR(full_path);
2282 goto mkdir_out;
2283 }
2284
2285 server = tcon->ses->server;
2286
2287 if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) {
2288 rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,
2289 cifs_sb);
2290 d_drop(direntry); /* for time being always refresh inode info */
2291 goto mkdir_out;
2292 }
2293
2294 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2295 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
2296 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
2297 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
2298 tcon, xid);
2299 if (rc != -EOPNOTSUPP)
2300 goto mkdir_out;
2301 }
2302 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2303
2304 if (!server->ops->mkdir) {
2305 rc = -ENOSYS;
2306 goto mkdir_out;
2307 }
2308
2309 /* BB add setting the equivalent of mode via CreateX w/ACLs */
2310 rc = server->ops->mkdir(xid, inode, mode, tcon, full_path, cifs_sb);
2311 if (rc) {
2312 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
2313 d_drop(direntry);
2314 goto mkdir_out;
2315 }
2316
2317 /* TODO: skip this for smb2/smb3 */
2318 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
2319 xid);
2320 mkdir_out:
2321 /*
2322 * Force revalidate to get parent dir info when needed since cached
2323 * attributes are invalid now.
2324 */
2325 CIFS_I(inode)->time = 0;
2326 free_dentry_path(page);
2327 free_xid(xid);
2328 cifs_put_tlink(tlink);
2329 return ERR_PTR(rc);
2330 }
2331
2332 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
2333 {
2334 int rc = 0;
2335 unsigned int xid;
2336 struct cifs_sb_info *cifs_sb;
2337 struct tcon_link *tlink;
2338 struct cifs_tcon *tcon;
2339 struct TCP_Server_Info *server;
2340 const char *full_path;
2341 void *page = alloc_dentry_path();
2342 struct cifsInodeInfo *cifsInode;
2343
2344 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
2345
2346 xid = get_xid();
2347
2348 full_path = build_path_from_dentry(direntry, page);
2349 if (IS_ERR(full_path)) {
2350 rc = PTR_ERR(full_path);
2351 goto rmdir_exit;
2352 }
2353
2354 cifs_sb = CIFS_SB(inode->i_sb);
2355 if (unlikely(cifs_forced_shutdown(cifs_sb))) {
2356 rc = -EIO;
2357 goto rmdir_exit;
2358 }
2359
2360 tlink = cifs_sb_tlink(cifs_sb);
2361 if (IS_ERR(tlink)) {
2362 rc = PTR_ERR(tlink);
2363 goto rmdir_exit;
2364 }
2365 tcon = tlink_tcon(tlink);
2366 server = tcon->ses->server;
2367
2368 if (!server->ops->rmdir) {
2369 rc = -ENOSYS;
2370 cifs_put_tlink(tlink);
2371 goto rmdir_exit;
2372 }
2373
2374 if (tcon->nodelete) {
2375 rc = -EACCES;
2376 cifs_put_tlink(tlink);
2377 goto rmdir_exit;
2378 }
2379
2380 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
2381 cifs_put_tlink(tlink);
2382
2383 cifsInode = CIFS_I(d_inode(direntry));
2384
2385 if (!rc) {
2386 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
2387 spin_lock(&d_inode(direntry)->i_lock);
2388 i_size_write(d_inode(direntry), 0);
2389 clear_nlink(d_inode(direntry));
2390 spin_unlock(&d_inode(direntry)->i_lock);
2391 }
2392
2393 /* force revalidate to go get info when needed */
2394 cifsInode->time = 0;
2395
2396 cifsInode = CIFS_I(inode);
2397 /*
2398 * Force revalidate to get parent dir info when needed since cached
2399 * attributes are invalid now.
2400 */
2401 cifsInode->time = 0;
2402
2403 inode_set_ctime_current(d_inode(direntry));
2404 inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
2405
2406 rmdir_exit:
2407 free_dentry_path(page);
2408 free_xid(xid);
2409 return rc;
2410 }
2411
2412 static int
2413 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
2414 const char *from_path, struct dentry *to_dentry,
2415 const char *to_path)
2416 {
2417 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
2418 struct tcon_link *tlink;
2419 struct cifs_tcon *tcon;
2420 struct TCP_Server_Info *server;
2421 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2422 struct cifs_fid fid;
2423 struct cifs_open_parms oparms;
2424 int oplock;
2425 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2426 int rc;
2427
2428 tlink = cifs_sb_tlink(cifs_sb);
2429 if (IS_ERR(tlink))
2430 return PTR_ERR(tlink);
2431 tcon = tlink_tcon(tlink);
2432 server = tcon->ses->server;
2433
2434 if (!server->ops->rename) {
2435 rc = -ENOSYS;
2436 goto do_rename_exit;
2437 }
2438
2439 /* try path-based rename first */
2440 rc = server->ops->rename(xid, tcon, from_dentry,
2441 from_path, to_path, cifs_sb);
2442
2443 /*
2444 * Don't bother with rename by filehandle unless file is busy and
2445 * source. Note that cross directory moves do not work with
2446 * rename by filehandle to various Windows servers.
2447 */
2448 if (rc == 0 || rc != -EBUSY)
2449 goto do_rename_exit;
2450
2451 /* Don't fall back to using SMB on SMB 2+ mount */
2452 if (server->vals->protocol_id != 0)
2453 goto do_rename_exit;
2454
2455 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2456 /* open-file renames don't work across directories */
2457 if (to_dentry->d_parent != from_dentry->d_parent)
2458 goto do_rename_exit;
2459
2460 /*
2461 * CIFSSMBRenameOpenFile() uses SMB_SET_FILE_RENAME_INFORMATION
2462 * which is SMB PASSTHROUGH level.
2463 */
2464 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU))
2465 goto do_rename_exit;
2466
2467 oparms = (struct cifs_open_parms) {
2468 .tcon = tcon,
2469 .cifs_sb = cifs_sb,
2470 /* open the file to be renamed -- we need DELETE perms */
2471 .desired_access = DELETE,
2472 .create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR),
2473 .disposition = FILE_OPEN,
2474 .path = from_path,
2475 .fid = &fid,
2476 };
2477
2478 rc = CIFS_open(xid, &oparms, &oplock, NULL);
2479 if (rc == 0) {
2480 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
2481 (const char *) to_dentry->d_name.name,
2482 cifs_sb->local_nls, cifs_remap(cifs_sb));
2483 CIFSSMBClose(xid, tcon, fid.netfid);
2484 }
2485 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2486 do_rename_exit:
2487 if (rc == 0) {
2488 d_move(from_dentry, to_dentry);
2489 /* Force a new lookup */
2490 d_drop(from_dentry);
2491 }
2492 cifs_put_tlink(tlink);
2493 return rc;
2494 }
2495
2496 int
2497 cifs_rename2(struct mnt_idmap *idmap, struct inode *source_dir,
2498 struct dentry *source_dentry, struct inode *target_dir,
2499 struct dentry *target_dentry, unsigned int flags)
2500 {
2501 const char *from_name, *to_name;
2502 struct TCP_Server_Info *server;
2503 void *page1, *page2;
2504 struct cifs_sb_info *cifs_sb;
2505 struct tcon_link *tlink;
2506 struct cifs_tcon *tcon;
2507 bool rehash = false;
2508 unsigned int xid;
2509 int rc, tmprc;
2510 int retry_count = 0;
2511 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
2512 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2513 FILE_UNIX_BASIC_INFO *info_buf_target;
2514 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2515
2516 if (flags & ~RENAME_NOREPLACE)
2517 return -EINVAL;
2518
2519 cifs_sb = CIFS_SB(source_dir->i_sb);
2520 if (unlikely(cifs_forced_shutdown(cifs_sb)))
2521 return -EIO;
2522
2523 /*
2524 * Prevent any concurrent opens on the target by unhashing the dentry.
2525 * VFS already unhashes the target when renaming directories.
2526 */
2527 if (d_is_positive(target_dentry) && !d_is_dir(target_dentry)) {
2528 if (!d_unhashed(target_dentry)) {
2529 d_drop(target_dentry);
2530 rehash = true;
2531 }
2532 }
2533
2534 tlink = cifs_sb_tlink(cifs_sb);
2535 if (IS_ERR(tlink))
2536 return PTR_ERR(tlink);
2537 tcon = tlink_tcon(tlink);
2538 server = tcon->ses->server;
2539
2540 page1 = alloc_dentry_path();
2541 page2 = alloc_dentry_path();
2542 xid = get_xid();
2543
2544 from_name = build_path_from_dentry(source_dentry, page1);
2545 if (IS_ERR(from_name)) {
2546 rc = PTR_ERR(from_name);
2547 goto cifs_rename_exit;
2548 }
2549
2550 to_name = build_path_from_dentry(target_dentry, page2);
2551 if (IS_ERR(to_name)) {
2552 rc = PTR_ERR(to_name);
2553 goto cifs_rename_exit;
2554 }
2555
2556 cifs_close_deferred_file_under_dentry(tcon, source_dentry);
2557 if (d_inode(target_dentry) != NULL) {
2558 netfs_wait_for_outstanding_io(d_inode(target_dentry));
2559 cifs_close_deferred_file_under_dentry(tcon, target_dentry);
2560 }
2561
2562 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2563 to_name);
2564
2565 if (rc == -EACCES) {
2566 while (retry_count < 3) {
2567 cifs_close_all_deferred_files(tcon);
2568 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2569 to_name);
2570 if (rc != -EACCES)
2571 break;
2572 retry_count++;
2573 }
2574 }
2575
2576 if (!rc)
2577 rehash = false;
2578 /*
2579 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
2580 */
2581 if (flags & RENAME_NOREPLACE)
2582 goto cifs_rename_exit;
2583
2584 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2585 if (rc == -EEXIST && tcon->unix_ext) {
2586 /*
2587 * Are src and dst hardlinks of same inode? We can only tell
2588 * with unix extensions enabled.
2589 */
2590 info_buf_source =
2591 kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
2592 GFP_KERNEL);
2593 if (info_buf_source == NULL) {
2594 rc = -ENOMEM;
2595 goto cifs_rename_exit;
2596 }
2597
2598 info_buf_target = info_buf_source + 1;
2599 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
2600 info_buf_source,
2601 cifs_sb->local_nls,
2602 cifs_remap(cifs_sb));
2603 if (tmprc != 0)
2604 goto unlink_target;
2605
2606 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
2607 info_buf_target,
2608 cifs_sb->local_nls,
2609 cifs_remap(cifs_sb));
2610
2611 if (tmprc == 0 && (info_buf_source->UniqueId ==
2612 info_buf_target->UniqueId)) {
2613 /* same file, POSIX says that this is a noop */
2614 rc = 0;
2615 goto cifs_rename_exit;
2616 }
2617 }
2618 /*
2619 * else ... BB we could add the same check for Windows by
2620 * checking the UniqueId via FILE_INTERNAL_INFO
2621 */
2622
2623 unlink_target:
2624 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2625 if (d_really_is_positive(target_dentry)) {
2626 if (!rc) {
2627 struct inode *inode = d_inode(target_dentry);
2628 /*
2629 * Samba and ksmbd servers allow renaming a target
2630 * directory that is open, so make sure to update
2631 * ->i_nlink and then mark it as delete pending.
2632 */
2633 if (S_ISDIR(inode->i_mode)) {
2634 drop_cached_dir_by_name(xid, tcon, to_name, cifs_sb);
2635 spin_lock(&inode->i_lock);
2636 i_size_write(inode, 0);
2637 clear_nlink(inode);
2638 spin_unlock(&inode->i_lock);
2639 set_bit(CIFS_INO_DELETE_PENDING, &CIFS_I(inode)->flags);
2640 CIFS_I(inode)->time = 0; /* force reval */
2641 inode_set_ctime_current(inode);
2642 inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
2643 }
2644 } else if (rc == -EACCES || rc == -EEXIST) {
2645 /*
2646 * Rename failed, possibly due to a busy target.
2647 * Retry it by unliking the target first.
2648 */
2649 if (d_is_dir(target_dentry)) {
2650 tmprc = cifs_rmdir(target_dir, target_dentry);
2651 } else {
2652 tmprc = __cifs_unlink(target_dir, target_dentry,
2653 server->vals->protocol_id > SMB10_PROT_ID);
2654 }
2655 if (tmprc) {
2656 /*
2657 * Some servers will return STATUS_ACCESS_DENIED
2658 * or STATUS_DIRECTORY_NOT_EMPTY when failing to
2659 * rename a non-empty directory. Make sure to
2660 * propagate the appropriate error back to
2661 * userspace.
2662 */
2663 if (tmprc == -EEXIST || tmprc == -ENOTEMPTY)
2664 rc = tmprc;
2665 goto cifs_rename_exit;
2666 }
2667 rc = cifs_do_rename(xid, source_dentry, from_name,
2668 target_dentry, to_name);
2669 if (!rc)
2670 rehash = false;
2671 }
2672 }
2673
2674 /* force revalidate to go get info when needed */
2675 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
2676
2677 cifs_rename_exit:
2678 if (rehash)
2679 d_rehash(target_dentry);
2680 kfree(info_buf_source);
2681 free_dentry_path(page2);
2682 free_dentry_path(page1);
2683 free_xid(xid);
2684 cifs_put_tlink(tlink);
2685 return rc;
2686 }
2687
2688 static bool
2689 cifs_dentry_needs_reval(struct dentry *dentry)
2690 {
2691 struct inode *inode = d_inode(dentry);
2692 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2693 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2694 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2695 struct cached_fid *cfid = NULL;
2696
2697 if (test_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags))
2698 return false;
2699 if (cifs_i->time == 0)
2700 return true;
2701
2702 if (CIFS_CACHE_READ(cifs_i))
2703 return false;
2704
2705 if (!lookupCacheEnabled)
2706 return true;
2707
2708 if (!open_cached_dir_by_dentry(tcon, dentry->d_parent, &cfid)) {
2709 if (cifs_i->time > cfid->time) {
2710 close_cached_dir(cfid);
2711 return false;
2712 }
2713 close_cached_dir(cfid);
2714 }
2715 /*
2716 * depending on inode type, check if attribute caching disabled for
2717 * files or directories
2718 */
2719 if (S_ISDIR(inode->i_mode)) {
2720 if (!cifs_sb->ctx->acdirmax)
2721 return true;
2722 if (!time_in_range(jiffies, cifs_i->time,
2723 cifs_i->time + cifs_sb->ctx->acdirmax))
2724 return true;
2725 } else { /* file */
2726 if (!cifs_sb->ctx->acregmax)
2727 return true;
2728 if (!time_in_range(jiffies, cifs_i->time,
2729 cifs_i->time + cifs_sb->ctx->acregmax))
2730 return true;
2731 }
2732
2733 /* hardlinked files w/ noserverino get "special" treatment */
2734 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
2735 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
2736 return true;
2737
2738 return false;
2739 }
2740
2741 /**
2742 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
2743 *
2744 * @key: currently unused
2745 * @mode: the task state to sleep in
2746 */
2747 static int
2748 cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
2749 {
2750 schedule();
2751 if (signal_pending_state(mode, current))
2752 return -ERESTARTSYS;
2753 return 0;
2754 }
2755
2756 int
2757 cifs_revalidate_mapping(struct inode *inode)
2758 {
2759 int rc;
2760 struct cifsInodeInfo *cifs_inode = CIFS_I(inode);
2761 unsigned long *flags = &cifs_inode->flags;
2762 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2763
2764 /* swapfiles are not supposed to be shared */
2765 if (IS_SWAPFILE(inode))
2766 return 0;
2767
2768 rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
2769 TASK_KILLABLE|TASK_FREEZABLE_UNSAFE);
2770 if (rc)
2771 return rc;
2772
2773 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
2774 /* for cache=singleclient, do not invalidate */
2775 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE)
2776 goto skip_invalidate;
2777
2778 cifs_inode->netfs.zero_point = cifs_inode->netfs.remote_i_size;
2779 rc = filemap_invalidate_inode(inode, true, 0, LLONG_MAX);
2780 if (rc) {
2781 cifs_dbg(VFS, "%s: invalidate inode %p failed with rc %d\n",
2782 __func__, inode, rc);
2783 set_bit(CIFS_INO_INVALID_MAPPING, flags);
2784 }
2785 }
2786
2787 skip_invalidate:
2788 clear_bit_unlock(CIFS_INO_LOCK, flags);
2789 smp_mb__after_atomic();
2790 wake_up_bit(flags, CIFS_INO_LOCK);
2791
2792 return rc;
2793 }
2794
2795 int
2796 cifs_zap_mapping(struct inode *inode)
2797 {
2798 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
2799 return cifs_revalidate_mapping(inode);
2800 }
2801
2802 int cifs_revalidate_file_attr(struct file *filp)
2803 {
2804 int rc = 0;
2805 struct dentry *dentry = file_dentry(filp);
2806 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2807 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
2808 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2809
2810 if (!cifs_dentry_needs_reval(dentry))
2811 return rc;
2812
2813 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2814 if (tlink_tcon(cfile->tlink)->unix_ext)
2815 rc = cifs_get_file_info_unix(filp);
2816 else
2817 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2818 rc = cifs_get_file_info(filp);
2819
2820 return rc;
2821 }
2822
2823 int cifs_revalidate_dentry_attr(struct dentry *dentry)
2824 {
2825 unsigned int xid;
2826 int rc = 0;
2827 struct inode *inode = d_inode(dentry);
2828 struct super_block *sb = dentry->d_sb;
2829 const char *full_path;
2830 void *page;
2831 int count = 0;
2832
2833 if (inode == NULL)
2834 return -ENOENT;
2835
2836 if (!cifs_dentry_needs_reval(dentry))
2837 return rc;
2838
2839 xid = get_xid();
2840
2841 page = alloc_dentry_path();
2842 full_path = build_path_from_dentry(dentry, page);
2843 if (IS_ERR(full_path)) {
2844 rc = PTR_ERR(full_path);
2845 goto out;
2846 }
2847
2848 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2849 full_path, inode, icount_read(inode),
2850 dentry, cifs_get_time(dentry), jiffies);
2851
2852 again:
2853 if (cifs_sb_master_tcon(CIFS_SB(sb))->posix_extensions) {
2854 rc = smb311_posix_get_inode_info(&inode, full_path,
2855 NULL, sb, xid);
2856 } else if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext) {
2857 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2858 } else {
2859 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2860 xid, NULL);
2861 }
2862 if (rc == -EAGAIN && count++ < 10)
2863 goto again;
2864 out:
2865 free_dentry_path(page);
2866 free_xid(xid);
2867
2868 return rc;
2869 }
2870
2871 int cifs_revalidate_file(struct file *filp)
2872 {
2873 int rc;
2874 struct inode *inode = file_inode(filp);
2875
2876 rc = cifs_revalidate_file_attr(filp);
2877 if (rc)
2878 return rc;
2879
2880 return cifs_revalidate_mapping(inode);
2881 }
2882
2883 /* revalidate a dentry's inode attributes */
2884 int cifs_revalidate_dentry(struct dentry *dentry)
2885 {
2886 int rc;
2887 struct inode *inode = d_inode(dentry);
2888
2889 rc = cifs_revalidate_dentry_attr(dentry);
2890 if (rc)
2891 return rc;
2892
2893 return cifs_revalidate_mapping(inode);
2894 }
2895
2896 int cifs_getattr(struct mnt_idmap *idmap, const struct path *path,
2897 struct kstat *stat, u32 request_mask, unsigned int flags)
2898 {
2899 struct dentry *dentry = path->dentry;
2900 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2901 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2902 struct inode *inode = d_inode(dentry);
2903 int rc;
2904
2905 if (unlikely(cifs_forced_shutdown(CIFS_SB(inode->i_sb))))
2906 return -EIO;
2907
2908 /*
2909 * We need to be sure that all dirty pages are written and the server
2910 * has actual ctime, mtime and file length.
2911 */
2912 if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_SIZE | STATX_BLOCKS)) &&
2913 !CIFS_CACHE_READ(CIFS_I(inode)) &&
2914 inode->i_mapping && inode->i_mapping->nrpages != 0) {
2915 rc = filemap_fdatawait(inode->i_mapping);
2916 if (rc) {
2917 mapping_set_error(inode->i_mapping, rc);
2918 return rc;
2919 }
2920 }
2921
2922 if ((flags & AT_STATX_SYNC_TYPE) == AT_STATX_FORCE_SYNC)
2923 CIFS_I(inode)->time = 0; /* force revalidate */
2924
2925 /*
2926 * If the caller doesn't require syncing, only sync if
2927 * necessary (e.g. due to earlier truncate or setattr
2928 * invalidating the cached metadata)
2929 */
2930 if (((flags & AT_STATX_SYNC_TYPE) != AT_STATX_DONT_SYNC) ||
2931 (CIFS_I(inode)->time == 0)) {
2932 rc = cifs_revalidate_dentry_attr(dentry);
2933 if (rc)
2934 return rc;
2935 }
2936
2937 generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);
2938 stat->blksize = cifs_sb->ctx->bsize;
2939 stat->ino = CIFS_I(inode)->uniqueid;
2940
2941 /* old CIFS Unix Extensions doesn't return create time */
2942 if (CIFS_I(inode)->createtime) {
2943 stat->result_mask |= STATX_BTIME;
2944 stat->btime =
2945 cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
2946 }
2947
2948 stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2949 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2950 stat->attributes |= STATX_ATTR_COMPRESSED;
2951 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2952 stat->attributes |= STATX_ATTR_ENCRYPTED;
2953
2954 /*
2955 * If on a multiuser mount without unix extensions or cifsacl being
2956 * enabled, and the admin hasn't overridden them, set the ownership
2957 * to the fsuid/fsgid of the current process.
2958 */
2959 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2960 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2961 !tcon->unix_ext) {
2962 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2963 stat->uid = current_fsuid();
2964 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2965 stat->gid = current_fsgid();
2966 }
2967 return 0;
2968 }
2969
2970 int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start,
2971 u64 len)
2972 {
2973 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2974 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_i->netfs.inode.i_sb);
2975 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2976 struct TCP_Server_Info *server = tcon->ses->server;
2977 struct cifsFileInfo *cfile;
2978 int rc;
2979
2980 if (unlikely(cifs_forced_shutdown(cifs_sb)))
2981 return -EIO;
2982
2983 /*
2984 * We need to be sure that all dirty pages are written as they
2985 * might fill holes on the server.
2986 */
2987 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2988 inode->i_mapping->nrpages != 0) {
2989 rc = filemap_fdatawait(inode->i_mapping);
2990 if (rc) {
2991 mapping_set_error(inode->i_mapping, rc);
2992 return rc;
2993 }
2994 }
2995
2996 cfile = find_readable_file(cifs_i, false);
2997 if (cfile == NULL)
2998 return -EINVAL;
2999
3000 if (server->ops->fiemap) {
3001 rc = server->ops->fiemap(tcon, cfile, fei, start, len);
3002 cifsFileInfo_put(cfile);
3003 return rc;
3004 }
3005
3006 cifsFileInfo_put(cfile);
3007 return -EOPNOTSUPP;
3008 }
3009
3010 void cifs_setsize(struct inode *inode, loff_t offset)
3011 {
3012 spin_lock(&inode->i_lock);
3013 i_size_write(inode, offset);
3014 spin_unlock(&inode->i_lock);
3015 inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
3016 truncate_pagecache(inode, offset);
3017 netfs_wait_for_outstanding_io(inode);
3018 }
3019
3020 int cifs_file_set_size(const unsigned int xid, struct dentry *dentry,
3021 const char *full_path, struct cifsFileInfo *open_file,
3022 loff_t size)
3023 {
3024 struct inode *inode = d_inode(dentry);
3025 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3026 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
3027 struct tcon_link *tlink = NULL;
3028 struct cifs_tcon *tcon = NULL;
3029 struct TCP_Server_Info *server;
3030 int rc = -EINVAL;
3031
3032 /*
3033 * To avoid spurious oplock breaks from server, in the case of
3034 * inodes that we already have open, avoid doing path based
3035 * setting of file size if we can do it by handle.
3036 * This keeps our caching token (oplock) and avoids timeouts
3037 * when the local oplock break takes longer to flush
3038 * writebehind data than the SMB timeout for the SetPathInfo
3039 * request would allow
3040 */
3041 if (open_file && (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE)) {
3042 tcon = tlink_tcon(open_file->tlink);
3043 server = tcon->ses->server;
3044 rc = server->ops->set_file_size(xid, tcon,
3045 open_file,
3046 size, false);
3047 cifs_dbg(FYI, "%s: set_file_size: rc = %d\n", __func__, rc);
3048 } else {
3049 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
3050 if (open_file) {
3051 tcon = tlink_tcon(open_file->tlink);
3052 server = tcon->ses->server;
3053 rc = server->ops->set_file_size(xid, tcon,
3054 open_file,
3055 size, false);
3056 cifs_dbg(FYI, "%s: set_file_size: rc = %d\n", __func__, rc);
3057 cifsFileInfo_put(open_file);
3058 }
3059 }
3060
3061 if (!rc)
3062 goto set_size_out;
3063
3064 if (tcon == NULL) {
3065 tlink = cifs_sb_tlink(cifs_sb);
3066 if (IS_ERR(tlink))
3067 return PTR_ERR(tlink);
3068 tcon = tlink_tcon(tlink);
3069 server = tcon->ses->server;
3070 }
3071
3072 /*
3073 * Set file size by pathname rather than by handle either because no
3074 * valid, writeable file handle for it was found or because there was
3075 * an error setting it by handle.
3076 */
3077 rc = server->ops->set_path_size(xid, tcon, full_path, size,
3078 cifs_sb, false, dentry);
3079 cifs_dbg(FYI, "%s: SetEOF by path (setattrs) rc = %d\n", __func__, rc);
3080 cifs_put_tlink(tlink);
3081
3082 set_size_out:
3083 if (rc == 0) {
3084 netfs_resize_file(&cifsInode->netfs, size, true);
3085 cifs_setsize(inode, size);
3086 /*
3087 * i_blocks is not related to (i_size / i_blksize), but instead
3088 * 512 byte (2**9) size is required for calculating num blocks.
3089 * Until we can query the server for actual allocation size,
3090 * this is best estimate we have for blocks allocated for a file
3091 * Number of blocks must be rounded up so size 1 is not 0 blocks
3092 */
3093 inode->i_blocks = (512 - 1 + size) >> 9;
3094 }
3095
3096 return rc;
3097 }
3098
3099 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
3100 static int
3101 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
3102 {
3103 int rc;
3104 unsigned int xid;
3105 const char *full_path;
3106 void *page = alloc_dentry_path();
3107 struct inode *inode = d_inode(direntry);
3108 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
3109 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3110 struct tcon_link *tlink;
3111 struct cifs_tcon *pTcon;
3112 struct cifs_unix_set_info_args *args = NULL;
3113 struct cifsFileInfo *open_file = NULL;
3114
3115 cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
3116 direntry, attrs->ia_valid);
3117
3118 xid = get_xid();
3119
3120 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
3121 attrs->ia_valid |= ATTR_FORCE;
3122
3123 rc = setattr_prepare(&nop_mnt_idmap, direntry, attrs);
3124 if (rc < 0)
3125 goto out;
3126
3127 if (attrs->ia_valid & ATTR_FILE)
3128 open_file = attrs->ia_file->private_data;
3129
3130 full_path = build_path_from_dentry(direntry, page);
3131 if (IS_ERR(full_path)) {
3132 rc = PTR_ERR(full_path);
3133 goto out;
3134 }
3135
3136 /*
3137 * Attempt to flush data before changing attributes. We need to do
3138 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
3139 * ownership or mode then we may also need to do this. Here, we take
3140 * the safe way out and just do the flush on all setattr requests. If
3141 * the flush returns error, store it to report later and continue.
3142 *
3143 * BB: This should be smarter. Why bother flushing pages that
3144 * will be truncated anyway? Also, should we error out here if
3145 * the flush returns error?
3146 */
3147 rc = filemap_write_and_wait(inode->i_mapping);
3148 if (is_interrupt_error(rc)) {
3149 rc = -ERESTARTSYS;
3150 goto out;
3151 }
3152
3153 mapping_set_error(inode->i_mapping, rc);
3154 rc = 0;
3155
3156 if (attrs->ia_valid & ATTR_SIZE) {
3157 rc = cifs_file_set_size(xid, direntry, full_path,
3158 open_file, attrs->ia_size);
3159 if (rc != 0)
3160 goto out;
3161 /*
3162 * Avoid setting timestamps on the server for ftruncate(2) to
3163 * prevent it from disabling automatic timestamp updates as per
3164 * MS-FSA 2.1.4.17.
3165 */
3166 attrs->ia_valid &= ~(ATTR_CTIME | ATTR_MTIME);
3167 }
3168
3169 /* skip mode change if it's just for clearing setuid/setgid */
3170 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
3171 attrs->ia_valid &= ~ATTR_MODE;
3172
3173 args = kmalloc(sizeof(*args), GFP_KERNEL);
3174 if (args == NULL) {
3175 rc = -ENOMEM;
3176 goto out;
3177 }
3178
3179 /* set up the struct */
3180 if (attrs->ia_valid & ATTR_MODE)
3181 args->mode = attrs->ia_mode;
3182 else
3183 args->mode = NO_CHANGE_64;
3184
3185 if (attrs->ia_valid & ATTR_UID)
3186 args->uid = attrs->ia_uid;
3187 else
3188 args->uid = INVALID_UID; /* no change */
3189
3190 if (attrs->ia_valid & ATTR_GID)
3191 args->gid = attrs->ia_gid;
3192 else
3193 args->gid = INVALID_GID; /* no change */
3194
3195 if (attrs->ia_valid & ATTR_ATIME)
3196 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
3197 else
3198 args->atime = NO_CHANGE_64;
3199
3200 if (attrs->ia_valid & ATTR_MTIME)
3201 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
3202 else
3203 args->mtime = NO_CHANGE_64;
3204
3205 if (attrs->ia_valid & ATTR_CTIME)
3206 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
3207 else
3208 args->ctime = NO_CHANGE_64;
3209
3210 args->device = 0;
3211 rc = -EINVAL;
3212 if (open_file && (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE)) {
3213 pTcon = tlink_tcon(open_file->tlink);
3214 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args,
3215 open_file->fid.netfid,
3216 open_file->pid);
3217 } else {
3218 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
3219 if (open_file) {
3220 pTcon = tlink_tcon(open_file->tlink);
3221 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args,
3222 open_file->fid.netfid,
3223 open_file->pid);
3224 cifsFileInfo_put(open_file);
3225 }
3226 }
3227
3228 if (rc) {
3229 tlink = cifs_sb_tlink(cifs_sb);
3230 if (IS_ERR(tlink)) {
3231 rc = PTR_ERR(tlink);
3232 goto out;
3233 }
3234 pTcon = tlink_tcon(tlink);
3235 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
3236 cifs_sb->local_nls,
3237 cifs_remap(cifs_sb));
3238 cifs_put_tlink(tlink);
3239 }
3240
3241 if (rc)
3242 goto out;
3243
3244 if ((attrs->ia_valid & ATTR_SIZE) &&
3245 attrs->ia_size != i_size_read(inode)) {
3246 truncate_setsize(inode, attrs->ia_size);
3247 netfs_resize_file(&cifsInode->netfs, attrs->ia_size, true);
3248 fscache_resize_cookie(cifs_inode_cookie(inode), attrs->ia_size);
3249 }
3250
3251 setattr_copy(&nop_mnt_idmap, inode, attrs);
3252 mark_inode_dirty(inode);
3253
3254 /* force revalidate when any of these times are set since some
3255 of the fs types (eg ext3, fat) do not have fine enough
3256 time granularity to match protocol, and we do not have a
3257 a way (yet) to query the server fs's time granularity (and
3258 whether it rounds times down).
3259 */
3260 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
3261 cifsInode->time = 0;
3262 out:
3263 kfree(args);
3264 free_dentry_path(page);
3265 free_xid(xid);
3266 return rc;
3267 }
3268 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
3269
3270 static int
3271 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
3272 {
3273 unsigned int xid;
3274 kuid_t uid = INVALID_UID;
3275 kgid_t gid = INVALID_GID;
3276 struct inode *inode = d_inode(direntry);
3277 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3278 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
3279 struct cifsFileInfo *cfile = NULL;
3280 const char *full_path;
3281 void *page = alloc_dentry_path();
3282 int rc = -EACCES;
3283 __u32 dosattr = 0;
3284 __u64 mode = NO_CHANGE_64;
3285 bool posix = cifs_sb_master_tcon(cifs_sb)->posix_extensions;
3286
3287 xid = get_xid();
3288
3289 cifs_dbg(FYI, "setattr on file %pd attrs->ia_valid 0x%x\n",
3290 direntry, attrs->ia_valid);
3291
3292 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
3293 attrs->ia_valid |= ATTR_FORCE;
3294
3295 rc = setattr_prepare(&nop_mnt_idmap, direntry, attrs);
3296 if (rc < 0)
3297 goto cifs_setattr_exit;
3298
3299 if (attrs->ia_valid & ATTR_FILE)
3300 cfile = attrs->ia_file->private_data;
3301
3302 full_path = build_path_from_dentry(direntry, page);
3303 if (IS_ERR(full_path)) {
3304 rc = PTR_ERR(full_path);
3305 goto cifs_setattr_exit;
3306 }
3307
3308 /*
3309 * Attempt to flush data before changing attributes. We need to do
3310 * this for ATTR_SIZE and ATTR_MTIME. If the flush of the data
3311 * returns error, store it to report later and continue.
3312 *
3313 * BB: This should be smarter. Why bother flushing pages that
3314 * will be truncated anyway? Also, should we error out here if
3315 * the flush returns error? Do we need to check for ATTR_MTIME_SET flag?
3316 */
3317 if (attrs->ia_valid & (ATTR_MTIME | ATTR_SIZE | ATTR_CTIME)) {
3318 rc = filemap_write_and_wait(inode->i_mapping);
3319 if (is_interrupt_error(rc)) {
3320 rc = -ERESTARTSYS;
3321 goto cifs_setattr_exit;
3322 }
3323 mapping_set_error(inode->i_mapping, rc);
3324 }
3325
3326 rc = 0;
3327
3328 if (attrs->ia_valid & ATTR_MTIME) {
3329 rc = cifs_file_flush(xid, inode, cfile);
3330 if (rc)
3331 goto cifs_setattr_exit;
3332 }
3333
3334 if (attrs->ia_valid & ATTR_SIZE) {
3335 rc = cifs_file_set_size(xid, direntry, full_path,
3336 cfile, attrs->ia_size);
3337 if (rc != 0)
3338 goto cifs_setattr_exit;
3339 /*
3340 * Avoid setting timestamps on the server for ftruncate(2) to
3341 * prevent it from disabling automatic timestamp updates as per
3342 * MS-FSA 2.1.4.17.
3343 */
3344 attrs->ia_valid &= ~(ATTR_CTIME | ATTR_MTIME);
3345 }
3346
3347 if (attrs->ia_valid & ATTR_UID)
3348 uid = attrs->ia_uid;
3349
3350 if (attrs->ia_valid & ATTR_GID)
3351 gid = attrs->ia_gid;
3352
3353 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
3354 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
3355 if (uid_valid(uid) || gid_valid(gid)) {
3356 mode = NO_CHANGE_64;
3357 rc = id_mode_to_cifs_acl(inode, full_path, &mode,
3358 uid, gid);
3359 if (rc) {
3360 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
3361 __func__, rc);
3362 goto cifs_setattr_exit;
3363 }
3364 }
3365 } else
3366 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
3367 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
3368
3369 /* skip mode change if it's just for clearing setuid/setgid */
3370 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
3371 attrs->ia_valid &= ~ATTR_MODE;
3372
3373 if (attrs->ia_valid & ATTR_MODE) {
3374 mode = attrs->ia_mode;
3375 rc = 0;
3376 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
3377 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID) ||
3378 posix) {
3379 rc = id_mode_to_cifs_acl(inode, full_path, &mode,
3380 INVALID_UID, INVALID_GID);
3381 if (rc) {
3382 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
3383 __func__, rc);
3384 goto cifs_setattr_exit;
3385 }
3386
3387 /*
3388 * In case of CIFS_MOUNT_CIFS_ACL, we cannot support all modes.
3389 * Pick up the actual mode bits that were set.
3390 */
3391 if (mode != attrs->ia_mode)
3392 attrs->ia_mode = mode;
3393 } else
3394 if (((mode & S_IWUGO) == 0) &&
3395 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
3396
3397 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
3398
3399 /* fix up mode if we're not using dynperm */
3400 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
3401 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
3402 } else if ((mode & S_IWUGO) &&
3403 (cifsInode->cifsAttrs & ATTR_READONLY)) {
3404
3405 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
3406 /* Attributes of 0 are ignored */
3407 if (dosattr == 0)
3408 dosattr |= ATTR_NORMAL;
3409
3410 /* reset local inode permissions to normal */
3411 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
3412 attrs->ia_mode &= ~(S_IALLUGO);
3413 if (S_ISDIR(inode->i_mode))
3414 attrs->ia_mode |=
3415 cifs_sb->ctx->dir_mode;
3416 else
3417 attrs->ia_mode |=
3418 cifs_sb->ctx->file_mode;
3419 }
3420 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
3421 /* ignore mode change - ATTR_READONLY hasn't changed */
3422 attrs->ia_valid &= ~ATTR_MODE;
3423 }
3424 }
3425
3426 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
3427 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
3428 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
3429 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
3430
3431 /* Even if error on time set, no sense failing the call if
3432 the server would set the time to a reasonable value anyway,
3433 and this check ensures that we are not being called from
3434 sys_utimes in which case we ought to fail the call back to
3435 the user when the server rejects the call */
3436 if ((rc) && (attrs->ia_valid &
3437 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
3438 rc = 0;
3439 }
3440
3441 /* do not need local check to inode_check_ok since the server does
3442 that */
3443 if (rc)
3444 goto cifs_setattr_exit;
3445
3446 if ((attrs->ia_valid & ATTR_SIZE) &&
3447 attrs->ia_size != i_size_read(inode)) {
3448 truncate_setsize(inode, attrs->ia_size);
3449 netfs_resize_file(&cifsInode->netfs, attrs->ia_size, true);
3450 fscache_resize_cookie(cifs_inode_cookie(inode), attrs->ia_size);
3451 }
3452
3453 setattr_copy(&nop_mnt_idmap, inode, attrs);
3454 mark_inode_dirty(inode);
3455
3456 cifs_setattr_exit:
3457 free_xid(xid);
3458 free_dentry_path(page);
3459 return rc;
3460 }
3461
3462 int
3463 cifs_setattr(struct mnt_idmap *idmap, struct dentry *direntry,
3464 struct iattr *attrs)
3465 {
3466 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
3467 int rc, retries = 0;
3468 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
3469 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
3470 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
3471
3472 if (unlikely(cifs_forced_shutdown(cifs_sb)))
3473 return -EIO;
3474 /*
3475 * Avoid setting [cm]time with O_TRUNC to prevent the server from
3476 * disabling automatic timestamp updates as specified in
3477 * MS-FSA 2.1.4.17.
3478 */
3479 if (attrs->ia_valid & ATTR_OPEN)
3480 return 0;
3481
3482 do {
3483 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
3484 if (pTcon->unix_ext)
3485 rc = cifs_setattr_unix(direntry, attrs);
3486 else
3487 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
3488 rc = cifs_setattr_nounix(direntry, attrs);
3489 retries++;
3490 } while (is_retryable_error(rc) && retries < 2);
3491
3492 /* BB: add cifs_setattr_legacy for really old servers */
3493 return rc;
3494 }
3495