4 * Copyright (C) International Business Machines Corp., 2002,2010
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/stat.h>
23 #include <linux/slab.h>
24 #include <linux/pagemap.h>
25 #include <linux/freezer.h>
26 #include <linux/sched/signal.h>
27 #include <linux/wait_bit.h>
28 #include <linux/fiemap.h>
29 #include <asm/div64.h>
33 #include "cifsproto.h"
34 #include "smb2proto.h"
35 #include "cifs_debug.h"
36 #include "cifs_fs_sb.h"
37 #include "cifs_unicode.h"
39 #include "fs_context.h"
40 #include "cifs_ioctl.h"
42 static void cifs_set_ops(struct inode *inode)
44 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
46 switch (inode->i_mode & S_IFMT) {
48 inode->i_op = &cifs_file_inode_ops;
49 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
50 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
51 inode->i_fop = &cifs_file_direct_nobrl_ops;
53 inode->i_fop = &cifs_file_direct_ops;
54 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
55 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
56 inode->i_fop = &cifs_file_strict_nobrl_ops;
58 inode->i_fop = &cifs_file_strict_ops;
59 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
60 inode->i_fop = &cifs_file_nobrl_ops;
61 else { /* not direct, send byte range locks */
62 inode->i_fop = &cifs_file_ops;
65 /* check if server can support readpages */
66 if (cifs_sb_master_tcon(cifs_sb)->ses->server->max_read <
67 PAGE_SIZE + MAX_CIFS_HDR_SIZE)
68 inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
70 inode->i_data.a_ops = &cifs_addr_ops;
73 #ifdef CONFIG_CIFS_DFS_UPCALL
74 if (IS_AUTOMOUNT(inode)) {
75 inode->i_op = &cifs_dfs_referral_inode_operations;
77 #else /* NO DFS support, treat as a directory */
80 inode->i_op = &cifs_dir_inode_ops;
81 inode->i_fop = &cifs_dir_ops;
85 inode->i_op = &cifs_symlink_inode_ops;
88 init_special_inode(inode, inode->i_mode, inode->i_rdev);
93 /* check inode attributes against fattr. If they don't match, tag the
94 * inode for cache invalidation
97 cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
99 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
101 cifs_dbg(FYI, "%s: revalidating inode %llu\n",
102 __func__, cifs_i->uniqueid);
104 if (inode->i_state & I_NEW) {
105 cifs_dbg(FYI, "%s: inode %llu is new\n",
106 __func__, cifs_i->uniqueid);
110 /* don't bother with revalidation if we have an oplock */
111 if (CIFS_CACHE_READ(cifs_i)) {
112 cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
113 __func__, cifs_i->uniqueid);
117 /* revalidate if mtime or size have changed */
118 fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);
119 if (timespec64_equal(&inode->i_mtime, &fattr->cf_mtime) &&
120 cifs_i->server_eof == fattr->cf_eof) {
121 cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
122 __func__, cifs_i->uniqueid);
126 cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
127 __func__, cifs_i->uniqueid);
128 set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags);
132 * copy nlink to the inode, unless it wasn't provided. Provide
133 * sane values if we don't have an existing one and none was provided
136 cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
139 * if we're in a situation where we can't trust what we
140 * got from the server (readdir, some non-unix cases)
141 * fake reasonable values
143 if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
144 /* only provide fake values on a new inode */
145 if (inode->i_state & I_NEW) {
146 if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
154 /* we trust the server, so update it */
155 set_nlink(inode, fattr->cf_nlink);
158 /* populate an inode with info from a cifs_fattr struct */
160 cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
162 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
163 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
165 if (!(inode->i_state & I_NEW) &&
166 unlikely(inode_wrong_type(inode, fattr->cf_mode))) {
167 CIFS_I(inode)->time = 0; /* force reval */
171 cifs_revalidate_cache(inode, fattr);
173 spin_lock(&inode->i_lock);
174 fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);
175 fattr->cf_atime = timestamp_truncate(fattr->cf_atime, inode);
176 fattr->cf_ctime = timestamp_truncate(fattr->cf_ctime, inode);
177 /* we do not want atime to be less than mtime, it broke some apps */
178 if (timespec64_compare(&fattr->cf_atime, &fattr->cf_mtime) < 0)
179 inode->i_atime = fattr->cf_mtime;
181 inode->i_atime = fattr->cf_atime;
182 inode->i_mtime = fattr->cf_mtime;
183 inode->i_ctime = fattr->cf_ctime;
184 inode->i_rdev = fattr->cf_rdev;
185 cifs_nlink_fattr_to_inode(inode, fattr);
186 inode->i_uid = fattr->cf_uid;
187 inode->i_gid = fattr->cf_gid;
189 /* if dynperm is set, don't clobber existing mode */
190 if (inode->i_state & I_NEW ||
191 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
192 inode->i_mode = fattr->cf_mode;
194 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
196 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
199 cifs_i->time = jiffies;
201 if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING)
202 set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
204 clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
206 cifs_i->server_eof = fattr->cf_eof;
208 * Can't safely change the file size here if the client is writing to
209 * it due to potential races.
211 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
212 i_size_write(inode, fattr->cf_eof);
215 * i_blocks is not related to (i_size / i_blksize),
216 * but instead 512 byte (2**9) size is required for
217 * calculating num blocks.
219 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
221 spin_unlock(&inode->i_lock);
223 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
224 inode->i_flags |= S_AUTOMOUNT;
225 if (inode->i_state & I_NEW)
231 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
233 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
235 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
238 fattr->cf_uniqueid = iunique(sb, ROOT_I);
241 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
243 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
244 struct cifs_sb_info *cifs_sb)
246 memset(fattr, 0, sizeof(*fattr));
247 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
248 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
249 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
251 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
252 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
253 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
254 /* old POSIX extensions don't get create time */
256 fattr->cf_mode = le64_to_cpu(info->Permissions);
259 * Since we set the inode type below we need to mask off
260 * to avoid strange results if bits set above.
262 fattr->cf_mode &= ~S_IFMT;
263 switch (le32_to_cpu(info->Type)) {
265 fattr->cf_mode |= S_IFREG;
266 fattr->cf_dtype = DT_REG;
269 fattr->cf_mode |= S_IFLNK;
270 fattr->cf_dtype = DT_LNK;
273 fattr->cf_mode |= S_IFDIR;
274 fattr->cf_dtype = DT_DIR;
277 fattr->cf_mode |= S_IFCHR;
278 fattr->cf_dtype = DT_CHR;
279 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
280 le64_to_cpu(info->DevMinor) & MINORMASK);
283 fattr->cf_mode |= S_IFBLK;
284 fattr->cf_dtype = DT_BLK;
285 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
286 le64_to_cpu(info->DevMinor) & MINORMASK);
289 fattr->cf_mode |= S_IFIFO;
290 fattr->cf_dtype = DT_FIFO;
293 fattr->cf_mode |= S_IFSOCK;
294 fattr->cf_dtype = DT_SOCK;
297 /* safest to call it a file if we do not know */
298 fattr->cf_mode |= S_IFREG;
299 fattr->cf_dtype = DT_REG;
300 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
304 fattr->cf_uid = cifs_sb->ctx->linux_uid;
305 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
306 u64 id = le64_to_cpu(info->Uid);
307 if (id < ((uid_t)-1)) {
308 kuid_t uid = make_kuid(&init_user_ns, id);
314 fattr->cf_gid = cifs_sb->ctx->linux_gid;
315 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
316 u64 id = le64_to_cpu(info->Gid);
317 if (id < ((gid_t)-1)) {
318 kgid_t gid = make_kgid(&init_user_ns, id);
324 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
328 * Fill a cifs_fattr struct with fake inode info.
330 * Needed to setup cifs_fattr data for the directory which is the
331 * junction to the new submount (ie to setup the fake directory
332 * which represents a DFS referral).
335 cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
337 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
339 cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
341 memset(fattr, 0, sizeof(*fattr));
342 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
343 fattr->cf_uid = cifs_sb->ctx->linux_uid;
344 fattr->cf_gid = cifs_sb->ctx->linux_gid;
345 ktime_get_coarse_real_ts64(&fattr->cf_mtime);
346 fattr->cf_atime = fattr->cf_ctime = fattr->cf_mtime;
348 fattr->cf_flags = CIFS_FATTR_DFS_REFERRAL;
352 cifs_get_file_info_unix(struct file *filp)
356 FILE_UNIX_BASIC_INFO find_data;
357 struct cifs_fattr fattr;
358 struct inode *inode = file_inode(filp);
359 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
360 struct cifsFileInfo *cfile = filp->private_data;
361 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
364 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
366 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
367 } else if (rc == -EREMOTE) {
368 cifs_create_dfs_fattr(&fattr, inode->i_sb);
371 goto cifs_gfiunix_out;
373 rc = cifs_fattr_to_inode(inode, &fattr);
380 int cifs_get_inode_info_unix(struct inode **pinode,
381 const unsigned char *full_path,
382 struct super_block *sb, unsigned int xid)
385 FILE_UNIX_BASIC_INFO find_data;
386 struct cifs_fattr fattr;
387 struct cifs_tcon *tcon;
388 struct tcon_link *tlink;
389 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
391 cifs_dbg(FYI, "Getting info on %s\n", full_path);
393 tlink = cifs_sb_tlink(cifs_sb);
395 return PTR_ERR(tlink);
396 tcon = tlink_tcon(tlink);
398 /* could have done a find first instead but this returns more info */
399 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
400 cifs_sb->local_nls, cifs_remap(cifs_sb));
401 cifs_put_tlink(tlink);
404 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
405 } else if (rc == -EREMOTE) {
406 cifs_create_dfs_fattr(&fattr, sb);
412 /* check for Minshall+French symlinks */
413 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
414 int tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
417 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
420 if (*pinode == NULL) {
422 cifs_fill_uniqueid(sb, &fattr);
423 *pinode = cifs_iget(sb, &fattr);
427 /* we already have inode, update it */
429 /* if uniqueid is different, return error */
430 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
431 CIFS_I(*pinode)->uniqueid != fattr.cf_uniqueid)) {
432 CIFS_I(*pinode)->time = 0; /* force reval */
437 /* if filetype is different, return error */
438 rc = cifs_fattr_to_inode(*pinode, &fattr);
446 cifs_sfu_type(struct cifs_fattr *fattr, const char *path,
447 struct cifs_sb_info *cifs_sb, unsigned int xid)
451 struct tcon_link *tlink;
452 struct cifs_tcon *tcon;
454 struct cifs_open_parms oparms;
455 struct cifs_io_parms io_parms = {0};
457 unsigned int bytes_read;
459 int buf_type = CIFS_NO_BUFFER;
463 fattr->cf_mode &= ~S_IFMT;
465 if (fattr->cf_eof == 0) {
466 fattr->cf_mode |= S_IFIFO;
467 fattr->cf_dtype = DT_FIFO;
469 } else if (fattr->cf_eof < 8) {
470 fattr->cf_mode |= S_IFREG;
471 fattr->cf_dtype = DT_REG;
472 return -EINVAL; /* EOPNOTSUPP? */
475 tlink = cifs_sb_tlink(cifs_sb);
477 return PTR_ERR(tlink);
478 tcon = tlink_tcon(tlink);
481 oparms.cifs_sb = cifs_sb;
482 oparms.desired_access = GENERIC_READ;
483 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
484 oparms.disposition = FILE_OPEN;
487 oparms.reconnect = false;
489 if (tcon->ses->server->oplocks)
493 rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);
495 cifs_dbg(FYI, "check sfu type of %s, open rc = %d\n", path, rc);
496 cifs_put_tlink(tlink);
501 io_parms.netfid = fid.netfid;
502 io_parms.pid = current->tgid;
503 io_parms.tcon = tcon;
505 io_parms.length = 24;
507 rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,
508 &bytes_read, &pbuf, &buf_type);
509 if ((rc == 0) && (bytes_read >= 8)) {
510 if (memcmp("IntxBLK", pbuf, 8) == 0) {
511 cifs_dbg(FYI, "Block device\n");
512 fattr->cf_mode |= S_IFBLK;
513 fattr->cf_dtype = DT_BLK;
514 if (bytes_read == 24) {
515 /* we have enough to decode dev num */
516 __u64 mjr; /* major */
517 __u64 mnr; /* minor */
518 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
519 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
520 fattr->cf_rdev = MKDEV(mjr, mnr);
522 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
523 cifs_dbg(FYI, "Char device\n");
524 fattr->cf_mode |= S_IFCHR;
525 fattr->cf_dtype = DT_CHR;
526 if (bytes_read == 24) {
527 /* we have enough to decode dev num */
528 __u64 mjr; /* major */
529 __u64 mnr; /* minor */
530 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
531 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
532 fattr->cf_rdev = MKDEV(mjr, mnr);
534 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
535 cifs_dbg(FYI, "Symlink\n");
536 fattr->cf_mode |= S_IFLNK;
537 fattr->cf_dtype = DT_LNK;
539 fattr->cf_mode |= S_IFREG; /* file? */
540 fattr->cf_dtype = DT_REG;
544 fattr->cf_mode |= S_IFREG; /* then it is a file */
545 fattr->cf_dtype = DT_REG;
546 rc = -EOPNOTSUPP; /* or some unknown SFU type */
549 tcon->ses->server->ops->close(xid, tcon, &fid);
550 cifs_put_tlink(tlink);
554 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
557 * Fetch mode bits as provided by SFU.
559 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
561 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
562 struct cifs_sb_info *cifs_sb, unsigned int xid)
564 #ifdef CONFIG_CIFS_XATTR
568 struct tcon_link *tlink;
569 struct cifs_tcon *tcon;
571 tlink = cifs_sb_tlink(cifs_sb);
573 return PTR_ERR(tlink);
574 tcon = tlink_tcon(tlink);
576 if (tcon->ses->server->ops->query_all_EAs == NULL) {
577 cifs_put_tlink(tlink);
581 rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
582 "SETFILEBITS", ea_value, 4 /* size of buf */,
584 cifs_put_tlink(tlink);
588 mode = le32_to_cpu(*((__le32 *)ea_value));
589 fattr->cf_mode &= ~SFBITS_MASK;
590 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
591 mode, fattr->cf_mode);
592 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
593 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
602 /* Fill a cifs_fattr struct with info from POSIX info struct */
604 smb311_posix_info_to_fattr(struct cifs_fattr *fattr, struct smb311_posix_qinfo *info,
605 struct super_block *sb, bool adjust_tz, bool symlink)
607 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
608 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
610 memset(fattr, 0, sizeof(*fattr));
612 /* no fattr->flags to set */
613 fattr->cf_cifsattrs = le32_to_cpu(info->DosAttributes);
614 fattr->cf_uniqueid = le64_to_cpu(info->Inode);
616 if (info->LastAccessTime)
617 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
619 ktime_get_coarse_real_ts64(&fattr->cf_atime);
621 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
622 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
625 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
626 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
629 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
630 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
631 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
633 fattr->cf_nlink = le32_to_cpu(info->HardLinks);
634 fattr->cf_mode = (umode_t) le32_to_cpu(info->Mode);
635 /* The srv fs device id is overridden on network mount so setting rdev isn't needed here */
636 /* fattr->cf_rdev = le32_to_cpu(info->DeviceId); */
639 fattr->cf_mode |= S_IFLNK;
640 fattr->cf_dtype = DT_LNK;
641 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
642 fattr->cf_mode |= S_IFDIR;
643 fattr->cf_dtype = DT_DIR;
645 fattr->cf_mode |= S_IFREG;
646 fattr->cf_dtype = DT_REG;
648 /* else if reparse point ... TODO: add support for FIFO and blk dev; special file types */
650 fattr->cf_uid = cifs_sb->ctx->linux_uid; /* TODO: map uid and gid from SID */
651 fattr->cf_gid = cifs_sb->ctx->linux_gid;
653 cifs_dbg(FYI, "POSIX query info: mode 0x%x uniqueid 0x%llx nlink %d\n",
654 fattr->cf_mode, fattr->cf_uniqueid, fattr->cf_nlink);
658 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
660 cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
661 struct super_block *sb, bool adjust_tz,
662 bool symlink, u32 reparse_tag)
664 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
665 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
667 memset(fattr, 0, sizeof(*fattr));
668 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
669 if (info->DeletePending)
670 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
672 if (info->LastAccessTime)
673 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
675 ktime_get_coarse_real_ts64(&fattr->cf_atime);
677 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
678 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
681 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
682 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
685 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
686 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
687 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
689 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
690 if (reparse_tag == IO_REPARSE_TAG_LX_SYMLINK) {
691 fattr->cf_mode |= S_IFLNK | cifs_sb->ctx->file_mode;
692 fattr->cf_dtype = DT_LNK;
693 } else if (reparse_tag == IO_REPARSE_TAG_LX_FIFO) {
694 fattr->cf_mode |= S_IFIFO | cifs_sb->ctx->file_mode;
695 fattr->cf_dtype = DT_FIFO;
696 } else if (reparse_tag == IO_REPARSE_TAG_AF_UNIX) {
697 fattr->cf_mode |= S_IFSOCK | cifs_sb->ctx->file_mode;
698 fattr->cf_dtype = DT_SOCK;
699 } else if (reparse_tag == IO_REPARSE_TAG_LX_CHR) {
700 fattr->cf_mode |= S_IFCHR | cifs_sb->ctx->file_mode;
701 fattr->cf_dtype = DT_CHR;
702 } else if (reparse_tag == IO_REPARSE_TAG_LX_BLK) {
703 fattr->cf_mode |= S_IFBLK | cifs_sb->ctx->file_mode;
704 fattr->cf_dtype = DT_BLK;
705 } else if (symlink) { /* TODO add more reparse tag checks */
706 fattr->cf_mode = S_IFLNK;
707 fattr->cf_dtype = DT_LNK;
708 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
709 fattr->cf_mode = S_IFDIR | cifs_sb->ctx->dir_mode;
710 fattr->cf_dtype = DT_DIR;
712 * Server can return wrong NumberOfLinks value for directories
713 * when Unix extensions are disabled - fake it.
716 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
718 fattr->cf_mode = S_IFREG | cifs_sb->ctx->file_mode;
719 fattr->cf_dtype = DT_REG;
721 /* clear write bits if ATTR_READONLY is set */
722 if (fattr->cf_cifsattrs & ATTR_READONLY)
723 fattr->cf_mode &= ~(S_IWUGO);
726 * Don't accept zero nlink from non-unix servers unless
727 * delete is pending. Instead mark it as unknown.
729 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
730 !info->DeletePending) {
731 cifs_dbg(VFS, "bogus file nlink value %u\n",
733 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
737 fattr->cf_uid = cifs_sb->ctx->linux_uid;
738 fattr->cf_gid = cifs_sb->ctx->linux_gid;
742 cifs_get_file_info(struct file *filp)
746 FILE_ALL_INFO find_data;
747 struct cifs_fattr fattr;
748 struct inode *inode = file_inode(filp);
749 struct cifsFileInfo *cfile = filp->private_data;
750 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
751 struct TCP_Server_Info *server = tcon->ses->server;
753 if (!server->ops->query_file_info)
757 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
760 /* TODO: add support to query reparse tag */
761 cifs_all_info_to_fattr(&fattr, &find_data, inode->i_sb, false,
762 false, 0 /* no reparse tag */);
765 cifs_create_dfs_fattr(&fattr, inode->i_sb);
771 * FIXME: legacy server -- fall back to path-based call?
772 * for now, just skip revalidating and mark inode for
776 CIFS_I(inode)->time = 0;
783 * don't bother with SFU junk here -- just mark inode as needing
786 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
787 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
788 /* if filetype is different, return error */
789 rc = cifs_fattr_to_inode(inode, &fattr);
795 /* Simple function to return a 64 bit hash of string. Rarely called */
796 static __u64 simple_hashstr(const char *str)
798 const __u64 hash_mult = 1125899906842597ULL; /* a big enough prime */
802 hash = (hash + (__u64) *str++) * hash_mult;
808 * cifs_backup_query_path_info - SMB1 fallback code to get ino
810 * Fallback code to get file metadata when we don't have access to
811 * full_path (EACCES) and have backup creds.
813 * @xid: transaction id used to identify original request in logs
814 * @tcon: information about the server share we have mounted
815 * @sb: the superblock stores info such as disk space available
816 * @full_path: name of the file we are getting the metadata for
817 * @resp_buf: will be set to cifs resp buf and needs to be freed with
818 * cifs_buf_release() when done with @data
819 * @data: will be set to search info result buffer
822 cifs_backup_query_path_info(int xid,
823 struct cifs_tcon *tcon,
824 struct super_block *sb,
825 const char *full_path,
827 FILE_ALL_INFO **data)
829 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
830 struct cifs_search_info info = {0};
835 info.endOfSearch = false;
837 info.info_level = SMB_FIND_FILE_UNIX;
838 else if ((tcon->ses->capabilities &
839 tcon->ses->server->vals->cap_nt_find) == 0)
840 info.info_level = SMB_FIND_FILE_INFO_STANDARD;
841 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
842 info.info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
843 else /* no srvino useful for fallback to some netapp */
844 info.info_level = SMB_FIND_FILE_DIRECTORY_INFO;
846 flags = CIFS_SEARCH_CLOSE_ALWAYS |
847 CIFS_SEARCH_CLOSE_AT_END |
848 CIFS_SEARCH_BACKUP_SEARCH;
850 rc = CIFSFindFirst(xid, tcon, full_path,
851 cifs_sb, NULL, flags, &info, false);
855 *resp_buf = (void *)info.ntwrk_buf_start;
856 *data = (FILE_ALL_INFO *)info.srch_entries_start;
861 cifs_set_fattr_ino(int xid,
862 struct cifs_tcon *tcon,
863 struct super_block *sb,
864 struct inode **inode,
865 const char *full_path,
867 struct cifs_fattr *fattr)
869 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
870 struct TCP_Server_Info *server = tcon->ses->server;
873 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
875 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
877 fattr->cf_uniqueid = iunique(sb, ROOT_I);
882 * If we have an inode pass a NULL tcon to ensure we don't
883 * make a round trip to the server. This only works for SMB2+.
885 rc = server->ops->get_srv_inum(xid,
886 *inode ? NULL : tcon,
892 * If that fails reuse existing ino or generate one
893 * and disable server ones
896 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
898 fattr->cf_uniqueid = iunique(sb, ROOT_I);
899 cifs_autodisable_serverino(cifs_sb);
904 /* If no errors, check for zero root inode (invalid) */
905 if (fattr->cf_uniqueid == 0 && strlen(full_path) == 0) {
906 cifs_dbg(FYI, "Invalid (0) inodenum\n");
909 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
911 /* make an ino by hashing the UNC */
912 fattr->cf_flags |= CIFS_FATTR_FAKE_ROOT_INO;
913 fattr->cf_uniqueid = simple_hashstr(tcon->treeName);
918 static inline bool is_inode_cache_good(struct inode *ino)
920 return ino && CIFS_CACHE_READ(CIFS_I(ino)) && CIFS_I(ino)->time != 0;
924 cifs_get_inode_info(struct inode **inode,
925 const char *full_path,
926 FILE_ALL_INFO *in_data,
927 struct super_block *sb, int xid,
928 const struct cifs_fid *fid)
931 struct cifs_tcon *tcon;
932 struct TCP_Server_Info *server;
933 struct tcon_link *tlink;
934 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
935 bool adjust_tz = false;
936 struct cifs_fattr fattr = {0};
937 bool is_reparse_point = false;
938 FILE_ALL_INFO *data = in_data;
939 FILE_ALL_INFO *tmp_data = NULL;
940 void *smb1_backup_rsp_buf = NULL;
943 __u32 reparse_tag = 0;
945 tlink = cifs_sb_tlink(cifs_sb);
947 return PTR_ERR(tlink);
948 tcon = tlink_tcon(tlink);
949 server = tcon->ses->server;
952 * 1. Fetch file metadata if not provided (data)
956 if (is_inode_cache_good(*inode)) {
957 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
960 tmp_data = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
965 rc = server->ops->query_path_info(xid, tcon, cifs_sb,
967 &adjust_tz, &is_reparse_point);
972 * 2. Convert it to internal cifs metadata (fattr)
978 * If the file is a reparse point, it is more complicated
979 * since we have to check if its reparse tag matches a known
980 * special file type e.g. symlink or fifo or char etc.
982 if ((le32_to_cpu(data->Attributes) & ATTR_REPARSE) &&
983 server->ops->query_reparse_tag) {
984 rc = server->ops->query_reparse_tag(xid, tcon, cifs_sb,
985 full_path, &reparse_tag);
986 cifs_dbg(FYI, "reparse tag 0x%x\n", reparse_tag);
988 cifs_all_info_to_fattr(&fattr, data, sb, adjust_tz,
989 is_reparse_point, reparse_tag);
992 /* DFS link, no metadata available on this server */
993 cifs_create_dfs_fattr(&fattr, sb);
998 * perm errors, try again with backup flags if possible
1000 * For SMB2 and later the backup intent flag
1001 * is already sent if needed on open and there
1002 * is no path based FindFirst operation to use
1005 if (backup_cred(cifs_sb) && is_smb1_server(server)) {
1006 /* for easier reading */
1007 FILE_DIRECTORY_INFO *fdi;
1008 SEARCH_ID_FULL_DIR_INFO *si;
1010 rc = cifs_backup_query_path_info(xid, tcon, sb,
1012 &smb1_backup_rsp_buf,
1017 fdi = (FILE_DIRECTORY_INFO *)data;
1018 si = (SEARCH_ID_FULL_DIR_INFO *)data;
1020 cifs_dir_info_to_fattr(&fattr, fdi, cifs_sb);
1021 fattr.cf_uniqueid = le64_to_cpu(si->UniqueId);
1022 /* uniqueid set, skip get inum step */
1023 goto handle_mnt_opt;
1025 /* nothing we can do, bail out */
1030 cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc);
1035 * 3. Get or update inode number (fattr.cf_uniqueid)
1038 cifs_set_fattr_ino(xid, tcon, sb, inode, full_path, data, &fattr);
1041 * 4. Tweak fattr based on mount options
1045 /* query for SFU type info if supported and needed */
1046 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
1047 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
1048 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
1050 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
1053 /* fill in 0777 bits from ACL */
1054 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID) {
1055 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, true,
1060 cifs_dbg(FYI, "%s: Get mode from SID failed. rc=%d\n",
1064 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
1065 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, false,
1070 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
1076 /* fill in remaining high mode bits e.g. SUID, VTX */
1077 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
1078 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
1080 /* check for Minshall+French symlinks */
1081 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
1082 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
1085 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
1089 * 5. Update inode with final fattr data
1093 *inode = cifs_iget(sb, &fattr);
1097 /* we already have inode, update it */
1099 /* if uniqueid is different, return error */
1100 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
1101 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
1102 CIFS_I(*inode)->time = 0; /* force reval */
1106 /* if filetype is different, return error */
1107 rc = cifs_fattr_to_inode(*inode, &fattr);
1110 cifs_buf_release(smb1_backup_rsp_buf);
1111 cifs_put_tlink(tlink);
1117 smb311_posix_get_inode_info(struct inode **inode,
1118 const char *full_path,
1119 struct super_block *sb, unsigned int xid)
1121 struct cifs_tcon *tcon;
1122 struct tcon_link *tlink;
1123 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1124 bool adjust_tz = false;
1125 struct cifs_fattr fattr = {0};
1126 bool symlink = false;
1127 struct smb311_posix_qinfo *data = NULL;
1131 tlink = cifs_sb_tlink(cifs_sb);
1133 return PTR_ERR(tlink);
1134 tcon = tlink_tcon(tlink);
1137 * 1. Fetch file metadata
1140 if (is_inode_cache_good(*inode)) {
1141 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
1144 data = kmalloc(sizeof(struct smb311_posix_qinfo), GFP_KERNEL);
1150 rc = smb311_posix_query_path_info(xid, tcon, cifs_sb,
1152 &adjust_tz, &symlink);
1155 * 2. Convert it to internal cifs metadata (fattr)
1160 smb311_posix_info_to_fattr(&fattr, data, sb, adjust_tz, symlink);
1163 /* DFS link, no metadata available on this server */
1164 cifs_create_dfs_fattr(&fattr, sb);
1169 * For SMB2 and later the backup intent flag
1170 * is already sent if needed on open and there
1171 * is no path based FindFirst operation to use
1172 * to retry with so nothing we can do, bail out
1176 cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc);
1182 * 3. Tweak fattr based on mount options
1185 /* check for Minshall+French symlinks */
1186 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
1187 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
1190 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
1194 * 4. Update inode with final fattr data
1198 *inode = cifs_iget(sb, &fattr);
1202 /* we already have inode, update it */
1204 /* if uniqueid is different, return error */
1205 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
1206 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
1207 CIFS_I(*inode)->time = 0; /* force reval */
1212 /* if filetype is different, return error */
1213 rc = cifs_fattr_to_inode(*inode, &fattr);
1216 cifs_put_tlink(tlink);
1222 static const struct inode_operations cifs_ipc_inode_ops = {
1223 .lookup = cifs_lookup,
1227 cifs_find_inode(struct inode *inode, void *opaque)
1229 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
1231 /* don't match inode with different uniqueid */
1232 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
1235 /* use createtime like an i_generation field */
1236 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
1239 /* don't match inode of different type */
1240 if (inode_wrong_type(inode, fattr->cf_mode))
1243 /* if it's not a directory or has no dentries, then flag it */
1244 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
1245 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
1251 cifs_init_inode(struct inode *inode, void *opaque)
1253 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
1255 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
1256 CIFS_I(inode)->createtime = fattr->cf_createtime;
1261 * walk dentry list for an inode and report whether it has aliases that
1262 * are hashed. We use this to determine if a directory inode can actually
1266 inode_has_hashed_dentries(struct inode *inode)
1268 struct dentry *dentry;
1270 spin_lock(&inode->i_lock);
1271 hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
1272 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
1273 spin_unlock(&inode->i_lock);
1277 spin_unlock(&inode->i_lock);
1281 /* Given fattrs, get a corresponding inode */
1283 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
1286 struct inode *inode;
1289 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
1291 /* hash down to 32-bits on 32-bit arch */
1292 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
1294 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
1296 /* was there a potentially problematic inode collision? */
1297 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
1298 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
1300 if (inode_has_hashed_dentries(inode)) {
1301 cifs_autodisable_serverino(CIFS_SB(sb));
1303 fattr->cf_uniqueid = iunique(sb, ROOT_I);
1304 goto retry_iget5_locked;
1308 /* can't fail - see cifs_find_inode() */
1309 cifs_fattr_to_inode(inode, fattr);
1310 if (sb->s_flags & SB_NOATIME)
1311 inode->i_flags |= S_NOATIME | S_NOCMTIME;
1312 if (inode->i_state & I_NEW) {
1313 inode->i_ino = hash;
1314 #ifdef CONFIG_CIFS_FSCACHE
1315 /* initialize per-inode cache cookie pointer */
1316 CIFS_I(inode)->fscache = NULL;
1318 unlock_new_inode(inode);
1325 /* gets root inode */
1326 struct inode *cifs_root_iget(struct super_block *sb)
1329 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1330 struct inode *inode = NULL;
1332 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1336 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
1337 && cifs_sb->prepath) {
1338 len = strlen(cifs_sb->prepath);
1339 path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
1341 return ERR_PTR(-ENOMEM);
1343 memcpy(path+1, cifs_sb->prepath, len);
1345 path = kstrdup("", GFP_KERNEL);
1347 return ERR_PTR(-ENOMEM);
1351 if (tcon->unix_ext) {
1352 rc = cifs_get_inode_info_unix(&inode, path, sb, xid);
1353 /* some servers mistakenly claim POSIX support */
1354 if (rc != -EOPNOTSUPP)
1356 cifs_dbg(VFS, "server does not support POSIX extensions\n");
1357 tcon->unix_ext = false;
1360 convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
1361 if (tcon->posix_extensions)
1362 rc = smb311_posix_get_inode_info(&inode, path, sb, xid);
1364 rc = cifs_get_inode_info(&inode, path, NULL, sb, xid, NULL);
1368 inode = ERR_PTR(rc);
1372 #ifdef CONFIG_CIFS_FSCACHE
1373 /* populate tcon->resource_id */
1374 tcon->resource_id = CIFS_I(inode)->uniqueid;
1377 if (rc && tcon->pipe) {
1378 cifs_dbg(FYI, "ipc connection - fake read inode\n");
1379 spin_lock(&inode->i_lock);
1380 inode->i_mode |= S_IFDIR;
1381 set_nlink(inode, 2);
1382 inode->i_op = &cifs_ipc_inode_ops;
1383 inode->i_fop = &simple_dir_operations;
1384 inode->i_uid = cifs_sb->ctx->linux_uid;
1385 inode->i_gid = cifs_sb->ctx->linux_gid;
1386 spin_unlock(&inode->i_lock);
1389 inode = ERR_PTR(rc);
1399 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1400 const char *full_path, __u32 dosattr)
1402 bool set_time = false;
1403 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1404 struct TCP_Server_Info *server;
1405 FILE_BASIC_INFO info_buf;
1410 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1411 if (!server->ops->set_file_info)
1416 if (attrs->ia_valid & ATTR_ATIME) {
1418 info_buf.LastAccessTime =
1419 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1421 info_buf.LastAccessTime = 0;
1423 if (attrs->ia_valid & ATTR_MTIME) {
1425 info_buf.LastWriteTime =
1426 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1428 info_buf.LastWriteTime = 0;
1431 * Samba throws this field away, but windows may actually use it.
1432 * Do not set ctime unless other time stamps are changed explicitly
1433 * (i.e. by utimes()) since we would then have a mix of client and
1436 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1437 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1438 info_buf.ChangeTime =
1439 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1441 info_buf.ChangeTime = 0;
1443 info_buf.CreationTime = 0; /* don't change */
1444 info_buf.Attributes = cpu_to_le32(dosattr);
1446 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1450 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1451 * and rename it to a random name that hopefully won't conflict with
1455 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1456 const unsigned int xid)
1460 struct cifs_fid fid;
1461 struct cifs_open_parms oparms;
1462 struct inode *inode = d_inode(dentry);
1463 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1464 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1465 struct tcon_link *tlink;
1466 struct cifs_tcon *tcon;
1467 __u32 dosattr, origattr;
1468 FILE_BASIC_INFO *info_buf = NULL;
1470 tlink = cifs_sb_tlink(cifs_sb);
1472 return PTR_ERR(tlink);
1473 tcon = tlink_tcon(tlink);
1476 * We cannot rename the file if the server doesn't support
1477 * CAP_INFOLEVEL_PASSTHRU
1479 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1485 oparms.cifs_sb = cifs_sb;
1486 oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1487 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
1488 oparms.disposition = FILE_OPEN;
1489 oparms.path = full_path;
1491 oparms.reconnect = false;
1493 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1497 origattr = cifsInode->cifsAttrs;
1499 origattr |= ATTR_NORMAL;
1501 dosattr = origattr & ~ATTR_READONLY;
1503 dosattr |= ATTR_NORMAL;
1504 dosattr |= ATTR_HIDDEN;
1506 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1507 if (dosattr != origattr) {
1508 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1509 if (info_buf == NULL) {
1513 info_buf->Attributes = cpu_to_le32(dosattr);
1514 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1516 /* although we would like to mark the file hidden
1517 if that fails we will still try to rename it */
1519 cifsInode->cifsAttrs = dosattr;
1521 dosattr = origattr; /* since not able to change them */
1524 /* rename the file */
1525 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1527 cifs_remap(cifs_sb));
1533 /* try to set DELETE_ON_CLOSE */
1534 if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1535 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1538 * some samba versions return -ENOENT when we try to set the
1539 * file disposition here. Likely a samba bug, but work around
1540 * it for now. This means that some cifsXXX files may hang
1541 * around after they shouldn't.
1543 * BB: remove this hack after more servers have the fix
1551 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1555 CIFSSMBClose(xid, tcon, fid.netfid);
1558 cifs_put_tlink(tlink);
1562 * reset everything back to the original state. Don't bother
1563 * dealing with errors here since we can't do anything about
1567 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1568 cifs_sb->local_nls, cifs_remap(cifs_sb));
1570 if (dosattr != origattr) {
1571 info_buf->Attributes = cpu_to_le32(origattr);
1572 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1574 cifsInode->cifsAttrs = origattr;
1580 /* copied from fs/nfs/dir.c with small changes */
1582 cifs_drop_nlink(struct inode *inode)
1584 spin_lock(&inode->i_lock);
1585 if (inode->i_nlink > 0)
1587 spin_unlock(&inode->i_lock);
1591 * If d_inode(dentry) is null (usually meaning the cached dentry
1592 * is a negative dentry) then we would attempt a standard SMB delete, but
1593 * if that fails we can not attempt the fall back mechanisms on EACCES
1594 * but will return the EACCES to the caller. Note that the VFS does not call
1595 * unlink on negative dentries currently.
1597 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1601 const char *full_path;
1603 struct inode *inode = d_inode(dentry);
1604 struct cifsInodeInfo *cifs_inode;
1605 struct super_block *sb = dir->i_sb;
1606 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1607 struct tcon_link *tlink;
1608 struct cifs_tcon *tcon;
1609 struct TCP_Server_Info *server;
1610 struct iattr *attrs = NULL;
1611 __u32 dosattr = 0, origattr = 0;
1613 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1615 if (unlikely(cifs_forced_shutdown(cifs_sb)))
1618 tlink = cifs_sb_tlink(cifs_sb);
1620 return PTR_ERR(tlink);
1621 tcon = tlink_tcon(tlink);
1622 server = tcon->ses->server;
1625 page = alloc_dentry_path();
1627 if (tcon->nodelete) {
1632 /* Unlink can be called from rename so we can not take the
1633 * sb->s_vfs_rename_mutex here */
1634 full_path = build_path_from_dentry(dentry, page);
1635 if (IS_ERR(full_path)) {
1636 rc = PTR_ERR(full_path);
1640 cifs_close_deferred_file(CIFS_I(inode));
1641 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1642 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1643 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1644 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1645 cifs_remap(cifs_sb));
1646 cifs_dbg(FYI, "posix del rc %d\n", rc);
1647 if ((rc == 0) || (rc == -ENOENT))
1648 goto psx_del_no_retry;
1652 if (!server->ops->unlink) {
1654 goto psx_del_no_retry;
1657 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1662 cifs_drop_nlink(inode);
1663 } else if (rc == -ENOENT) {
1665 } else if (rc == -EBUSY) {
1666 if (server->ops->rename_pending_delete) {
1667 rc = server->ops->rename_pending_delete(full_path,
1670 cifs_drop_nlink(inode);
1672 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1673 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1674 if (attrs == NULL) {
1679 /* try to reset dos attributes */
1680 cifs_inode = CIFS_I(inode);
1681 origattr = cifs_inode->cifsAttrs;
1683 origattr |= ATTR_NORMAL;
1684 dosattr = origattr & ~ATTR_READONLY;
1686 dosattr |= ATTR_NORMAL;
1687 dosattr |= ATTR_HIDDEN;
1689 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1693 goto retry_std_delete;
1696 /* undo the setattr if we errored out and it's needed */
1697 if (rc != 0 && dosattr != 0)
1698 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1702 cifs_inode = CIFS_I(inode);
1703 cifs_inode->time = 0; /* will force revalidate to get info
1705 inode->i_ctime = current_time(inode);
1707 dir->i_ctime = dir->i_mtime = current_time(dir);
1708 cifs_inode = CIFS_I(dir);
1709 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1711 free_dentry_path(page);
1714 cifs_put_tlink(tlink);
1719 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1720 const char *full_path, struct cifs_sb_info *cifs_sb,
1721 struct cifs_tcon *tcon, const unsigned int xid)
1724 struct inode *inode = NULL;
1726 if (tcon->posix_extensions)
1727 rc = smb311_posix_get_inode_info(&inode, full_path, parent->i_sb, xid);
1728 else if (tcon->unix_ext)
1729 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1732 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1738 if (!S_ISDIR(inode->i_mode)) {
1740 * mkdir succeeded, but another client has managed to remove the
1741 * sucker and replace it with non-directory. Return success,
1742 * but don't leave the child in dcache.
1749 * setting nlink not necessary except in cases where we failed to get it
1750 * from the server or was set bogus. Also, since this is a brand new
1751 * inode, no need to grab the i_lock before setting the i_nlink.
1753 if (inode->i_nlink < 2)
1754 set_nlink(inode, 2);
1755 mode &= ~current_umask();
1756 /* must turn on setgid bit if parent dir has it */
1757 if (parent->i_mode & S_ISGID)
1760 if (tcon->unix_ext) {
1761 struct cifs_unix_set_info_args args = {
1763 .ctime = NO_CHANGE_64,
1764 .atime = NO_CHANGE_64,
1765 .mtime = NO_CHANGE_64,
1768 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1769 args.uid = current_fsuid();
1770 if (parent->i_mode & S_ISGID)
1771 args.gid = parent->i_gid;
1773 args.gid = current_fsgid();
1775 args.uid = INVALID_UID; /* no change */
1776 args.gid = INVALID_GID; /* no change */
1778 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1780 cifs_remap(cifs_sb));
1782 struct TCP_Server_Info *server = tcon->ses->server;
1783 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1784 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1785 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1787 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1788 inode->i_mode = (mode | S_IFDIR);
1790 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1791 inode->i_uid = current_fsuid();
1792 if (inode->i_mode & S_ISGID)
1793 inode->i_gid = parent->i_gid;
1795 inode->i_gid = current_fsgid();
1798 d_instantiate(dentry, inode);
1803 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1804 const char *full_path, struct cifs_sb_info *cifs_sb,
1805 struct cifs_tcon *tcon, const unsigned int xid)
1809 FILE_UNIX_BASIC_INFO *info = NULL;
1810 struct inode *newinode = NULL;
1811 struct cifs_fattr fattr;
1813 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1816 goto posix_mkdir_out;
1819 mode &= ~current_umask();
1820 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1821 NULL /* netfid */, info, &oplock, full_path,
1822 cifs_sb->local_nls, cifs_remap(cifs_sb));
1823 if (rc == -EOPNOTSUPP)
1824 goto posix_mkdir_out;
1826 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1828 goto posix_mkdir_out;
1831 if (info->Type == cpu_to_le32(-1))
1832 /* no return info, go query for it */
1833 goto posix_mkdir_get_info;
1835 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1836 * need to set uid/gid.
1839 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1840 cifs_fill_uniqueid(inode->i_sb, &fattr);
1841 newinode = cifs_iget(inode->i_sb, &fattr);
1843 goto posix_mkdir_get_info;
1845 d_instantiate(dentry, newinode);
1847 #ifdef CONFIG_CIFS_DEBUG2
1848 cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1849 dentry, dentry, newinode);
1851 if (newinode->i_nlink != 2)
1852 cifs_dbg(FYI, "unexpected number of links %d\n",
1859 posix_mkdir_get_info:
1860 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1862 goto posix_mkdir_out;
1865 int cifs_mkdir(struct user_namespace *mnt_userns, struct inode *inode,
1866 struct dentry *direntry, umode_t mode)
1870 struct cifs_sb_info *cifs_sb;
1871 struct tcon_link *tlink;
1872 struct cifs_tcon *tcon;
1873 struct TCP_Server_Info *server;
1874 const char *full_path;
1877 cifs_dbg(FYI, "In cifs_mkdir, mode = %04ho inode = 0x%p\n",
1880 cifs_sb = CIFS_SB(inode->i_sb);
1881 if (unlikely(cifs_forced_shutdown(cifs_sb)))
1883 tlink = cifs_sb_tlink(cifs_sb);
1885 return PTR_ERR(tlink);
1886 tcon = tlink_tcon(tlink);
1890 page = alloc_dentry_path();
1891 full_path = build_path_from_dentry(direntry, page);
1892 if (IS_ERR(full_path)) {
1893 rc = PTR_ERR(full_path);
1897 server = tcon->ses->server;
1899 if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) {
1900 rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,
1902 d_drop(direntry); /* for time being always refresh inode info */
1906 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1907 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1908 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1910 if (rc != -EOPNOTSUPP)
1914 if (!server->ops->mkdir) {
1919 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1920 rc = server->ops->mkdir(xid, inode, mode, tcon, full_path, cifs_sb);
1922 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1927 /* TODO: skip this for smb2/smb3 */
1928 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1932 * Force revalidate to get parent dir info when needed since cached
1933 * attributes are invalid now.
1935 CIFS_I(inode)->time = 0;
1936 free_dentry_path(page);
1938 cifs_put_tlink(tlink);
1942 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1946 struct cifs_sb_info *cifs_sb;
1947 struct tcon_link *tlink;
1948 struct cifs_tcon *tcon;
1949 struct TCP_Server_Info *server;
1950 const char *full_path;
1951 void *page = alloc_dentry_path();
1952 struct cifsInodeInfo *cifsInode;
1954 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1958 full_path = build_path_from_dentry(direntry, page);
1959 if (IS_ERR(full_path)) {
1960 rc = PTR_ERR(full_path);
1964 cifs_sb = CIFS_SB(inode->i_sb);
1965 if (unlikely(cifs_forced_shutdown(cifs_sb))) {
1970 tlink = cifs_sb_tlink(cifs_sb);
1971 if (IS_ERR(tlink)) {
1972 rc = PTR_ERR(tlink);
1975 tcon = tlink_tcon(tlink);
1976 server = tcon->ses->server;
1978 if (!server->ops->rmdir) {
1980 cifs_put_tlink(tlink);
1984 if (tcon->nodelete) {
1986 cifs_put_tlink(tlink);
1990 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1991 cifs_put_tlink(tlink);
1994 spin_lock(&d_inode(direntry)->i_lock);
1995 i_size_write(d_inode(direntry), 0);
1996 clear_nlink(d_inode(direntry));
1997 spin_unlock(&d_inode(direntry)->i_lock);
2000 cifsInode = CIFS_I(d_inode(direntry));
2001 /* force revalidate to go get info when needed */
2002 cifsInode->time = 0;
2004 cifsInode = CIFS_I(inode);
2006 * Force revalidate to get parent dir info when needed since cached
2007 * attributes are invalid now.
2009 cifsInode->time = 0;
2011 d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
2012 current_time(inode);
2015 free_dentry_path(page);
2021 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
2022 const char *from_path, struct dentry *to_dentry,
2023 const char *to_path)
2025 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
2026 struct tcon_link *tlink;
2027 struct cifs_tcon *tcon;
2028 struct TCP_Server_Info *server;
2029 struct cifs_fid fid;
2030 struct cifs_open_parms oparms;
2033 tlink = cifs_sb_tlink(cifs_sb);
2035 return PTR_ERR(tlink);
2036 tcon = tlink_tcon(tlink);
2037 server = tcon->ses->server;
2039 if (!server->ops->rename)
2042 /* try path-based rename first */
2043 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
2046 * Don't bother with rename by filehandle unless file is busy and
2047 * source. Note that cross directory moves do not work with
2048 * rename by filehandle to various Windows servers.
2050 if (rc == 0 || rc != -EBUSY)
2051 goto do_rename_exit;
2053 /* Don't fall back to using SMB on SMB 2+ mount */
2054 if (server->vals->protocol_id != 0)
2055 goto do_rename_exit;
2057 /* open-file renames don't work across directories */
2058 if (to_dentry->d_parent != from_dentry->d_parent)
2059 goto do_rename_exit;
2062 oparms.cifs_sb = cifs_sb;
2063 /* open the file to be renamed -- we need DELETE perms */
2064 oparms.desired_access = DELETE;
2065 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
2066 oparms.disposition = FILE_OPEN;
2067 oparms.path = from_path;
2069 oparms.reconnect = false;
2071 rc = CIFS_open(xid, &oparms, &oplock, NULL);
2073 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
2074 (const char *) to_dentry->d_name.name,
2075 cifs_sb->local_nls, cifs_remap(cifs_sb));
2076 CIFSSMBClose(xid, tcon, fid.netfid);
2080 d_move(from_dentry, to_dentry);
2081 cifs_put_tlink(tlink);
2086 cifs_rename2(struct user_namespace *mnt_userns, struct inode *source_dir,
2087 struct dentry *source_dentry, struct inode *target_dir,
2088 struct dentry *target_dentry, unsigned int flags)
2090 const char *from_name, *to_name;
2091 void *page1, *page2;
2092 struct cifs_sb_info *cifs_sb;
2093 struct tcon_link *tlink;
2094 struct cifs_tcon *tcon;
2095 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
2096 FILE_UNIX_BASIC_INFO *info_buf_target;
2099 int retry_count = 0;
2101 if (flags & ~RENAME_NOREPLACE)
2104 cifs_sb = CIFS_SB(source_dir->i_sb);
2105 if (unlikely(cifs_forced_shutdown(cifs_sb)))
2108 tlink = cifs_sb_tlink(cifs_sb);
2110 return PTR_ERR(tlink);
2111 tcon = tlink_tcon(tlink);
2113 page1 = alloc_dentry_path();
2114 page2 = alloc_dentry_path();
2117 from_name = build_path_from_dentry(source_dentry, page1);
2118 if (IS_ERR(from_name)) {
2119 rc = PTR_ERR(from_name);
2120 goto cifs_rename_exit;
2123 to_name = build_path_from_dentry(target_dentry, page2);
2124 if (IS_ERR(to_name)) {
2125 rc = PTR_ERR(to_name);
2126 goto cifs_rename_exit;
2129 cifs_close_deferred_file(CIFS_I(d_inode(source_dentry)));
2130 if (d_inode(target_dentry) != NULL)
2131 cifs_close_deferred_file(CIFS_I(d_inode(target_dentry)));
2133 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2136 if (rc == -EACCES) {
2137 while (retry_count < 3) {
2138 cifs_close_all_deferred_files(tcon);
2139 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2148 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
2150 if (flags & RENAME_NOREPLACE)
2151 goto cifs_rename_exit;
2153 if (rc == -EEXIST && tcon->unix_ext) {
2155 * Are src and dst hardlinks of same inode? We can only tell
2156 * with unix extensions enabled.
2159 kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
2161 if (info_buf_source == NULL) {
2163 goto cifs_rename_exit;
2166 info_buf_target = info_buf_source + 1;
2167 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
2170 cifs_remap(cifs_sb));
2174 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
2177 cifs_remap(cifs_sb));
2179 if (tmprc == 0 && (info_buf_source->UniqueId ==
2180 info_buf_target->UniqueId)) {
2181 /* same file, POSIX says that this is a noop */
2183 goto cifs_rename_exit;
2187 * else ... BB we could add the same check for Windows by
2188 * checking the UniqueId via FILE_INTERNAL_INFO
2192 /* Try unlinking the target dentry if it's not negative */
2193 if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
2194 if (d_is_dir(target_dentry))
2195 tmprc = cifs_rmdir(target_dir, target_dentry);
2197 tmprc = cifs_unlink(target_dir, target_dentry);
2199 goto cifs_rename_exit;
2200 rc = cifs_do_rename(xid, source_dentry, from_name,
2201 target_dentry, to_name);
2204 /* force revalidate to go get info when needed */
2205 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
2207 source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
2208 target_dir->i_mtime = current_time(source_dir);
2211 kfree(info_buf_source);
2212 free_dentry_path(page2);
2213 free_dentry_path(page1);
2215 cifs_put_tlink(tlink);
2220 cifs_dentry_needs_reval(struct dentry *dentry)
2222 struct inode *inode = d_inode(dentry);
2223 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2224 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2225 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2226 struct cached_fid *cfid = NULL;
2228 if (cifs_i->time == 0)
2231 if (CIFS_CACHE_READ(cifs_i))
2234 if (!lookupCacheEnabled)
2237 if (!open_cached_dir_by_dentry(tcon, dentry->d_parent, &cfid)) {
2238 mutex_lock(&cfid->fid_mutex);
2239 if (cfid->time && cifs_i->time > cfid->time) {
2240 mutex_unlock(&cfid->fid_mutex);
2241 close_cached_dir(cfid);
2244 mutex_unlock(&cfid->fid_mutex);
2245 close_cached_dir(cfid);
2248 * depending on inode type, check if attribute caching disabled for
2249 * files or directories
2251 if (S_ISDIR(inode->i_mode)) {
2252 if (!cifs_sb->ctx->acdirmax)
2254 if (!time_in_range(jiffies, cifs_i->time,
2255 cifs_i->time + cifs_sb->ctx->acdirmax))
2258 if (!cifs_sb->ctx->acregmax)
2260 if (!time_in_range(jiffies, cifs_i->time,
2261 cifs_i->time + cifs_sb->ctx->acregmax))
2265 /* hardlinked files w/ noserverino get "special" treatment */
2266 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
2267 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
2274 * Zap the cache. Called when invalid_mapping flag is set.
2277 cifs_invalidate_mapping(struct inode *inode)
2281 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
2282 rc = invalidate_inode_pages2(inode->i_mapping);
2284 cifs_dbg(VFS, "%s: Could not invalidate inode %p\n",
2288 cifs_fscache_reset_inode_cookie(inode);
2293 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
2295 * @key: currently unused
2296 * @mode: the task state to sleep in
2299 cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
2301 freezable_schedule_unsafe();
2302 if (signal_pending_state(mode, current))
2303 return -ERESTARTSYS;
2308 cifs_revalidate_mapping(struct inode *inode)
2311 unsigned long *flags = &CIFS_I(inode)->flags;
2313 /* swapfiles are not supposed to be shared */
2314 if (IS_SWAPFILE(inode))
2317 rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
2322 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
2323 rc = cifs_invalidate_mapping(inode);
2325 set_bit(CIFS_INO_INVALID_MAPPING, flags);
2328 clear_bit_unlock(CIFS_INO_LOCK, flags);
2329 smp_mb__after_atomic();
2330 wake_up_bit(flags, CIFS_INO_LOCK);
2336 cifs_zap_mapping(struct inode *inode)
2338 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
2339 return cifs_revalidate_mapping(inode);
2342 int cifs_revalidate_file_attr(struct file *filp)
2345 struct dentry *dentry = file_dentry(filp);
2346 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
2348 if (!cifs_dentry_needs_reval(dentry))
2351 if (tlink_tcon(cfile->tlink)->unix_ext)
2352 rc = cifs_get_file_info_unix(filp);
2354 rc = cifs_get_file_info(filp);
2359 int cifs_revalidate_dentry_attr(struct dentry *dentry)
2363 struct inode *inode = d_inode(dentry);
2364 struct super_block *sb = dentry->d_sb;
2365 const char *full_path;
2372 if (!cifs_dentry_needs_reval(dentry))
2377 page = alloc_dentry_path();
2378 full_path = build_path_from_dentry(dentry, page);
2379 if (IS_ERR(full_path)) {
2380 rc = PTR_ERR(full_path);
2384 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2385 full_path, inode, inode->i_count.counter,
2386 dentry, cifs_get_time(dentry), jiffies);
2389 if (cifs_sb_master_tcon(CIFS_SB(sb))->posix_extensions)
2390 rc = smb311_posix_get_inode_info(&inode, full_path, sb, xid);
2391 else if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
2392 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2394 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2396 if (rc == -EAGAIN && count++ < 10)
2399 free_dentry_path(page);
2405 int cifs_revalidate_file(struct file *filp)
2408 struct inode *inode = file_inode(filp);
2410 rc = cifs_revalidate_file_attr(filp);
2414 return cifs_revalidate_mapping(inode);
2417 /* revalidate a dentry's inode attributes */
2418 int cifs_revalidate_dentry(struct dentry *dentry)
2421 struct inode *inode = d_inode(dentry);
2423 rc = cifs_revalidate_dentry_attr(dentry);
2427 return cifs_revalidate_mapping(inode);
2430 int cifs_getattr(struct user_namespace *mnt_userns, const struct path *path,
2431 struct kstat *stat, u32 request_mask, unsigned int flags)
2433 struct dentry *dentry = path->dentry;
2434 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2435 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2436 struct inode *inode = d_inode(dentry);
2439 if (unlikely(cifs_forced_shutdown(CIFS_SB(inode->i_sb))))
2443 * We need to be sure that all dirty pages are written and the server
2444 * has actual ctime, mtime and file length.
2446 if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_SIZE | STATX_BLOCKS)) &&
2447 !CIFS_CACHE_READ(CIFS_I(inode)) &&
2448 inode->i_mapping && inode->i_mapping->nrpages != 0) {
2449 rc = filemap_fdatawait(inode->i_mapping);
2451 mapping_set_error(inode->i_mapping, rc);
2456 if ((flags & AT_STATX_SYNC_TYPE) == AT_STATX_FORCE_SYNC)
2457 CIFS_I(inode)->time = 0; /* force revalidate */
2460 * If the caller doesn't require syncing, only sync if
2461 * necessary (e.g. due to earlier truncate or setattr
2462 * invalidating the cached metadata)
2464 if (((flags & AT_STATX_SYNC_TYPE) != AT_STATX_DONT_SYNC) ||
2465 (CIFS_I(inode)->time == 0)) {
2466 rc = cifs_revalidate_dentry_attr(dentry);
2471 generic_fillattr(&init_user_ns, inode, stat);
2472 stat->blksize = cifs_sb->ctx->bsize;
2473 stat->ino = CIFS_I(inode)->uniqueid;
2475 /* old CIFS Unix Extensions doesn't return create time */
2476 if (CIFS_I(inode)->createtime) {
2477 stat->result_mask |= STATX_BTIME;
2479 cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
2482 stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2483 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2484 stat->attributes |= STATX_ATTR_COMPRESSED;
2485 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2486 stat->attributes |= STATX_ATTR_ENCRYPTED;
2489 * If on a multiuser mount without unix extensions or cifsacl being
2490 * enabled, and the admin hasn't overridden them, set the ownership
2491 * to the fsuid/fsgid of the current process.
2493 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2494 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2496 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2497 stat->uid = current_fsuid();
2498 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2499 stat->gid = current_fsgid();
2504 int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start,
2507 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2508 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_i->vfs_inode.i_sb);
2509 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2510 struct TCP_Server_Info *server = tcon->ses->server;
2511 struct cifsFileInfo *cfile;
2514 if (unlikely(cifs_forced_shutdown(cifs_sb)))
2518 * We need to be sure that all dirty pages are written as they
2519 * might fill holes on the server.
2521 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2522 inode->i_mapping->nrpages != 0) {
2523 rc = filemap_fdatawait(inode->i_mapping);
2525 mapping_set_error(inode->i_mapping, rc);
2530 cfile = find_readable_file(cifs_i, false);
2534 if (server->ops->fiemap) {
2535 rc = server->ops->fiemap(tcon, cfile, fei, start, len);
2536 cifsFileInfo_put(cfile);
2540 cifsFileInfo_put(cfile);
2544 int cifs_truncate_page(struct address_space *mapping, loff_t from)
2546 pgoff_t index = from >> PAGE_SHIFT;
2547 unsigned offset = from & (PAGE_SIZE - 1);
2551 page = grab_cache_page(mapping, index);
2555 zero_user_segment(page, offset, PAGE_SIZE);
2561 void cifs_setsize(struct inode *inode, loff_t offset)
2563 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2565 spin_lock(&inode->i_lock);
2566 i_size_write(inode, offset);
2567 spin_unlock(&inode->i_lock);
2569 /* Cached inode must be refreshed on truncate */
2571 truncate_pagecache(inode, offset);
2575 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2576 unsigned int xid, const char *full_path)
2579 struct cifsFileInfo *open_file;
2580 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2581 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2582 struct tcon_link *tlink = NULL;
2583 struct cifs_tcon *tcon = NULL;
2584 struct TCP_Server_Info *server;
2587 * To avoid spurious oplock breaks from server, in the case of
2588 * inodes that we already have open, avoid doing path based
2589 * setting of file size if we can do it by handle.
2590 * This keeps our caching token (oplock) and avoids timeouts
2591 * when the local oplock break takes longer to flush
2592 * writebehind data than the SMB timeout for the SetPathInfo
2593 * request would allow
2595 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2597 tcon = tlink_tcon(open_file->tlink);
2598 server = tcon->ses->server;
2599 if (server->ops->set_file_size)
2600 rc = server->ops->set_file_size(xid, tcon, open_file,
2601 attrs->ia_size, false);
2604 cifsFileInfo_put(open_file);
2605 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2613 tlink = cifs_sb_tlink(cifs_sb);
2615 return PTR_ERR(tlink);
2616 tcon = tlink_tcon(tlink);
2617 server = tcon->ses->server;
2621 * Set file size by pathname rather than by handle either because no
2622 * valid, writeable file handle for it was found or because there was
2623 * an error setting it by handle.
2625 if (server->ops->set_path_size)
2626 rc = server->ops->set_path_size(xid, tcon, full_path,
2627 attrs->ia_size, cifs_sb, false);
2630 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2633 cifs_put_tlink(tlink);
2637 cifsInode->server_eof = attrs->ia_size;
2638 cifs_setsize(inode, attrs->ia_size);
2640 * i_blocks is not related to (i_size / i_blksize), but instead
2641 * 512 byte (2**9) size is required for calculating num blocks.
2642 * Until we can query the server for actual allocation size,
2643 * this is best estimate we have for blocks allocated for a file
2644 * Number of blocks must be rounded up so size 1 is not 0 blocks
2646 inode->i_blocks = (512 - 1 + attrs->ia_size) >> 9;
2649 * The man page of truncate says if the size changed,
2650 * then the st_ctime and st_mtime fields for the file
2653 attrs->ia_ctime = attrs->ia_mtime = current_time(inode);
2654 attrs->ia_valid |= ATTR_CTIME | ATTR_MTIME;
2656 cifs_truncate_page(inode->i_mapping, inode->i_size);
2663 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2667 const char *full_path;
2668 void *page = alloc_dentry_path();
2669 struct inode *inode = d_inode(direntry);
2670 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2671 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2672 struct tcon_link *tlink;
2673 struct cifs_tcon *pTcon;
2674 struct cifs_unix_set_info_args *args = NULL;
2675 struct cifsFileInfo *open_file;
2677 cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2678 direntry, attrs->ia_valid);
2682 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2683 attrs->ia_valid |= ATTR_FORCE;
2685 rc = setattr_prepare(&init_user_ns, direntry, attrs);
2689 full_path = build_path_from_dentry(direntry, page);
2690 if (IS_ERR(full_path)) {
2691 rc = PTR_ERR(full_path);
2696 * Attempt to flush data before changing attributes. We need to do
2697 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2698 * ownership or mode then we may also need to do this. Here, we take
2699 * the safe way out and just do the flush on all setattr requests. If
2700 * the flush returns error, store it to report later and continue.
2702 * BB: This should be smarter. Why bother flushing pages that
2703 * will be truncated anyway? Also, should we error out here if
2704 * the flush returns error?
2706 rc = filemap_write_and_wait(inode->i_mapping);
2707 if (is_interrupt_error(rc)) {
2712 mapping_set_error(inode->i_mapping, rc);
2715 if (attrs->ia_valid & ATTR_SIZE) {
2716 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2721 /* skip mode change if it's just for clearing setuid/setgid */
2722 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2723 attrs->ia_valid &= ~ATTR_MODE;
2725 args = kmalloc(sizeof(*args), GFP_KERNEL);
2731 /* set up the struct */
2732 if (attrs->ia_valid & ATTR_MODE)
2733 args->mode = attrs->ia_mode;
2735 args->mode = NO_CHANGE_64;
2737 if (attrs->ia_valid & ATTR_UID)
2738 args->uid = attrs->ia_uid;
2740 args->uid = INVALID_UID; /* no change */
2742 if (attrs->ia_valid & ATTR_GID)
2743 args->gid = attrs->ia_gid;
2745 args->gid = INVALID_GID; /* no change */
2747 if (attrs->ia_valid & ATTR_ATIME)
2748 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2750 args->atime = NO_CHANGE_64;
2752 if (attrs->ia_valid & ATTR_MTIME)
2753 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2755 args->mtime = NO_CHANGE_64;
2757 if (attrs->ia_valid & ATTR_CTIME)
2758 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2760 args->ctime = NO_CHANGE_64;
2763 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2765 u16 nfid = open_file->fid.netfid;
2766 u32 npid = open_file->pid;
2767 pTcon = tlink_tcon(open_file->tlink);
2768 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2769 cifsFileInfo_put(open_file);
2771 tlink = cifs_sb_tlink(cifs_sb);
2772 if (IS_ERR(tlink)) {
2773 rc = PTR_ERR(tlink);
2776 pTcon = tlink_tcon(tlink);
2777 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2779 cifs_remap(cifs_sb));
2780 cifs_put_tlink(tlink);
2786 if ((attrs->ia_valid & ATTR_SIZE) &&
2787 attrs->ia_size != i_size_read(inode))
2788 truncate_setsize(inode, attrs->ia_size);
2790 setattr_copy(&init_user_ns, inode, attrs);
2791 mark_inode_dirty(inode);
2793 /* force revalidate when any of these times are set since some
2794 of the fs types (eg ext3, fat) do not have fine enough
2795 time granularity to match protocol, and we do not have a
2796 a way (yet) to query the server fs's time granularity (and
2797 whether it rounds times down).
2799 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2800 cifsInode->time = 0;
2803 free_dentry_path(page);
2809 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2812 kuid_t uid = INVALID_UID;
2813 kgid_t gid = INVALID_GID;
2814 struct inode *inode = d_inode(direntry);
2815 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2816 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2817 struct cifsFileInfo *wfile;
2818 struct cifs_tcon *tcon;
2819 const char *full_path;
2820 void *page = alloc_dentry_path();
2823 __u64 mode = NO_CHANGE_64;
2827 cifs_dbg(FYI, "setattr on file %pd attrs->ia_valid 0x%x\n",
2828 direntry, attrs->ia_valid);
2830 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2831 attrs->ia_valid |= ATTR_FORCE;
2833 rc = setattr_prepare(&init_user_ns, direntry, attrs);
2835 goto cifs_setattr_exit;
2837 full_path = build_path_from_dentry(direntry, page);
2838 if (IS_ERR(full_path)) {
2839 rc = PTR_ERR(full_path);
2840 goto cifs_setattr_exit;
2844 * Attempt to flush data before changing attributes. We need to do
2845 * this for ATTR_SIZE and ATTR_MTIME. If the flush of the data
2846 * returns error, store it to report later and continue.
2848 * BB: This should be smarter. Why bother flushing pages that
2849 * will be truncated anyway? Also, should we error out here if
2850 * the flush returns error? Do we need to check for ATTR_MTIME_SET flag?
2852 if (attrs->ia_valid & (ATTR_MTIME | ATTR_SIZE | ATTR_CTIME)) {
2853 rc = filemap_write_and_wait(inode->i_mapping);
2854 if (is_interrupt_error(rc)) {
2856 goto cifs_setattr_exit;
2858 mapping_set_error(inode->i_mapping, rc);
2863 if ((attrs->ia_valid & ATTR_MTIME) &&
2864 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2865 rc = cifs_get_writable_file(cifsInode, FIND_WR_ANY, &wfile);
2867 tcon = tlink_tcon(wfile->tlink);
2868 rc = tcon->ses->server->ops->flush(xid, tcon, &wfile->fid);
2869 cifsFileInfo_put(wfile);
2871 goto cifs_setattr_exit;
2872 } else if (rc != -EBADF)
2873 goto cifs_setattr_exit;
2878 if (attrs->ia_valid & ATTR_SIZE) {
2879 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2881 goto cifs_setattr_exit;
2884 if (attrs->ia_valid & ATTR_UID)
2885 uid = attrs->ia_uid;
2887 if (attrs->ia_valid & ATTR_GID)
2888 gid = attrs->ia_gid;
2890 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2891 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2892 if (uid_valid(uid) || gid_valid(gid)) {
2893 mode = NO_CHANGE_64;
2894 rc = id_mode_to_cifs_acl(inode, full_path, &mode,
2897 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2899 goto cifs_setattr_exit;
2903 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2904 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2906 /* skip mode change if it's just for clearing setuid/setgid */
2907 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2908 attrs->ia_valid &= ~ATTR_MODE;
2910 if (attrs->ia_valid & ATTR_MODE) {
2911 mode = attrs->ia_mode;
2913 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2914 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2915 rc = id_mode_to_cifs_acl(inode, full_path, &mode,
2916 INVALID_UID, INVALID_GID);
2918 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2920 goto cifs_setattr_exit;
2924 * In case of CIFS_MOUNT_CIFS_ACL, we cannot support all modes.
2925 * Pick up the actual mode bits that were set.
2927 if (mode != attrs->ia_mode)
2928 attrs->ia_mode = mode;
2930 if (((mode & S_IWUGO) == 0) &&
2931 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2933 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2935 /* fix up mode if we're not using dynperm */
2936 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2937 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2938 } else if ((mode & S_IWUGO) &&
2939 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2941 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2942 /* Attributes of 0 are ignored */
2944 dosattr |= ATTR_NORMAL;
2946 /* reset local inode permissions to normal */
2947 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2948 attrs->ia_mode &= ~(S_IALLUGO);
2949 if (S_ISDIR(inode->i_mode))
2951 cifs_sb->ctx->dir_mode;
2954 cifs_sb->ctx->file_mode;
2956 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2957 /* ignore mode change - ATTR_READONLY hasn't changed */
2958 attrs->ia_valid &= ~ATTR_MODE;
2962 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2963 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2964 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2965 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2967 /* Even if error on time set, no sense failing the call if
2968 the server would set the time to a reasonable value anyway,
2969 and this check ensures that we are not being called from
2970 sys_utimes in which case we ought to fail the call back to
2971 the user when the server rejects the call */
2972 if ((rc) && (attrs->ia_valid &
2973 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2977 /* do not need local check to inode_check_ok since the server does
2980 goto cifs_setattr_exit;
2982 if ((attrs->ia_valid & ATTR_SIZE) &&
2983 attrs->ia_size != i_size_read(inode))
2984 truncate_setsize(inode, attrs->ia_size);
2986 setattr_copy(&init_user_ns, inode, attrs);
2987 mark_inode_dirty(inode);
2991 free_dentry_path(page);
2996 cifs_setattr(struct user_namespace *mnt_userns, struct dentry *direntry,
2997 struct iattr *attrs)
2999 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
3000 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
3001 int rc, retries = 0;
3003 if (unlikely(cifs_forced_shutdown(cifs_sb)))
3007 if (pTcon->unix_ext)
3008 rc = cifs_setattr_unix(direntry, attrs);
3010 rc = cifs_setattr_nounix(direntry, attrs);
3012 } while (is_retryable_error(rc) && retries < 2);
3014 /* BB: add cifs_setattr_legacy for really old servers */