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