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