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