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);
372 rc = cifs_fattr_to_inode(inode, &fattr);
377 int cifs_get_inode_info_unix(struct inode **pinode,
378 const unsigned char *full_path,
379 struct super_block *sb, unsigned int xid)
382 FILE_UNIX_BASIC_INFO find_data;
383 struct cifs_fattr fattr;
384 struct cifs_tcon *tcon;
385 struct tcon_link *tlink;
386 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
388 cifs_dbg(FYI, "Getting info on %s\n", full_path);
390 tlink = cifs_sb_tlink(cifs_sb);
392 return PTR_ERR(tlink);
393 tcon = tlink_tcon(tlink);
395 /* could have done a find first instead but this returns more info */
396 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
397 cifs_sb->local_nls, cifs_remap(cifs_sb));
398 cifs_put_tlink(tlink);
401 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
402 } else if (rc == -EREMOTE) {
403 cifs_create_dfs_fattr(&fattr, sb);
409 /* check for Minshall+French symlinks */
410 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
411 int tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
414 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
417 if (*pinode == NULL) {
419 cifs_fill_uniqueid(sb, &fattr);
420 *pinode = cifs_iget(sb, &fattr);
424 /* we already have inode, update it */
426 /* if uniqueid is different, return error */
427 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
428 CIFS_I(*pinode)->uniqueid != fattr.cf_uniqueid)) {
429 CIFS_I(*pinode)->time = 0; /* force reval */
434 /* if filetype is different, return error */
435 rc = cifs_fattr_to_inode(*pinode, &fattr);
443 cifs_sfu_type(struct cifs_fattr *fattr, const char *path,
444 struct cifs_sb_info *cifs_sb, unsigned int xid)
448 struct tcon_link *tlink;
449 struct cifs_tcon *tcon;
451 struct cifs_open_parms oparms;
452 struct cifs_io_parms io_parms = {0};
454 unsigned int bytes_read;
456 int buf_type = CIFS_NO_BUFFER;
460 fattr->cf_mode &= ~S_IFMT;
462 if (fattr->cf_eof == 0) {
463 fattr->cf_mode |= S_IFIFO;
464 fattr->cf_dtype = DT_FIFO;
466 } else if (fattr->cf_eof < 8) {
467 fattr->cf_mode |= S_IFREG;
468 fattr->cf_dtype = DT_REG;
469 return -EINVAL; /* EOPNOTSUPP? */
472 tlink = cifs_sb_tlink(cifs_sb);
474 return PTR_ERR(tlink);
475 tcon = tlink_tcon(tlink);
478 oparms.cifs_sb = cifs_sb;
479 oparms.desired_access = GENERIC_READ;
480 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
481 oparms.disposition = FILE_OPEN;
484 oparms.reconnect = false;
486 if (tcon->ses->server->oplocks)
490 rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);
492 cifs_dbg(FYI, "check sfu type of %s, open rc = %d\n", path, rc);
493 cifs_put_tlink(tlink);
498 io_parms.netfid = fid.netfid;
499 io_parms.pid = current->tgid;
500 io_parms.tcon = tcon;
502 io_parms.length = 24;
504 rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,
505 &bytes_read, &pbuf, &buf_type);
506 if ((rc == 0) && (bytes_read >= 8)) {
507 if (memcmp("IntxBLK", pbuf, 8) == 0) {
508 cifs_dbg(FYI, "Block device\n");
509 fattr->cf_mode |= S_IFBLK;
510 fattr->cf_dtype = DT_BLK;
511 if (bytes_read == 24) {
512 /* we have enough to decode dev num */
513 __u64 mjr; /* major */
514 __u64 mnr; /* minor */
515 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
516 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
517 fattr->cf_rdev = MKDEV(mjr, mnr);
519 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
520 cifs_dbg(FYI, "Char device\n");
521 fattr->cf_mode |= S_IFCHR;
522 fattr->cf_dtype = DT_CHR;
523 if (bytes_read == 24) {
524 /* we have enough to decode dev num */
525 __u64 mjr; /* major */
526 __u64 mnr; /* minor */
527 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
528 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
529 fattr->cf_rdev = MKDEV(mjr, mnr);
531 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
532 cifs_dbg(FYI, "Symlink\n");
533 fattr->cf_mode |= S_IFLNK;
534 fattr->cf_dtype = DT_LNK;
536 fattr->cf_mode |= S_IFREG; /* file? */
537 fattr->cf_dtype = DT_REG;
541 fattr->cf_mode |= S_IFREG; /* then it is a file */
542 fattr->cf_dtype = DT_REG;
543 rc = -EOPNOTSUPP; /* or some unknown SFU type */
546 tcon->ses->server->ops->close(xid, tcon, &fid);
547 cifs_put_tlink(tlink);
551 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
554 * Fetch mode bits as provided by SFU.
556 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
558 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
559 struct cifs_sb_info *cifs_sb, unsigned int xid)
561 #ifdef CONFIG_CIFS_XATTR
565 struct tcon_link *tlink;
566 struct cifs_tcon *tcon;
568 tlink = cifs_sb_tlink(cifs_sb);
570 return PTR_ERR(tlink);
571 tcon = tlink_tcon(tlink);
573 if (tcon->ses->server->ops->query_all_EAs == NULL) {
574 cifs_put_tlink(tlink);
578 rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
579 "SETFILEBITS", ea_value, 4 /* size of buf */,
581 cifs_put_tlink(tlink);
585 mode = le32_to_cpu(*((__le32 *)ea_value));
586 fattr->cf_mode &= ~SFBITS_MASK;
587 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
588 mode, fattr->cf_mode);
589 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
590 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
599 /* Fill a cifs_fattr struct with info from POSIX info struct */
601 smb311_posix_info_to_fattr(struct cifs_fattr *fattr, struct smb311_posix_qinfo *info,
602 struct super_block *sb, bool adjust_tz, bool symlink)
604 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
605 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
607 memset(fattr, 0, sizeof(*fattr));
609 /* no fattr->flags to set */
610 fattr->cf_cifsattrs = le32_to_cpu(info->DosAttributes);
611 fattr->cf_uniqueid = le64_to_cpu(info->Inode);
613 if (info->LastAccessTime)
614 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
616 ktime_get_coarse_real_ts64(&fattr->cf_atime);
618 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
619 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
622 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
623 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
626 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
627 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
628 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
630 fattr->cf_nlink = le32_to_cpu(info->HardLinks);
631 fattr->cf_mode = (umode_t) le32_to_cpu(info->Mode);
632 /* The srv fs device id is overridden on network mount so setting rdev isn't needed here */
633 /* fattr->cf_rdev = le32_to_cpu(info->DeviceId); */
636 fattr->cf_mode |= S_IFLNK;
637 fattr->cf_dtype = DT_LNK;
638 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
639 fattr->cf_mode |= S_IFDIR;
640 fattr->cf_dtype = DT_DIR;
642 fattr->cf_mode |= S_IFREG;
643 fattr->cf_dtype = DT_REG;
645 /* else if reparse point ... TODO: add support for FIFO and blk dev; special file types */
647 fattr->cf_uid = cifs_sb->ctx->linux_uid; /* TODO: map uid and gid from SID */
648 fattr->cf_gid = cifs_sb->ctx->linux_gid;
650 cifs_dbg(FYI, "POSIX query info: mode 0x%x uniqueid 0x%llx nlink %d\n",
651 fattr->cf_mode, fattr->cf_uniqueid, fattr->cf_nlink);
655 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
657 cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
658 struct super_block *sb, bool adjust_tz,
659 bool symlink, u32 reparse_tag)
661 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
662 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
664 memset(fattr, 0, sizeof(*fattr));
665 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
666 if (info->DeletePending)
667 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
669 if (info->LastAccessTime)
670 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
672 ktime_get_coarse_real_ts64(&fattr->cf_atime);
674 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
675 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
678 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
679 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
682 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
683 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
684 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
686 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
687 if (reparse_tag == IO_REPARSE_TAG_LX_SYMLINK) {
688 fattr->cf_mode |= S_IFLNK | cifs_sb->ctx->file_mode;
689 fattr->cf_dtype = DT_LNK;
690 } else if (reparse_tag == IO_REPARSE_TAG_LX_FIFO) {
691 fattr->cf_mode |= S_IFIFO | cifs_sb->ctx->file_mode;
692 fattr->cf_dtype = DT_FIFO;
693 } else if (reparse_tag == IO_REPARSE_TAG_AF_UNIX) {
694 fattr->cf_mode |= S_IFSOCK | cifs_sb->ctx->file_mode;
695 fattr->cf_dtype = DT_SOCK;
696 } else if (reparse_tag == IO_REPARSE_TAG_LX_CHR) {
697 fattr->cf_mode |= S_IFCHR | cifs_sb->ctx->file_mode;
698 fattr->cf_dtype = DT_CHR;
699 } else if (reparse_tag == IO_REPARSE_TAG_LX_BLK) {
700 fattr->cf_mode |= S_IFBLK | cifs_sb->ctx->file_mode;
701 fattr->cf_dtype = DT_BLK;
702 } else if (symlink) { /* TODO add more reparse tag checks */
703 fattr->cf_mode = S_IFLNK;
704 fattr->cf_dtype = DT_LNK;
705 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
706 fattr->cf_mode = S_IFDIR | cifs_sb->ctx->dir_mode;
707 fattr->cf_dtype = DT_DIR;
709 * Server can return wrong NumberOfLinks value for directories
710 * when Unix extensions are disabled - fake it.
713 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
715 fattr->cf_mode = S_IFREG | cifs_sb->ctx->file_mode;
716 fattr->cf_dtype = DT_REG;
718 /* clear write bits if ATTR_READONLY is set */
719 if (fattr->cf_cifsattrs & ATTR_READONLY)
720 fattr->cf_mode &= ~(S_IWUGO);
723 * Don't accept zero nlink from non-unix servers unless
724 * delete is pending. Instead mark it as unknown.
726 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
727 !info->DeletePending) {
728 cifs_dbg(VFS, "bogus file nlink value %u\n",
730 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
734 fattr->cf_uid = cifs_sb->ctx->linux_uid;
735 fattr->cf_gid = cifs_sb->ctx->linux_gid;
739 cifs_get_file_info(struct file *filp)
743 FILE_ALL_INFO find_data;
744 struct cifs_fattr fattr;
745 struct inode *inode = file_inode(filp);
746 struct cifsFileInfo *cfile = filp->private_data;
747 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
748 struct TCP_Server_Info *server = tcon->ses->server;
750 if (!server->ops->query_file_info)
754 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
757 /* TODO: add support to query reparse tag */
758 cifs_all_info_to_fattr(&fattr, &find_data, inode->i_sb, false,
759 false, 0 /* no reparse tag */);
762 cifs_create_dfs_fattr(&fattr, inode->i_sb);
768 * FIXME: legacy server -- fall back to path-based call?
769 * for now, just skip revalidating and mark inode for
773 CIFS_I(inode)->time = 0;
780 * don't bother with SFU junk here -- just mark inode as needing
783 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
784 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
785 /* if filetype is different, return error */
786 rc = cifs_fattr_to_inode(inode, &fattr);
792 /* Simple function to return a 64 bit hash of string. Rarely called */
793 static __u64 simple_hashstr(const char *str)
795 const __u64 hash_mult = 1125899906842597ULL; /* a big enough prime */
799 hash = (hash + (__u64) *str++) * hash_mult;
805 * cifs_backup_query_path_info - SMB1 fallback code to get ino
807 * Fallback code to get file metadata when we don't have access to
808 * full_path (EACCES) and have backup creds.
810 * @xid: transaction id used to identify original request in logs
811 * @tcon: information about the server share we have mounted
812 * @sb: the superblock stores info such as disk space available
813 * @full_path: name of the file we are getting the metadata for
814 * @resp_buf: will be set to cifs resp buf and needs to be freed with
815 * cifs_buf_release() when done with @data
816 * @data: will be set to search info result buffer
819 cifs_backup_query_path_info(int xid,
820 struct cifs_tcon *tcon,
821 struct super_block *sb,
822 const char *full_path,
824 FILE_ALL_INFO **data)
826 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
827 struct cifs_search_info info = {0};
832 info.endOfSearch = false;
834 info.info_level = SMB_FIND_FILE_UNIX;
835 else if ((tcon->ses->capabilities &
836 tcon->ses->server->vals->cap_nt_find) == 0)
837 info.info_level = SMB_FIND_FILE_INFO_STANDARD;
838 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
839 info.info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
840 else /* no srvino useful for fallback to some netapp */
841 info.info_level = SMB_FIND_FILE_DIRECTORY_INFO;
843 flags = CIFS_SEARCH_CLOSE_ALWAYS |
844 CIFS_SEARCH_CLOSE_AT_END |
845 CIFS_SEARCH_BACKUP_SEARCH;
847 rc = CIFSFindFirst(xid, tcon, full_path,
848 cifs_sb, NULL, flags, &info, false);
852 *resp_buf = (void *)info.ntwrk_buf_start;
853 *data = (FILE_ALL_INFO *)info.srch_entries_start;
858 cifs_set_fattr_ino(int xid,
859 struct cifs_tcon *tcon,
860 struct super_block *sb,
861 struct inode **inode,
862 const char *full_path,
864 struct cifs_fattr *fattr)
866 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
867 struct TCP_Server_Info *server = tcon->ses->server;
870 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
872 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
874 fattr->cf_uniqueid = iunique(sb, ROOT_I);
879 * If we have an inode pass a NULL tcon to ensure we don't
880 * make a round trip to the server. This only works for SMB2+.
882 rc = server->ops->get_srv_inum(xid,
883 *inode ? NULL : tcon,
889 * If that fails reuse existing ino or generate one
890 * and disable server ones
893 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
895 fattr->cf_uniqueid = iunique(sb, ROOT_I);
896 cifs_autodisable_serverino(cifs_sb);
901 /* If no errors, check for zero root inode (invalid) */
902 if (fattr->cf_uniqueid == 0 && strlen(full_path) == 0) {
903 cifs_dbg(FYI, "Invalid (0) inodenum\n");
906 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
908 /* make an ino by hashing the UNC */
909 fattr->cf_flags |= CIFS_FATTR_FAKE_ROOT_INO;
910 fattr->cf_uniqueid = simple_hashstr(tcon->treeName);
915 static inline bool is_inode_cache_good(struct inode *ino)
917 return ino && CIFS_CACHE_READ(CIFS_I(ino)) && CIFS_I(ino)->time != 0;
921 cifs_get_inode_info(struct inode **inode,
922 const char *full_path,
923 FILE_ALL_INFO *in_data,
924 struct super_block *sb, int xid,
925 const struct cifs_fid *fid)
928 struct cifs_tcon *tcon;
929 struct TCP_Server_Info *server;
930 struct tcon_link *tlink;
931 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
932 bool adjust_tz = false;
933 struct cifs_fattr fattr = {0};
934 bool is_reparse_point = false;
935 FILE_ALL_INFO *data = in_data;
936 FILE_ALL_INFO *tmp_data = NULL;
937 void *smb1_backup_rsp_buf = NULL;
940 __u32 reparse_tag = 0;
942 tlink = cifs_sb_tlink(cifs_sb);
944 return PTR_ERR(tlink);
945 tcon = tlink_tcon(tlink);
946 server = tcon->ses->server;
949 * 1. Fetch file metadata if not provided (data)
953 if (is_inode_cache_good(*inode)) {
954 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
957 tmp_data = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
962 rc = server->ops->query_path_info(xid, tcon, cifs_sb,
964 &adjust_tz, &is_reparse_point);
969 * 2. Convert it to internal cifs metadata (fattr)
975 * If the file is a reparse point, it is more complicated
976 * since we have to check if its reparse tag matches a known
977 * special file type e.g. symlink or fifo or char etc.
979 if ((le32_to_cpu(data->Attributes) & ATTR_REPARSE) &&
980 server->ops->query_reparse_tag) {
981 rc = server->ops->query_reparse_tag(xid, tcon, cifs_sb,
982 full_path, &reparse_tag);
983 cifs_dbg(FYI, "reparse tag 0x%x\n", reparse_tag);
985 cifs_all_info_to_fattr(&fattr, data, sb, adjust_tz,
986 is_reparse_point, reparse_tag);
989 /* DFS link, no metadata available on this server */
990 cifs_create_dfs_fattr(&fattr, sb);
995 * perm errors, try again with backup flags if possible
997 * For SMB2 and later the backup intent flag
998 * is already sent if needed on open and there
999 * is no path based FindFirst operation to use
1002 if (backup_cred(cifs_sb) && is_smb1_server(server)) {
1003 /* for easier reading */
1004 FILE_DIRECTORY_INFO *fdi;
1005 SEARCH_ID_FULL_DIR_INFO *si;
1007 rc = cifs_backup_query_path_info(xid, tcon, sb,
1009 &smb1_backup_rsp_buf,
1014 fdi = (FILE_DIRECTORY_INFO *)data;
1015 si = (SEARCH_ID_FULL_DIR_INFO *)data;
1017 cifs_dir_info_to_fattr(&fattr, fdi, cifs_sb);
1018 fattr.cf_uniqueid = le64_to_cpu(si->UniqueId);
1019 /* uniqueid set, skip get inum step */
1020 goto handle_mnt_opt;
1022 /* nothing we can do, bail out */
1027 cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc);
1032 * 3. Get or update inode number (fattr.cf_uniqueid)
1035 cifs_set_fattr_ino(xid, tcon, sb, inode, full_path, data, &fattr);
1038 * 4. Tweak fattr based on mount options
1042 /* query for SFU type info if supported and needed */
1043 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
1044 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
1045 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
1047 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
1050 /* fill in 0777 bits from ACL */
1051 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID) {
1052 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, true,
1057 cifs_dbg(FYI, "%s: Get mode from SID failed. rc=%d\n",
1061 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
1062 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, false,
1067 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
1073 /* fill in remaining high mode bits e.g. SUID, VTX */
1074 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
1075 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
1077 /* check for Minshall+French symlinks */
1078 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
1079 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
1082 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
1086 * 5. Update inode with final fattr data
1090 *inode = cifs_iget(sb, &fattr);
1094 /* we already have inode, update it */
1096 /* if uniqueid is different, return error */
1097 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
1098 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
1099 CIFS_I(*inode)->time = 0; /* force reval */
1103 /* if filetype is different, return error */
1104 rc = cifs_fattr_to_inode(*inode, &fattr);
1107 cifs_buf_release(smb1_backup_rsp_buf);
1108 cifs_put_tlink(tlink);
1114 smb311_posix_get_inode_info(struct inode **inode,
1115 const char *full_path,
1116 struct super_block *sb, unsigned int xid)
1118 struct cifs_tcon *tcon;
1119 struct tcon_link *tlink;
1120 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1121 bool adjust_tz = false;
1122 struct cifs_fattr fattr = {0};
1123 bool symlink = false;
1124 struct smb311_posix_qinfo *data = NULL;
1128 tlink = cifs_sb_tlink(cifs_sb);
1130 return PTR_ERR(tlink);
1131 tcon = tlink_tcon(tlink);
1134 * 1. Fetch file metadata
1137 if (is_inode_cache_good(*inode)) {
1138 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
1141 data = kmalloc(sizeof(struct smb311_posix_qinfo), GFP_KERNEL);
1147 rc = smb311_posix_query_path_info(xid, tcon, cifs_sb,
1149 &adjust_tz, &symlink);
1152 * 2. Convert it to internal cifs metadata (fattr)
1157 smb311_posix_info_to_fattr(&fattr, data, sb, adjust_tz, symlink);
1160 /* DFS link, no metadata available on this server */
1161 cifs_create_dfs_fattr(&fattr, sb);
1166 * For SMB2 and later the backup intent flag
1167 * is already sent if needed on open and there
1168 * is no path based FindFirst operation to use
1169 * to retry with so nothing we can do, bail out
1173 cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc);
1179 * 3. Tweak fattr based on mount options
1182 /* check for Minshall+French symlinks */
1183 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
1184 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
1187 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
1191 * 4. Update inode with final fattr data
1195 *inode = cifs_iget(sb, &fattr);
1199 /* we already have inode, update it */
1201 /* if uniqueid is different, return error */
1202 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
1203 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
1204 CIFS_I(*inode)->time = 0; /* force reval */
1209 /* if filetype is different, return error */
1210 rc = cifs_fattr_to_inode(*inode, &fattr);
1213 cifs_put_tlink(tlink);
1219 static const struct inode_operations cifs_ipc_inode_ops = {
1220 .lookup = cifs_lookup,
1224 cifs_find_inode(struct inode *inode, void *opaque)
1226 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
1228 /* don't match inode with different uniqueid */
1229 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
1232 /* use createtime like an i_generation field */
1233 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
1236 /* don't match inode of different type */
1237 if (inode_wrong_type(inode, fattr->cf_mode))
1240 /* if it's not a directory or has no dentries, then flag it */
1241 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
1242 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
1248 cifs_init_inode(struct inode *inode, void *opaque)
1250 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
1252 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
1253 CIFS_I(inode)->createtime = fattr->cf_createtime;
1258 * walk dentry list for an inode and report whether it has aliases that
1259 * are hashed. We use this to determine if a directory inode can actually
1263 inode_has_hashed_dentries(struct inode *inode)
1265 struct dentry *dentry;
1267 spin_lock(&inode->i_lock);
1268 hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
1269 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
1270 spin_unlock(&inode->i_lock);
1274 spin_unlock(&inode->i_lock);
1278 /* Given fattrs, get a corresponding inode */
1280 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
1283 struct inode *inode;
1286 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
1288 /* hash down to 32-bits on 32-bit arch */
1289 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
1291 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
1293 /* was there a potentially problematic inode collision? */
1294 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
1295 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
1297 if (inode_has_hashed_dentries(inode)) {
1298 cifs_autodisable_serverino(CIFS_SB(sb));
1300 fattr->cf_uniqueid = iunique(sb, ROOT_I);
1301 goto retry_iget5_locked;
1305 /* can't fail - see cifs_find_inode() */
1306 cifs_fattr_to_inode(inode, fattr);
1307 if (sb->s_flags & SB_NOATIME)
1308 inode->i_flags |= S_NOATIME | S_NOCMTIME;
1309 if (inode->i_state & I_NEW) {
1310 inode->i_ino = hash;
1311 #ifdef CONFIG_CIFS_FSCACHE
1312 /* initialize per-inode cache cookie pointer */
1313 CIFS_I(inode)->fscache = NULL;
1315 unlock_new_inode(inode);
1322 /* gets root inode */
1323 struct inode *cifs_root_iget(struct super_block *sb)
1326 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1327 struct inode *inode = NULL;
1329 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1333 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
1334 && cifs_sb->prepath) {
1335 len = strlen(cifs_sb->prepath);
1336 path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
1338 return ERR_PTR(-ENOMEM);
1340 memcpy(path+1, cifs_sb->prepath, len);
1342 path = kstrdup("", GFP_KERNEL);
1344 return ERR_PTR(-ENOMEM);
1348 if (tcon->unix_ext) {
1349 rc = cifs_get_inode_info_unix(&inode, path, sb, xid);
1350 /* some servers mistakenly claim POSIX support */
1351 if (rc != -EOPNOTSUPP)
1353 cifs_dbg(VFS, "server does not support POSIX extensions\n");
1354 tcon->unix_ext = false;
1357 convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
1358 if (tcon->posix_extensions)
1359 rc = smb311_posix_get_inode_info(&inode, path, sb, xid);
1361 rc = cifs_get_inode_info(&inode, path, NULL, sb, xid, NULL);
1365 inode = ERR_PTR(rc);
1369 #ifdef CONFIG_CIFS_FSCACHE
1370 /* populate tcon->resource_id */
1371 tcon->resource_id = CIFS_I(inode)->uniqueid;
1374 if (rc && tcon->pipe) {
1375 cifs_dbg(FYI, "ipc connection - fake read inode\n");
1376 spin_lock(&inode->i_lock);
1377 inode->i_mode |= S_IFDIR;
1378 set_nlink(inode, 2);
1379 inode->i_op = &cifs_ipc_inode_ops;
1380 inode->i_fop = &simple_dir_operations;
1381 inode->i_uid = cifs_sb->ctx->linux_uid;
1382 inode->i_gid = cifs_sb->ctx->linux_gid;
1383 spin_unlock(&inode->i_lock);
1386 inode = ERR_PTR(rc);
1396 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1397 const char *full_path, __u32 dosattr)
1399 bool set_time = false;
1400 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1401 struct TCP_Server_Info *server;
1402 FILE_BASIC_INFO info_buf;
1407 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1408 if (!server->ops->set_file_info)
1413 if (attrs->ia_valid & ATTR_ATIME) {
1415 info_buf.LastAccessTime =
1416 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1418 info_buf.LastAccessTime = 0;
1420 if (attrs->ia_valid & ATTR_MTIME) {
1422 info_buf.LastWriteTime =
1423 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1425 info_buf.LastWriteTime = 0;
1428 * Samba throws this field away, but windows may actually use it.
1429 * Do not set ctime unless other time stamps are changed explicitly
1430 * (i.e. by utimes()) since we would then have a mix of client and
1433 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1434 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1435 info_buf.ChangeTime =
1436 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1438 info_buf.ChangeTime = 0;
1440 info_buf.CreationTime = 0; /* don't change */
1441 info_buf.Attributes = cpu_to_le32(dosattr);
1443 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1447 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1448 * and rename it to a random name that hopefully won't conflict with
1452 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1453 const unsigned int xid)
1457 struct cifs_fid fid;
1458 struct cifs_open_parms oparms;
1459 struct inode *inode = d_inode(dentry);
1460 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1461 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1462 struct tcon_link *tlink;
1463 struct cifs_tcon *tcon;
1464 __u32 dosattr, origattr;
1465 FILE_BASIC_INFO *info_buf = NULL;
1467 tlink = cifs_sb_tlink(cifs_sb);
1469 return PTR_ERR(tlink);
1470 tcon = tlink_tcon(tlink);
1473 * We cannot rename the file if the server doesn't support
1474 * CAP_INFOLEVEL_PASSTHRU
1476 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1482 oparms.cifs_sb = cifs_sb;
1483 oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1484 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
1485 oparms.disposition = FILE_OPEN;
1486 oparms.path = full_path;
1488 oparms.reconnect = false;
1490 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1494 origattr = cifsInode->cifsAttrs;
1496 origattr |= ATTR_NORMAL;
1498 dosattr = origattr & ~ATTR_READONLY;
1500 dosattr |= ATTR_NORMAL;
1501 dosattr |= ATTR_HIDDEN;
1503 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1504 if (dosattr != origattr) {
1505 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1506 if (info_buf == NULL) {
1510 info_buf->Attributes = cpu_to_le32(dosattr);
1511 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1513 /* although we would like to mark the file hidden
1514 if that fails we will still try to rename it */
1516 cifsInode->cifsAttrs = dosattr;
1518 dosattr = origattr; /* since not able to change them */
1521 /* rename the file */
1522 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1524 cifs_remap(cifs_sb));
1530 /* try to set DELETE_ON_CLOSE */
1531 if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1532 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1535 * some samba versions return -ENOENT when we try to set the
1536 * file disposition here. Likely a samba bug, but work around
1537 * it for now. This means that some cifsXXX files may hang
1538 * around after they shouldn't.
1540 * BB: remove this hack after more servers have the fix
1548 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1552 CIFSSMBClose(xid, tcon, fid.netfid);
1555 cifs_put_tlink(tlink);
1559 * reset everything back to the original state. Don't bother
1560 * dealing with errors here since we can't do anything about
1564 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1565 cifs_sb->local_nls, cifs_remap(cifs_sb));
1567 if (dosattr != origattr) {
1568 info_buf->Attributes = cpu_to_le32(origattr);
1569 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1571 cifsInode->cifsAttrs = origattr;
1577 /* copied from fs/nfs/dir.c with small changes */
1579 cifs_drop_nlink(struct inode *inode)
1581 spin_lock(&inode->i_lock);
1582 if (inode->i_nlink > 0)
1584 spin_unlock(&inode->i_lock);
1588 * If d_inode(dentry) is null (usually meaning the cached dentry
1589 * is a negative dentry) then we would attempt a standard SMB delete, but
1590 * if that fails we can not attempt the fall back mechanisms on EACCES
1591 * but will return the EACCES to the caller. Note that the VFS does not call
1592 * unlink on negative dentries currently.
1594 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1598 const char *full_path;
1600 struct inode *inode = d_inode(dentry);
1601 struct cifsInodeInfo *cifs_inode;
1602 struct super_block *sb = dir->i_sb;
1603 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1604 struct tcon_link *tlink;
1605 struct cifs_tcon *tcon;
1606 struct TCP_Server_Info *server;
1607 struct iattr *attrs = NULL;
1608 __u32 dosattr = 0, origattr = 0;
1610 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1612 if (unlikely(cifs_forced_shutdown(cifs_sb)))
1615 tlink = cifs_sb_tlink(cifs_sb);
1617 return PTR_ERR(tlink);
1618 tcon = tlink_tcon(tlink);
1619 server = tcon->ses->server;
1622 page = alloc_dentry_path();
1624 if (tcon->nodelete) {
1629 /* Unlink can be called from rename so we can not take the
1630 * sb->s_vfs_rename_mutex here */
1631 full_path = build_path_from_dentry(dentry, page);
1632 if (IS_ERR(full_path)) {
1633 rc = PTR_ERR(full_path);
1637 cifs_close_all_deferred_files(tcon);
1638 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1639 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1640 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1641 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1642 cifs_remap(cifs_sb));
1643 cifs_dbg(FYI, "posix del rc %d\n", rc);
1644 if ((rc == 0) || (rc == -ENOENT))
1645 goto psx_del_no_retry;
1649 if (!server->ops->unlink) {
1651 goto psx_del_no_retry;
1654 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1659 cifs_drop_nlink(inode);
1660 } else if (rc == -ENOENT) {
1662 } else if (rc == -EBUSY) {
1663 if (server->ops->rename_pending_delete) {
1664 rc = server->ops->rename_pending_delete(full_path,
1667 cifs_drop_nlink(inode);
1669 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1670 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1671 if (attrs == NULL) {
1676 /* try to reset dos attributes */
1677 cifs_inode = CIFS_I(inode);
1678 origattr = cifs_inode->cifsAttrs;
1680 origattr |= ATTR_NORMAL;
1681 dosattr = origattr & ~ATTR_READONLY;
1683 dosattr |= ATTR_NORMAL;
1684 dosattr |= ATTR_HIDDEN;
1686 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1690 goto retry_std_delete;
1693 /* undo the setattr if we errored out and it's needed */
1694 if (rc != 0 && dosattr != 0)
1695 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1699 cifs_inode = CIFS_I(inode);
1700 cifs_inode->time = 0; /* will force revalidate to get info
1702 inode->i_ctime = current_time(inode);
1704 dir->i_ctime = dir->i_mtime = current_time(dir);
1705 cifs_inode = CIFS_I(dir);
1706 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1708 free_dentry_path(page);
1711 cifs_put_tlink(tlink);
1716 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1717 const char *full_path, struct cifs_sb_info *cifs_sb,
1718 struct cifs_tcon *tcon, const unsigned int xid)
1721 struct inode *inode = NULL;
1723 if (tcon->posix_extensions)
1724 rc = smb311_posix_get_inode_info(&inode, full_path, parent->i_sb, xid);
1725 else if (tcon->unix_ext)
1726 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1729 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1735 if (!S_ISDIR(inode->i_mode)) {
1737 * mkdir succeeded, but another client has managed to remove the
1738 * sucker and replace it with non-directory. Return success,
1739 * but don't leave the child in dcache.
1746 * setting nlink not necessary except in cases where we failed to get it
1747 * from the server or was set bogus. Also, since this is a brand new
1748 * inode, no need to grab the i_lock before setting the i_nlink.
1750 if (inode->i_nlink < 2)
1751 set_nlink(inode, 2);
1752 mode &= ~current_umask();
1753 /* must turn on setgid bit if parent dir has it */
1754 if (parent->i_mode & S_ISGID)
1757 if (tcon->unix_ext) {
1758 struct cifs_unix_set_info_args args = {
1760 .ctime = NO_CHANGE_64,
1761 .atime = NO_CHANGE_64,
1762 .mtime = NO_CHANGE_64,
1765 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1766 args.uid = current_fsuid();
1767 if (parent->i_mode & S_ISGID)
1768 args.gid = parent->i_gid;
1770 args.gid = current_fsgid();
1772 args.uid = INVALID_UID; /* no change */
1773 args.gid = INVALID_GID; /* no change */
1775 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1777 cifs_remap(cifs_sb));
1779 struct TCP_Server_Info *server = tcon->ses->server;
1780 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1781 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1782 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1784 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1785 inode->i_mode = (mode | S_IFDIR);
1787 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1788 inode->i_uid = current_fsuid();
1789 if (inode->i_mode & S_ISGID)
1790 inode->i_gid = parent->i_gid;
1792 inode->i_gid = current_fsgid();
1795 d_instantiate(dentry, inode);
1800 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1801 const char *full_path, struct cifs_sb_info *cifs_sb,
1802 struct cifs_tcon *tcon, const unsigned int xid)
1806 FILE_UNIX_BASIC_INFO *info = NULL;
1807 struct inode *newinode = NULL;
1808 struct cifs_fattr fattr;
1810 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1813 goto posix_mkdir_out;
1816 mode &= ~current_umask();
1817 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1818 NULL /* netfid */, info, &oplock, full_path,
1819 cifs_sb->local_nls, cifs_remap(cifs_sb));
1820 if (rc == -EOPNOTSUPP)
1821 goto posix_mkdir_out;
1823 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1825 goto posix_mkdir_out;
1828 if (info->Type == cpu_to_le32(-1))
1829 /* no return info, go query for it */
1830 goto posix_mkdir_get_info;
1832 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1833 * need to set uid/gid.
1836 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1837 cifs_fill_uniqueid(inode->i_sb, &fattr);
1838 newinode = cifs_iget(inode->i_sb, &fattr);
1840 goto posix_mkdir_get_info;
1842 d_instantiate(dentry, newinode);
1844 #ifdef CONFIG_CIFS_DEBUG2
1845 cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1846 dentry, dentry, newinode);
1848 if (newinode->i_nlink != 2)
1849 cifs_dbg(FYI, "unexpected number of links %d\n",
1856 posix_mkdir_get_info:
1857 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1859 goto posix_mkdir_out;
1862 int cifs_mkdir(struct user_namespace *mnt_userns, struct inode *inode,
1863 struct dentry *direntry, umode_t mode)
1867 struct cifs_sb_info *cifs_sb;
1868 struct tcon_link *tlink;
1869 struct cifs_tcon *tcon;
1870 struct TCP_Server_Info *server;
1871 const char *full_path;
1874 cifs_dbg(FYI, "In cifs_mkdir, mode = %04ho inode = 0x%p\n",
1877 cifs_sb = CIFS_SB(inode->i_sb);
1878 if (unlikely(cifs_forced_shutdown(cifs_sb)))
1880 tlink = cifs_sb_tlink(cifs_sb);
1882 return PTR_ERR(tlink);
1883 tcon = tlink_tcon(tlink);
1887 page = alloc_dentry_path();
1888 full_path = build_path_from_dentry(direntry, page);
1889 if (IS_ERR(full_path)) {
1890 rc = PTR_ERR(full_path);
1894 server = tcon->ses->server;
1896 if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) {
1897 rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,
1899 d_drop(direntry); /* for time being always refresh inode info */
1903 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1904 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1905 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1907 if (rc != -EOPNOTSUPP)
1911 if (!server->ops->mkdir) {
1916 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1917 rc = server->ops->mkdir(xid, inode, mode, tcon, full_path, cifs_sb);
1919 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1924 /* TODO: skip this for smb2/smb3 */
1925 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1929 * Force revalidate to get parent dir info when needed since cached
1930 * attributes are invalid now.
1932 CIFS_I(inode)->time = 0;
1933 free_dentry_path(page);
1935 cifs_put_tlink(tlink);
1939 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1943 struct cifs_sb_info *cifs_sb;
1944 struct tcon_link *tlink;
1945 struct cifs_tcon *tcon;
1946 struct TCP_Server_Info *server;
1947 const char *full_path;
1948 void *page = alloc_dentry_path();
1949 struct cifsInodeInfo *cifsInode;
1951 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1955 full_path = build_path_from_dentry(direntry, page);
1956 if (IS_ERR(full_path)) {
1957 rc = PTR_ERR(full_path);
1961 cifs_sb = CIFS_SB(inode->i_sb);
1962 if (unlikely(cifs_forced_shutdown(cifs_sb))) {
1967 tlink = cifs_sb_tlink(cifs_sb);
1968 if (IS_ERR(tlink)) {
1969 rc = PTR_ERR(tlink);
1972 tcon = tlink_tcon(tlink);
1973 server = tcon->ses->server;
1975 if (!server->ops->rmdir) {
1977 cifs_put_tlink(tlink);
1981 if (tcon->nodelete) {
1983 cifs_put_tlink(tlink);
1987 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1988 cifs_put_tlink(tlink);
1991 spin_lock(&d_inode(direntry)->i_lock);
1992 i_size_write(d_inode(direntry), 0);
1993 clear_nlink(d_inode(direntry));
1994 spin_unlock(&d_inode(direntry)->i_lock);
1997 cifsInode = CIFS_I(d_inode(direntry));
1998 /* force revalidate to go get info when needed */
1999 cifsInode->time = 0;
2001 cifsInode = CIFS_I(inode);
2003 * Force revalidate to get parent dir info when needed since cached
2004 * attributes are invalid now.
2006 cifsInode->time = 0;
2008 d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
2009 current_time(inode);
2012 free_dentry_path(page);
2018 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
2019 const char *from_path, struct dentry *to_dentry,
2020 const char *to_path)
2022 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
2023 struct tcon_link *tlink;
2024 struct cifs_tcon *tcon;
2025 struct TCP_Server_Info *server;
2026 struct cifs_fid fid;
2027 struct cifs_open_parms oparms;
2030 tlink = cifs_sb_tlink(cifs_sb);
2032 return PTR_ERR(tlink);
2033 tcon = tlink_tcon(tlink);
2034 server = tcon->ses->server;
2036 if (!server->ops->rename)
2039 /* try path-based rename first */
2040 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
2043 * Don't bother with rename by filehandle unless file is busy and
2044 * source. Note that cross directory moves do not work with
2045 * rename by filehandle to various Windows servers.
2047 if (rc == 0 || rc != -EBUSY)
2048 goto do_rename_exit;
2050 /* Don't fall back to using SMB on SMB 2+ mount */
2051 if (server->vals->protocol_id != 0)
2052 goto do_rename_exit;
2054 /* open-file renames don't work across directories */
2055 if (to_dentry->d_parent != from_dentry->d_parent)
2056 goto do_rename_exit;
2059 oparms.cifs_sb = cifs_sb;
2060 /* open the file to be renamed -- we need DELETE perms */
2061 oparms.desired_access = DELETE;
2062 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
2063 oparms.disposition = FILE_OPEN;
2064 oparms.path = from_path;
2066 oparms.reconnect = false;
2068 rc = CIFS_open(xid, &oparms, &oplock, NULL);
2070 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
2071 (const char *) to_dentry->d_name.name,
2072 cifs_sb->local_nls, cifs_remap(cifs_sb));
2073 CIFSSMBClose(xid, tcon, fid.netfid);
2077 d_move(from_dentry, to_dentry);
2078 cifs_put_tlink(tlink);
2083 cifs_rename2(struct user_namespace *mnt_userns, struct inode *source_dir,
2084 struct dentry *source_dentry, struct inode *target_dir,
2085 struct dentry *target_dentry, unsigned int flags)
2087 const char *from_name, *to_name;
2088 void *page1, *page2;
2089 struct cifs_sb_info *cifs_sb;
2090 struct tcon_link *tlink;
2091 struct cifs_tcon *tcon;
2092 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
2093 FILE_UNIX_BASIC_INFO *info_buf_target;
2097 if (flags & ~RENAME_NOREPLACE)
2100 cifs_sb = CIFS_SB(source_dir->i_sb);
2101 if (unlikely(cifs_forced_shutdown(cifs_sb)))
2104 tlink = cifs_sb_tlink(cifs_sb);
2106 return PTR_ERR(tlink);
2107 tcon = tlink_tcon(tlink);
2109 page1 = alloc_dentry_path();
2110 page2 = alloc_dentry_path();
2113 from_name = build_path_from_dentry(source_dentry, page1);
2114 if (IS_ERR(from_name)) {
2115 rc = PTR_ERR(from_name);
2116 goto cifs_rename_exit;
2119 to_name = build_path_from_dentry(target_dentry, page2);
2120 if (IS_ERR(to_name)) {
2121 rc = PTR_ERR(to_name);
2122 goto cifs_rename_exit;
2125 cifs_close_all_deferred_files(tcon);
2126 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2130 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
2132 if (flags & RENAME_NOREPLACE)
2133 goto cifs_rename_exit;
2135 if (rc == -EEXIST && tcon->unix_ext) {
2137 * Are src and dst hardlinks of same inode? We can only tell
2138 * with unix extensions enabled.
2141 kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
2143 if (info_buf_source == NULL) {
2145 goto cifs_rename_exit;
2148 info_buf_target = info_buf_source + 1;
2149 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
2152 cifs_remap(cifs_sb));
2156 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
2159 cifs_remap(cifs_sb));
2161 if (tmprc == 0 && (info_buf_source->UniqueId ==
2162 info_buf_target->UniqueId)) {
2163 /* same file, POSIX says that this is a noop */
2165 goto cifs_rename_exit;
2169 * else ... BB we could add the same check for Windows by
2170 * checking the UniqueId via FILE_INTERNAL_INFO
2174 /* Try unlinking the target dentry if it's not negative */
2175 if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
2176 if (d_is_dir(target_dentry))
2177 tmprc = cifs_rmdir(target_dir, target_dentry);
2179 tmprc = cifs_unlink(target_dir, target_dentry);
2181 goto cifs_rename_exit;
2182 rc = cifs_do_rename(xid, source_dentry, from_name,
2183 target_dentry, to_name);
2186 /* force revalidate to go get info when needed */
2187 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
2189 source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
2190 target_dir->i_mtime = current_time(source_dir);
2193 kfree(info_buf_source);
2194 free_dentry_path(page2);
2195 free_dentry_path(page1);
2197 cifs_put_tlink(tlink);
2202 cifs_dentry_needs_reval(struct dentry *dentry)
2204 struct inode *inode = d_inode(dentry);
2205 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2206 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2207 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2208 struct cached_fid *cfid = NULL;
2210 if (cifs_i->time == 0)
2213 if (CIFS_CACHE_READ(cifs_i))
2216 if (!lookupCacheEnabled)
2219 if (!open_cached_dir_by_dentry(tcon, dentry->d_parent, &cfid)) {
2220 mutex_lock(&cfid->fid_mutex);
2221 if (cfid->time && cifs_i->time > cfid->time) {
2222 mutex_unlock(&cfid->fid_mutex);
2223 close_cached_dir(cfid);
2226 mutex_unlock(&cfid->fid_mutex);
2227 close_cached_dir(cfid);
2230 * depending on inode type, check if attribute caching disabled for
2231 * files or directories
2233 if (S_ISDIR(inode->i_mode)) {
2234 if (!cifs_sb->ctx->acdirmax)
2236 if (!time_in_range(jiffies, cifs_i->time,
2237 cifs_i->time + cifs_sb->ctx->acdirmax))
2240 if (!cifs_sb->ctx->acregmax)
2242 if (!time_in_range(jiffies, cifs_i->time,
2243 cifs_i->time + cifs_sb->ctx->acregmax))
2247 /* hardlinked files w/ noserverino get "special" treatment */
2248 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
2249 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
2256 * Zap the cache. Called when invalid_mapping flag is set.
2259 cifs_invalidate_mapping(struct inode *inode)
2263 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
2264 rc = invalidate_inode_pages2(inode->i_mapping);
2266 cifs_dbg(VFS, "%s: Could not invalidate inode %p\n",
2270 cifs_fscache_reset_inode_cookie(inode);
2275 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
2277 * @key: currently unused
2278 * @mode: the task state to sleep in
2281 cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
2283 freezable_schedule_unsafe();
2284 if (signal_pending_state(mode, current))
2285 return -ERESTARTSYS;
2290 cifs_revalidate_mapping(struct inode *inode)
2293 unsigned long *flags = &CIFS_I(inode)->flags;
2295 /* swapfiles are not supposed to be shared */
2296 if (IS_SWAPFILE(inode))
2299 rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
2304 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
2305 rc = cifs_invalidate_mapping(inode);
2307 set_bit(CIFS_INO_INVALID_MAPPING, flags);
2310 clear_bit_unlock(CIFS_INO_LOCK, flags);
2311 smp_mb__after_atomic();
2312 wake_up_bit(flags, CIFS_INO_LOCK);
2318 cifs_zap_mapping(struct inode *inode)
2320 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
2321 return cifs_revalidate_mapping(inode);
2324 int cifs_revalidate_file_attr(struct file *filp)
2327 struct dentry *dentry = file_dentry(filp);
2328 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
2330 if (!cifs_dentry_needs_reval(dentry))
2333 if (tlink_tcon(cfile->tlink)->unix_ext)
2334 rc = cifs_get_file_info_unix(filp);
2336 rc = cifs_get_file_info(filp);
2341 int cifs_revalidate_dentry_attr(struct dentry *dentry)
2345 struct inode *inode = d_inode(dentry);
2346 struct super_block *sb = dentry->d_sb;
2347 const char *full_path;
2354 if (!cifs_dentry_needs_reval(dentry))
2359 page = alloc_dentry_path();
2360 full_path = build_path_from_dentry(dentry, page);
2361 if (IS_ERR(full_path)) {
2362 rc = PTR_ERR(full_path);
2366 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2367 full_path, inode, inode->i_count.counter,
2368 dentry, cifs_get_time(dentry), jiffies);
2371 if (cifs_sb_master_tcon(CIFS_SB(sb))->posix_extensions)
2372 rc = smb311_posix_get_inode_info(&inode, full_path, sb, xid);
2373 else if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
2374 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2376 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2378 if (rc == -EAGAIN && count++ < 10)
2381 free_dentry_path(page);
2387 int cifs_revalidate_file(struct file *filp)
2390 struct inode *inode = file_inode(filp);
2392 rc = cifs_revalidate_file_attr(filp);
2396 return cifs_revalidate_mapping(inode);
2399 /* revalidate a dentry's inode attributes */
2400 int cifs_revalidate_dentry(struct dentry *dentry)
2403 struct inode *inode = d_inode(dentry);
2405 rc = cifs_revalidate_dentry_attr(dentry);
2409 return cifs_revalidate_mapping(inode);
2412 int cifs_getattr(struct user_namespace *mnt_userns, const struct path *path,
2413 struct kstat *stat, u32 request_mask, unsigned int flags)
2415 struct dentry *dentry = path->dentry;
2416 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2417 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2418 struct inode *inode = d_inode(dentry);
2421 if (unlikely(cifs_forced_shutdown(CIFS_SB(inode->i_sb))))
2425 * We need to be sure that all dirty pages are written and the server
2426 * has actual ctime, mtime and file length.
2428 if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_SIZE | STATX_BLOCKS)) &&
2429 !CIFS_CACHE_READ(CIFS_I(inode)) &&
2430 inode->i_mapping && inode->i_mapping->nrpages != 0) {
2431 rc = filemap_fdatawait(inode->i_mapping);
2433 mapping_set_error(inode->i_mapping, rc);
2438 if ((flags & AT_STATX_SYNC_TYPE) == AT_STATX_FORCE_SYNC)
2439 CIFS_I(inode)->time = 0; /* force revalidate */
2442 * If the caller doesn't require syncing, only sync if
2443 * necessary (e.g. due to earlier truncate or setattr
2444 * invalidating the cached metadata)
2446 if (((flags & AT_STATX_SYNC_TYPE) != AT_STATX_DONT_SYNC) ||
2447 (CIFS_I(inode)->time == 0)) {
2448 rc = cifs_revalidate_dentry_attr(dentry);
2453 generic_fillattr(&init_user_ns, inode, stat);
2454 stat->blksize = cifs_sb->ctx->bsize;
2455 stat->ino = CIFS_I(inode)->uniqueid;
2457 /* old CIFS Unix Extensions doesn't return create time */
2458 if (CIFS_I(inode)->createtime) {
2459 stat->result_mask |= STATX_BTIME;
2461 cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
2464 stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2465 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2466 stat->attributes |= STATX_ATTR_COMPRESSED;
2467 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2468 stat->attributes |= STATX_ATTR_ENCRYPTED;
2471 * If on a multiuser mount without unix extensions or cifsacl being
2472 * enabled, and the admin hasn't overridden them, set the ownership
2473 * to the fsuid/fsgid of the current process.
2475 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2476 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2478 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2479 stat->uid = current_fsuid();
2480 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2481 stat->gid = current_fsgid();
2486 int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start,
2489 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2490 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_i->vfs_inode.i_sb);
2491 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2492 struct TCP_Server_Info *server = tcon->ses->server;
2493 struct cifsFileInfo *cfile;
2496 if (unlikely(cifs_forced_shutdown(cifs_sb)))
2500 * We need to be sure that all dirty pages are written as they
2501 * might fill holes on the server.
2503 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2504 inode->i_mapping->nrpages != 0) {
2505 rc = filemap_fdatawait(inode->i_mapping);
2507 mapping_set_error(inode->i_mapping, rc);
2512 cfile = find_readable_file(cifs_i, false);
2516 if (server->ops->fiemap) {
2517 rc = server->ops->fiemap(tcon, cfile, fei, start, len);
2518 cifsFileInfo_put(cfile);
2522 cifsFileInfo_put(cfile);
2526 int cifs_truncate_page(struct address_space *mapping, loff_t from)
2528 pgoff_t index = from >> PAGE_SHIFT;
2529 unsigned offset = from & (PAGE_SIZE - 1);
2533 page = grab_cache_page(mapping, index);
2537 zero_user_segment(page, offset, PAGE_SIZE);
2543 void cifs_setsize(struct inode *inode, loff_t offset)
2545 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2547 spin_lock(&inode->i_lock);
2548 i_size_write(inode, offset);
2549 spin_unlock(&inode->i_lock);
2551 /* Cached inode must be refreshed on truncate */
2553 truncate_pagecache(inode, offset);
2557 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2558 unsigned int xid, const char *full_path)
2561 struct cifsFileInfo *open_file;
2562 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2563 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2564 struct tcon_link *tlink = NULL;
2565 struct cifs_tcon *tcon = NULL;
2566 struct TCP_Server_Info *server;
2569 * To avoid spurious oplock breaks from server, in the case of
2570 * inodes that we already have open, avoid doing path based
2571 * setting of file size if we can do it by handle.
2572 * This keeps our caching token (oplock) and avoids timeouts
2573 * when the local oplock break takes longer to flush
2574 * writebehind data than the SMB timeout for the SetPathInfo
2575 * request would allow
2577 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2579 tcon = tlink_tcon(open_file->tlink);
2580 server = tcon->ses->server;
2581 if (server->ops->set_file_size)
2582 rc = server->ops->set_file_size(xid, tcon, open_file,
2583 attrs->ia_size, false);
2586 cifsFileInfo_put(open_file);
2587 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2595 tlink = cifs_sb_tlink(cifs_sb);
2597 return PTR_ERR(tlink);
2598 tcon = tlink_tcon(tlink);
2599 server = tcon->ses->server;
2603 * Set file size by pathname rather than by handle either because no
2604 * valid, writeable file handle for it was found or because there was
2605 * an error setting it by handle.
2607 if (server->ops->set_path_size)
2608 rc = server->ops->set_path_size(xid, tcon, full_path,
2609 attrs->ia_size, cifs_sb, false);
2612 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2615 cifs_put_tlink(tlink);
2619 cifsInode->server_eof = attrs->ia_size;
2620 cifs_setsize(inode, attrs->ia_size);
2622 * i_blocks is not related to (i_size / i_blksize), but instead
2623 * 512 byte (2**9) size is required for calculating num blocks.
2624 * Until we can query the server for actual allocation size,
2625 * this is best estimate we have for blocks allocated for a file
2626 * Number of blocks must be rounded up so size 1 is not 0 blocks
2628 inode->i_blocks = (512 - 1 + attrs->ia_size) >> 9;
2631 * The man page of truncate says if the size changed,
2632 * then the st_ctime and st_mtime fields for the file
2635 attrs->ia_ctime = attrs->ia_mtime = current_time(inode);
2636 attrs->ia_valid |= ATTR_CTIME | ATTR_MTIME;
2638 cifs_truncate_page(inode->i_mapping, inode->i_size);
2645 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2649 const char *full_path;
2650 void *page = alloc_dentry_path();
2651 struct inode *inode = d_inode(direntry);
2652 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2653 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2654 struct tcon_link *tlink;
2655 struct cifs_tcon *pTcon;
2656 struct cifs_unix_set_info_args *args = NULL;
2657 struct cifsFileInfo *open_file;
2659 cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2660 direntry, attrs->ia_valid);
2664 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2665 attrs->ia_valid |= ATTR_FORCE;
2667 rc = setattr_prepare(&init_user_ns, direntry, attrs);
2671 full_path = build_path_from_dentry(direntry, page);
2672 if (IS_ERR(full_path)) {
2673 rc = PTR_ERR(full_path);
2678 * Attempt to flush data before changing attributes. We need to do
2679 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2680 * ownership or mode then we may also need to do this. Here, we take
2681 * the safe way out and just do the flush on all setattr requests. If
2682 * the flush returns error, store it to report later and continue.
2684 * BB: This should be smarter. Why bother flushing pages that
2685 * will be truncated anyway? Also, should we error out here if
2686 * the flush returns error?
2688 rc = filemap_write_and_wait(inode->i_mapping);
2689 if (is_interrupt_error(rc)) {
2694 mapping_set_error(inode->i_mapping, rc);
2697 if (attrs->ia_valid & ATTR_SIZE) {
2698 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2703 /* skip mode change if it's just for clearing setuid/setgid */
2704 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2705 attrs->ia_valid &= ~ATTR_MODE;
2707 args = kmalloc(sizeof(*args), GFP_KERNEL);
2713 /* set up the struct */
2714 if (attrs->ia_valid & ATTR_MODE)
2715 args->mode = attrs->ia_mode;
2717 args->mode = NO_CHANGE_64;
2719 if (attrs->ia_valid & ATTR_UID)
2720 args->uid = attrs->ia_uid;
2722 args->uid = INVALID_UID; /* no change */
2724 if (attrs->ia_valid & ATTR_GID)
2725 args->gid = attrs->ia_gid;
2727 args->gid = INVALID_GID; /* no change */
2729 if (attrs->ia_valid & ATTR_ATIME)
2730 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2732 args->atime = NO_CHANGE_64;
2734 if (attrs->ia_valid & ATTR_MTIME)
2735 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2737 args->mtime = NO_CHANGE_64;
2739 if (attrs->ia_valid & ATTR_CTIME)
2740 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2742 args->ctime = NO_CHANGE_64;
2745 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2747 u16 nfid = open_file->fid.netfid;
2748 u32 npid = open_file->pid;
2749 pTcon = tlink_tcon(open_file->tlink);
2750 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2751 cifsFileInfo_put(open_file);
2753 tlink = cifs_sb_tlink(cifs_sb);
2754 if (IS_ERR(tlink)) {
2755 rc = PTR_ERR(tlink);
2758 pTcon = tlink_tcon(tlink);
2759 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2761 cifs_remap(cifs_sb));
2762 cifs_put_tlink(tlink);
2768 if ((attrs->ia_valid & ATTR_SIZE) &&
2769 attrs->ia_size != i_size_read(inode))
2770 truncate_setsize(inode, attrs->ia_size);
2772 setattr_copy(&init_user_ns, inode, attrs);
2773 mark_inode_dirty(inode);
2775 /* force revalidate when any of these times are set since some
2776 of the fs types (eg ext3, fat) do not have fine enough
2777 time granularity to match protocol, and we do not have a
2778 a way (yet) to query the server fs's time granularity (and
2779 whether it rounds times down).
2781 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2782 cifsInode->time = 0;
2785 free_dentry_path(page);
2791 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2794 kuid_t uid = INVALID_UID;
2795 kgid_t gid = INVALID_GID;
2796 struct inode *inode = d_inode(direntry);
2797 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2798 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2799 struct cifsFileInfo *wfile;
2800 struct cifs_tcon *tcon;
2801 const char *full_path;
2802 void *page = alloc_dentry_path();
2805 __u64 mode = NO_CHANGE_64;
2809 cifs_dbg(FYI, "setattr on file %pd attrs->ia_valid 0x%x\n",
2810 direntry, attrs->ia_valid);
2812 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2813 attrs->ia_valid |= ATTR_FORCE;
2815 rc = setattr_prepare(&init_user_ns, direntry, attrs);
2817 goto cifs_setattr_exit;
2819 full_path = build_path_from_dentry(direntry, page);
2820 if (IS_ERR(full_path)) {
2821 rc = PTR_ERR(full_path);
2822 goto cifs_setattr_exit;
2826 * Attempt to flush data before changing attributes. We need to do
2827 * this for ATTR_SIZE and ATTR_MTIME. If the flush of the data
2828 * returns error, store it to report later and continue.
2830 * BB: This should be smarter. Why bother flushing pages that
2831 * will be truncated anyway? Also, should we error out here if
2832 * the flush returns error? Do we need to check for ATTR_MTIME_SET flag?
2834 if (attrs->ia_valid & (ATTR_MTIME | ATTR_SIZE | ATTR_CTIME)) {
2835 rc = filemap_write_and_wait(inode->i_mapping);
2836 if (is_interrupt_error(rc)) {
2838 goto cifs_setattr_exit;
2840 mapping_set_error(inode->i_mapping, rc);
2845 if ((attrs->ia_valid & ATTR_MTIME) &&
2846 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2847 rc = cifs_get_writable_file(cifsInode, FIND_WR_ANY, &wfile);
2849 tcon = tlink_tcon(wfile->tlink);
2850 rc = tcon->ses->server->ops->flush(xid, tcon, &wfile->fid);
2851 cifsFileInfo_put(wfile);
2853 goto cifs_setattr_exit;
2854 } else if (rc != -EBADF)
2855 goto cifs_setattr_exit;
2860 if (attrs->ia_valid & ATTR_SIZE) {
2861 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2863 goto cifs_setattr_exit;
2866 if (attrs->ia_valid & ATTR_UID)
2867 uid = attrs->ia_uid;
2869 if (attrs->ia_valid & ATTR_GID)
2870 gid = attrs->ia_gid;
2872 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2873 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2874 if (uid_valid(uid) || gid_valid(gid)) {
2875 mode = NO_CHANGE_64;
2876 rc = id_mode_to_cifs_acl(inode, full_path, &mode,
2879 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2881 goto cifs_setattr_exit;
2885 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2886 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2888 /* skip mode change if it's just for clearing setuid/setgid */
2889 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2890 attrs->ia_valid &= ~ATTR_MODE;
2892 if (attrs->ia_valid & ATTR_MODE) {
2893 mode = attrs->ia_mode;
2895 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2896 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2897 rc = id_mode_to_cifs_acl(inode, full_path, &mode,
2898 INVALID_UID, INVALID_GID);
2900 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2902 goto cifs_setattr_exit;
2906 * In case of CIFS_MOUNT_CIFS_ACL, we cannot support all modes.
2907 * Pick up the actual mode bits that were set.
2909 if (mode != attrs->ia_mode)
2910 attrs->ia_mode = mode;
2912 if (((mode & S_IWUGO) == 0) &&
2913 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2915 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2917 /* fix up mode if we're not using dynperm */
2918 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2919 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2920 } else if ((mode & S_IWUGO) &&
2921 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2923 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2924 /* Attributes of 0 are ignored */
2926 dosattr |= ATTR_NORMAL;
2928 /* reset local inode permissions to normal */
2929 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2930 attrs->ia_mode &= ~(S_IALLUGO);
2931 if (S_ISDIR(inode->i_mode))
2933 cifs_sb->ctx->dir_mode;
2936 cifs_sb->ctx->file_mode;
2938 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2939 /* ignore mode change - ATTR_READONLY hasn't changed */
2940 attrs->ia_valid &= ~ATTR_MODE;
2944 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2945 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2946 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2947 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2949 /* Even if error on time set, no sense failing the call if
2950 the server would set the time to a reasonable value anyway,
2951 and this check ensures that we are not being called from
2952 sys_utimes in which case we ought to fail the call back to
2953 the user when the server rejects the call */
2954 if ((rc) && (attrs->ia_valid &
2955 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2959 /* do not need local check to inode_check_ok since the server does
2962 goto cifs_setattr_exit;
2964 if ((attrs->ia_valid & ATTR_SIZE) &&
2965 attrs->ia_size != i_size_read(inode))
2966 truncate_setsize(inode, attrs->ia_size);
2968 setattr_copy(&init_user_ns, inode, attrs);
2969 mark_inode_dirty(inode);
2973 free_dentry_path(page);
2978 cifs_setattr(struct user_namespace *mnt_userns, struct dentry *direntry,
2979 struct iattr *attrs)
2981 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
2982 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2983 int rc, retries = 0;
2985 if (unlikely(cifs_forced_shutdown(cifs_sb)))
2989 if (pTcon->unix_ext)
2990 rc = cifs_setattr_unix(direntry, attrs);
2992 rc = cifs_setattr_nounix(direntry, attrs);
2994 } while (is_retryable_error(rc) && retries < 2);
2996 /* BB: add cifs_setattr_legacy for really old servers */