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