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