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