1 // SPDX-License-Identifier: LGPL-2.1
4 * Copyright (C) International Business Machines Corp., 2002,2010
5 * Author(s): Steve French (sfrench@us.ibm.com)
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>
20 #include "cifsproto.h"
21 #include "smb2proto.h"
22 #include "cifs_debug.h"
23 #include "cifs_fs_sb.h"
24 #include "cifs_unicode.h"
26 #include "fs_context.h"
27 #include "cifs_ioctl.h"
28 #include "cached_dir.h"
30 static void cifs_set_ops(struct inode *inode)
32 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
34 switch (inode->i_mode & S_IFMT) {
36 inode->i_op = &cifs_file_inode_ops;
37 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
38 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
39 inode->i_fop = &cifs_file_direct_nobrl_ops;
41 inode->i_fop = &cifs_file_direct_ops;
42 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
43 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
44 inode->i_fop = &cifs_file_strict_nobrl_ops;
46 inode->i_fop = &cifs_file_strict_ops;
47 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
48 inode->i_fop = &cifs_file_nobrl_ops;
49 else { /* not direct, send byte range locks */
50 inode->i_fop = &cifs_file_ops;
53 /* check if server can support readahead */
54 if (cifs_sb_master_tcon(cifs_sb)->ses->server->max_read <
55 PAGE_SIZE + MAX_CIFS_HDR_SIZE)
56 inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
58 inode->i_data.a_ops = &cifs_addr_ops;
61 #ifdef CONFIG_CIFS_DFS_UPCALL
62 if (IS_AUTOMOUNT(inode)) {
63 inode->i_op = &cifs_dfs_referral_inode_operations;
65 #else /* NO DFS support, treat as a directory */
68 inode->i_op = &cifs_dir_inode_ops;
69 inode->i_fop = &cifs_dir_ops;
73 inode->i_op = &cifs_symlink_inode_ops;
76 init_special_inode(inode, inode->i_mode, inode->i_rdev);
81 /* check inode attributes against fattr. If they don't match, tag the
82 * inode for cache invalidation
85 cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
87 struct cifs_fscache_inode_coherency_data cd;
88 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
90 cifs_dbg(FYI, "%s: revalidating inode %llu\n",
91 __func__, cifs_i->uniqueid);
93 if (inode->i_state & I_NEW) {
94 cifs_dbg(FYI, "%s: inode %llu is new\n",
95 __func__, cifs_i->uniqueid);
99 /* don't bother with revalidation if we have an oplock */
100 if (CIFS_CACHE_READ(cifs_i)) {
101 cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
102 __func__, cifs_i->uniqueid);
106 /* revalidate if mtime or size have changed */
107 fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);
108 if (timespec64_equal(&inode->i_mtime, &fattr->cf_mtime) &&
109 cifs_i->server_eof == fattr->cf_eof) {
110 cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
111 __func__, cifs_i->uniqueid);
115 cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
116 __func__, cifs_i->uniqueid);
117 set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags);
118 /* Invalidate fscache cookie */
119 cifs_fscache_fill_coherency(&cifs_i->netfs.inode, &cd);
120 fscache_invalidate(cifs_inode_cookie(inode), &cd, i_size_read(inode), 0);
124 * copy nlink to the inode, unless it wasn't provided. Provide
125 * sane values if we don't have an existing one and none was provided
128 cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
131 * if we're in a situation where we can't trust what we
132 * got from the server (readdir, some non-unix cases)
133 * fake reasonable values
135 if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
136 /* only provide fake values on a new inode */
137 if (inode->i_state & I_NEW) {
138 if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
146 /* we trust the server, so update it */
147 set_nlink(inode, fattr->cf_nlink);
150 /* populate an inode with info from a cifs_fattr struct */
152 cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
154 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
155 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
157 if (!(inode->i_state & I_NEW) &&
158 unlikely(inode_wrong_type(inode, fattr->cf_mode))) {
159 CIFS_I(inode)->time = 0; /* force reval */
163 cifs_revalidate_cache(inode, fattr);
165 spin_lock(&inode->i_lock);
166 fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);
167 fattr->cf_atime = timestamp_truncate(fattr->cf_atime, inode);
168 fattr->cf_ctime = timestamp_truncate(fattr->cf_ctime, inode);
169 /* we do not want atime to be less than mtime, it broke some apps */
170 if (timespec64_compare(&fattr->cf_atime, &fattr->cf_mtime) < 0)
171 inode->i_atime = fattr->cf_mtime;
173 inode->i_atime = fattr->cf_atime;
174 inode->i_mtime = fattr->cf_mtime;
175 inode->i_ctime = fattr->cf_ctime;
176 inode->i_rdev = fattr->cf_rdev;
177 cifs_nlink_fattr_to_inode(inode, fattr);
178 inode->i_uid = fattr->cf_uid;
179 inode->i_gid = fattr->cf_gid;
181 /* if dynperm is set, don't clobber existing mode */
182 if (inode->i_state & I_NEW ||
183 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
184 inode->i_mode = fattr->cf_mode;
186 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
188 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
191 cifs_i->time = jiffies;
193 if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING)
194 set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
196 clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
198 cifs_i->server_eof = fattr->cf_eof;
200 * Can't safely change the file size here if the client is writing to
201 * it due to potential races.
203 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
204 i_size_write(inode, fattr->cf_eof);
207 * i_blocks is not related to (i_size / i_blksize),
208 * but instead 512 byte (2**9) size is required for
209 * calculating num blocks.
211 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
214 if (S_ISLNK(fattr->cf_mode)) {
215 kfree(cifs_i->symlink_target);
216 cifs_i->symlink_target = fattr->cf_symlink_target;
217 fattr->cf_symlink_target = NULL;
219 if (unlikely(!cifs_i->symlink_target))
220 inode->i_link = ERR_PTR(-EOPNOTSUPP);
222 inode->i_link = cifs_i->symlink_target;
224 spin_unlock(&inode->i_lock);
226 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
227 inode->i_flags |= S_AUTOMOUNT;
228 if (inode->i_state & I_NEW)
234 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
236 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
238 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
241 fattr->cf_uniqueid = iunique(sb, ROOT_I);
244 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
246 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
247 struct cifs_sb_info *cifs_sb)
249 memset(fattr, 0, sizeof(*fattr));
250 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
251 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
252 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
254 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
255 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
256 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
257 /* old POSIX extensions don't get create time */
259 fattr->cf_mode = le64_to_cpu(info->Permissions);
262 * Since we set the inode type below we need to mask off
263 * to avoid strange results if bits set above.
265 fattr->cf_mode &= ~S_IFMT;
266 switch (le32_to_cpu(info->Type)) {
268 fattr->cf_mode |= S_IFREG;
269 fattr->cf_dtype = DT_REG;
272 fattr->cf_mode |= S_IFLNK;
273 fattr->cf_dtype = DT_LNK;
276 fattr->cf_mode |= S_IFDIR;
277 fattr->cf_dtype = DT_DIR;
280 fattr->cf_mode |= S_IFCHR;
281 fattr->cf_dtype = DT_CHR;
282 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
283 le64_to_cpu(info->DevMinor) & MINORMASK);
286 fattr->cf_mode |= S_IFBLK;
287 fattr->cf_dtype = DT_BLK;
288 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
289 le64_to_cpu(info->DevMinor) & MINORMASK);
292 fattr->cf_mode |= S_IFIFO;
293 fattr->cf_dtype = DT_FIFO;
296 fattr->cf_mode |= S_IFSOCK;
297 fattr->cf_dtype = DT_SOCK;
300 /* safest to call it a file if we do not know */
301 fattr->cf_mode |= S_IFREG;
302 fattr->cf_dtype = DT_REG;
303 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
307 fattr->cf_uid = cifs_sb->ctx->linux_uid;
308 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
309 u64 id = le64_to_cpu(info->Uid);
310 if (id < ((uid_t)-1)) {
311 kuid_t uid = make_kuid(&init_user_ns, id);
317 fattr->cf_gid = cifs_sb->ctx->linux_gid;
318 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
319 u64 id = le64_to_cpu(info->Gid);
320 if (id < ((gid_t)-1)) {
321 kgid_t gid = make_kgid(&init_user_ns, id);
327 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
331 * Fill a cifs_fattr struct with fake inode info.
333 * Needed to setup cifs_fattr data for the directory which is the
334 * junction to the new submount (ie to setup the fake directory
335 * which represents a DFS referral).
338 cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
340 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
342 cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
344 memset(fattr, 0, sizeof(*fattr));
345 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
346 fattr->cf_uid = cifs_sb->ctx->linux_uid;
347 fattr->cf_gid = cifs_sb->ctx->linux_gid;
348 ktime_get_coarse_real_ts64(&fattr->cf_mtime);
349 fattr->cf_atime = fattr->cf_ctime = fattr->cf_mtime;
351 fattr->cf_flags = CIFS_FATTR_DFS_REFERRAL;
354 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
356 cifs_get_file_info_unix(struct file *filp)
360 FILE_UNIX_BASIC_INFO find_data;
361 struct cifs_fattr fattr = {};
362 struct inode *inode = file_inode(filp);
363 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
364 struct cifsFileInfo *cfile = filp->private_data;
365 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
369 if (cfile->symlink_target) {
370 fattr.cf_symlink_target = kstrdup(cfile->symlink_target, GFP_KERNEL);
371 if (!fattr.cf_symlink_target)
375 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
377 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
378 } else if (rc == -EREMOTE) {
379 cifs_create_dfs_fattr(&fattr, inode->i_sb);
382 goto cifs_gfiunix_out;
384 rc = cifs_fattr_to_inode(inode, &fattr);
391 int cifs_get_inode_info_unix(struct inode **pinode,
392 const unsigned char *full_path,
393 struct super_block *sb, unsigned int xid)
396 FILE_UNIX_BASIC_INFO find_data;
397 struct cifs_fattr fattr;
398 struct cifs_tcon *tcon;
399 struct TCP_Server_Info *server;
400 struct tcon_link *tlink;
401 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
403 cifs_dbg(FYI, "Getting info on %s\n", full_path);
405 tlink = cifs_sb_tlink(cifs_sb);
407 return PTR_ERR(tlink);
408 tcon = tlink_tcon(tlink);
409 server = tcon->ses->server;
411 /* could have done a find first instead but this returns more info */
412 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
413 cifs_sb->local_nls, cifs_remap(cifs_sb));
414 cifs_dbg(FYI, "%s: query path info: rc = %d\n", __func__, rc);
415 cifs_put_tlink(tlink);
418 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
419 } else if (rc == -EREMOTE) {
420 cifs_create_dfs_fattr(&fattr, sb);
426 /* check for Minshall+French symlinks */
427 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
428 int tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
431 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
434 if (S_ISLNK(fattr.cf_mode) && !fattr.cf_symlink_target) {
435 if (!server->ops->query_symlink)
437 rc = server->ops->query_symlink(xid, tcon, cifs_sb, full_path,
438 &fattr.cf_symlink_target, false);
440 cifs_dbg(FYI, "%s: query_symlink: %d\n", __func__, rc);
445 if (*pinode == NULL) {
447 cifs_fill_uniqueid(sb, &fattr);
448 *pinode = cifs_iget(sb, &fattr);
452 /* we already have inode, update it */
454 /* if uniqueid is different, return error */
455 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
456 CIFS_I(*pinode)->uniqueid != fattr.cf_uniqueid)) {
457 CIFS_I(*pinode)->time = 0; /* force reval */
462 /* if filetype is different, return error */
463 rc = cifs_fattr_to_inode(*pinode, &fattr);
467 kfree(fattr.cf_symlink_target);
471 int cifs_get_inode_info_unix(struct inode **pinode,
472 const unsigned char *full_path,
473 struct super_block *sb, unsigned int xid)
477 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
480 cifs_sfu_type(struct cifs_fattr *fattr, const char *path,
481 struct cifs_sb_info *cifs_sb, unsigned int xid)
485 struct tcon_link *tlink;
486 struct cifs_tcon *tcon;
488 struct cifs_open_parms oparms;
489 struct cifs_io_parms io_parms = {0};
491 unsigned int bytes_read;
493 int buf_type = CIFS_NO_BUFFER;
497 fattr->cf_mode &= ~S_IFMT;
499 if (fattr->cf_eof == 0) {
500 fattr->cf_mode |= S_IFIFO;
501 fattr->cf_dtype = DT_FIFO;
503 } else if (fattr->cf_eof < 8) {
504 fattr->cf_mode |= S_IFREG;
505 fattr->cf_dtype = DT_REG;
506 return -EINVAL; /* EOPNOTSUPP? */
509 tlink = cifs_sb_tlink(cifs_sb);
511 return PTR_ERR(tlink);
512 tcon = tlink_tcon(tlink);
515 oparms.cifs_sb = cifs_sb;
516 oparms.desired_access = GENERIC_READ;
517 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
518 oparms.disposition = FILE_OPEN;
521 oparms.reconnect = false;
523 if (tcon->ses->server->oplocks)
527 rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);
529 cifs_dbg(FYI, "check sfu type of %s, open rc = %d\n", path, rc);
530 cifs_put_tlink(tlink);
535 io_parms.netfid = fid.netfid;
536 io_parms.pid = current->tgid;
537 io_parms.tcon = tcon;
539 io_parms.length = 24;
541 rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,
542 &bytes_read, &pbuf, &buf_type);
543 if ((rc == 0) && (bytes_read >= 8)) {
544 if (memcmp("IntxBLK", pbuf, 8) == 0) {
545 cifs_dbg(FYI, "Block device\n");
546 fattr->cf_mode |= S_IFBLK;
547 fattr->cf_dtype = DT_BLK;
548 if (bytes_read == 24) {
549 /* we have enough to decode dev num */
550 __u64 mjr; /* major */
551 __u64 mnr; /* minor */
552 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
553 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
554 fattr->cf_rdev = MKDEV(mjr, mnr);
556 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
557 cifs_dbg(FYI, "Char device\n");
558 fattr->cf_mode |= S_IFCHR;
559 fattr->cf_dtype = DT_CHR;
560 if (bytes_read == 24) {
561 /* we have enough to decode dev num */
562 __u64 mjr; /* major */
563 __u64 mnr; /* minor */
564 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
565 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
566 fattr->cf_rdev = MKDEV(mjr, mnr);
568 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
569 cifs_dbg(FYI, "Symlink\n");
570 fattr->cf_mode |= S_IFLNK;
571 fattr->cf_dtype = DT_LNK;
573 fattr->cf_mode |= S_IFREG; /* file? */
574 fattr->cf_dtype = DT_REG;
578 fattr->cf_mode |= S_IFREG; /* then it is a file */
579 fattr->cf_dtype = DT_REG;
580 rc = -EOPNOTSUPP; /* or some unknown SFU type */
583 tcon->ses->server->ops->close(xid, tcon, &fid);
584 cifs_put_tlink(tlink);
588 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
591 * Fetch mode bits as provided by SFU.
593 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
595 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
596 struct cifs_sb_info *cifs_sb, unsigned int xid)
598 #ifdef CONFIG_CIFS_XATTR
602 struct tcon_link *tlink;
603 struct cifs_tcon *tcon;
605 tlink = cifs_sb_tlink(cifs_sb);
607 return PTR_ERR(tlink);
608 tcon = tlink_tcon(tlink);
610 if (tcon->ses->server->ops->query_all_EAs == NULL) {
611 cifs_put_tlink(tlink);
615 rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
616 "SETFILEBITS", ea_value, 4 /* size of buf */,
618 cifs_put_tlink(tlink);
622 mode = le32_to_cpu(*((__le32 *)ea_value));
623 fattr->cf_mode &= ~SFBITS_MASK;
624 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
625 mode, fattr->cf_mode);
626 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
627 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
636 /* Fill a cifs_fattr struct with info from POSIX info struct */
637 static void smb311_posix_info_to_fattr(struct cifs_fattr *fattr, struct cifs_open_info_data *data,
638 struct super_block *sb, bool adjust_tz, bool symlink)
640 struct smb311_posix_qinfo *info = &data->posix_fi;
641 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
642 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
644 memset(fattr, 0, sizeof(*fattr));
646 /* no fattr->flags to set */
647 fattr->cf_cifsattrs = le32_to_cpu(info->DosAttributes);
648 fattr->cf_uniqueid = le64_to_cpu(info->Inode);
650 if (info->LastAccessTime)
651 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
653 ktime_get_coarse_real_ts64(&fattr->cf_atime);
655 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
656 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
659 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
660 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
663 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
664 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
665 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
667 fattr->cf_nlink = le32_to_cpu(info->HardLinks);
668 fattr->cf_mode = (umode_t) le32_to_cpu(info->Mode);
669 /* The srv fs device id is overridden on network mount so setting rdev isn't needed here */
670 /* fattr->cf_rdev = le32_to_cpu(info->DeviceId); */
673 fattr->cf_mode |= S_IFLNK;
674 fattr->cf_dtype = DT_LNK;
675 fattr->cf_symlink_target = data->symlink_target;
676 data->symlink_target = NULL;
677 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
678 fattr->cf_mode |= S_IFDIR;
679 fattr->cf_dtype = DT_DIR;
681 fattr->cf_mode |= S_IFREG;
682 fattr->cf_dtype = DT_REG;
684 /* else if reparse point ... TODO: add support for FIFO and blk dev; special file types */
686 fattr->cf_uid = cifs_sb->ctx->linux_uid; /* TODO: map uid and gid from SID */
687 fattr->cf_gid = cifs_sb->ctx->linux_gid;
689 cifs_dbg(FYI, "POSIX query info: mode 0x%x uniqueid 0x%llx nlink %d\n",
690 fattr->cf_mode, fattr->cf_uniqueid, fattr->cf_nlink);
693 static void cifs_open_info_to_fattr(struct cifs_fattr *fattr, struct cifs_open_info_data *data,
694 struct super_block *sb, bool adjust_tz, bool symlink,
697 struct smb2_file_all_info *info = &data->fi;
698 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
699 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
701 memset(fattr, 0, sizeof(*fattr));
702 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
703 if (info->DeletePending)
704 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
706 if (info->LastAccessTime)
707 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
709 ktime_get_coarse_real_ts64(&fattr->cf_atime);
711 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
712 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
715 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
716 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
719 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
720 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
721 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
723 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
724 if (reparse_tag == IO_REPARSE_TAG_LX_SYMLINK) {
725 fattr->cf_mode |= S_IFLNK | cifs_sb->ctx->file_mode;
726 fattr->cf_dtype = DT_LNK;
727 } else if (reparse_tag == IO_REPARSE_TAG_LX_FIFO) {
728 fattr->cf_mode |= S_IFIFO | cifs_sb->ctx->file_mode;
729 fattr->cf_dtype = DT_FIFO;
730 } else if (reparse_tag == IO_REPARSE_TAG_AF_UNIX) {
731 fattr->cf_mode |= S_IFSOCK | cifs_sb->ctx->file_mode;
732 fattr->cf_dtype = DT_SOCK;
733 } else if (reparse_tag == IO_REPARSE_TAG_LX_CHR) {
734 fattr->cf_mode |= S_IFCHR | cifs_sb->ctx->file_mode;
735 fattr->cf_dtype = DT_CHR;
736 } else if (reparse_tag == IO_REPARSE_TAG_LX_BLK) {
737 fattr->cf_mode |= S_IFBLK | cifs_sb->ctx->file_mode;
738 fattr->cf_dtype = DT_BLK;
739 } else if (symlink || reparse_tag == IO_REPARSE_TAG_SYMLINK ||
740 reparse_tag == IO_REPARSE_TAG_NFS) {
741 fattr->cf_mode = S_IFLNK;
742 fattr->cf_dtype = DT_LNK;
743 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
744 fattr->cf_mode = S_IFDIR | cifs_sb->ctx->dir_mode;
745 fattr->cf_dtype = DT_DIR;
747 * Server can return wrong NumberOfLinks value for directories
748 * when Unix extensions are disabled - fake it.
751 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
753 fattr->cf_mode = S_IFREG | cifs_sb->ctx->file_mode;
754 fattr->cf_dtype = DT_REG;
756 /* clear write bits if ATTR_READONLY is set */
757 if (fattr->cf_cifsattrs & ATTR_READONLY)
758 fattr->cf_mode &= ~(S_IWUGO);
761 * Don't accept zero nlink from non-unix servers unless
762 * delete is pending. Instead mark it as unknown.
764 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
765 !info->DeletePending) {
766 cifs_dbg(VFS, "bogus file nlink value %u\n",
768 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
772 if (S_ISLNK(fattr->cf_mode)) {
773 fattr->cf_symlink_target = data->symlink_target;
774 data->symlink_target = NULL;
777 fattr->cf_uid = cifs_sb->ctx->linux_uid;
778 fattr->cf_gid = cifs_sb->ctx->linux_gid;
782 cifs_get_file_info(struct file *filp)
786 struct cifs_open_info_data data = {};
787 struct cifs_fattr fattr;
788 struct inode *inode = file_inode(filp);
789 struct cifsFileInfo *cfile = filp->private_data;
790 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
791 struct TCP_Server_Info *server = tcon->ses->server;
792 bool symlink = false;
795 if (!server->ops->query_file_info)
799 rc = server->ops->query_file_info(xid, tcon, cfile, &data);
802 /* TODO: add support to query reparse tag */
803 if (data.symlink_target) {
805 tag = IO_REPARSE_TAG_SYMLINK;
807 cifs_open_info_to_fattr(&fattr, &data, inode->i_sb, false, symlink, tag);
810 cifs_create_dfs_fattr(&fattr, inode->i_sb);
816 * FIXME: legacy server -- fall back to path-based call?
817 * for now, just skip revalidating and mark inode for
821 CIFS_I(inode)->time = 0;
828 * don't bother with SFU junk here -- just mark inode as needing
831 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
832 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
833 /* if filetype is different, return error */
834 rc = cifs_fattr_to_inode(inode, &fattr);
836 cifs_free_open_info(&data);
841 /* Simple function to return a 64 bit hash of string. Rarely called */
842 static __u64 simple_hashstr(const char *str)
844 const __u64 hash_mult = 1125899906842597ULL; /* a big enough prime */
848 hash = (hash + (__u64) *str++) * hash_mult;
853 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
855 * cifs_backup_query_path_info - SMB1 fallback code to get ino
857 * Fallback code to get file metadata when we don't have access to
858 * full_path (EACCES) and have backup creds.
860 * @xid: transaction id used to identify original request in logs
861 * @tcon: information about the server share we have mounted
862 * @sb: the superblock stores info such as disk space available
863 * @full_path: name of the file we are getting the metadata for
864 * @resp_buf: will be set to cifs resp buf and needs to be freed with
865 * cifs_buf_release() when done with @data
866 * @data: will be set to search info result buffer
869 cifs_backup_query_path_info(int xid,
870 struct cifs_tcon *tcon,
871 struct super_block *sb,
872 const char *full_path,
874 FILE_ALL_INFO **data)
876 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
877 struct cifs_search_info info = {0};
882 info.endOfSearch = false;
884 info.info_level = SMB_FIND_FILE_UNIX;
885 else if ((tcon->ses->capabilities &
886 tcon->ses->server->vals->cap_nt_find) == 0)
887 info.info_level = SMB_FIND_FILE_INFO_STANDARD;
888 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
889 info.info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
890 else /* no srvino useful for fallback to some netapp */
891 info.info_level = SMB_FIND_FILE_DIRECTORY_INFO;
893 flags = CIFS_SEARCH_CLOSE_ALWAYS |
894 CIFS_SEARCH_CLOSE_AT_END |
895 CIFS_SEARCH_BACKUP_SEARCH;
897 rc = CIFSFindFirst(xid, tcon, full_path,
898 cifs_sb, NULL, flags, &info, false);
902 *resp_buf = (void *)info.ntwrk_buf_start;
903 *data = (FILE_ALL_INFO *)info.srch_entries_start;
906 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
908 static void cifs_set_fattr_ino(int xid, struct cifs_tcon *tcon, struct super_block *sb,
909 struct inode **inode, const char *full_path,
910 struct cifs_open_info_data *data, struct cifs_fattr *fattr)
912 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
913 struct TCP_Server_Info *server = tcon->ses->server;
916 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
918 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
920 fattr->cf_uniqueid = iunique(sb, ROOT_I);
925 * If we have an inode pass a NULL tcon to ensure we don't
926 * make a round trip to the server. This only works for SMB2+.
928 rc = server->ops->get_srv_inum(xid, *inode ? NULL : tcon, cifs_sb, full_path,
929 &fattr->cf_uniqueid, data);
932 * If that fails reuse existing ino or generate one
933 * and disable server ones
936 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
938 fattr->cf_uniqueid = iunique(sb, ROOT_I);
939 cifs_autodisable_serverino(cifs_sb);
944 /* If no errors, check for zero root inode (invalid) */
945 if (fattr->cf_uniqueid == 0 && strlen(full_path) == 0) {
946 cifs_dbg(FYI, "Invalid (0) inodenum\n");
949 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
951 /* make an ino by hashing the UNC */
952 fattr->cf_flags |= CIFS_FATTR_FAKE_ROOT_INO;
953 fattr->cf_uniqueid = simple_hashstr(tcon->tree_name);
958 static inline bool is_inode_cache_good(struct inode *ino)
960 return ino && CIFS_CACHE_READ(CIFS_I(ino)) && CIFS_I(ino)->time != 0;
963 int cifs_get_inode_info(struct inode **inode, const char *full_path,
964 struct cifs_open_info_data *data, struct super_block *sb, int xid,
965 const struct cifs_fid *fid)
967 struct cifs_tcon *tcon;
968 struct TCP_Server_Info *server;
969 struct tcon_link *tlink;
970 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
971 bool adjust_tz = false;
972 struct cifs_fattr fattr = {0};
973 bool is_reparse_point = false;
974 struct cifs_open_info_data tmp_data = {};
975 void *smb1_backup_rsp_buf = NULL;
978 __u32 reparse_tag = 0;
980 tlink = cifs_sb_tlink(cifs_sb);
982 return PTR_ERR(tlink);
983 tcon = tlink_tcon(tlink);
984 server = tcon->ses->server;
987 * 1. Fetch file metadata if not provided (data)
991 if (is_inode_cache_good(*inode)) {
992 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
995 rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path, &tmp_data,
996 &adjust_tz, &is_reparse_point);
997 #ifdef CONFIG_CIFS_DFS_UPCALL
998 if (rc == -ENOENT && is_tcon_dfs(tcon))
999 rc = cifs_dfs_query_info_nonascii_quirk(xid, tcon,
1007 * 2. Convert it to internal cifs metadata (fattr)
1013 * If the file is a reparse point, it is more complicated
1014 * since we have to check if its reparse tag matches a known
1015 * special file type e.g. symlink or fifo or char etc.
1017 if (is_reparse_point && data->symlink_target) {
1018 reparse_tag = IO_REPARSE_TAG_SYMLINK;
1019 } else if ((le32_to_cpu(data->fi.Attributes) & ATTR_REPARSE) &&
1020 server->ops->query_reparse_tag) {
1021 tmprc = server->ops->query_reparse_tag(xid, tcon, cifs_sb, full_path,
1024 cifs_dbg(FYI, "%s: query_reparse_tag: rc = %d\n", __func__, tmprc);
1025 if (server->ops->query_symlink) {
1026 tmprc = server->ops->query_symlink(xid, tcon, cifs_sb, full_path,
1027 &data->symlink_target,
1030 cifs_dbg(FYI, "%s: query_symlink: rc = %d\n", __func__,
1034 cifs_open_info_to_fattr(&fattr, data, sb, adjust_tz, is_reparse_point, reparse_tag);
1037 /* DFS link, no metadata available on this server */
1038 cifs_create_dfs_fattr(&fattr, sb);
1042 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1044 * perm errors, try again with backup flags if possible
1046 * For SMB2 and later the backup intent flag
1047 * is already sent if needed on open and there
1048 * is no path based FindFirst operation to use
1051 if (backup_cred(cifs_sb) && is_smb1_server(server)) {
1052 /* for easier reading */
1054 FILE_DIRECTORY_INFO *fdi;
1055 SEARCH_ID_FULL_DIR_INFO *si;
1057 rc = cifs_backup_query_path_info(xid, tcon, sb,
1059 &smb1_backup_rsp_buf,
1064 move_cifs_info_to_smb2(&data->fi, fi);
1065 fdi = (FILE_DIRECTORY_INFO *)fi;
1066 si = (SEARCH_ID_FULL_DIR_INFO *)fi;
1068 cifs_dir_info_to_fattr(&fattr, fdi, cifs_sb);
1069 fattr.cf_uniqueid = le64_to_cpu(si->UniqueId);
1070 /* uniqueid set, skip get inum step */
1071 goto handle_mnt_opt;
1073 /* nothing we can do, bail out */
1078 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1081 cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc);
1086 * 3. Get or update inode number (fattr.cf_uniqueid)
1089 cifs_set_fattr_ino(xid, tcon, sb, inode, full_path, data, &fattr);
1092 * 4. Tweak fattr based on mount options
1094 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1096 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1097 /* query for SFU type info if supported and needed */
1098 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
1099 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
1100 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
1102 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
1105 /* fill in 0777 bits from ACL */
1106 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID) {
1107 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, true,
1112 cifs_dbg(FYI, "%s: Get mode from SID failed. rc=%d\n",
1116 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
1117 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, false,
1122 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
1128 /* fill in remaining high mode bits e.g. SUID, VTX */
1129 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
1130 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
1132 /* check for Minshall+French symlinks */
1133 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
1134 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
1137 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
1141 * 5. Update inode with final fattr data
1145 *inode = cifs_iget(sb, &fattr);
1149 /* we already have inode, update it */
1151 /* if uniqueid is different, return error */
1152 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
1153 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
1154 CIFS_I(*inode)->time = 0; /* force reval */
1158 /* if filetype is different, return error */
1159 rc = cifs_fattr_to_inode(*inode, &fattr);
1162 cifs_buf_release(smb1_backup_rsp_buf);
1163 cifs_put_tlink(tlink);
1164 cifs_free_open_info(&tmp_data);
1165 kfree(fattr.cf_symlink_target);
1170 smb311_posix_get_inode_info(struct inode **inode,
1171 const char *full_path,
1172 struct super_block *sb, unsigned int xid)
1174 struct cifs_tcon *tcon;
1175 struct tcon_link *tlink;
1176 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1177 bool adjust_tz = false;
1178 struct cifs_fattr fattr = {0};
1179 bool symlink = false;
1180 struct cifs_open_info_data data = {};
1184 tlink = cifs_sb_tlink(cifs_sb);
1186 return PTR_ERR(tlink);
1187 tcon = tlink_tcon(tlink);
1190 * 1. Fetch file metadata
1193 if (is_inode_cache_good(*inode)) {
1194 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
1198 rc = smb311_posix_query_path_info(xid, tcon, cifs_sb, full_path, &data, &adjust_tz,
1202 * 2. Convert it to internal cifs metadata (fattr)
1207 smb311_posix_info_to_fattr(&fattr, &data, sb, adjust_tz, symlink);
1210 /* DFS link, no metadata available on this server */
1211 cifs_create_dfs_fattr(&fattr, sb);
1216 * For SMB2 and later the backup intent flag
1217 * is already sent if needed on open and there
1218 * is no path based FindFirst operation to use
1219 * to retry with so nothing we can do, bail out
1223 cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc);
1229 * 3. Tweak fattr based on mount options
1232 /* check for Minshall+French symlinks */
1233 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
1234 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
1237 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
1241 * 4. Update inode with final fattr data
1245 *inode = cifs_iget(sb, &fattr);
1249 /* we already have inode, update it */
1251 /* if uniqueid is different, return error */
1252 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
1253 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
1254 CIFS_I(*inode)->time = 0; /* force reval */
1259 /* if filetype is different, return error */
1260 rc = cifs_fattr_to_inode(*inode, &fattr);
1263 cifs_put_tlink(tlink);
1264 cifs_free_open_info(&data);
1265 kfree(fattr.cf_symlink_target);
1270 static const struct inode_operations cifs_ipc_inode_ops = {
1271 .lookup = cifs_lookup,
1275 cifs_find_inode(struct inode *inode, void *opaque)
1277 struct cifs_fattr *fattr = opaque;
1279 /* don't match inode with different uniqueid */
1280 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
1283 /* use createtime like an i_generation field */
1284 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
1287 /* don't match inode of different type */
1288 if (inode_wrong_type(inode, fattr->cf_mode))
1291 /* if it's not a directory or has no dentries, then flag it */
1292 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
1293 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
1299 cifs_init_inode(struct inode *inode, void *opaque)
1301 struct cifs_fattr *fattr = opaque;
1303 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
1304 CIFS_I(inode)->createtime = fattr->cf_createtime;
1309 * walk dentry list for an inode and report whether it has aliases that
1310 * are hashed. We use this to determine if a directory inode can actually
1314 inode_has_hashed_dentries(struct inode *inode)
1316 struct dentry *dentry;
1318 spin_lock(&inode->i_lock);
1319 hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
1320 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
1321 spin_unlock(&inode->i_lock);
1325 spin_unlock(&inode->i_lock);
1329 /* Given fattrs, get a corresponding inode */
1331 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
1334 struct inode *inode;
1337 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
1339 /* hash down to 32-bits on 32-bit arch */
1340 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
1342 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
1344 /* was there a potentially problematic inode collision? */
1345 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
1346 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
1348 if (inode_has_hashed_dentries(inode)) {
1349 cifs_autodisable_serverino(CIFS_SB(sb));
1351 fattr->cf_uniqueid = iunique(sb, ROOT_I);
1352 goto retry_iget5_locked;
1356 /* can't fail - see cifs_find_inode() */
1357 cifs_fattr_to_inode(inode, fattr);
1358 if (sb->s_flags & SB_NOATIME)
1359 inode->i_flags |= S_NOATIME | S_NOCMTIME;
1360 if (inode->i_state & I_NEW) {
1361 inode->i_ino = hash;
1362 cifs_fscache_get_inode_cookie(inode);
1363 unlock_new_inode(inode);
1370 /* gets root inode */
1371 struct inode *cifs_root_iget(struct super_block *sb)
1374 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1375 struct inode *inode = NULL;
1377 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1381 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
1382 && cifs_sb->prepath) {
1383 len = strlen(cifs_sb->prepath);
1384 path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
1386 return ERR_PTR(-ENOMEM);
1388 memcpy(path+1, cifs_sb->prepath, len);
1390 path = kstrdup("", GFP_KERNEL);
1392 return ERR_PTR(-ENOMEM);
1396 if (tcon->unix_ext) {
1397 rc = cifs_get_inode_info_unix(&inode, path, sb, xid);
1398 /* some servers mistakenly claim POSIX support */
1399 if (rc != -EOPNOTSUPP)
1401 cifs_dbg(VFS, "server does not support POSIX extensions\n");
1402 tcon->unix_ext = false;
1405 convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
1406 if (tcon->posix_extensions)
1407 rc = smb311_posix_get_inode_info(&inode, path, sb, xid);
1409 rc = cifs_get_inode_info(&inode, path, NULL, sb, xid, NULL);
1413 inode = ERR_PTR(rc);
1417 if (rc && tcon->pipe) {
1418 cifs_dbg(FYI, "ipc connection - fake read inode\n");
1419 spin_lock(&inode->i_lock);
1420 inode->i_mode |= S_IFDIR;
1421 set_nlink(inode, 2);
1422 inode->i_op = &cifs_ipc_inode_ops;
1423 inode->i_fop = &simple_dir_operations;
1424 inode->i_uid = cifs_sb->ctx->linux_uid;
1425 inode->i_gid = cifs_sb->ctx->linux_gid;
1426 spin_unlock(&inode->i_lock);
1429 inode = ERR_PTR(rc);
1439 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1440 const char *full_path, __u32 dosattr)
1442 bool set_time = false;
1443 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1444 struct TCP_Server_Info *server;
1445 FILE_BASIC_INFO info_buf;
1450 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1451 if (!server->ops->set_file_info)
1456 if (attrs->ia_valid & ATTR_ATIME) {
1458 info_buf.LastAccessTime =
1459 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1461 info_buf.LastAccessTime = 0;
1463 if (attrs->ia_valid & ATTR_MTIME) {
1465 info_buf.LastWriteTime =
1466 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1468 info_buf.LastWriteTime = 0;
1471 * Samba throws this field away, but windows may actually use it.
1472 * Do not set ctime unless other time stamps are changed explicitly
1473 * (i.e. by utimes()) since we would then have a mix of client and
1476 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1477 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1478 info_buf.ChangeTime =
1479 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1481 info_buf.ChangeTime = 0;
1483 info_buf.CreationTime = 0; /* don't change */
1484 info_buf.Attributes = cpu_to_le32(dosattr);
1486 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1489 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1491 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1492 * and rename it to a random name that hopefully won't conflict with
1496 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1497 const unsigned int xid)
1501 struct cifs_fid fid;
1502 struct cifs_open_parms oparms;
1503 struct inode *inode = d_inode(dentry);
1504 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1505 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1506 struct tcon_link *tlink;
1507 struct cifs_tcon *tcon;
1508 __u32 dosattr, origattr;
1509 FILE_BASIC_INFO *info_buf = NULL;
1511 tlink = cifs_sb_tlink(cifs_sb);
1513 return PTR_ERR(tlink);
1514 tcon = tlink_tcon(tlink);
1517 * We cannot rename the file if the server doesn't support
1518 * CAP_INFOLEVEL_PASSTHRU
1520 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1526 oparms.cifs_sb = cifs_sb;
1527 oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1528 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
1529 oparms.disposition = FILE_OPEN;
1530 oparms.path = full_path;
1532 oparms.reconnect = false;
1534 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1538 origattr = cifsInode->cifsAttrs;
1540 origattr |= ATTR_NORMAL;
1542 dosattr = origattr & ~ATTR_READONLY;
1544 dosattr |= ATTR_NORMAL;
1545 dosattr |= ATTR_HIDDEN;
1547 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1548 if (dosattr != origattr) {
1549 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1550 if (info_buf == NULL) {
1554 info_buf->Attributes = cpu_to_le32(dosattr);
1555 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1557 /* although we would like to mark the file hidden
1558 if that fails we will still try to rename it */
1560 cifsInode->cifsAttrs = dosattr;
1562 dosattr = origattr; /* since not able to change them */
1565 /* rename the file */
1566 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1568 cifs_remap(cifs_sb));
1574 /* try to set DELETE_ON_CLOSE */
1575 if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1576 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1579 * some samba versions return -ENOENT when we try to set the
1580 * file disposition here. Likely a samba bug, but work around
1581 * it for now. This means that some cifsXXX files may hang
1582 * around after they shouldn't.
1584 * BB: remove this hack after more servers have the fix
1592 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1596 CIFSSMBClose(xid, tcon, fid.netfid);
1599 cifs_put_tlink(tlink);
1603 * reset everything back to the original state. Don't bother
1604 * dealing with errors here since we can't do anything about
1608 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1609 cifs_sb->local_nls, cifs_remap(cifs_sb));
1611 if (dosattr != origattr) {
1612 info_buf->Attributes = cpu_to_le32(origattr);
1613 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1615 cifsInode->cifsAttrs = origattr;
1620 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1622 /* copied from fs/nfs/dir.c with small changes */
1624 cifs_drop_nlink(struct inode *inode)
1626 spin_lock(&inode->i_lock);
1627 if (inode->i_nlink > 0)
1629 spin_unlock(&inode->i_lock);
1633 * If d_inode(dentry) is null (usually meaning the cached dentry
1634 * is a negative dentry) then we would attempt a standard SMB delete, but
1635 * if that fails we can not attempt the fall back mechanisms on EACCES
1636 * but will return the EACCES to the caller. Note that the VFS does not call
1637 * unlink on negative dentries currently.
1639 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1643 const char *full_path;
1645 struct inode *inode = d_inode(dentry);
1646 struct cifsInodeInfo *cifs_inode;
1647 struct super_block *sb = dir->i_sb;
1648 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1649 struct tcon_link *tlink;
1650 struct cifs_tcon *tcon;
1651 struct TCP_Server_Info *server;
1652 struct iattr *attrs = NULL;
1653 __u32 dosattr = 0, origattr = 0;
1655 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1657 if (unlikely(cifs_forced_shutdown(cifs_sb)))
1660 tlink = cifs_sb_tlink(cifs_sb);
1662 return PTR_ERR(tlink);
1663 tcon = tlink_tcon(tlink);
1664 server = tcon->ses->server;
1667 page = alloc_dentry_path();
1669 if (tcon->nodelete) {
1674 /* Unlink can be called from rename so we can not take the
1675 * sb->s_vfs_rename_mutex here */
1676 full_path = build_path_from_dentry(dentry, page);
1677 if (IS_ERR(full_path)) {
1678 rc = PTR_ERR(full_path);
1682 cifs_close_deferred_file_under_dentry(tcon, full_path);
1683 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1684 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1685 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1686 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1687 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1688 cifs_remap(cifs_sb));
1689 cifs_dbg(FYI, "posix del rc %d\n", rc);
1690 if ((rc == 0) || (rc == -ENOENT))
1691 goto psx_del_no_retry;
1693 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1696 if (!server->ops->unlink) {
1698 goto psx_del_no_retry;
1701 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1706 cifs_drop_nlink(inode);
1707 } else if (rc == -ENOENT) {
1709 } else if (rc == -EBUSY) {
1710 if (server->ops->rename_pending_delete) {
1711 rc = server->ops->rename_pending_delete(full_path,
1714 cifs_drop_nlink(inode);
1716 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1717 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1718 if (attrs == NULL) {
1723 /* try to reset dos attributes */
1724 cifs_inode = CIFS_I(inode);
1725 origattr = cifs_inode->cifsAttrs;
1727 origattr |= ATTR_NORMAL;
1728 dosattr = origattr & ~ATTR_READONLY;
1730 dosattr |= ATTR_NORMAL;
1731 dosattr |= ATTR_HIDDEN;
1733 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1737 goto retry_std_delete;
1740 /* undo the setattr if we errored out and it's needed */
1741 if (rc != 0 && dosattr != 0)
1742 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1746 cifs_inode = CIFS_I(inode);
1747 cifs_inode->time = 0; /* will force revalidate to get info
1749 inode->i_ctime = current_time(inode);
1751 dir->i_ctime = dir->i_mtime = current_time(dir);
1752 cifs_inode = CIFS_I(dir);
1753 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1755 free_dentry_path(page);
1758 cifs_put_tlink(tlink);
1763 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1764 const char *full_path, struct cifs_sb_info *cifs_sb,
1765 struct cifs_tcon *tcon, const unsigned int xid)
1768 struct inode *inode = NULL;
1770 if (tcon->posix_extensions)
1771 rc = smb311_posix_get_inode_info(&inode, full_path, parent->i_sb, xid);
1772 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1773 else if (tcon->unix_ext)
1774 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1776 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1778 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1784 if (!S_ISDIR(inode->i_mode)) {
1786 * mkdir succeeded, but another client has managed to remove the
1787 * sucker and replace it with non-directory. Return success,
1788 * but don't leave the child in dcache.
1795 * setting nlink not necessary except in cases where we failed to get it
1796 * from the server or was set bogus. Also, since this is a brand new
1797 * inode, no need to grab the i_lock before setting the i_nlink.
1799 if (inode->i_nlink < 2)
1800 set_nlink(inode, 2);
1801 mode &= ~current_umask();
1802 /* must turn on setgid bit if parent dir has it */
1803 if (parent->i_mode & S_ISGID)
1806 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1807 if (tcon->unix_ext) {
1808 struct cifs_unix_set_info_args args = {
1810 .ctime = NO_CHANGE_64,
1811 .atime = NO_CHANGE_64,
1812 .mtime = NO_CHANGE_64,
1815 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1816 args.uid = current_fsuid();
1817 if (parent->i_mode & S_ISGID)
1818 args.gid = parent->i_gid;
1820 args.gid = current_fsgid();
1822 args.uid = INVALID_UID; /* no change */
1823 args.gid = INVALID_GID; /* no change */
1825 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1827 cifs_remap(cifs_sb));
1831 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1832 struct TCP_Server_Info *server = tcon->ses->server;
1833 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1834 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1835 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1837 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1838 inode->i_mode = (mode | S_IFDIR);
1840 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1841 inode->i_uid = current_fsuid();
1842 if (inode->i_mode & S_ISGID)
1843 inode->i_gid = parent->i_gid;
1845 inode->i_gid = current_fsgid();
1848 d_instantiate(dentry, inode);
1852 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1854 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1855 const char *full_path, struct cifs_sb_info *cifs_sb,
1856 struct cifs_tcon *tcon, const unsigned int xid)
1860 FILE_UNIX_BASIC_INFO *info = NULL;
1861 struct inode *newinode = NULL;
1862 struct cifs_fattr fattr;
1864 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1867 goto posix_mkdir_out;
1870 mode &= ~current_umask();
1871 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1872 NULL /* netfid */, info, &oplock, full_path,
1873 cifs_sb->local_nls, cifs_remap(cifs_sb));
1874 if (rc == -EOPNOTSUPP)
1875 goto posix_mkdir_out;
1877 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1879 goto posix_mkdir_out;
1882 if (info->Type == cpu_to_le32(-1))
1883 /* no return info, go query for it */
1884 goto posix_mkdir_get_info;
1886 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1887 * need to set uid/gid.
1890 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1891 cifs_fill_uniqueid(inode->i_sb, &fattr);
1892 newinode = cifs_iget(inode->i_sb, &fattr);
1894 goto posix_mkdir_get_info;
1896 d_instantiate(dentry, newinode);
1898 #ifdef CONFIG_CIFS_DEBUG2
1899 cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1900 dentry, dentry, newinode);
1902 if (newinode->i_nlink != 2)
1903 cifs_dbg(FYI, "unexpected number of links %d\n",
1910 posix_mkdir_get_info:
1911 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1913 goto posix_mkdir_out;
1915 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1917 int cifs_mkdir(struct user_namespace *mnt_userns, struct inode *inode,
1918 struct dentry *direntry, umode_t mode)
1922 struct cifs_sb_info *cifs_sb;
1923 struct tcon_link *tlink;
1924 struct cifs_tcon *tcon;
1925 struct TCP_Server_Info *server;
1926 const char *full_path;
1929 cifs_dbg(FYI, "In cifs_mkdir, mode = %04ho inode = 0x%p\n",
1932 cifs_sb = CIFS_SB(inode->i_sb);
1933 if (unlikely(cifs_forced_shutdown(cifs_sb)))
1935 tlink = cifs_sb_tlink(cifs_sb);
1937 return PTR_ERR(tlink);
1938 tcon = tlink_tcon(tlink);
1942 page = alloc_dentry_path();
1943 full_path = build_path_from_dentry(direntry, page);
1944 if (IS_ERR(full_path)) {
1945 rc = PTR_ERR(full_path);
1949 server = tcon->ses->server;
1951 if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) {
1952 rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,
1954 d_drop(direntry); /* for time being always refresh inode info */
1958 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1959 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1960 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1961 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1963 if (rc != -EOPNOTSUPP)
1966 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1968 if (!server->ops->mkdir) {
1973 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1974 rc = server->ops->mkdir(xid, inode, mode, tcon, full_path, cifs_sb);
1976 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1981 /* TODO: skip this for smb2/smb3 */
1982 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1986 * Force revalidate to get parent dir info when needed since cached
1987 * attributes are invalid now.
1989 CIFS_I(inode)->time = 0;
1990 free_dentry_path(page);
1992 cifs_put_tlink(tlink);
1996 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
2000 struct cifs_sb_info *cifs_sb;
2001 struct tcon_link *tlink;
2002 struct cifs_tcon *tcon;
2003 struct TCP_Server_Info *server;
2004 const char *full_path;
2005 void *page = alloc_dentry_path();
2006 struct cifsInodeInfo *cifsInode;
2008 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
2012 full_path = build_path_from_dentry(direntry, page);
2013 if (IS_ERR(full_path)) {
2014 rc = PTR_ERR(full_path);
2018 cifs_sb = CIFS_SB(inode->i_sb);
2019 if (unlikely(cifs_forced_shutdown(cifs_sb))) {
2024 tlink = cifs_sb_tlink(cifs_sb);
2025 if (IS_ERR(tlink)) {
2026 rc = PTR_ERR(tlink);
2029 tcon = tlink_tcon(tlink);
2030 server = tcon->ses->server;
2032 if (!server->ops->rmdir) {
2034 cifs_put_tlink(tlink);
2038 if (tcon->nodelete) {
2040 cifs_put_tlink(tlink);
2044 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
2045 cifs_put_tlink(tlink);
2048 spin_lock(&d_inode(direntry)->i_lock);
2049 i_size_write(d_inode(direntry), 0);
2050 clear_nlink(d_inode(direntry));
2051 spin_unlock(&d_inode(direntry)->i_lock);
2054 cifsInode = CIFS_I(d_inode(direntry));
2055 /* force revalidate to go get info when needed */
2056 cifsInode->time = 0;
2058 cifsInode = CIFS_I(inode);
2060 * Force revalidate to get parent dir info when needed since cached
2061 * attributes are invalid now.
2063 cifsInode->time = 0;
2065 d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
2066 current_time(inode);
2069 free_dentry_path(page);
2075 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
2076 const char *from_path, struct dentry *to_dentry,
2077 const char *to_path)
2079 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
2080 struct tcon_link *tlink;
2081 struct cifs_tcon *tcon;
2082 struct TCP_Server_Info *server;
2083 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2084 struct cifs_fid fid;
2085 struct cifs_open_parms oparms;
2087 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2090 tlink = cifs_sb_tlink(cifs_sb);
2092 return PTR_ERR(tlink);
2093 tcon = tlink_tcon(tlink);
2094 server = tcon->ses->server;
2096 if (!server->ops->rename)
2099 /* try path-based rename first */
2100 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
2103 * Don't bother with rename by filehandle unless file is busy and
2104 * source. Note that cross directory moves do not work with
2105 * rename by filehandle to various Windows servers.
2107 if (rc == 0 || rc != -EBUSY)
2108 goto do_rename_exit;
2110 /* Don't fall back to using SMB on SMB 2+ mount */
2111 if (server->vals->protocol_id != 0)
2112 goto do_rename_exit;
2114 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2115 /* open-file renames don't work across directories */
2116 if (to_dentry->d_parent != from_dentry->d_parent)
2117 goto do_rename_exit;
2120 oparms.cifs_sb = cifs_sb;
2121 /* open the file to be renamed -- we need DELETE perms */
2122 oparms.desired_access = DELETE;
2123 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
2124 oparms.disposition = FILE_OPEN;
2125 oparms.path = from_path;
2127 oparms.reconnect = false;
2129 rc = CIFS_open(xid, &oparms, &oplock, NULL);
2131 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
2132 (const char *) to_dentry->d_name.name,
2133 cifs_sb->local_nls, cifs_remap(cifs_sb));
2134 CIFSSMBClose(xid, tcon, fid.netfid);
2136 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2139 d_move(from_dentry, to_dentry);
2140 cifs_put_tlink(tlink);
2145 cifs_rename2(struct user_namespace *mnt_userns, struct inode *source_dir,
2146 struct dentry *source_dentry, struct inode *target_dir,
2147 struct dentry *target_dentry, unsigned int flags)
2149 const char *from_name, *to_name;
2150 void *page1, *page2;
2151 struct cifs_sb_info *cifs_sb;
2152 struct tcon_link *tlink;
2153 struct cifs_tcon *tcon;
2156 int retry_count = 0;
2157 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
2158 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2159 FILE_UNIX_BASIC_INFO *info_buf_target;
2160 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2162 if (flags & ~RENAME_NOREPLACE)
2165 cifs_sb = CIFS_SB(source_dir->i_sb);
2166 if (unlikely(cifs_forced_shutdown(cifs_sb)))
2169 tlink = cifs_sb_tlink(cifs_sb);
2171 return PTR_ERR(tlink);
2172 tcon = tlink_tcon(tlink);
2174 page1 = alloc_dentry_path();
2175 page2 = alloc_dentry_path();
2178 from_name = build_path_from_dentry(source_dentry, page1);
2179 if (IS_ERR(from_name)) {
2180 rc = PTR_ERR(from_name);
2181 goto cifs_rename_exit;
2184 to_name = build_path_from_dentry(target_dentry, page2);
2185 if (IS_ERR(to_name)) {
2186 rc = PTR_ERR(to_name);
2187 goto cifs_rename_exit;
2190 cifs_close_deferred_file_under_dentry(tcon, from_name);
2191 if (d_inode(target_dentry) != NULL)
2192 cifs_close_deferred_file_under_dentry(tcon, to_name);
2194 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2197 if (rc == -EACCES) {
2198 while (retry_count < 3) {
2199 cifs_close_all_deferred_files(tcon);
2200 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2209 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
2211 if (flags & RENAME_NOREPLACE)
2212 goto cifs_rename_exit;
2214 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2215 if (rc == -EEXIST && tcon->unix_ext) {
2217 * Are src and dst hardlinks of same inode? We can only tell
2218 * with unix extensions enabled.
2221 kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
2223 if (info_buf_source == NULL) {
2225 goto cifs_rename_exit;
2228 info_buf_target = info_buf_source + 1;
2229 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
2232 cifs_remap(cifs_sb));
2236 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
2239 cifs_remap(cifs_sb));
2241 if (tmprc == 0 && (info_buf_source->UniqueId ==
2242 info_buf_target->UniqueId)) {
2243 /* same file, POSIX says that this is a noop */
2245 goto cifs_rename_exit;
2249 * else ... BB we could add the same check for Windows by
2250 * checking the UniqueId via FILE_INTERNAL_INFO
2254 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2256 /* Try unlinking the target dentry if it's not negative */
2257 if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
2258 if (d_is_dir(target_dentry))
2259 tmprc = cifs_rmdir(target_dir, target_dentry);
2261 tmprc = cifs_unlink(target_dir, target_dentry);
2263 goto cifs_rename_exit;
2264 rc = cifs_do_rename(xid, source_dentry, from_name,
2265 target_dentry, to_name);
2268 /* force revalidate to go get info when needed */
2269 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
2271 source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
2272 target_dir->i_mtime = current_time(source_dir);
2275 kfree(info_buf_source);
2276 free_dentry_path(page2);
2277 free_dentry_path(page1);
2279 cifs_put_tlink(tlink);
2284 cifs_dentry_needs_reval(struct dentry *dentry)
2286 struct inode *inode = d_inode(dentry);
2287 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2288 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2289 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2290 struct cached_fid *cfid = NULL;
2292 if (cifs_i->time == 0)
2295 if (CIFS_CACHE_READ(cifs_i))
2298 if (!lookupCacheEnabled)
2301 if (!open_cached_dir_by_dentry(tcon, dentry->d_parent, &cfid)) {
2302 mutex_lock(&cfid->fid_mutex);
2303 if (cfid->time && cifs_i->time > cfid->time) {
2304 mutex_unlock(&cfid->fid_mutex);
2305 close_cached_dir(cfid);
2308 mutex_unlock(&cfid->fid_mutex);
2309 close_cached_dir(cfid);
2312 * depending on inode type, check if attribute caching disabled for
2313 * files or directories
2315 if (S_ISDIR(inode->i_mode)) {
2316 if (!cifs_sb->ctx->acdirmax)
2318 if (!time_in_range(jiffies, cifs_i->time,
2319 cifs_i->time + cifs_sb->ctx->acdirmax))
2322 if (!cifs_sb->ctx->acregmax)
2324 if (!time_in_range(jiffies, cifs_i->time,
2325 cifs_i->time + cifs_sb->ctx->acregmax))
2329 /* hardlinked files w/ noserverino get "special" treatment */
2330 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
2331 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
2338 * Zap the cache. Called when invalid_mapping flag is set.
2341 cifs_invalidate_mapping(struct inode *inode)
2345 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
2346 rc = invalidate_inode_pages2(inode->i_mapping);
2348 cifs_dbg(VFS, "%s: Could not invalidate inode %p\n",
2356 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
2358 * @key: currently unused
2359 * @mode: the task state to sleep in
2362 cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
2365 if (signal_pending_state(mode, current))
2366 return -ERESTARTSYS;
2371 cifs_revalidate_mapping(struct inode *inode)
2374 unsigned long *flags = &CIFS_I(inode)->flags;
2375 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2377 /* swapfiles are not supposed to be shared */
2378 if (IS_SWAPFILE(inode))
2381 rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
2382 TASK_KILLABLE|TASK_FREEZABLE_UNSAFE);
2386 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
2387 /* for cache=singleclient, do not invalidate */
2388 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE)
2389 goto skip_invalidate;
2391 rc = cifs_invalidate_mapping(inode);
2393 set_bit(CIFS_INO_INVALID_MAPPING, flags);
2397 clear_bit_unlock(CIFS_INO_LOCK, flags);
2398 smp_mb__after_atomic();
2399 wake_up_bit(flags, CIFS_INO_LOCK);
2405 cifs_zap_mapping(struct inode *inode)
2407 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
2408 return cifs_revalidate_mapping(inode);
2411 int cifs_revalidate_file_attr(struct file *filp)
2414 struct dentry *dentry = file_dentry(filp);
2415 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2416 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
2417 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2419 if (!cifs_dentry_needs_reval(dentry))
2422 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2423 if (tlink_tcon(cfile->tlink)->unix_ext)
2424 rc = cifs_get_file_info_unix(filp);
2426 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2427 rc = cifs_get_file_info(filp);
2432 int cifs_revalidate_dentry_attr(struct dentry *dentry)
2436 struct inode *inode = d_inode(dentry);
2437 struct super_block *sb = dentry->d_sb;
2438 const char *full_path;
2445 if (!cifs_dentry_needs_reval(dentry))
2450 page = alloc_dentry_path();
2451 full_path = build_path_from_dentry(dentry, page);
2452 if (IS_ERR(full_path)) {
2453 rc = PTR_ERR(full_path);
2457 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2458 full_path, inode, inode->i_count.counter,
2459 dentry, cifs_get_time(dentry), jiffies);
2462 if (cifs_sb_master_tcon(CIFS_SB(sb))->posix_extensions)
2463 rc = smb311_posix_get_inode_info(&inode, full_path, sb, xid);
2464 else if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
2465 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2467 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2469 if (rc == -EAGAIN && count++ < 10)
2472 free_dentry_path(page);
2478 int cifs_revalidate_file(struct file *filp)
2481 struct inode *inode = file_inode(filp);
2483 rc = cifs_revalidate_file_attr(filp);
2487 return cifs_revalidate_mapping(inode);
2490 /* revalidate a dentry's inode attributes */
2491 int cifs_revalidate_dentry(struct dentry *dentry)
2494 struct inode *inode = d_inode(dentry);
2496 rc = cifs_revalidate_dentry_attr(dentry);
2500 return cifs_revalidate_mapping(inode);
2503 int cifs_getattr(struct user_namespace *mnt_userns, const struct path *path,
2504 struct kstat *stat, u32 request_mask, unsigned int flags)
2506 struct dentry *dentry = path->dentry;
2507 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2508 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2509 struct inode *inode = d_inode(dentry);
2512 if (unlikely(cifs_forced_shutdown(CIFS_SB(inode->i_sb))))
2516 * We need to be sure that all dirty pages are written and the server
2517 * has actual ctime, mtime and file length.
2519 if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_SIZE | STATX_BLOCKS)) &&
2520 !CIFS_CACHE_READ(CIFS_I(inode)) &&
2521 inode->i_mapping && inode->i_mapping->nrpages != 0) {
2522 rc = filemap_fdatawait(inode->i_mapping);
2524 mapping_set_error(inode->i_mapping, rc);
2529 if ((flags & AT_STATX_SYNC_TYPE) == AT_STATX_FORCE_SYNC)
2530 CIFS_I(inode)->time = 0; /* force revalidate */
2533 * If the caller doesn't require syncing, only sync if
2534 * necessary (e.g. due to earlier truncate or setattr
2535 * invalidating the cached metadata)
2537 if (((flags & AT_STATX_SYNC_TYPE) != AT_STATX_DONT_SYNC) ||
2538 (CIFS_I(inode)->time == 0)) {
2539 rc = cifs_revalidate_dentry_attr(dentry);
2544 generic_fillattr(&init_user_ns, inode, stat);
2545 stat->blksize = cifs_sb->ctx->bsize;
2546 stat->ino = CIFS_I(inode)->uniqueid;
2548 /* old CIFS Unix Extensions doesn't return create time */
2549 if (CIFS_I(inode)->createtime) {
2550 stat->result_mask |= STATX_BTIME;
2552 cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
2555 stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2556 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2557 stat->attributes |= STATX_ATTR_COMPRESSED;
2558 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2559 stat->attributes |= STATX_ATTR_ENCRYPTED;
2562 * If on a multiuser mount without unix extensions or cifsacl being
2563 * enabled, and the admin hasn't overridden them, set the ownership
2564 * to the fsuid/fsgid of the current process.
2566 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2567 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2569 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2570 stat->uid = current_fsuid();
2571 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2572 stat->gid = current_fsgid();
2577 int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start,
2580 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2581 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_i->netfs.inode.i_sb);
2582 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2583 struct TCP_Server_Info *server = tcon->ses->server;
2584 struct cifsFileInfo *cfile;
2587 if (unlikely(cifs_forced_shutdown(cifs_sb)))
2591 * We need to be sure that all dirty pages are written as they
2592 * might fill holes on the server.
2594 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2595 inode->i_mapping->nrpages != 0) {
2596 rc = filemap_fdatawait(inode->i_mapping);
2598 mapping_set_error(inode->i_mapping, rc);
2603 cfile = find_readable_file(cifs_i, false);
2607 if (server->ops->fiemap) {
2608 rc = server->ops->fiemap(tcon, cfile, fei, start, len);
2609 cifsFileInfo_put(cfile);
2613 cifsFileInfo_put(cfile);
2617 int cifs_truncate_page(struct address_space *mapping, loff_t from)
2619 pgoff_t index = from >> PAGE_SHIFT;
2620 unsigned offset = from & (PAGE_SIZE - 1);
2624 page = grab_cache_page(mapping, index);
2628 zero_user_segment(page, offset, PAGE_SIZE);
2634 void cifs_setsize(struct inode *inode, loff_t offset)
2636 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2638 spin_lock(&inode->i_lock);
2639 i_size_write(inode, offset);
2640 spin_unlock(&inode->i_lock);
2642 /* Cached inode must be refreshed on truncate */
2644 truncate_pagecache(inode, offset);
2648 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2649 unsigned int xid, const char *full_path)
2652 struct cifsFileInfo *open_file;
2653 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2654 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2655 struct tcon_link *tlink = NULL;
2656 struct cifs_tcon *tcon = NULL;
2657 struct TCP_Server_Info *server;
2660 * To avoid spurious oplock breaks from server, in the case of
2661 * inodes that we already have open, avoid doing path based
2662 * setting of file size if we can do it by handle.
2663 * This keeps our caching token (oplock) and avoids timeouts
2664 * when the local oplock break takes longer to flush
2665 * writebehind data than the SMB timeout for the SetPathInfo
2666 * request would allow
2668 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2670 tcon = tlink_tcon(open_file->tlink);
2671 server = tcon->ses->server;
2672 if (server->ops->set_file_size)
2673 rc = server->ops->set_file_size(xid, tcon, open_file,
2674 attrs->ia_size, false);
2677 cifsFileInfo_put(open_file);
2678 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2686 tlink = cifs_sb_tlink(cifs_sb);
2688 return PTR_ERR(tlink);
2689 tcon = tlink_tcon(tlink);
2690 server = tcon->ses->server;
2694 * Set file size by pathname rather than by handle either because no
2695 * valid, writeable file handle for it was found or because there was
2696 * an error setting it by handle.
2698 if (server->ops->set_path_size)
2699 rc = server->ops->set_path_size(xid, tcon, full_path,
2700 attrs->ia_size, cifs_sb, false);
2703 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2706 cifs_put_tlink(tlink);
2710 cifsInode->server_eof = attrs->ia_size;
2711 cifs_setsize(inode, attrs->ia_size);
2713 * i_blocks is not related to (i_size / i_blksize), but instead
2714 * 512 byte (2**9) size is required for calculating num blocks.
2715 * Until we can query the server for actual allocation size,
2716 * this is best estimate we have for blocks allocated for a file
2717 * Number of blocks must be rounded up so size 1 is not 0 blocks
2719 inode->i_blocks = (512 - 1 + attrs->ia_size) >> 9;
2722 * The man page of truncate says if the size changed,
2723 * then the st_ctime and st_mtime fields for the file
2726 attrs->ia_ctime = attrs->ia_mtime = current_time(inode);
2727 attrs->ia_valid |= ATTR_CTIME | ATTR_MTIME;
2729 cifs_truncate_page(inode->i_mapping, inode->i_size);
2735 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2737 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2741 const char *full_path;
2742 void *page = alloc_dentry_path();
2743 struct inode *inode = d_inode(direntry);
2744 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2745 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2746 struct tcon_link *tlink;
2747 struct cifs_tcon *pTcon;
2748 struct cifs_unix_set_info_args *args = NULL;
2749 struct cifsFileInfo *open_file;
2751 cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2752 direntry, attrs->ia_valid);
2756 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2757 attrs->ia_valid |= ATTR_FORCE;
2759 rc = setattr_prepare(&init_user_ns, direntry, attrs);
2763 full_path = build_path_from_dentry(direntry, page);
2764 if (IS_ERR(full_path)) {
2765 rc = PTR_ERR(full_path);
2770 * Attempt to flush data before changing attributes. We need to do
2771 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2772 * ownership or mode then we may also need to do this. Here, we take
2773 * the safe way out and just do the flush on all setattr requests. If
2774 * the flush returns error, store it to report later and continue.
2776 * BB: This should be smarter. Why bother flushing pages that
2777 * will be truncated anyway? Also, should we error out here if
2778 * the flush returns error?
2780 rc = filemap_write_and_wait(inode->i_mapping);
2781 if (is_interrupt_error(rc)) {
2786 mapping_set_error(inode->i_mapping, rc);
2789 if (attrs->ia_valid & ATTR_SIZE) {
2790 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2795 /* skip mode change if it's just for clearing setuid/setgid */
2796 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2797 attrs->ia_valid &= ~ATTR_MODE;
2799 args = kmalloc(sizeof(*args), GFP_KERNEL);
2805 /* set up the struct */
2806 if (attrs->ia_valid & ATTR_MODE)
2807 args->mode = attrs->ia_mode;
2809 args->mode = NO_CHANGE_64;
2811 if (attrs->ia_valid & ATTR_UID)
2812 args->uid = attrs->ia_uid;
2814 args->uid = INVALID_UID; /* no change */
2816 if (attrs->ia_valid & ATTR_GID)
2817 args->gid = attrs->ia_gid;
2819 args->gid = INVALID_GID; /* no change */
2821 if (attrs->ia_valid & ATTR_ATIME)
2822 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2824 args->atime = NO_CHANGE_64;
2826 if (attrs->ia_valid & ATTR_MTIME)
2827 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2829 args->mtime = NO_CHANGE_64;
2831 if (attrs->ia_valid & ATTR_CTIME)
2832 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2834 args->ctime = NO_CHANGE_64;
2837 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2839 u16 nfid = open_file->fid.netfid;
2840 u32 npid = open_file->pid;
2841 pTcon = tlink_tcon(open_file->tlink);
2842 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2843 cifsFileInfo_put(open_file);
2845 tlink = cifs_sb_tlink(cifs_sb);
2846 if (IS_ERR(tlink)) {
2847 rc = PTR_ERR(tlink);
2850 pTcon = tlink_tcon(tlink);
2851 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2853 cifs_remap(cifs_sb));
2854 cifs_put_tlink(tlink);
2860 if ((attrs->ia_valid & ATTR_SIZE) &&
2861 attrs->ia_size != i_size_read(inode)) {
2862 truncate_setsize(inode, attrs->ia_size);
2863 fscache_resize_cookie(cifs_inode_cookie(inode), attrs->ia_size);
2866 setattr_copy(&init_user_ns, inode, attrs);
2867 mark_inode_dirty(inode);
2869 /* force revalidate when any of these times are set since some
2870 of the fs types (eg ext3, fat) do not have fine enough
2871 time granularity to match protocol, and we do not have a
2872 a way (yet) to query the server fs's time granularity (and
2873 whether it rounds times down).
2875 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2876 cifsInode->time = 0;
2879 free_dentry_path(page);
2883 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2886 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2889 kuid_t uid = INVALID_UID;
2890 kgid_t gid = INVALID_GID;
2891 struct inode *inode = d_inode(direntry);
2892 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2893 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2894 struct cifsFileInfo *wfile;
2895 struct cifs_tcon *tcon;
2896 const char *full_path;
2897 void *page = alloc_dentry_path();
2900 __u64 mode = NO_CHANGE_64;
2904 cifs_dbg(FYI, "setattr on file %pd attrs->ia_valid 0x%x\n",
2905 direntry, attrs->ia_valid);
2907 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2908 attrs->ia_valid |= ATTR_FORCE;
2910 rc = setattr_prepare(&init_user_ns, direntry, attrs);
2912 goto cifs_setattr_exit;
2914 full_path = build_path_from_dentry(direntry, page);
2915 if (IS_ERR(full_path)) {
2916 rc = PTR_ERR(full_path);
2917 goto cifs_setattr_exit;
2921 * Attempt to flush data before changing attributes. We need to do
2922 * this for ATTR_SIZE and ATTR_MTIME. If the flush of the data
2923 * returns error, store it to report later and continue.
2925 * BB: This should be smarter. Why bother flushing pages that
2926 * will be truncated anyway? Also, should we error out here if
2927 * the flush returns error? Do we need to check for ATTR_MTIME_SET flag?
2929 if (attrs->ia_valid & (ATTR_MTIME | ATTR_SIZE | ATTR_CTIME)) {
2930 rc = filemap_write_and_wait(inode->i_mapping);
2931 if (is_interrupt_error(rc)) {
2933 goto cifs_setattr_exit;
2935 mapping_set_error(inode->i_mapping, rc);
2940 if ((attrs->ia_valid & ATTR_MTIME) &&
2941 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2942 rc = cifs_get_writable_file(cifsInode, FIND_WR_ANY, &wfile);
2944 tcon = tlink_tcon(wfile->tlink);
2945 rc = tcon->ses->server->ops->flush(xid, tcon, &wfile->fid);
2946 cifsFileInfo_put(wfile);
2948 goto cifs_setattr_exit;
2949 } else if (rc != -EBADF)
2950 goto cifs_setattr_exit;
2955 if (attrs->ia_valid & ATTR_SIZE) {
2956 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2958 goto cifs_setattr_exit;
2961 if (attrs->ia_valid & ATTR_UID)
2962 uid = attrs->ia_uid;
2964 if (attrs->ia_valid & ATTR_GID)
2965 gid = attrs->ia_gid;
2967 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2968 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2969 if (uid_valid(uid) || gid_valid(gid)) {
2970 mode = NO_CHANGE_64;
2971 rc = id_mode_to_cifs_acl(inode, full_path, &mode,
2974 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2976 goto cifs_setattr_exit;
2980 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2981 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2983 /* skip mode change if it's just for clearing setuid/setgid */
2984 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2985 attrs->ia_valid &= ~ATTR_MODE;
2987 if (attrs->ia_valid & ATTR_MODE) {
2988 mode = attrs->ia_mode;
2990 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2991 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2992 rc = id_mode_to_cifs_acl(inode, full_path, &mode,
2993 INVALID_UID, INVALID_GID);
2995 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2997 goto cifs_setattr_exit;
3001 * In case of CIFS_MOUNT_CIFS_ACL, we cannot support all modes.
3002 * Pick up the actual mode bits that were set.
3004 if (mode != attrs->ia_mode)
3005 attrs->ia_mode = mode;
3007 if (((mode & S_IWUGO) == 0) &&
3008 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
3010 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
3012 /* fix up mode if we're not using dynperm */
3013 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
3014 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
3015 } else if ((mode & S_IWUGO) &&
3016 (cifsInode->cifsAttrs & ATTR_READONLY)) {
3018 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
3019 /* Attributes of 0 are ignored */
3021 dosattr |= ATTR_NORMAL;
3023 /* reset local inode permissions to normal */
3024 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
3025 attrs->ia_mode &= ~(S_IALLUGO);
3026 if (S_ISDIR(inode->i_mode))
3028 cifs_sb->ctx->dir_mode;
3031 cifs_sb->ctx->file_mode;
3033 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
3034 /* ignore mode change - ATTR_READONLY hasn't changed */
3035 attrs->ia_valid &= ~ATTR_MODE;
3039 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
3040 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
3041 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
3042 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
3044 /* Even if error on time set, no sense failing the call if
3045 the server would set the time to a reasonable value anyway,
3046 and this check ensures that we are not being called from
3047 sys_utimes in which case we ought to fail the call back to
3048 the user when the server rejects the call */
3049 if ((rc) && (attrs->ia_valid &
3050 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
3054 /* do not need local check to inode_check_ok since the server does
3057 goto cifs_setattr_exit;
3059 if ((attrs->ia_valid & ATTR_SIZE) &&
3060 attrs->ia_size != i_size_read(inode)) {
3061 truncate_setsize(inode, attrs->ia_size);
3062 fscache_resize_cookie(cifs_inode_cookie(inode), attrs->ia_size);
3065 setattr_copy(&init_user_ns, inode, attrs);
3066 mark_inode_dirty(inode);
3070 free_dentry_path(page);
3075 cifs_setattr(struct user_namespace *mnt_userns, struct dentry *direntry,
3076 struct iattr *attrs)
3078 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
3079 int rc, retries = 0;
3080 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
3081 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
3082 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
3084 if (unlikely(cifs_forced_shutdown(cifs_sb)))
3088 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
3089 if (pTcon->unix_ext)
3090 rc = cifs_setattr_unix(direntry, attrs);
3092 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
3093 rc = cifs_setattr_nounix(direntry, attrs);
3095 } while (is_retryable_error(rc) && retries < 2);
3097 /* BB: add cifs_setattr_legacy for really old servers */