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