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