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#ifdef CONFIG_CIFS_FSCACHE
1360
1361 tcon->resource_id = CIFS_I(inode)->uniqueid;
1362#endif
1363
1364 if (rc && tcon->pipe) {
1365 cifs_dbg(FYI, "ipc connection - fake read inode\n");
1366 spin_lock(&inode->i_lock);
1367 inode->i_mode |= S_IFDIR;
1368 set_nlink(inode, 2);
1369 inode->i_op = &cifs_ipc_inode_ops;
1370 inode->i_fop = &simple_dir_operations;
1371 inode->i_uid = cifs_sb->ctx->linux_uid;
1372 inode->i_gid = cifs_sb->ctx->linux_gid;
1373 spin_unlock(&inode->i_lock);
1374 } else if (rc) {
1375 iget_failed(inode);
1376 inode = ERR_PTR(rc);
1377 }
1378
1379out:
1380 kfree(path);
1381 free_xid(xid);
1382 return inode;
1383}
1384
1385int
1386cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1387 const char *full_path, __u32 dosattr)
1388{
1389 bool set_time = false;
1390 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1391 struct TCP_Server_Info *server;
1392 FILE_BASIC_INFO info_buf;
1393
1394 if (attrs == NULL)
1395 return -EINVAL;
1396
1397 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1398 if (!server->ops->set_file_info)
1399 return -ENOSYS;
1400
1401 info_buf.Pad = 0;
1402
1403 if (attrs->ia_valid & ATTR_ATIME) {
1404 set_time = true;
1405 info_buf.LastAccessTime =
1406 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1407 } else
1408 info_buf.LastAccessTime = 0;
1409
1410 if (attrs->ia_valid & ATTR_MTIME) {
1411 set_time = true;
1412 info_buf.LastWriteTime =
1413 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1414 } else
1415 info_buf.LastWriteTime = 0;
1416
1417
1418
1419
1420
1421
1422
1423 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1424 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1425 info_buf.ChangeTime =
1426 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1427 } else
1428 info_buf.ChangeTime = 0;
1429
1430 info_buf.CreationTime = 0;
1431 info_buf.Attributes = cpu_to_le32(dosattr);
1432
1433 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1434}
1435
1436
1437
1438
1439
1440
1441int
1442cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1443 const unsigned int xid)
1444{
1445 int oplock = 0;
1446 int rc;
1447 struct cifs_fid fid;
1448 struct cifs_open_parms oparms;
1449 struct inode *inode = d_inode(dentry);
1450 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1451 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1452 struct tcon_link *tlink;
1453 struct cifs_tcon *tcon;
1454 __u32 dosattr, origattr;
1455 FILE_BASIC_INFO *info_buf = NULL;
1456
1457 tlink = cifs_sb_tlink(cifs_sb);
1458 if (IS_ERR(tlink))
1459 return PTR_ERR(tlink);
1460 tcon = tlink_tcon(tlink);
1461
1462
1463
1464
1465
1466 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1467 rc = -EBUSY;
1468 goto out;
1469 }
1470
1471 oparms.tcon = tcon;
1472 oparms.cifs_sb = cifs_sb;
1473 oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1474 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
1475 oparms.disposition = FILE_OPEN;
1476 oparms.path = full_path;
1477 oparms.fid = &fid;
1478 oparms.reconnect = false;
1479
1480 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1481 if (rc != 0)
1482 goto out;
1483
1484 origattr = cifsInode->cifsAttrs;
1485 if (origattr == 0)
1486 origattr |= ATTR_NORMAL;
1487
1488 dosattr = origattr & ~ATTR_READONLY;
1489 if (dosattr == 0)
1490 dosattr |= ATTR_NORMAL;
1491 dosattr |= ATTR_HIDDEN;
1492
1493
1494 if (dosattr != origattr) {
1495 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1496 if (info_buf == NULL) {
1497 rc = -ENOMEM;
1498 goto out_close;
1499 }
1500 info_buf->Attributes = cpu_to_le32(dosattr);
1501 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1502 current->tgid);
1503
1504
1505 if (!rc)
1506 cifsInode->cifsAttrs = dosattr;
1507 else
1508 dosattr = origattr;
1509 }
1510
1511
1512 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1513 cifs_sb->local_nls,
1514 cifs_remap(cifs_sb));
1515 if (rc != 0) {
1516 rc = -EBUSY;
1517 goto undo_setattr;
1518 }
1519
1520
1521 if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1522 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1523 current->tgid);
1524
1525
1526
1527
1528
1529
1530
1531
1532 if (rc == -ENOENT)
1533 rc = 0;
1534 else if (rc != 0) {
1535 rc = -EBUSY;
1536 goto undo_rename;
1537 }
1538 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1539 }
1540
1541out_close:
1542 CIFSSMBClose(xid, tcon, fid.netfid);
1543out:
1544 kfree(info_buf);
1545 cifs_put_tlink(tlink);
1546 return rc;
1547
1548
1549
1550
1551
1552
1553undo_rename:
1554 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1555 cifs_sb->local_nls, cifs_remap(cifs_sb));
1556undo_setattr:
1557 if (dosattr != origattr) {
1558 info_buf->Attributes = cpu_to_le32(origattr);
1559 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1560 current->tgid))
1561 cifsInode->cifsAttrs = origattr;
1562 }
1563
1564 goto out_close;
1565}
1566
1567
1568static void
1569cifs_drop_nlink(struct inode *inode)
1570{
1571 spin_lock(&inode->i_lock);
1572 if (inode->i_nlink > 0)
1573 drop_nlink(inode);
1574 spin_unlock(&inode->i_lock);
1575}
1576
1577
1578
1579
1580
1581
1582
1583
1584int cifs_unlink(struct inode *dir, struct dentry *dentry)
1585{
1586 int rc = 0;
1587 unsigned int xid;
1588 const char *full_path;
1589 void *page;
1590 struct inode *inode = d_inode(dentry);
1591 struct cifsInodeInfo *cifs_inode;
1592 struct super_block *sb = dir->i_sb;
1593 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1594 struct tcon_link *tlink;
1595 struct cifs_tcon *tcon;
1596 struct TCP_Server_Info *server;
1597 struct iattr *attrs = NULL;
1598 __u32 dosattr = 0, origattr = 0;
1599
1600 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1601
1602 if (unlikely(cifs_forced_shutdown(cifs_sb)))
1603 return -EIO;
1604
1605 tlink = cifs_sb_tlink(cifs_sb);
1606 if (IS_ERR(tlink))
1607 return PTR_ERR(tlink);
1608 tcon = tlink_tcon(tlink);
1609 server = tcon->ses->server;
1610
1611 xid = get_xid();
1612 page = alloc_dentry_path();
1613
1614 if (tcon->nodelete) {
1615 rc = -EACCES;
1616 goto unlink_out;
1617 }
1618
1619
1620
1621 full_path = build_path_from_dentry(dentry, page);
1622 if (IS_ERR(full_path)) {
1623 rc = PTR_ERR(full_path);
1624 goto unlink_out;
1625 }
1626
1627 cifs_close_deferred_file_under_dentry(tcon, full_path);
1628 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1629 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1630 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1631 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1632 cifs_remap(cifs_sb));
1633 cifs_dbg(FYI, "posix del rc %d\n", rc);
1634 if ((rc == 0) || (rc == -ENOENT))
1635 goto psx_del_no_retry;
1636 }
1637
1638retry_std_delete:
1639 if (!server->ops->unlink) {
1640 rc = -ENOSYS;
1641 goto psx_del_no_retry;
1642 }
1643
1644 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1645
1646psx_del_no_retry:
1647 if (!rc) {
1648 if (inode)
1649 cifs_drop_nlink(inode);
1650 } else if (rc == -ENOENT) {
1651 d_drop(dentry);
1652 } else if (rc == -EBUSY) {
1653 if (server->ops->rename_pending_delete) {
1654 rc = server->ops->rename_pending_delete(full_path,
1655 dentry, xid);
1656 if (rc == 0)
1657 cifs_drop_nlink(inode);
1658 }
1659 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1660 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1661 if (attrs == NULL) {
1662 rc = -ENOMEM;
1663 goto out_reval;
1664 }
1665
1666
1667 cifs_inode = CIFS_I(inode);
1668 origattr = cifs_inode->cifsAttrs;
1669 if (origattr == 0)
1670 origattr |= ATTR_NORMAL;
1671 dosattr = origattr & ~ATTR_READONLY;
1672 if (dosattr == 0)
1673 dosattr |= ATTR_NORMAL;
1674 dosattr |= ATTR_HIDDEN;
1675
1676 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1677 if (rc != 0)
1678 goto out_reval;
1679
1680 goto retry_std_delete;
1681 }
1682
1683
1684 if (rc != 0 && dosattr != 0)
1685 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1686
1687out_reval:
1688 if (inode) {
1689 cifs_inode = CIFS_I(inode);
1690 cifs_inode->time = 0;
1691
1692 inode->i_ctime = current_time(inode);
1693 }
1694 dir->i_ctime = dir->i_mtime = current_time(dir);
1695 cifs_inode = CIFS_I(dir);
1696 CIFS_I(dir)->time = 0;
1697unlink_out:
1698 free_dentry_path(page);
1699 kfree(attrs);
1700 free_xid(xid);
1701 cifs_put_tlink(tlink);
1702 return rc;
1703}
1704
1705static int
1706cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1707 const char *full_path, struct cifs_sb_info *cifs_sb,
1708 struct cifs_tcon *tcon, const unsigned int xid)
1709{
1710 int rc = 0;
1711 struct inode *inode = NULL;
1712
1713 if (tcon->posix_extensions)
1714 rc = smb311_posix_get_inode_info(&inode, full_path, parent->i_sb, xid);
1715 else if (tcon->unix_ext)
1716 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1717 xid);
1718 else
1719 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1720 xid, NULL);
1721
1722 if (rc)
1723 return rc;
1724
1725 if (!S_ISDIR(inode->i_mode)) {
1726
1727
1728
1729
1730
1731 iput(inode);
1732 d_drop(dentry);
1733 return 0;
1734 }
1735
1736
1737
1738
1739
1740 if (inode->i_nlink < 2)
1741 set_nlink(inode, 2);
1742 mode &= ~current_umask();
1743
1744 if (parent->i_mode & S_ISGID)
1745 mode |= S_ISGID;
1746
1747 if (tcon->unix_ext) {
1748 struct cifs_unix_set_info_args args = {
1749 .mode = mode,
1750 .ctime = NO_CHANGE_64,
1751 .atime = NO_CHANGE_64,
1752 .mtime = NO_CHANGE_64,
1753 .device = 0,
1754 };
1755 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1756 args.uid = current_fsuid();
1757 if (parent->i_mode & S_ISGID)
1758 args.gid = parent->i_gid;
1759 else
1760 args.gid = current_fsgid();
1761 } else {
1762 args.uid = INVALID_UID;
1763 args.gid = INVALID_GID;
1764 }
1765 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1766 cifs_sb->local_nls,
1767 cifs_remap(cifs_sb));
1768 } else {
1769 struct TCP_Server_Info *server = tcon->ses->server;
1770 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1771 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1772 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1773 tcon, xid);
1774 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1775 inode->i_mode = (mode | S_IFDIR);
1776
1777 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1778 inode->i_uid = current_fsuid();
1779 if (inode->i_mode & S_ISGID)
1780 inode->i_gid = parent->i_gid;
1781 else
1782 inode->i_gid = current_fsgid();
1783 }
1784 }
1785 d_instantiate(dentry, inode);
1786 return 0;
1787}
1788
1789static int
1790cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1791 const char *full_path, struct cifs_sb_info *cifs_sb,
1792 struct cifs_tcon *tcon, const unsigned int xid)
1793{
1794 int rc = 0;
1795 u32 oplock = 0;
1796 FILE_UNIX_BASIC_INFO *info = NULL;
1797 struct inode *newinode = NULL;
1798 struct cifs_fattr fattr;
1799
1800 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1801 if (info == NULL) {
1802 rc = -ENOMEM;
1803 goto posix_mkdir_out;
1804 }
1805
1806 mode &= ~current_umask();
1807 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1808 NULL , info, &oplock, full_path,
1809 cifs_sb->local_nls, cifs_remap(cifs_sb));
1810 if (rc == -EOPNOTSUPP)
1811 goto posix_mkdir_out;
1812 else if (rc) {
1813 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1814 d_drop(dentry);
1815 goto posix_mkdir_out;
1816 }
1817
1818 if (info->Type == cpu_to_le32(-1))
1819
1820 goto posix_mkdir_get_info;
1821
1822
1823
1824
1825
1826 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1827 cifs_fill_uniqueid(inode->i_sb, &fattr);
1828 newinode = cifs_iget(inode->i_sb, &fattr);
1829 if (!newinode)
1830 goto posix_mkdir_get_info;
1831
1832 d_instantiate(dentry, newinode);
1833
1834#ifdef CONFIG_CIFS_DEBUG2
1835 cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1836 dentry, dentry, newinode);
1837
1838 if (newinode->i_nlink != 2)
1839 cifs_dbg(FYI, "unexpected number of links %d\n",
1840 newinode->i_nlink);
1841#endif
1842
1843posix_mkdir_out:
1844 kfree(info);
1845 return rc;
1846posix_mkdir_get_info:
1847 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1848 xid);
1849 goto posix_mkdir_out;
1850}
1851
1852int cifs_mkdir(struct user_namespace *mnt_userns, struct inode *inode,
1853 struct dentry *direntry, umode_t mode)
1854{
1855 int rc = 0;
1856 unsigned int xid;
1857 struct cifs_sb_info *cifs_sb;
1858 struct tcon_link *tlink;
1859 struct cifs_tcon *tcon;
1860 struct TCP_Server_Info *server;
1861 const char *full_path;
1862 void *page;
1863
1864 cifs_dbg(FYI, "In cifs_mkdir, mode = %04ho inode = 0x%p\n",
1865 mode, inode);
1866
1867 cifs_sb = CIFS_SB(inode->i_sb);
1868 if (unlikely(cifs_forced_shutdown(cifs_sb)))
1869 return -EIO;
1870 tlink = cifs_sb_tlink(cifs_sb);
1871 if (IS_ERR(tlink))
1872 return PTR_ERR(tlink);
1873 tcon = tlink_tcon(tlink);
1874
1875 xid = get_xid();
1876
1877 page = alloc_dentry_path();
1878 full_path = build_path_from_dentry(direntry, page);
1879 if (IS_ERR(full_path)) {
1880 rc = PTR_ERR(full_path);
1881 goto mkdir_out;
1882 }
1883
1884 server = tcon->ses->server;
1885
1886 if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) {
1887 rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,
1888 cifs_sb);
1889 d_drop(direntry);
1890 goto mkdir_out;
1891 }
1892
1893 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1894 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1895 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1896 tcon, xid);
1897 if (rc != -EOPNOTSUPP)
1898 goto mkdir_out;
1899 }
1900
1901 if (!server->ops->mkdir) {
1902 rc = -ENOSYS;
1903 goto mkdir_out;
1904 }
1905
1906
1907 rc = server->ops->mkdir(xid, inode, mode, tcon, full_path, cifs_sb);
1908 if (rc) {
1909 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1910 d_drop(direntry);
1911 goto mkdir_out;
1912 }
1913
1914
1915 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1916 xid);
1917mkdir_out:
1918
1919
1920
1921
1922 CIFS_I(inode)->time = 0;
1923 free_dentry_path(page);
1924 free_xid(xid);
1925 cifs_put_tlink(tlink);
1926 return rc;
1927}
1928
1929int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1930{
1931 int rc = 0;
1932 unsigned int xid;
1933 struct cifs_sb_info *cifs_sb;
1934 struct tcon_link *tlink;
1935 struct cifs_tcon *tcon;
1936 struct TCP_Server_Info *server;
1937 const char *full_path;
1938 void *page = alloc_dentry_path();
1939 struct cifsInodeInfo *cifsInode;
1940
1941 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1942
1943 xid = get_xid();
1944
1945 full_path = build_path_from_dentry(direntry, page);
1946 if (IS_ERR(full_path)) {
1947 rc = PTR_ERR(full_path);
1948 goto rmdir_exit;
1949 }
1950
1951 cifs_sb = CIFS_SB(inode->i_sb);
1952 if (unlikely(cifs_forced_shutdown(cifs_sb))) {
1953 rc = -EIO;
1954 goto rmdir_exit;
1955 }
1956
1957 tlink = cifs_sb_tlink(cifs_sb);
1958 if (IS_ERR(tlink)) {
1959 rc = PTR_ERR(tlink);
1960 goto rmdir_exit;
1961 }
1962 tcon = tlink_tcon(tlink);
1963 server = tcon->ses->server;
1964
1965 if (!server->ops->rmdir) {
1966 rc = -ENOSYS;
1967 cifs_put_tlink(tlink);
1968 goto rmdir_exit;
1969 }
1970
1971 if (tcon->nodelete) {
1972 rc = -EACCES;
1973 cifs_put_tlink(tlink);
1974 goto rmdir_exit;
1975 }
1976
1977 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1978 cifs_put_tlink(tlink);
1979
1980 if (!rc) {
1981 spin_lock(&d_inode(direntry)->i_lock);
1982 i_size_write(d_inode(direntry), 0);
1983 clear_nlink(d_inode(direntry));
1984 spin_unlock(&d_inode(direntry)->i_lock);
1985 }
1986
1987 cifsInode = CIFS_I(d_inode(direntry));
1988
1989 cifsInode->time = 0;
1990
1991 cifsInode = CIFS_I(inode);
1992
1993
1994
1995
1996 cifsInode->time = 0;
1997
1998 d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
1999 current_time(inode);
2000
2001rmdir_exit:
2002 free_dentry_path(page);
2003 free_xid(xid);
2004 return rc;
2005}
2006
2007static int
2008cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
2009 const char *from_path, struct dentry *to_dentry,
2010 const char *to_path)
2011{
2012 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
2013 struct tcon_link *tlink;
2014 struct cifs_tcon *tcon;
2015 struct TCP_Server_Info *server;
2016 struct cifs_fid fid;
2017 struct cifs_open_parms oparms;
2018 int oplock, rc;
2019
2020 tlink = cifs_sb_tlink(cifs_sb);
2021 if (IS_ERR(tlink))
2022 return PTR_ERR(tlink);
2023 tcon = tlink_tcon(tlink);
2024 server = tcon->ses->server;
2025
2026 if (!server->ops->rename)
2027 return -ENOSYS;
2028
2029
2030 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
2031
2032
2033
2034
2035
2036
2037 if (rc == 0 || rc != -EBUSY)
2038 goto do_rename_exit;
2039
2040
2041 if (server->vals->protocol_id != 0)
2042 goto do_rename_exit;
2043
2044
2045 if (to_dentry->d_parent != from_dentry->d_parent)
2046 goto do_rename_exit;
2047
2048 oparms.tcon = tcon;
2049 oparms.cifs_sb = cifs_sb;
2050
2051 oparms.desired_access = DELETE;
2052 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
2053 oparms.disposition = FILE_OPEN;
2054 oparms.path = from_path;
2055 oparms.fid = &fid;
2056 oparms.reconnect = false;
2057
2058 rc = CIFS_open(xid, &oparms, &oplock, NULL);
2059 if (rc == 0) {
2060 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
2061 (const char *) to_dentry->d_name.name,
2062 cifs_sb->local_nls, cifs_remap(cifs_sb));
2063 CIFSSMBClose(xid, tcon, fid.netfid);
2064 }
2065do_rename_exit:
2066 if (rc == 0)
2067 d_move(from_dentry, to_dentry);
2068 cifs_put_tlink(tlink);
2069 return rc;
2070}
2071
2072int
2073cifs_rename2(struct user_namespace *mnt_userns, struct inode *source_dir,
2074 struct dentry *source_dentry, struct inode *target_dir,
2075 struct dentry *target_dentry, unsigned int flags)
2076{
2077 const char *from_name, *to_name;
2078 void *page1, *page2;
2079 struct cifs_sb_info *cifs_sb;
2080 struct tcon_link *tlink;
2081 struct cifs_tcon *tcon;
2082 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
2083 FILE_UNIX_BASIC_INFO *info_buf_target;
2084 unsigned int xid;
2085 int rc, tmprc;
2086 int retry_count = 0;
2087
2088 if (flags & ~RENAME_NOREPLACE)
2089 return -EINVAL;
2090
2091 cifs_sb = CIFS_SB(source_dir->i_sb);
2092 if (unlikely(cifs_forced_shutdown(cifs_sb)))
2093 return -EIO;
2094
2095 tlink = cifs_sb_tlink(cifs_sb);
2096 if (IS_ERR(tlink))
2097 return PTR_ERR(tlink);
2098 tcon = tlink_tcon(tlink);
2099
2100 page1 = alloc_dentry_path();
2101 page2 = alloc_dentry_path();
2102 xid = get_xid();
2103
2104 from_name = build_path_from_dentry(source_dentry, page1);
2105 if (IS_ERR(from_name)) {
2106 rc = PTR_ERR(from_name);
2107 goto cifs_rename_exit;
2108 }
2109
2110 to_name = build_path_from_dentry(target_dentry, page2);
2111 if (IS_ERR(to_name)) {
2112 rc = PTR_ERR(to_name);
2113 goto cifs_rename_exit;
2114 }
2115
2116 cifs_close_deferred_file_under_dentry(tcon, from_name);
2117 if (d_inode(target_dentry) != NULL)
2118 cifs_close_deferred_file_under_dentry(tcon, to_name);
2119
2120 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2121 to_name);
2122
2123 if (rc == -EACCES) {
2124 while (retry_count < 3) {
2125 cifs_close_all_deferred_files(tcon);
2126 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2127 to_name);
2128 if (rc != -EACCES)
2129 break;
2130 retry_count++;
2131 }
2132 }
2133
2134
2135
2136
2137 if (flags & RENAME_NOREPLACE)
2138 goto cifs_rename_exit;
2139
2140 if (rc == -EEXIST && tcon->unix_ext) {
2141
2142
2143
2144
2145 info_buf_source =
2146 kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
2147 GFP_KERNEL);
2148 if (info_buf_source == NULL) {
2149 rc = -ENOMEM;
2150 goto cifs_rename_exit;
2151 }
2152
2153 info_buf_target = info_buf_source + 1;
2154 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
2155 info_buf_source,
2156 cifs_sb->local_nls,
2157 cifs_remap(cifs_sb));
2158 if (tmprc != 0)
2159 goto unlink_target;
2160
2161 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
2162 info_buf_target,
2163 cifs_sb->local_nls,
2164 cifs_remap(cifs_sb));
2165
2166 if (tmprc == 0 && (info_buf_source->UniqueId ==
2167 info_buf_target->UniqueId)) {
2168
2169 rc = 0;
2170 goto cifs_rename_exit;
2171 }
2172 }
2173
2174
2175
2176
2177
2178unlink_target:
2179
2180 if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
2181 if (d_is_dir(target_dentry))
2182 tmprc = cifs_rmdir(target_dir, target_dentry);
2183 else
2184 tmprc = cifs_unlink(target_dir, target_dentry);
2185 if (tmprc)
2186 goto cifs_rename_exit;
2187 rc = cifs_do_rename(xid, source_dentry, from_name,
2188 target_dentry, to_name);
2189 }
2190
2191
2192 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
2193
2194 source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
2195 target_dir->i_mtime = current_time(source_dir);
2196
2197cifs_rename_exit:
2198 kfree(info_buf_source);
2199 free_dentry_path(page2);
2200 free_dentry_path(page1);
2201 free_xid(xid);
2202 cifs_put_tlink(tlink);
2203 return rc;
2204}
2205
2206static bool
2207cifs_dentry_needs_reval(struct dentry *dentry)
2208{
2209 struct inode *inode = d_inode(dentry);
2210 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2211 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2212 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2213 struct cached_fid *cfid = NULL;
2214
2215 if (cifs_i->time == 0)
2216 return true;
2217
2218 if (CIFS_CACHE_READ(cifs_i))
2219 return false;
2220
2221 if (!lookupCacheEnabled)
2222 return true;
2223
2224 if (!open_cached_dir_by_dentry(tcon, dentry->d_parent, &cfid)) {
2225 mutex_lock(&cfid->fid_mutex);
2226 if (cfid->time && cifs_i->time > cfid->time) {
2227 mutex_unlock(&cfid->fid_mutex);
2228 close_cached_dir(cfid);
2229 return false;
2230 }
2231 mutex_unlock(&cfid->fid_mutex);
2232 close_cached_dir(cfid);
2233 }
2234
2235
2236
2237
2238 if (S_ISDIR(inode->i_mode)) {
2239 if (!cifs_sb->ctx->acdirmax)
2240 return true;
2241 if (!time_in_range(jiffies, cifs_i->time,
2242 cifs_i->time + cifs_sb->ctx->acdirmax))
2243 return true;
2244 } else {
2245 if (!cifs_sb->ctx->acregmax)
2246 return true;
2247 if (!time_in_range(jiffies, cifs_i->time,
2248 cifs_i->time + cifs_sb->ctx->acregmax))
2249 return true;
2250 }
2251
2252
2253 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
2254 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
2255 return true;
2256
2257 return false;
2258}
2259
2260
2261
2262
2263int
2264cifs_invalidate_mapping(struct inode *inode)
2265{
2266 int rc = 0;
2267
2268 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
2269 rc = invalidate_inode_pages2(inode->i_mapping);
2270 if (rc)
2271 cifs_dbg(VFS, "%s: Could not invalidate inode %p\n",
2272 __func__, inode);
2273 }
2274
2275 cifs_fscache_reset_inode_cookie(inode);
2276 return rc;
2277}
2278
2279
2280
2281
2282
2283
2284
2285static int
2286cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
2287{
2288 freezable_schedule_unsafe();
2289 if (signal_pending_state(mode, current))
2290 return -ERESTARTSYS;
2291 return 0;
2292}
2293
2294int
2295cifs_revalidate_mapping(struct inode *inode)
2296{
2297 int rc;
2298 unsigned long *flags = &CIFS_I(inode)->flags;
2299 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
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
2312 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE)
2313 goto skip_invalidate;
2314
2315 rc = cifs_invalidate_mapping(inode);
2316 if (rc)
2317 set_bit(CIFS_INO_INVALID_MAPPING, flags);
2318 }
2319
2320skip_invalidate:
2321 clear_bit_unlock(CIFS_INO_LOCK, flags);
2322 smp_mb__after_atomic();
2323 wake_up_bit(flags, CIFS_INO_LOCK);
2324
2325 return rc;
2326}
2327
2328int
2329cifs_zap_mapping(struct inode *inode)
2330{
2331 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
2332 return cifs_revalidate_mapping(inode);
2333}
2334
2335int cifs_revalidate_file_attr(struct file *filp)
2336{
2337 int rc = 0;
2338 struct dentry *dentry = file_dentry(filp);
2339 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
2340
2341 if (!cifs_dentry_needs_reval(dentry))
2342 return rc;
2343
2344 if (tlink_tcon(cfile->tlink)->unix_ext)
2345 rc = cifs_get_file_info_unix(filp);
2346 else
2347 rc = cifs_get_file_info(filp);
2348
2349 return rc;
2350}
2351
2352int cifs_revalidate_dentry_attr(struct dentry *dentry)
2353{
2354 unsigned int xid;
2355 int rc = 0;
2356 struct inode *inode = d_inode(dentry);
2357 struct super_block *sb = dentry->d_sb;
2358 const char *full_path;
2359 void *page;
2360 int count = 0;
2361
2362 if (inode == NULL)
2363 return -ENOENT;
2364
2365 if (!cifs_dentry_needs_reval(dentry))
2366 return rc;
2367
2368 xid = get_xid();
2369
2370 page = alloc_dentry_path();
2371 full_path = build_path_from_dentry(dentry, page);
2372 if (IS_ERR(full_path)) {
2373 rc = PTR_ERR(full_path);
2374 goto out;
2375 }
2376
2377 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2378 full_path, inode, inode->i_count.counter,
2379 dentry, cifs_get_time(dentry), jiffies);
2380
2381again:
2382 if (cifs_sb_master_tcon(CIFS_SB(sb))->posix_extensions)
2383 rc = smb311_posix_get_inode_info(&inode, full_path, sb, xid);
2384 else if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
2385 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2386 else
2387 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2388 xid, NULL);
2389 if (rc == -EAGAIN && count++ < 10)
2390 goto again;
2391out:
2392 free_dentry_path(page);
2393 free_xid(xid);
2394
2395 return rc;
2396}
2397
2398int cifs_revalidate_file(struct file *filp)
2399{
2400 int rc;
2401 struct inode *inode = file_inode(filp);
2402
2403 rc = cifs_revalidate_file_attr(filp);
2404 if (rc)
2405 return rc;
2406
2407 return cifs_revalidate_mapping(inode);
2408}
2409
2410
2411int cifs_revalidate_dentry(struct dentry *dentry)
2412{
2413 int rc;
2414 struct inode *inode = d_inode(dentry);
2415
2416 rc = cifs_revalidate_dentry_attr(dentry);
2417 if (rc)
2418 return rc;
2419
2420 return cifs_revalidate_mapping(inode);
2421}
2422
2423int cifs_getattr(struct user_namespace *mnt_userns, const struct path *path,
2424 struct kstat *stat, u32 request_mask, unsigned int flags)
2425{
2426 struct dentry *dentry = path->dentry;
2427 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2428 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2429 struct inode *inode = d_inode(dentry);
2430 int rc;
2431
2432 if (unlikely(cifs_forced_shutdown(CIFS_SB(inode->i_sb))))
2433 return -EIO;
2434
2435
2436
2437
2438
2439 if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_SIZE | STATX_BLOCKS)) &&
2440 !CIFS_CACHE_READ(CIFS_I(inode)) &&
2441 inode->i_mapping && inode->i_mapping->nrpages != 0) {
2442 rc = filemap_fdatawait(inode->i_mapping);
2443 if (rc) {
2444 mapping_set_error(inode->i_mapping, rc);
2445 return rc;
2446 }
2447 }
2448
2449 if ((flags & AT_STATX_SYNC_TYPE) == AT_STATX_FORCE_SYNC)
2450 CIFS_I(inode)->time = 0;
2451
2452
2453
2454
2455
2456
2457 if (((flags & AT_STATX_SYNC_TYPE) != AT_STATX_DONT_SYNC) ||
2458 (CIFS_I(inode)->time == 0)) {
2459 rc = cifs_revalidate_dentry_attr(dentry);
2460 if (rc)
2461 return rc;
2462 }
2463
2464 generic_fillattr(&init_user_ns, inode, stat);
2465 stat->blksize = cifs_sb->ctx->bsize;
2466 stat->ino = CIFS_I(inode)->uniqueid;
2467
2468
2469 if (CIFS_I(inode)->createtime) {
2470 stat->result_mask |= STATX_BTIME;
2471 stat->btime =
2472 cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
2473 }
2474
2475 stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2476 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2477 stat->attributes |= STATX_ATTR_COMPRESSED;
2478 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2479 stat->attributes |= STATX_ATTR_ENCRYPTED;
2480
2481
2482
2483
2484
2485
2486 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2487 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2488 !tcon->unix_ext) {
2489 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2490 stat->uid = current_fsuid();
2491 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2492 stat->gid = current_fsgid();
2493 }
2494 return 0;
2495}
2496
2497int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start,
2498 u64 len)
2499{
2500 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2501 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_i->vfs_inode.i_sb);
2502 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2503 struct TCP_Server_Info *server = tcon->ses->server;
2504 struct cifsFileInfo *cfile;
2505 int rc;
2506
2507 if (unlikely(cifs_forced_shutdown(cifs_sb)))
2508 return -EIO;
2509
2510
2511
2512
2513
2514 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2515 inode->i_mapping->nrpages != 0) {
2516 rc = filemap_fdatawait(inode->i_mapping);
2517 if (rc) {
2518 mapping_set_error(inode->i_mapping, rc);
2519 return rc;
2520 }
2521 }
2522
2523 cfile = find_readable_file(cifs_i, false);
2524 if (cfile == NULL)
2525 return -EINVAL;
2526
2527 if (server->ops->fiemap) {
2528 rc = server->ops->fiemap(tcon, cfile, fei, start, len);
2529 cifsFileInfo_put(cfile);
2530 return rc;
2531 }
2532
2533 cifsFileInfo_put(cfile);
2534 return -ENOTSUPP;
2535}
2536
2537int cifs_truncate_page(struct address_space *mapping, loff_t from)
2538{
2539 pgoff_t index = from >> PAGE_SHIFT;
2540 unsigned offset = from & (PAGE_SIZE - 1);
2541 struct page *page;
2542 int rc = 0;
2543
2544 page = grab_cache_page(mapping, index);
2545 if (!page)
2546 return -ENOMEM;
2547
2548 zero_user_segment(page, offset, PAGE_SIZE);
2549 unlock_page(page);
2550 put_page(page);
2551 return rc;
2552}
2553
2554void cifs_setsize(struct inode *inode, loff_t offset)
2555{
2556 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2557
2558 spin_lock(&inode->i_lock);
2559 i_size_write(inode, offset);
2560 spin_unlock(&inode->i_lock);
2561
2562
2563 cifs_i->time = 0;
2564 truncate_pagecache(inode, offset);
2565}
2566
2567static int
2568cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2569 unsigned int xid, const char *full_path)
2570{
2571 int rc;
2572 struct cifsFileInfo *open_file;
2573 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2574 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2575 struct tcon_link *tlink = NULL;
2576 struct cifs_tcon *tcon = NULL;
2577 struct TCP_Server_Info *server;
2578
2579
2580
2581
2582
2583
2584
2585
2586
2587
2588 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2589 if (open_file) {
2590 tcon = tlink_tcon(open_file->tlink);
2591 server = tcon->ses->server;
2592 if (server->ops->set_file_size)
2593 rc = server->ops->set_file_size(xid, tcon, open_file,
2594 attrs->ia_size, false);
2595 else
2596 rc = -ENOSYS;
2597 cifsFileInfo_put(open_file);
2598 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2599 } else
2600 rc = -EINVAL;
2601
2602 if (!rc)
2603 goto set_size_out;
2604
2605 if (tcon == NULL) {
2606 tlink = cifs_sb_tlink(cifs_sb);
2607 if (IS_ERR(tlink))
2608 return PTR_ERR(tlink);
2609 tcon = tlink_tcon(tlink);
2610 server = tcon->ses->server;
2611 }
2612
2613
2614
2615
2616
2617
2618 if (server->ops->set_path_size)
2619 rc = server->ops->set_path_size(xid, tcon, full_path,
2620 attrs->ia_size, cifs_sb, false);
2621 else
2622 rc = -ENOSYS;
2623 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2624
2625 if (tlink)
2626 cifs_put_tlink(tlink);
2627
2628set_size_out:
2629 if (rc == 0) {
2630 cifsInode->server_eof = attrs->ia_size;
2631 cifs_setsize(inode, attrs->ia_size);
2632
2633
2634
2635
2636
2637
2638
2639 inode->i_blocks = (512 - 1 + attrs->ia_size) >> 9;
2640
2641
2642
2643
2644
2645
2646 attrs->ia_ctime = attrs->ia_mtime = current_time(inode);
2647 attrs->ia_valid |= ATTR_CTIME | ATTR_MTIME;
2648
2649 cifs_truncate_page(inode->i_mapping, inode->i_size);
2650 }
2651
2652 return rc;
2653}
2654
2655static int
2656cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2657{
2658 int rc;
2659 unsigned int xid;
2660 const char *full_path;
2661 void *page = alloc_dentry_path();
2662 struct inode *inode = d_inode(direntry);
2663 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2664 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2665 struct tcon_link *tlink;
2666 struct cifs_tcon *pTcon;
2667 struct cifs_unix_set_info_args *args = NULL;
2668 struct cifsFileInfo *open_file;
2669
2670 cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2671 direntry, attrs->ia_valid);
2672
2673 xid = get_xid();
2674
2675 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2676 attrs->ia_valid |= ATTR_FORCE;
2677
2678 rc = setattr_prepare(&init_user_ns, direntry, attrs);
2679 if (rc < 0)
2680 goto out;
2681
2682 full_path = build_path_from_dentry(direntry, page);
2683 if (IS_ERR(full_path)) {
2684 rc = PTR_ERR(full_path);
2685 goto out;
2686 }
2687
2688
2689
2690
2691
2692
2693
2694
2695
2696
2697
2698
2699 rc = filemap_write_and_wait(inode->i_mapping);
2700 if (is_interrupt_error(rc)) {
2701 rc = -ERESTARTSYS;
2702 goto out;
2703 }
2704
2705 mapping_set_error(inode->i_mapping, rc);
2706 rc = 0;
2707
2708 if (attrs->ia_valid & ATTR_SIZE) {
2709 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2710 if (rc != 0)
2711 goto out;
2712 }
2713
2714
2715 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2716 attrs->ia_valid &= ~ATTR_MODE;
2717
2718 args = kmalloc(sizeof(*args), GFP_KERNEL);
2719 if (args == NULL) {
2720 rc = -ENOMEM;
2721 goto out;
2722 }
2723
2724
2725 if (attrs->ia_valid & ATTR_MODE)
2726 args->mode = attrs->ia_mode;
2727 else
2728 args->mode = NO_CHANGE_64;
2729
2730 if (attrs->ia_valid & ATTR_UID)
2731 args->uid = attrs->ia_uid;
2732 else
2733 args->uid = INVALID_UID;
2734
2735 if (attrs->ia_valid & ATTR_GID)
2736 args->gid = attrs->ia_gid;
2737 else
2738 args->gid = INVALID_GID;
2739
2740 if (attrs->ia_valid & ATTR_ATIME)
2741 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2742 else
2743 args->atime = NO_CHANGE_64;
2744
2745 if (attrs->ia_valid & ATTR_MTIME)
2746 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2747 else
2748 args->mtime = NO_CHANGE_64;
2749
2750 if (attrs->ia_valid & ATTR_CTIME)
2751 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2752 else
2753 args->ctime = NO_CHANGE_64;
2754
2755 args->device = 0;
2756 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2757 if (open_file) {
2758 u16 nfid = open_file->fid.netfid;
2759 u32 npid = open_file->pid;
2760 pTcon = tlink_tcon(open_file->tlink);
2761 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2762 cifsFileInfo_put(open_file);
2763 } else {
2764 tlink = cifs_sb_tlink(cifs_sb);
2765 if (IS_ERR(tlink)) {
2766 rc = PTR_ERR(tlink);
2767 goto out;
2768 }
2769 pTcon = tlink_tcon(tlink);
2770 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2771 cifs_sb->local_nls,
2772 cifs_remap(cifs_sb));
2773 cifs_put_tlink(tlink);
2774 }
2775
2776 if (rc)
2777 goto out;
2778
2779 if ((attrs->ia_valid & ATTR_SIZE) &&
2780 attrs->ia_size != i_size_read(inode))
2781 truncate_setsize(inode, attrs->ia_size);
2782
2783 setattr_copy(&init_user_ns, inode, attrs);
2784 mark_inode_dirty(inode);
2785
2786
2787
2788
2789
2790
2791
2792 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2793 cifsInode->time = 0;
2794out:
2795 kfree(args);
2796 free_dentry_path(page);
2797 free_xid(xid);
2798 return rc;
2799}
2800
2801static int
2802cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2803{
2804 unsigned int xid;
2805 kuid_t uid = INVALID_UID;
2806 kgid_t gid = INVALID_GID;
2807 struct inode *inode = d_inode(direntry);
2808 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2809 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2810 struct cifsFileInfo *wfile;
2811 struct cifs_tcon *tcon;
2812 const char *full_path;
2813 void *page = alloc_dentry_path();
2814 int rc = -EACCES;
2815 __u32 dosattr = 0;
2816 __u64 mode = NO_CHANGE_64;
2817
2818 xid = get_xid();
2819
2820 cifs_dbg(FYI, "setattr on file %pd attrs->ia_valid 0x%x\n",
2821 direntry, attrs->ia_valid);
2822
2823 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2824 attrs->ia_valid |= ATTR_FORCE;
2825
2826 rc = setattr_prepare(&init_user_ns, direntry, attrs);
2827 if (rc < 0)
2828 goto cifs_setattr_exit;
2829
2830 full_path = build_path_from_dentry(direntry, page);
2831 if (IS_ERR(full_path)) {
2832 rc = PTR_ERR(full_path);
2833 goto cifs_setattr_exit;
2834 }
2835
2836
2837
2838
2839
2840
2841
2842
2843
2844
2845 if (attrs->ia_valid & (ATTR_MTIME | ATTR_SIZE | ATTR_CTIME)) {
2846 rc = filemap_write_and_wait(inode->i_mapping);
2847 if (is_interrupt_error(rc)) {
2848 rc = -ERESTARTSYS;
2849 goto cifs_setattr_exit;
2850 }
2851 mapping_set_error(inode->i_mapping, rc);
2852 }
2853
2854 rc = 0;
2855
2856 if ((attrs->ia_valid & ATTR_MTIME) &&
2857 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2858 rc = cifs_get_writable_file(cifsInode, FIND_WR_ANY, &wfile);
2859 if (!rc) {
2860 tcon = tlink_tcon(wfile->tlink);
2861 rc = tcon->ses->server->ops->flush(xid, tcon, &wfile->fid);
2862 cifsFileInfo_put(wfile);
2863 if (rc)
2864 goto cifs_setattr_exit;
2865 } else if (rc != -EBADF)
2866 goto cifs_setattr_exit;
2867 else
2868 rc = 0;
2869 }
2870
2871 if (attrs->ia_valid & ATTR_SIZE) {
2872 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2873 if (rc != 0)
2874 goto cifs_setattr_exit;
2875 }
2876
2877 if (attrs->ia_valid & ATTR_UID)
2878 uid = attrs->ia_uid;
2879
2880 if (attrs->ia_valid & ATTR_GID)
2881 gid = attrs->ia_gid;
2882
2883 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2884 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2885 if (uid_valid(uid) || gid_valid(gid)) {
2886 mode = NO_CHANGE_64;
2887 rc = id_mode_to_cifs_acl(inode, full_path, &mode,
2888 uid, gid);
2889 if (rc) {
2890 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2891 __func__, rc);
2892 goto cifs_setattr_exit;
2893 }
2894 }
2895 } else
2896 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2897 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2898
2899
2900 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2901 attrs->ia_valid &= ~ATTR_MODE;
2902
2903 if (attrs->ia_valid & ATTR_MODE) {
2904 mode = attrs->ia_mode;
2905 rc = 0;
2906 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2907 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2908 rc = id_mode_to_cifs_acl(inode, full_path, &mode,
2909 INVALID_UID, INVALID_GID);
2910 if (rc) {
2911 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2912 __func__, rc);
2913 goto cifs_setattr_exit;
2914 }
2915
2916
2917
2918
2919
2920 if (mode != attrs->ia_mode)
2921 attrs->ia_mode = mode;
2922 } else
2923 if (((mode & S_IWUGO) == 0) &&
2924 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2925
2926 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2927
2928
2929 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2930 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2931 } else if ((mode & S_IWUGO) &&
2932 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2933
2934 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2935
2936 if (dosattr == 0)
2937 dosattr |= ATTR_NORMAL;
2938
2939
2940 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2941 attrs->ia_mode &= ~(S_IALLUGO);
2942 if (S_ISDIR(inode->i_mode))
2943 attrs->ia_mode |=
2944 cifs_sb->ctx->dir_mode;
2945 else
2946 attrs->ia_mode |=
2947 cifs_sb->ctx->file_mode;
2948 }
2949 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2950
2951 attrs->ia_valid &= ~ATTR_MODE;
2952 }
2953 }
2954
2955 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2956 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2957 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2958
2959
2960
2961
2962
2963
2964
2965 if ((rc) && (attrs->ia_valid &
2966 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2967 rc = 0;
2968 }
2969
2970
2971
2972 if (rc)
2973 goto cifs_setattr_exit;
2974
2975 if ((attrs->ia_valid & ATTR_SIZE) &&
2976 attrs->ia_size != i_size_read(inode))
2977 truncate_setsize(inode, attrs->ia_size);
2978
2979 setattr_copy(&init_user_ns, inode, attrs);
2980 mark_inode_dirty(inode);
2981
2982cifs_setattr_exit:
2983 free_xid(xid);
2984 free_dentry_path(page);
2985 return rc;
2986}
2987
2988int
2989cifs_setattr(struct user_namespace *mnt_userns, struct dentry *direntry,
2990 struct iattr *attrs)
2991{
2992 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
2993 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2994 int rc, retries = 0;
2995
2996 if (unlikely(cifs_forced_shutdown(cifs_sb)))
2997 return -EIO;
2998
2999 do {
3000 if (pTcon->unix_ext)
3001 rc = cifs_setattr_unix(direntry, attrs);
3002 else
3003 rc = cifs_setattr_nounix(direntry, attrs);
3004 retries++;
3005 } while (is_retryable_error(rc) && retries < 2);
3006
3007
3008 return rc;
3009}
3010