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