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 spin_unlock(&inode->i_lock);
221 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
222 inode->i_flags |= S_AUTOMOUNT;
223 if (inode->i_state & I_NEW)
229 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
231 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
233 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
236 fattr->cf_uniqueid = iunique(sb, ROOT_I);
239 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
241 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
242 struct cifs_sb_info *cifs_sb)
244 memset(fattr, 0, sizeof(*fattr));
245 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
246 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
247 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
249 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
250 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
251 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
252 /* old POSIX extensions don't get create time */
254 fattr->cf_mode = le64_to_cpu(info->Permissions);
257 * Since we set the inode type below we need to mask off
258 * to avoid strange results if bits set above.
260 fattr->cf_mode &= ~S_IFMT;
261 switch (le32_to_cpu(info->Type)) {
263 fattr->cf_mode |= S_IFREG;
264 fattr->cf_dtype = DT_REG;
267 fattr->cf_mode |= S_IFLNK | cifs_sb->ctx->file_mode;
268 fattr->cf_dtype = DT_LNK;
271 fattr->cf_mode |= S_IFDIR;
272 fattr->cf_dtype = DT_DIR;
275 fattr->cf_mode |= S_IFCHR;
276 fattr->cf_dtype = DT_CHR;
277 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
278 le64_to_cpu(info->DevMinor) & MINORMASK);
281 fattr->cf_mode |= S_IFBLK;
282 fattr->cf_dtype = DT_BLK;
283 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
284 le64_to_cpu(info->DevMinor) & MINORMASK);
287 fattr->cf_mode |= S_IFIFO;
288 fattr->cf_dtype = DT_FIFO;
291 fattr->cf_mode |= S_IFSOCK;
292 fattr->cf_dtype = DT_SOCK;
295 /* safest to call it a file if we do not know */
296 fattr->cf_mode |= S_IFREG;
297 fattr->cf_dtype = DT_REG;
298 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
302 fattr->cf_uid = cifs_sb->ctx->linux_uid;
303 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
304 u64 id = le64_to_cpu(info->Uid);
305 if (id < ((uid_t)-1)) {
306 kuid_t uid = make_kuid(&init_user_ns, id);
312 fattr->cf_gid = cifs_sb->ctx->linux_gid;
313 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
314 u64 id = le64_to_cpu(info->Gid);
315 if (id < ((gid_t)-1)) {
316 kgid_t gid = make_kgid(&init_user_ns, id);
322 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
326 * Fill a cifs_fattr struct with fake inode info.
328 * Needed to setup cifs_fattr data for the directory which is the
329 * junction to the new submount (ie to setup the fake directory
330 * which represents a DFS referral).
333 cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
335 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
337 cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
339 memset(fattr, 0, sizeof(*fattr));
340 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
341 fattr->cf_uid = cifs_sb->ctx->linux_uid;
342 fattr->cf_gid = cifs_sb->ctx->linux_gid;
343 ktime_get_coarse_real_ts64(&fattr->cf_mtime);
344 fattr->cf_atime = fattr->cf_ctime = fattr->cf_mtime;
346 fattr->cf_flags = CIFS_FATTR_DFS_REFERRAL;
349 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
351 cifs_get_file_info_unix(struct file *filp)
355 FILE_UNIX_BASIC_INFO find_data;
356 struct cifs_fattr fattr = {};
357 struct inode *inode = file_inode(filp);
358 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
359 struct cifsFileInfo *cfile = filp->private_data;
360 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
364 if (cfile->symlink_target) {
365 fattr.cf_symlink_target = kstrdup(cfile->symlink_target, GFP_KERNEL);
366 if (!fattr.cf_symlink_target) {
368 goto cifs_gfiunix_out;
372 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
374 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
375 } else if (rc == -EREMOTE) {
376 cifs_create_dfs_fattr(&fattr, inode->i_sb);
379 goto cifs_gfiunix_out;
381 rc = cifs_fattr_to_inode(inode, &fattr);
388 int cifs_get_inode_info_unix(struct inode **pinode,
389 const unsigned char *full_path,
390 struct super_block *sb, unsigned int xid)
393 FILE_UNIX_BASIC_INFO find_data;
394 struct cifs_fattr fattr;
395 struct cifs_tcon *tcon;
396 struct TCP_Server_Info *server;
397 struct tcon_link *tlink;
398 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
400 cifs_dbg(FYI, "Getting info on %s\n", full_path);
402 tlink = cifs_sb_tlink(cifs_sb);
404 return PTR_ERR(tlink);
405 tcon = tlink_tcon(tlink);
406 server = tcon->ses->server;
408 /* could have done a find first instead but this returns more info */
409 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
410 cifs_sb->local_nls, cifs_remap(cifs_sb));
411 cifs_dbg(FYI, "%s: query path info: rc = %d\n", __func__, rc);
412 cifs_put_tlink(tlink);
415 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
416 } else if (rc == -EREMOTE) {
417 cifs_create_dfs_fattr(&fattr, sb);
423 /* check for Minshall+French symlinks */
424 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
425 int tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
428 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
431 if (S_ISLNK(fattr.cf_mode) && !fattr.cf_symlink_target) {
432 if (!server->ops->query_symlink)
434 rc = server->ops->query_symlink(xid, tcon, cifs_sb, full_path,
435 &fattr.cf_symlink_target, false);
437 cifs_dbg(FYI, "%s: query_symlink: %d\n", __func__, rc);
442 if (*pinode == NULL) {
444 cifs_fill_uniqueid(sb, &fattr);
445 *pinode = cifs_iget(sb, &fattr);
449 /* we already have inode, update it */
451 /* if uniqueid is different, return error */
452 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
453 CIFS_I(*pinode)->uniqueid != fattr.cf_uniqueid)) {
454 CIFS_I(*pinode)->time = 0; /* force reval */
459 /* if filetype is different, return error */
460 rc = cifs_fattr_to_inode(*pinode, &fattr);
464 kfree(fattr.cf_symlink_target);
468 int cifs_get_inode_info_unix(struct inode **pinode,
469 const unsigned char *full_path,
470 struct super_block *sb, unsigned int xid)
474 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
477 cifs_sfu_type(struct cifs_fattr *fattr, const char *path,
478 struct cifs_sb_info *cifs_sb, unsigned int xid)
482 struct tcon_link *tlink;
483 struct cifs_tcon *tcon;
485 struct cifs_open_parms oparms;
486 struct cifs_io_parms io_parms = {0};
488 unsigned int bytes_read;
490 int buf_type = CIFS_NO_BUFFER;
494 fattr->cf_mode &= ~S_IFMT;
496 if (fattr->cf_eof == 0) {
497 fattr->cf_mode |= S_IFIFO;
498 fattr->cf_dtype = DT_FIFO;
500 } else if (fattr->cf_eof < 8) {
501 fattr->cf_mode |= S_IFREG;
502 fattr->cf_dtype = DT_REG;
503 return -EINVAL; /* EOPNOTSUPP? */
506 tlink = cifs_sb_tlink(cifs_sb);
508 return PTR_ERR(tlink);
509 tcon = tlink_tcon(tlink);
511 oparms = (struct cifs_open_parms) {
514 .desired_access = GENERIC_READ,
515 .create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR),
516 .disposition = FILE_OPEN,
521 if (tcon->ses->server->oplocks)
525 rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);
527 cifs_dbg(FYI, "check sfu type of %s, open rc = %d\n", path, rc);
528 cifs_put_tlink(tlink);
533 io_parms.netfid = fid.netfid;
534 io_parms.pid = current->tgid;
535 io_parms.tcon = tcon;
537 io_parms.length = 24;
539 rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,
540 &bytes_read, &pbuf, &buf_type);
541 if ((rc == 0) && (bytes_read >= 8)) {
542 if (memcmp("IntxBLK", pbuf, 8) == 0) {
543 cifs_dbg(FYI, "Block device\n");
544 fattr->cf_mode |= S_IFBLK;
545 fattr->cf_dtype = DT_BLK;
546 if (bytes_read == 24) {
547 /* we have enough to decode dev num */
548 __u64 mjr; /* major */
549 __u64 mnr; /* minor */
550 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
551 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
552 fattr->cf_rdev = MKDEV(mjr, mnr);
554 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
555 cifs_dbg(FYI, "Char device\n");
556 fattr->cf_mode |= S_IFCHR;
557 fattr->cf_dtype = DT_CHR;
558 if (bytes_read == 24) {
559 /* we have enough to decode dev num */
560 __u64 mjr; /* major */
561 __u64 mnr; /* minor */
562 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
563 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
564 fattr->cf_rdev = MKDEV(mjr, mnr);
566 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
567 cifs_dbg(FYI, "Symlink\n");
568 fattr->cf_mode |= S_IFLNK;
569 fattr->cf_dtype = DT_LNK;
570 } else if (memcmp("LnxFIFO", pbuf, 8) == 0) {
571 cifs_dbg(FYI, "FIFO\n");
572 fattr->cf_mode |= S_IFIFO;
573 fattr->cf_dtype = DT_FIFO;
575 fattr->cf_mode |= S_IFREG; /* file? */
576 fattr->cf_dtype = DT_REG;
580 fattr->cf_mode |= S_IFREG; /* then it is a file */
581 fattr->cf_dtype = DT_REG;
582 rc = -EOPNOTSUPP; /* or some unknown SFU type */
585 tcon->ses->server->ops->close(xid, tcon, &fid);
586 cifs_put_tlink(tlink);
590 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
593 * Fetch mode bits as provided by SFU.
595 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
597 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
598 struct cifs_sb_info *cifs_sb, unsigned int xid)
600 #ifdef CONFIG_CIFS_XATTR
604 struct tcon_link *tlink;
605 struct cifs_tcon *tcon;
607 tlink = cifs_sb_tlink(cifs_sb);
609 return PTR_ERR(tlink);
610 tcon = tlink_tcon(tlink);
612 if (tcon->ses->server->ops->query_all_EAs == NULL) {
613 cifs_put_tlink(tlink);
617 rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
618 "SETFILEBITS", ea_value, 4 /* size of buf */,
620 cifs_put_tlink(tlink);
624 mode = le32_to_cpu(*((__le32 *)ea_value));
625 fattr->cf_mode &= ~SFBITS_MASK;
626 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
627 mode, fattr->cf_mode);
628 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
629 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
638 /* Fill a cifs_fattr struct with info from POSIX info struct */
639 static void smb311_posix_info_to_fattr(struct cifs_fattr *fattr, struct cifs_open_info_data *data,
640 struct super_block *sb, bool adjust_tz, bool symlink)
642 struct smb311_posix_qinfo *info = &data->posix_fi;
643 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
644 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
646 memset(fattr, 0, sizeof(*fattr));
648 /* no fattr->flags to set */
649 fattr->cf_cifsattrs = le32_to_cpu(info->DosAttributes);
650 fattr->cf_uniqueid = le64_to_cpu(info->Inode);
652 if (info->LastAccessTime)
653 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
655 ktime_get_coarse_real_ts64(&fattr->cf_atime);
657 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
658 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
661 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
662 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
665 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
666 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
667 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
669 fattr->cf_nlink = le32_to_cpu(info->HardLinks);
670 fattr->cf_mode = (umode_t) le32_to_cpu(info->Mode);
671 /* The srv fs device id is overridden on network mount so setting rdev isn't needed here */
672 /* fattr->cf_rdev = le32_to_cpu(info->DeviceId); */
675 fattr->cf_mode |= S_IFLNK;
676 fattr->cf_dtype = DT_LNK;
677 fattr->cf_symlink_target = data->symlink_target;
678 data->symlink_target = NULL;
679 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
680 fattr->cf_mode |= S_IFDIR;
681 fattr->cf_dtype = DT_DIR;
683 fattr->cf_mode |= S_IFREG;
684 fattr->cf_dtype = DT_REG;
686 /* else if reparse point ... TODO: add support for FIFO and blk dev; special file types */
688 fattr->cf_uid = cifs_sb->ctx->linux_uid; /* TODO: map uid and gid from SID */
689 fattr->cf_gid = cifs_sb->ctx->linux_gid;
691 cifs_dbg(FYI, "POSIX query info: mode 0x%x uniqueid 0x%llx nlink %d\n",
692 fattr->cf_mode, fattr->cf_uniqueid, fattr->cf_nlink);
695 static void cifs_open_info_to_fattr(struct cifs_fattr *fattr, struct cifs_open_info_data *data,
696 struct super_block *sb, bool adjust_tz, bool symlink,
699 struct smb2_file_all_info *info = &data->fi;
700 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
701 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
703 memset(fattr, 0, sizeof(*fattr));
704 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
705 if (info->DeletePending)
706 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
708 if (info->LastAccessTime)
709 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
711 ktime_get_coarse_real_ts64(&fattr->cf_atime);
713 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
714 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
717 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
718 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
721 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
722 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
723 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
725 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
726 if (reparse_tag == IO_REPARSE_TAG_LX_SYMLINK) {
727 fattr->cf_mode |= S_IFLNK | cifs_sb->ctx->file_mode;
728 fattr->cf_dtype = DT_LNK;
729 } else if (reparse_tag == IO_REPARSE_TAG_LX_FIFO) {
730 fattr->cf_mode |= S_IFIFO | cifs_sb->ctx->file_mode;
731 fattr->cf_dtype = DT_FIFO;
732 } else if (reparse_tag == IO_REPARSE_TAG_AF_UNIX) {
733 fattr->cf_mode |= S_IFSOCK | cifs_sb->ctx->file_mode;
734 fattr->cf_dtype = DT_SOCK;
735 } else if (reparse_tag == IO_REPARSE_TAG_LX_CHR) {
736 fattr->cf_mode |= S_IFCHR | cifs_sb->ctx->file_mode;
737 fattr->cf_dtype = DT_CHR;
738 } else if (reparse_tag == IO_REPARSE_TAG_LX_BLK) {
739 fattr->cf_mode |= S_IFBLK | cifs_sb->ctx->file_mode;
740 fattr->cf_dtype = DT_BLK;
741 } else if (symlink || reparse_tag == IO_REPARSE_TAG_SYMLINK ||
742 reparse_tag == IO_REPARSE_TAG_NFS) {
743 fattr->cf_mode = S_IFLNK;
744 fattr->cf_dtype = DT_LNK;
745 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
746 fattr->cf_mode = S_IFDIR | cifs_sb->ctx->dir_mode;
747 fattr->cf_dtype = DT_DIR;
749 * Server can return wrong NumberOfLinks value for directories
750 * when Unix extensions are disabled - fake it.
753 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
755 fattr->cf_mode = S_IFREG | cifs_sb->ctx->file_mode;
756 fattr->cf_dtype = DT_REG;
758 /* clear write bits if ATTR_READONLY is set */
759 if (fattr->cf_cifsattrs & ATTR_READONLY)
760 fattr->cf_mode &= ~(S_IWUGO);
763 * Don't accept zero nlink from non-unix servers unless
764 * delete is pending. Instead mark it as unknown.
766 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
767 !info->DeletePending) {
768 cifs_dbg(VFS, "bogus file nlink value %u\n",
770 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
774 if (S_ISLNK(fattr->cf_mode)) {
775 if (likely(data->symlink_target))
776 fattr->cf_eof = strnlen(data->symlink_target, PATH_MAX);
777 fattr->cf_symlink_target = data->symlink_target;
778 data->symlink_target = NULL;
781 fattr->cf_uid = cifs_sb->ctx->linux_uid;
782 fattr->cf_gid = cifs_sb->ctx->linux_gid;
786 cifs_get_file_info(struct file *filp)
790 struct cifs_open_info_data data = {};
791 struct cifs_fattr fattr;
792 struct inode *inode = file_inode(filp);
793 struct cifsFileInfo *cfile = filp->private_data;
794 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
795 struct TCP_Server_Info *server = tcon->ses->server;
796 bool symlink = false;
799 if (!server->ops->query_file_info)
803 rc = server->ops->query_file_info(xid, tcon, cfile, &data);
806 /* TODO: add support to query reparse tag */
807 if (data.symlink_target) {
809 tag = IO_REPARSE_TAG_SYMLINK;
811 cifs_open_info_to_fattr(&fattr, &data, inode->i_sb, false, symlink, tag);
814 cifs_create_dfs_fattr(&fattr, inode->i_sb);
820 * FIXME: legacy server -- fall back to path-based call?
821 * for now, just skip revalidating and mark inode for
825 CIFS_I(inode)->time = 0;
832 * don't bother with SFU junk here -- just mark inode as needing
835 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
836 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
837 /* if filetype is different, return error */
838 rc = cifs_fattr_to_inode(inode, &fattr);
840 cifs_free_open_info(&data);
845 /* Simple function to return a 64 bit hash of string. Rarely called */
846 static __u64 simple_hashstr(const char *str)
848 const __u64 hash_mult = 1125899906842597ULL; /* a big enough prime */
852 hash = (hash + (__u64) *str++) * hash_mult;
857 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
859 * cifs_backup_query_path_info - SMB1 fallback code to get ino
861 * Fallback code to get file metadata when we don't have access to
862 * full_path (EACCES) and have backup creds.
864 * @xid: transaction id used to identify original request in logs
865 * @tcon: information about the server share we have mounted
866 * @sb: the superblock stores info such as disk space available
867 * @full_path: name of the file we are getting the metadata for
868 * @resp_buf: will be set to cifs resp buf and needs to be freed with
869 * cifs_buf_release() when done with @data
870 * @data: will be set to search info result buffer
873 cifs_backup_query_path_info(int xid,
874 struct cifs_tcon *tcon,
875 struct super_block *sb,
876 const char *full_path,
878 FILE_ALL_INFO **data)
880 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
881 struct cifs_search_info info = {0};
886 info.endOfSearch = false;
888 info.info_level = SMB_FIND_FILE_UNIX;
889 else if ((tcon->ses->capabilities &
890 tcon->ses->server->vals->cap_nt_find) == 0)
891 info.info_level = SMB_FIND_FILE_INFO_STANDARD;
892 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
893 info.info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
894 else /* no srvino useful for fallback to some netapp */
895 info.info_level = SMB_FIND_FILE_DIRECTORY_INFO;
897 flags = CIFS_SEARCH_CLOSE_ALWAYS |
898 CIFS_SEARCH_CLOSE_AT_END |
899 CIFS_SEARCH_BACKUP_SEARCH;
901 rc = CIFSFindFirst(xid, tcon, full_path,
902 cifs_sb, NULL, flags, &info, false);
906 *resp_buf = (void *)info.ntwrk_buf_start;
907 *data = (FILE_ALL_INFO *)info.srch_entries_start;
910 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
912 static void cifs_set_fattr_ino(int xid, struct cifs_tcon *tcon, struct super_block *sb,
913 struct inode **inode, const char *full_path,
914 struct cifs_open_info_data *data, struct cifs_fattr *fattr)
916 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
917 struct TCP_Server_Info *server = tcon->ses->server;
920 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
922 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
924 fattr->cf_uniqueid = iunique(sb, ROOT_I);
929 * If we have an inode pass a NULL tcon to ensure we don't
930 * make a round trip to the server. This only works for SMB2+.
932 rc = server->ops->get_srv_inum(xid, *inode ? NULL : tcon, cifs_sb, full_path,
933 &fattr->cf_uniqueid, data);
936 * If that fails reuse existing ino or generate one
937 * and disable server ones
940 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
942 fattr->cf_uniqueid = iunique(sb, ROOT_I);
943 cifs_autodisable_serverino(cifs_sb);
948 /* If no errors, check for zero root inode (invalid) */
949 if (fattr->cf_uniqueid == 0 && strlen(full_path) == 0) {
950 cifs_dbg(FYI, "Invalid (0) inodenum\n");
953 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
955 /* make an ino by hashing the UNC */
956 fattr->cf_flags |= CIFS_FATTR_FAKE_ROOT_INO;
957 fattr->cf_uniqueid = simple_hashstr(tcon->tree_name);
962 static inline bool is_inode_cache_good(struct inode *ino)
964 return ino && CIFS_CACHE_READ(CIFS_I(ino)) && CIFS_I(ino)->time != 0;
967 int cifs_get_inode_info(struct inode **inode, const char *full_path,
968 struct cifs_open_info_data *data, struct super_block *sb, int xid,
969 const struct cifs_fid *fid)
971 struct cifs_tcon *tcon;
972 struct TCP_Server_Info *server;
973 struct tcon_link *tlink;
974 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
975 bool adjust_tz = false;
976 struct cifs_fattr fattr = {0};
977 bool is_reparse_point = false;
978 struct cifs_open_info_data tmp_data = {};
979 void *smb1_backup_rsp_buf = NULL;
982 __u32 reparse_tag = 0;
984 tlink = cifs_sb_tlink(cifs_sb);
986 return PTR_ERR(tlink);
987 tcon = tlink_tcon(tlink);
988 server = tcon->ses->server;
991 * 1. Fetch file metadata if not provided (data)
995 if (is_inode_cache_good(*inode)) {
996 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
999 rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path, &tmp_data,
1000 &adjust_tz, &is_reparse_point);
1005 * 2. Convert it to internal cifs metadata (fattr)
1011 * If the file is a reparse point, it is more complicated
1012 * since we have to check if its reparse tag matches a known
1013 * special file type e.g. symlink or fifo or char etc.
1015 if (is_reparse_point && data->symlink_target) {
1016 reparse_tag = IO_REPARSE_TAG_SYMLINK;
1017 } else if ((le32_to_cpu(data->fi.Attributes) & ATTR_REPARSE) &&
1018 server->ops->query_reparse_tag) {
1019 tmprc = server->ops->query_reparse_tag(xid, tcon, cifs_sb, full_path,
1022 cifs_dbg(FYI, "%s: query_reparse_tag: rc = %d\n", __func__, tmprc);
1023 if (server->ops->query_symlink) {
1024 tmprc = server->ops->query_symlink(xid, tcon, cifs_sb, full_path,
1025 &data->symlink_target,
1028 cifs_dbg(FYI, "%s: query_symlink: rc = %d\n", __func__,
1032 cifs_open_info_to_fattr(&fattr, data, sb, adjust_tz, is_reparse_point, reparse_tag);
1035 /* DFS link, no metadata available on this server */
1036 cifs_create_dfs_fattr(&fattr, sb);
1040 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1042 * perm errors, try again with backup flags if possible
1044 * For SMB2 and later the backup intent flag
1045 * is already sent if needed on open and there
1046 * is no path based FindFirst operation to use
1049 if (backup_cred(cifs_sb) && is_smb1_server(server)) {
1050 /* for easier reading */
1052 FILE_DIRECTORY_INFO *fdi;
1053 SEARCH_ID_FULL_DIR_INFO *si;
1055 rc = cifs_backup_query_path_info(xid, tcon, sb,
1057 &smb1_backup_rsp_buf,
1062 move_cifs_info_to_smb2(&data->fi, fi);
1063 fdi = (FILE_DIRECTORY_INFO *)fi;
1064 si = (SEARCH_ID_FULL_DIR_INFO *)fi;
1066 cifs_dir_info_to_fattr(&fattr, fdi, cifs_sb);
1067 fattr.cf_uniqueid = le64_to_cpu(si->UniqueId);
1068 /* uniqueid set, skip get inum step */
1069 goto handle_mnt_opt;
1071 /* nothing we can do, bail out */
1076 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1079 cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc);
1084 * 3. Get or update inode number (fattr.cf_uniqueid)
1087 cifs_set_fattr_ino(xid, tcon, sb, inode, full_path, data, &fattr);
1090 * 4. Tweak fattr based on mount options
1092 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1094 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1095 /* query for SFU type info if supported and needed */
1096 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
1097 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
1098 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
1100 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
1103 /* fill in 0777 bits from ACL */
1104 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID) {
1105 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, true,
1110 cifs_dbg(FYI, "%s: Get mode from SID failed. rc=%d\n",
1114 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
1115 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, false,
1120 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
1126 /* fill in remaining high mode bits e.g. SUID, VTX */
1127 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
1128 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
1130 /* check for Minshall+French symlinks */
1131 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
1132 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
1135 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
1139 * 5. Update inode with final fattr data
1143 *inode = cifs_iget(sb, &fattr);
1147 /* we already have inode, update it */
1149 /* if uniqueid is different, return error */
1150 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
1151 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
1152 CIFS_I(*inode)->time = 0; /* force reval */
1156 /* if filetype is different, return error */
1157 rc = cifs_fattr_to_inode(*inode, &fattr);
1160 cifs_buf_release(smb1_backup_rsp_buf);
1161 cifs_put_tlink(tlink);
1162 cifs_free_open_info(&tmp_data);
1163 kfree(fattr.cf_symlink_target);
1168 smb311_posix_get_inode_info(struct inode **inode,
1169 const char *full_path,
1170 struct super_block *sb, unsigned int xid)
1172 struct cifs_tcon *tcon;
1173 struct tcon_link *tlink;
1174 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1175 bool adjust_tz = false;
1176 struct cifs_fattr fattr = {0};
1177 bool symlink = false;
1178 struct cifs_open_info_data data = {};
1182 tlink = cifs_sb_tlink(cifs_sb);
1184 return PTR_ERR(tlink);
1185 tcon = tlink_tcon(tlink);
1188 * 1. Fetch file metadata
1191 if (is_inode_cache_good(*inode)) {
1192 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
1196 rc = smb311_posix_query_path_info(xid, tcon, cifs_sb, full_path, &data, &adjust_tz,
1200 * 2. Convert it to internal cifs metadata (fattr)
1205 smb311_posix_info_to_fattr(&fattr, &data, sb, adjust_tz, symlink);
1208 /* DFS link, no metadata available on this server */
1209 cifs_create_dfs_fattr(&fattr, sb);
1214 * For SMB2 and later the backup intent flag
1215 * is already sent if needed on open and there
1216 * is no path based FindFirst operation to use
1217 * to retry with so nothing we can do, bail out
1221 cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc);
1227 * 3. Tweak fattr based on mount options
1230 /* check for Minshall+French symlinks */
1231 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
1232 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
1235 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
1239 * 4. Update inode with final fattr data
1243 *inode = cifs_iget(sb, &fattr);
1247 /* we already have inode, update it */
1249 /* if uniqueid is different, return error */
1250 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
1251 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
1252 CIFS_I(*inode)->time = 0; /* force reval */
1257 /* if filetype is different, return error */
1258 rc = cifs_fattr_to_inode(*inode, &fattr);
1261 cifs_put_tlink(tlink);
1262 cifs_free_open_info(&data);
1263 kfree(fattr.cf_symlink_target);
1268 static const struct inode_operations cifs_ipc_inode_ops = {
1269 .lookup = cifs_lookup,
1273 cifs_find_inode(struct inode *inode, void *opaque)
1275 struct cifs_fattr *fattr = opaque;
1277 /* [!] The compared values must be the same in struct cifs_fscache_inode_key. */
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)) {
1525 oparms = (struct cifs_open_parms) {
1528 .desired_access = DELETE | FILE_WRITE_ATTRIBUTES,
1529 .create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR),
1530 .disposition = FILE_OPEN,
1535 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1539 origattr = cifsInode->cifsAttrs;
1541 origattr |= ATTR_NORMAL;
1543 dosattr = origattr & ~ATTR_READONLY;
1545 dosattr |= ATTR_NORMAL;
1546 dosattr |= ATTR_HIDDEN;
1548 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1549 if (dosattr != origattr) {
1550 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1551 if (info_buf == NULL) {
1555 info_buf->Attributes = cpu_to_le32(dosattr);
1556 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1558 /* although we would like to mark the file hidden
1559 if that fails we will still try to rename it */
1561 cifsInode->cifsAttrs = dosattr;
1563 dosattr = origattr; /* since not able to change them */
1566 /* rename the file */
1567 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1569 cifs_remap(cifs_sb));
1575 /* try to set DELETE_ON_CLOSE */
1576 if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1577 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1580 * some samba versions return -ENOENT when we try to set the
1581 * file disposition here. Likely a samba bug, but work around
1582 * it for now. This means that some cifsXXX files may hang
1583 * around after they shouldn't.
1585 * BB: remove this hack after more servers have the fix
1593 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1597 CIFSSMBClose(xid, tcon, fid.netfid);
1600 cifs_put_tlink(tlink);
1604 * reset everything back to the original state. Don't bother
1605 * dealing with errors here since we can't do anything about
1609 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1610 cifs_sb->local_nls, cifs_remap(cifs_sb));
1612 if (dosattr != origattr) {
1613 info_buf->Attributes = cpu_to_le32(origattr);
1614 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1616 cifsInode->cifsAttrs = origattr;
1621 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1623 /* copied from fs/nfs/dir.c with small changes */
1625 cifs_drop_nlink(struct inode *inode)
1627 spin_lock(&inode->i_lock);
1628 if (inode->i_nlink > 0)
1630 spin_unlock(&inode->i_lock);
1634 * If d_inode(dentry) is null (usually meaning the cached dentry
1635 * is a negative dentry) then we would attempt a standard SMB delete, but
1636 * if that fails we can not attempt the fall back mechanisms on EACCES
1637 * but will return the EACCES to the caller. Note that the VFS does not call
1638 * unlink on negative dentries currently.
1640 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1644 const char *full_path;
1646 struct inode *inode = d_inode(dentry);
1647 struct cifsInodeInfo *cifs_inode;
1648 struct super_block *sb = dir->i_sb;
1649 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1650 struct tcon_link *tlink;
1651 struct cifs_tcon *tcon;
1652 struct TCP_Server_Info *server;
1653 struct iattr *attrs = NULL;
1654 __u32 dosattr = 0, origattr = 0;
1656 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1658 if (unlikely(cifs_forced_shutdown(cifs_sb)))
1661 tlink = cifs_sb_tlink(cifs_sb);
1663 return PTR_ERR(tlink);
1664 tcon = tlink_tcon(tlink);
1665 server = tcon->ses->server;
1668 page = alloc_dentry_path();
1670 if (tcon->nodelete) {
1675 /* Unlink can be called from rename so we can not take the
1676 * sb->s_vfs_rename_mutex here */
1677 full_path = build_path_from_dentry(dentry, page);
1678 if (IS_ERR(full_path)) {
1679 rc = PTR_ERR(full_path);
1683 cifs_close_deferred_file_under_dentry(tcon, full_path);
1684 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1685 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1686 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1687 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1688 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1689 cifs_remap(cifs_sb));
1690 cifs_dbg(FYI, "posix del rc %d\n", rc);
1691 if ((rc == 0) || (rc == -ENOENT))
1692 goto psx_del_no_retry;
1694 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1697 if (!server->ops->unlink) {
1699 goto psx_del_no_retry;
1702 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1707 cifs_drop_nlink(inode);
1708 } else if (rc == -ENOENT) {
1710 } else if (rc == -EBUSY) {
1711 if (server->ops->rename_pending_delete) {
1712 rc = server->ops->rename_pending_delete(full_path,
1715 cifs_drop_nlink(inode);
1717 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1718 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1719 if (attrs == NULL) {
1724 /* try to reset dos attributes */
1725 cifs_inode = CIFS_I(inode);
1726 origattr = cifs_inode->cifsAttrs;
1728 origattr |= ATTR_NORMAL;
1729 dosattr = origattr & ~ATTR_READONLY;
1731 dosattr |= ATTR_NORMAL;
1732 dosattr |= ATTR_HIDDEN;
1734 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1738 goto retry_std_delete;
1741 /* undo the setattr if we errored out and it's needed */
1742 if (rc != 0 && dosattr != 0)
1743 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1747 cifs_inode = CIFS_I(inode);
1748 cifs_inode->time = 0; /* will force revalidate to get info
1750 inode->i_ctime = current_time(inode);
1752 dir->i_ctime = dir->i_mtime = current_time(dir);
1753 cifs_inode = CIFS_I(dir);
1754 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1756 free_dentry_path(page);
1759 cifs_put_tlink(tlink);
1764 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1765 const char *full_path, struct cifs_sb_info *cifs_sb,
1766 struct cifs_tcon *tcon, const unsigned int xid)
1769 struct inode *inode = NULL;
1771 if (tcon->posix_extensions)
1772 rc = smb311_posix_get_inode_info(&inode, full_path, parent->i_sb, xid);
1773 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1774 else if (tcon->unix_ext)
1775 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1777 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1779 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1785 if (!S_ISDIR(inode->i_mode)) {
1787 * mkdir succeeded, but another client has managed to remove the
1788 * sucker and replace it with non-directory. Return success,
1789 * but don't leave the child in dcache.
1796 * setting nlink not necessary except in cases where we failed to get it
1797 * from the server or was set bogus. Also, since this is a brand new
1798 * inode, no need to grab the i_lock before setting the i_nlink.
1800 if (inode->i_nlink < 2)
1801 set_nlink(inode, 2);
1802 mode &= ~current_umask();
1803 /* must turn on setgid bit if parent dir has it */
1804 if (parent->i_mode & S_ISGID)
1807 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1808 if (tcon->unix_ext) {
1809 struct cifs_unix_set_info_args args = {
1811 .ctime = NO_CHANGE_64,
1812 .atime = NO_CHANGE_64,
1813 .mtime = NO_CHANGE_64,
1816 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1817 args.uid = current_fsuid();
1818 if (parent->i_mode & S_ISGID)
1819 args.gid = parent->i_gid;
1821 args.gid = current_fsgid();
1823 args.uid = INVALID_UID; /* no change */
1824 args.gid = INVALID_GID; /* no change */
1826 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1828 cifs_remap(cifs_sb));
1832 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1833 struct TCP_Server_Info *server = tcon->ses->server;
1834 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1835 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1836 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1838 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1839 inode->i_mode = (mode | S_IFDIR);
1841 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1842 inode->i_uid = current_fsuid();
1843 if (inode->i_mode & S_ISGID)
1844 inode->i_gid = parent->i_gid;
1846 inode->i_gid = current_fsgid();
1849 d_instantiate(dentry, inode);
1853 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1855 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1856 const char *full_path, struct cifs_sb_info *cifs_sb,
1857 struct cifs_tcon *tcon, const unsigned int xid)
1861 FILE_UNIX_BASIC_INFO *info = NULL;
1862 struct inode *newinode = NULL;
1863 struct cifs_fattr fattr;
1865 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1868 goto posix_mkdir_out;
1871 mode &= ~current_umask();
1872 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1873 NULL /* netfid */, info, &oplock, full_path,
1874 cifs_sb->local_nls, cifs_remap(cifs_sb));
1875 if (rc == -EOPNOTSUPP)
1876 goto posix_mkdir_out;
1878 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1880 goto posix_mkdir_out;
1883 if (info->Type == cpu_to_le32(-1))
1884 /* no return info, go query for it */
1885 goto posix_mkdir_get_info;
1887 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1888 * need to set uid/gid.
1891 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1892 cifs_fill_uniqueid(inode->i_sb, &fattr);
1893 newinode = cifs_iget(inode->i_sb, &fattr);
1895 goto posix_mkdir_get_info;
1897 d_instantiate(dentry, newinode);
1899 #ifdef CONFIG_CIFS_DEBUG2
1900 cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1901 dentry, dentry, newinode);
1903 if (newinode->i_nlink != 2)
1904 cifs_dbg(FYI, "unexpected number of links %d\n",
1911 posix_mkdir_get_info:
1912 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1914 goto posix_mkdir_out;
1916 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1918 int cifs_mkdir(struct user_namespace *mnt_userns, struct inode *inode,
1919 struct dentry *direntry, umode_t mode)
1923 struct cifs_sb_info *cifs_sb;
1924 struct tcon_link *tlink;
1925 struct cifs_tcon *tcon;
1926 struct TCP_Server_Info *server;
1927 const char *full_path;
1930 cifs_dbg(FYI, "In cifs_mkdir, mode = %04ho inode = 0x%p\n",
1933 cifs_sb = CIFS_SB(inode->i_sb);
1934 if (unlikely(cifs_forced_shutdown(cifs_sb)))
1936 tlink = cifs_sb_tlink(cifs_sb);
1938 return PTR_ERR(tlink);
1939 tcon = tlink_tcon(tlink);
1943 page = alloc_dentry_path();
1944 full_path = build_path_from_dentry(direntry, page);
1945 if (IS_ERR(full_path)) {
1946 rc = PTR_ERR(full_path);
1950 server = tcon->ses->server;
1952 if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) {
1953 rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,
1955 d_drop(direntry); /* for time being always refresh inode info */
1959 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1960 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1961 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1962 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1964 if (rc != -EOPNOTSUPP)
1967 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1969 if (!server->ops->mkdir) {
1974 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1975 rc = server->ops->mkdir(xid, inode, mode, tcon, full_path, cifs_sb);
1977 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1982 /* TODO: skip this for smb2/smb3 */
1983 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1987 * Force revalidate to get parent dir info when needed since cached
1988 * attributes are invalid now.
1990 CIFS_I(inode)->time = 0;
1991 free_dentry_path(page);
1993 cifs_put_tlink(tlink);
1997 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
2001 struct cifs_sb_info *cifs_sb;
2002 struct tcon_link *tlink;
2003 struct cifs_tcon *tcon;
2004 struct TCP_Server_Info *server;
2005 const char *full_path;
2006 void *page = alloc_dentry_path();
2007 struct cifsInodeInfo *cifsInode;
2009 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
2013 full_path = build_path_from_dentry(direntry, page);
2014 if (IS_ERR(full_path)) {
2015 rc = PTR_ERR(full_path);
2019 cifs_sb = CIFS_SB(inode->i_sb);
2020 if (unlikely(cifs_forced_shutdown(cifs_sb))) {
2025 tlink = cifs_sb_tlink(cifs_sb);
2026 if (IS_ERR(tlink)) {
2027 rc = PTR_ERR(tlink);
2030 tcon = tlink_tcon(tlink);
2031 server = tcon->ses->server;
2033 if (!server->ops->rmdir) {
2035 cifs_put_tlink(tlink);
2039 if (tcon->nodelete) {
2041 cifs_put_tlink(tlink);
2045 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
2046 cifs_put_tlink(tlink);
2049 spin_lock(&d_inode(direntry)->i_lock);
2050 i_size_write(d_inode(direntry), 0);
2051 clear_nlink(d_inode(direntry));
2052 spin_unlock(&d_inode(direntry)->i_lock);
2055 cifsInode = CIFS_I(d_inode(direntry));
2056 /* force revalidate to go get info when needed */
2057 cifsInode->time = 0;
2059 cifsInode = CIFS_I(inode);
2061 * Force revalidate to get parent dir info when needed since cached
2062 * attributes are invalid now.
2064 cifsInode->time = 0;
2066 d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
2067 current_time(inode);
2070 free_dentry_path(page);
2076 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
2077 const char *from_path, struct dentry *to_dentry,
2078 const char *to_path)
2080 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
2081 struct tcon_link *tlink;
2082 struct cifs_tcon *tcon;
2083 struct TCP_Server_Info *server;
2084 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2085 struct cifs_fid fid;
2086 struct cifs_open_parms oparms;
2088 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2091 tlink = cifs_sb_tlink(cifs_sb);
2093 return PTR_ERR(tlink);
2094 tcon = tlink_tcon(tlink);
2095 server = tcon->ses->server;
2097 if (!server->ops->rename)
2100 /* try path-based rename first */
2101 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
2104 * Don't bother with rename by filehandle unless file is busy and
2105 * source. Note that cross directory moves do not work with
2106 * rename by filehandle to various Windows servers.
2108 if (rc == 0 || rc != -EBUSY)
2109 goto do_rename_exit;
2111 /* Don't fall back to using SMB on SMB 2+ mount */
2112 if (server->vals->protocol_id != 0)
2113 goto do_rename_exit;
2115 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2116 /* open-file renames don't work across directories */
2117 if (to_dentry->d_parent != from_dentry->d_parent)
2118 goto do_rename_exit;
2120 oparms = (struct cifs_open_parms) {
2123 /* open the file to be renamed -- we need DELETE perms */
2124 .desired_access = DELETE,
2125 .create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR),
2126 .disposition = FILE_OPEN,
2131 rc = CIFS_open(xid, &oparms, &oplock, NULL);
2133 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
2134 (const char *) to_dentry->d_name.name,
2135 cifs_sb->local_nls, cifs_remap(cifs_sb));
2136 CIFSSMBClose(xid, tcon, fid.netfid);
2138 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2141 d_move(from_dentry, to_dentry);
2142 cifs_put_tlink(tlink);
2147 cifs_rename2(struct user_namespace *mnt_userns, struct inode *source_dir,
2148 struct dentry *source_dentry, struct inode *target_dir,
2149 struct dentry *target_dentry, unsigned int flags)
2151 const char *from_name, *to_name;
2152 void *page1, *page2;
2153 struct cifs_sb_info *cifs_sb;
2154 struct tcon_link *tlink;
2155 struct cifs_tcon *tcon;
2158 int retry_count = 0;
2159 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
2160 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2161 FILE_UNIX_BASIC_INFO *info_buf_target;
2162 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2164 if (flags & ~RENAME_NOREPLACE)
2167 cifs_sb = CIFS_SB(source_dir->i_sb);
2168 if (unlikely(cifs_forced_shutdown(cifs_sb)))
2171 tlink = cifs_sb_tlink(cifs_sb);
2173 return PTR_ERR(tlink);
2174 tcon = tlink_tcon(tlink);
2176 page1 = alloc_dentry_path();
2177 page2 = alloc_dentry_path();
2180 from_name = build_path_from_dentry(source_dentry, page1);
2181 if (IS_ERR(from_name)) {
2182 rc = PTR_ERR(from_name);
2183 goto cifs_rename_exit;
2186 to_name = build_path_from_dentry(target_dentry, page2);
2187 if (IS_ERR(to_name)) {
2188 rc = PTR_ERR(to_name);
2189 goto cifs_rename_exit;
2192 cifs_close_deferred_file_under_dentry(tcon, from_name);
2193 if (d_inode(target_dentry) != NULL)
2194 cifs_close_deferred_file_under_dentry(tcon, to_name);
2196 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2199 if (rc == -EACCES) {
2200 while (retry_count < 3) {
2201 cifs_close_all_deferred_files(tcon);
2202 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2211 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
2213 if (flags & RENAME_NOREPLACE)
2214 goto cifs_rename_exit;
2216 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2217 if (rc == -EEXIST && tcon->unix_ext) {
2219 * Are src and dst hardlinks of same inode? We can only tell
2220 * with unix extensions enabled.
2223 kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
2225 if (info_buf_source == NULL) {
2227 goto cifs_rename_exit;
2230 info_buf_target = info_buf_source + 1;
2231 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
2234 cifs_remap(cifs_sb));
2238 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
2241 cifs_remap(cifs_sb));
2243 if (tmprc == 0 && (info_buf_source->UniqueId ==
2244 info_buf_target->UniqueId)) {
2245 /* same file, POSIX says that this is a noop */
2247 goto cifs_rename_exit;
2251 * else ... BB we could add the same check for Windows by
2252 * checking the UniqueId via FILE_INTERNAL_INFO
2256 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2258 /* Try unlinking the target dentry if it's not negative */
2259 if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
2260 if (d_is_dir(target_dentry))
2261 tmprc = cifs_rmdir(target_dir, target_dentry);
2263 tmprc = cifs_unlink(target_dir, target_dentry);
2265 goto cifs_rename_exit;
2266 rc = cifs_do_rename(xid, source_dentry, from_name,
2267 target_dentry, to_name);
2270 /* force revalidate to go get info when needed */
2271 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
2273 source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
2274 target_dir->i_mtime = current_time(source_dir);
2277 kfree(info_buf_source);
2278 free_dentry_path(page2);
2279 free_dentry_path(page1);
2281 cifs_put_tlink(tlink);
2286 cifs_dentry_needs_reval(struct dentry *dentry)
2288 struct inode *inode = d_inode(dentry);
2289 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2290 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2291 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2292 struct cached_fid *cfid = NULL;
2294 if (cifs_i->time == 0)
2297 if (CIFS_CACHE_READ(cifs_i))
2300 if (!lookupCacheEnabled)
2303 if (!open_cached_dir_by_dentry(tcon, dentry->d_parent, &cfid)) {
2304 spin_lock(&cfid->fid_lock);
2305 if (cfid->time && cifs_i->time > cfid->time) {
2306 spin_unlock(&cfid->fid_lock);
2307 close_cached_dir(cfid);
2310 spin_unlock(&cfid->fid_lock);
2311 close_cached_dir(cfid);
2314 * depending on inode type, check if attribute caching disabled for
2315 * files or directories
2317 if (S_ISDIR(inode->i_mode)) {
2318 if (!cifs_sb->ctx->acdirmax)
2320 if (!time_in_range(jiffies, cifs_i->time,
2321 cifs_i->time + cifs_sb->ctx->acdirmax))
2324 if (!cifs_sb->ctx->acregmax)
2326 if (!time_in_range(jiffies, cifs_i->time,
2327 cifs_i->time + cifs_sb->ctx->acregmax))
2331 /* hardlinked files w/ noserverino get "special" treatment */
2332 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
2333 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
2340 * Zap the cache. Called when invalid_mapping flag is set.
2343 cifs_invalidate_mapping(struct inode *inode)
2347 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
2348 rc = invalidate_inode_pages2(inode->i_mapping);
2350 cifs_dbg(VFS, "%s: Could not invalidate inode %p\n",
2358 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
2360 * @key: currently unused
2361 * @mode: the task state to sleep in
2364 cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
2367 if (signal_pending_state(mode, current))
2368 return -ERESTARTSYS;
2373 cifs_revalidate_mapping(struct inode *inode)
2376 unsigned long *flags = &CIFS_I(inode)->flags;
2377 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2379 /* swapfiles are not supposed to be shared */
2380 if (IS_SWAPFILE(inode))
2383 rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
2384 TASK_KILLABLE|TASK_FREEZABLE_UNSAFE);
2388 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
2389 /* for cache=singleclient, do not invalidate */
2390 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE)
2391 goto skip_invalidate;
2393 rc = cifs_invalidate_mapping(inode);
2395 set_bit(CIFS_INO_INVALID_MAPPING, flags);
2399 clear_bit_unlock(CIFS_INO_LOCK, flags);
2400 smp_mb__after_atomic();
2401 wake_up_bit(flags, CIFS_INO_LOCK);
2407 cifs_zap_mapping(struct inode *inode)
2409 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
2410 return cifs_revalidate_mapping(inode);
2413 int cifs_revalidate_file_attr(struct file *filp)
2416 struct dentry *dentry = file_dentry(filp);
2417 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2418 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
2419 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2421 if (!cifs_dentry_needs_reval(dentry))
2424 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2425 if (tlink_tcon(cfile->tlink)->unix_ext)
2426 rc = cifs_get_file_info_unix(filp);
2428 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2429 rc = cifs_get_file_info(filp);
2434 int cifs_revalidate_dentry_attr(struct dentry *dentry)
2438 struct inode *inode = d_inode(dentry);
2439 struct super_block *sb = dentry->d_sb;
2440 const char *full_path;
2447 if (!cifs_dentry_needs_reval(dentry))
2452 page = alloc_dentry_path();
2453 full_path = build_path_from_dentry(dentry, page);
2454 if (IS_ERR(full_path)) {
2455 rc = PTR_ERR(full_path);
2459 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2460 full_path, inode, inode->i_count.counter,
2461 dentry, cifs_get_time(dentry), jiffies);
2464 if (cifs_sb_master_tcon(CIFS_SB(sb))->posix_extensions)
2465 rc = smb311_posix_get_inode_info(&inode, full_path, sb, xid);
2466 else if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
2467 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2469 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2471 if (rc == -EAGAIN && count++ < 10)
2474 free_dentry_path(page);
2480 int cifs_revalidate_file(struct file *filp)
2483 struct inode *inode = file_inode(filp);
2485 rc = cifs_revalidate_file_attr(filp);
2489 return cifs_revalidate_mapping(inode);
2492 /* revalidate a dentry's inode attributes */
2493 int cifs_revalidate_dentry(struct dentry *dentry)
2496 struct inode *inode = d_inode(dentry);
2498 rc = cifs_revalidate_dentry_attr(dentry);
2502 return cifs_revalidate_mapping(inode);
2505 int cifs_getattr(struct user_namespace *mnt_userns, const struct path *path,
2506 struct kstat *stat, u32 request_mask, unsigned int flags)
2508 struct dentry *dentry = path->dentry;
2509 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2510 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2511 struct inode *inode = d_inode(dentry);
2514 if (unlikely(cifs_forced_shutdown(CIFS_SB(inode->i_sb))))
2518 * We need to be sure that all dirty pages are written and the server
2519 * has actual ctime, mtime and file length.
2521 if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_SIZE | STATX_BLOCKS)) &&
2522 !CIFS_CACHE_READ(CIFS_I(inode)) &&
2523 inode->i_mapping && inode->i_mapping->nrpages != 0) {
2524 rc = filemap_fdatawait(inode->i_mapping);
2526 mapping_set_error(inode->i_mapping, rc);
2531 if ((flags & AT_STATX_SYNC_TYPE) == AT_STATX_FORCE_SYNC)
2532 CIFS_I(inode)->time = 0; /* force revalidate */
2535 * If the caller doesn't require syncing, only sync if
2536 * necessary (e.g. due to earlier truncate or setattr
2537 * invalidating the cached metadata)
2539 if (((flags & AT_STATX_SYNC_TYPE) != AT_STATX_DONT_SYNC) ||
2540 (CIFS_I(inode)->time == 0)) {
2541 rc = cifs_revalidate_dentry_attr(dentry);
2546 generic_fillattr(&init_user_ns, inode, stat);
2547 stat->blksize = cifs_sb->ctx->bsize;
2548 stat->ino = CIFS_I(inode)->uniqueid;
2550 /* old CIFS Unix Extensions doesn't return create time */
2551 if (CIFS_I(inode)->createtime) {
2552 stat->result_mask |= STATX_BTIME;
2554 cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
2557 stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2558 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2559 stat->attributes |= STATX_ATTR_COMPRESSED;
2560 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2561 stat->attributes |= STATX_ATTR_ENCRYPTED;
2564 * If on a multiuser mount without unix extensions or cifsacl being
2565 * enabled, and the admin hasn't overridden them, set the ownership
2566 * to the fsuid/fsgid of the current process.
2568 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2569 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2571 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2572 stat->uid = current_fsuid();
2573 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2574 stat->gid = current_fsgid();
2579 int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start,
2582 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2583 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_i->netfs.inode.i_sb);
2584 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2585 struct TCP_Server_Info *server = tcon->ses->server;
2586 struct cifsFileInfo *cfile;
2589 if (unlikely(cifs_forced_shutdown(cifs_sb)))
2593 * We need to be sure that all dirty pages are written as they
2594 * might fill holes on the server.
2596 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2597 inode->i_mapping->nrpages != 0) {
2598 rc = filemap_fdatawait(inode->i_mapping);
2600 mapping_set_error(inode->i_mapping, rc);
2605 cfile = find_readable_file(cifs_i, false);
2609 if (server->ops->fiemap) {
2610 rc = server->ops->fiemap(tcon, cfile, fei, start, len);
2611 cifsFileInfo_put(cfile);
2615 cifsFileInfo_put(cfile);
2619 int cifs_truncate_page(struct address_space *mapping, loff_t from)
2621 pgoff_t index = from >> PAGE_SHIFT;
2622 unsigned offset = from & (PAGE_SIZE - 1);
2626 page = grab_cache_page(mapping, index);
2630 zero_user_segment(page, offset, PAGE_SIZE);
2636 void cifs_setsize(struct inode *inode, loff_t offset)
2638 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2640 spin_lock(&inode->i_lock);
2641 i_size_write(inode, offset);
2642 spin_unlock(&inode->i_lock);
2644 /* Cached inode must be refreshed on truncate */
2646 truncate_pagecache(inode, offset);
2650 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2651 unsigned int xid, const char *full_path)
2654 struct cifsFileInfo *open_file;
2655 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2656 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2657 struct tcon_link *tlink = NULL;
2658 struct cifs_tcon *tcon = NULL;
2659 struct TCP_Server_Info *server;
2662 * To avoid spurious oplock breaks from server, in the case of
2663 * inodes that we already have open, avoid doing path based
2664 * setting of file size if we can do it by handle.
2665 * This keeps our caching token (oplock) and avoids timeouts
2666 * when the local oplock break takes longer to flush
2667 * writebehind data than the SMB timeout for the SetPathInfo
2668 * request would allow
2670 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2672 tcon = tlink_tcon(open_file->tlink);
2673 server = tcon->ses->server;
2674 if (server->ops->set_file_size)
2675 rc = server->ops->set_file_size(xid, tcon, open_file,
2676 attrs->ia_size, false);
2679 cifsFileInfo_put(open_file);
2680 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2688 tlink = cifs_sb_tlink(cifs_sb);
2690 return PTR_ERR(tlink);
2691 tcon = tlink_tcon(tlink);
2692 server = tcon->ses->server;
2696 * Set file size by pathname rather than by handle either because no
2697 * valid, writeable file handle for it was found or because there was
2698 * an error setting it by handle.
2700 if (server->ops->set_path_size)
2701 rc = server->ops->set_path_size(xid, tcon, full_path,
2702 attrs->ia_size, cifs_sb, false);
2705 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2708 cifs_put_tlink(tlink);
2712 cifsInode->server_eof = attrs->ia_size;
2713 cifs_setsize(inode, attrs->ia_size);
2715 * i_blocks is not related to (i_size / i_blksize), but instead
2716 * 512 byte (2**9) size is required for calculating num blocks.
2717 * Until we can query the server for actual allocation size,
2718 * this is best estimate we have for blocks allocated for a file
2719 * Number of blocks must be rounded up so size 1 is not 0 blocks
2721 inode->i_blocks = (512 - 1 + attrs->ia_size) >> 9;
2724 * The man page of truncate says if the size changed,
2725 * then the st_ctime and st_mtime fields for the file
2728 attrs->ia_ctime = attrs->ia_mtime = current_time(inode);
2729 attrs->ia_valid |= ATTR_CTIME | ATTR_MTIME;
2731 cifs_truncate_page(inode->i_mapping, inode->i_size);
2737 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2739 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2743 const char *full_path;
2744 void *page = alloc_dentry_path();
2745 struct inode *inode = d_inode(direntry);
2746 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2747 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2748 struct tcon_link *tlink;
2749 struct cifs_tcon *pTcon;
2750 struct cifs_unix_set_info_args *args = NULL;
2751 struct cifsFileInfo *open_file;
2753 cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2754 direntry, attrs->ia_valid);
2758 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2759 attrs->ia_valid |= ATTR_FORCE;
2761 rc = setattr_prepare(&init_user_ns, direntry, attrs);
2765 full_path = build_path_from_dentry(direntry, page);
2766 if (IS_ERR(full_path)) {
2767 rc = PTR_ERR(full_path);
2772 * Attempt to flush data before changing attributes. We need to do
2773 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2774 * ownership or mode then we may also need to do this. Here, we take
2775 * the safe way out and just do the flush on all setattr requests. If
2776 * the flush returns error, store it to report later and continue.
2778 * BB: This should be smarter. Why bother flushing pages that
2779 * will be truncated anyway? Also, should we error out here if
2780 * the flush returns error?
2782 rc = filemap_write_and_wait(inode->i_mapping);
2783 if (is_interrupt_error(rc)) {
2788 mapping_set_error(inode->i_mapping, rc);
2791 if (attrs->ia_valid & ATTR_SIZE) {
2792 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2797 /* skip mode change if it's just for clearing setuid/setgid */
2798 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2799 attrs->ia_valid &= ~ATTR_MODE;
2801 args = kmalloc(sizeof(*args), GFP_KERNEL);
2807 /* set up the struct */
2808 if (attrs->ia_valid & ATTR_MODE)
2809 args->mode = attrs->ia_mode;
2811 args->mode = NO_CHANGE_64;
2813 if (attrs->ia_valid & ATTR_UID)
2814 args->uid = attrs->ia_uid;
2816 args->uid = INVALID_UID; /* no change */
2818 if (attrs->ia_valid & ATTR_GID)
2819 args->gid = attrs->ia_gid;
2821 args->gid = INVALID_GID; /* no change */
2823 if (attrs->ia_valid & ATTR_ATIME)
2824 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2826 args->atime = NO_CHANGE_64;
2828 if (attrs->ia_valid & ATTR_MTIME)
2829 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2831 args->mtime = NO_CHANGE_64;
2833 if (attrs->ia_valid & ATTR_CTIME)
2834 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2836 args->ctime = NO_CHANGE_64;
2839 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2841 u16 nfid = open_file->fid.netfid;
2842 u32 npid = open_file->pid;
2843 pTcon = tlink_tcon(open_file->tlink);
2844 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2845 cifsFileInfo_put(open_file);
2847 tlink = cifs_sb_tlink(cifs_sb);
2848 if (IS_ERR(tlink)) {
2849 rc = PTR_ERR(tlink);
2852 pTcon = tlink_tcon(tlink);
2853 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2855 cifs_remap(cifs_sb));
2856 cifs_put_tlink(tlink);
2862 if ((attrs->ia_valid & ATTR_SIZE) &&
2863 attrs->ia_size != i_size_read(inode)) {
2864 truncate_setsize(inode, attrs->ia_size);
2865 fscache_resize_cookie(cifs_inode_cookie(inode), attrs->ia_size);
2868 setattr_copy(&init_user_ns, inode, attrs);
2869 mark_inode_dirty(inode);
2871 /* force revalidate when any of these times are set since some
2872 of the fs types (eg ext3, fat) do not have fine enough
2873 time granularity to match protocol, and we do not have a
2874 a way (yet) to query the server fs's time granularity (and
2875 whether it rounds times down).
2877 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2878 cifsInode->time = 0;
2881 free_dentry_path(page);
2885 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2888 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2891 kuid_t uid = INVALID_UID;
2892 kgid_t gid = INVALID_GID;
2893 struct inode *inode = d_inode(direntry);
2894 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2895 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2896 struct cifsFileInfo *wfile;
2897 struct cifs_tcon *tcon;
2898 const char *full_path;
2899 void *page = alloc_dentry_path();
2902 __u64 mode = NO_CHANGE_64;
2906 cifs_dbg(FYI, "setattr on file %pd attrs->ia_valid 0x%x\n",
2907 direntry, attrs->ia_valid);
2909 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2910 attrs->ia_valid |= ATTR_FORCE;
2912 rc = setattr_prepare(&init_user_ns, direntry, attrs);
2914 goto cifs_setattr_exit;
2916 full_path = build_path_from_dentry(direntry, page);
2917 if (IS_ERR(full_path)) {
2918 rc = PTR_ERR(full_path);
2919 goto cifs_setattr_exit;
2923 * Attempt to flush data before changing attributes. We need to do
2924 * this for ATTR_SIZE and ATTR_MTIME. If the flush of the data
2925 * returns error, store it to report later and continue.
2927 * BB: This should be smarter. Why bother flushing pages that
2928 * will be truncated anyway? Also, should we error out here if
2929 * the flush returns error? Do we need to check for ATTR_MTIME_SET flag?
2931 if (attrs->ia_valid & (ATTR_MTIME | ATTR_SIZE | ATTR_CTIME)) {
2932 rc = filemap_write_and_wait(inode->i_mapping);
2933 if (is_interrupt_error(rc)) {
2935 goto cifs_setattr_exit;
2937 mapping_set_error(inode->i_mapping, rc);
2942 if ((attrs->ia_valid & ATTR_MTIME) &&
2943 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2944 rc = cifs_get_writable_file(cifsInode, FIND_WR_ANY, &wfile);
2946 tcon = tlink_tcon(wfile->tlink);
2947 rc = tcon->ses->server->ops->flush(xid, tcon, &wfile->fid);
2948 cifsFileInfo_put(wfile);
2950 goto cifs_setattr_exit;
2951 } else if (rc != -EBADF)
2952 goto cifs_setattr_exit;
2957 if (attrs->ia_valid & ATTR_SIZE) {
2958 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2960 goto cifs_setattr_exit;
2963 if (attrs->ia_valid & ATTR_UID)
2964 uid = attrs->ia_uid;
2966 if (attrs->ia_valid & ATTR_GID)
2967 gid = attrs->ia_gid;
2969 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2970 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2971 if (uid_valid(uid) || gid_valid(gid)) {
2972 mode = NO_CHANGE_64;
2973 rc = id_mode_to_cifs_acl(inode, full_path, &mode,
2976 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2978 goto cifs_setattr_exit;
2982 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2983 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2985 /* skip mode change if it's just for clearing setuid/setgid */
2986 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2987 attrs->ia_valid &= ~ATTR_MODE;
2989 if (attrs->ia_valid & ATTR_MODE) {
2990 mode = attrs->ia_mode;
2992 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2993 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2994 rc = id_mode_to_cifs_acl(inode, full_path, &mode,
2995 INVALID_UID, INVALID_GID);
2997 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2999 goto cifs_setattr_exit;
3003 * In case of CIFS_MOUNT_CIFS_ACL, we cannot support all modes.
3004 * Pick up the actual mode bits that were set.
3006 if (mode != attrs->ia_mode)
3007 attrs->ia_mode = mode;
3009 if (((mode & S_IWUGO) == 0) &&
3010 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
3012 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
3014 /* fix up mode if we're not using dynperm */
3015 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
3016 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
3017 } else if ((mode & S_IWUGO) &&
3018 (cifsInode->cifsAttrs & ATTR_READONLY)) {
3020 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
3021 /* Attributes of 0 are ignored */
3023 dosattr |= ATTR_NORMAL;
3025 /* reset local inode permissions to normal */
3026 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
3027 attrs->ia_mode &= ~(S_IALLUGO);
3028 if (S_ISDIR(inode->i_mode))
3030 cifs_sb->ctx->dir_mode;
3033 cifs_sb->ctx->file_mode;
3035 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
3036 /* ignore mode change - ATTR_READONLY hasn't changed */
3037 attrs->ia_valid &= ~ATTR_MODE;
3041 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
3042 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
3043 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
3044 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
3046 /* Even if error on time set, no sense failing the call if
3047 the server would set the time to a reasonable value anyway,
3048 and this check ensures that we are not being called from
3049 sys_utimes in which case we ought to fail the call back to
3050 the user when the server rejects the call */
3051 if ((rc) && (attrs->ia_valid &
3052 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
3056 /* do not need local check to inode_check_ok since the server does
3059 goto cifs_setattr_exit;
3061 if ((attrs->ia_valid & ATTR_SIZE) &&
3062 attrs->ia_size != i_size_read(inode)) {
3063 truncate_setsize(inode, attrs->ia_size);
3064 fscache_resize_cookie(cifs_inode_cookie(inode), attrs->ia_size);
3067 setattr_copy(&init_user_ns, inode, attrs);
3068 mark_inode_dirty(inode);
3072 free_dentry_path(page);
3077 cifs_setattr(struct user_namespace *mnt_userns, struct dentry *direntry,
3078 struct iattr *attrs)
3080 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
3081 int rc, retries = 0;
3082 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
3083 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
3084 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
3086 if (unlikely(cifs_forced_shutdown(cifs_sb)))
3090 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
3091 if (pTcon->unix_ext)
3092 rc = cifs_setattr_unix(direntry, attrs);
3094 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
3095 rc = cifs_setattr_nounix(direntry, attrs);
3097 } while (is_retryable_error(rc) && retries < 2);
3099 /* BB: add cifs_setattr_legacy for really old servers */