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