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>
30 #include <asm/div64.h>
34 #include "cifsproto.h"
35 #include "smb2proto.h"
36 #include "cifs_debug.h"
37 #include "cifs_fs_sb.h"
38 #include "cifs_unicode.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 cifs_revalidate_cache(inode, fattr);
167 spin_lock(&inode->i_lock);
168 fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);
169 fattr->cf_atime = timestamp_truncate(fattr->cf_atime, inode);
170 fattr->cf_ctime = timestamp_truncate(fattr->cf_ctime, inode);
171 /* we do not want atime to be less than mtime, it broke some apps */
172 if (timespec64_compare(&fattr->cf_atime, &fattr->cf_mtime) < 0)
173 inode->i_atime = fattr->cf_mtime;
175 inode->i_atime = fattr->cf_atime;
176 inode->i_mtime = fattr->cf_mtime;
177 inode->i_ctime = fattr->cf_ctime;
178 inode->i_rdev = fattr->cf_rdev;
179 cifs_nlink_fattr_to_inode(inode, fattr);
180 inode->i_uid = fattr->cf_uid;
181 inode->i_gid = fattr->cf_gid;
183 /* if dynperm is set, don't clobber existing mode */
184 if (inode->i_state & I_NEW ||
185 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
186 inode->i_mode = fattr->cf_mode;
188 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
190 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
193 cifs_i->time = jiffies;
195 if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING)
196 set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
198 clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
200 cifs_i->server_eof = fattr->cf_eof;
202 * Can't safely change the file size here if the client is writing to
203 * it due to potential races.
205 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
206 i_size_write(inode, fattr->cf_eof);
209 * i_blocks is not related to (i_size / i_blksize),
210 * but instead 512 byte (2**9) size is required for
211 * calculating num blocks.
213 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
215 spin_unlock(&inode->i_lock);
217 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
218 inode->i_flags |= S_AUTOMOUNT;
219 if (inode->i_state & I_NEW)
224 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
226 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
228 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
231 fattr->cf_uniqueid = iunique(sb, ROOT_I);
234 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
236 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
237 struct cifs_sb_info *cifs_sb)
239 memset(fattr, 0, sizeof(*fattr));
240 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
241 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
242 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
244 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
245 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
246 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
247 /* old POSIX extensions don't get create time */
249 fattr->cf_mode = le64_to_cpu(info->Permissions);
252 * Since we set the inode type below we need to mask off
253 * to avoid strange results if bits set above.
255 fattr->cf_mode &= ~S_IFMT;
256 switch (le32_to_cpu(info->Type)) {
258 fattr->cf_mode |= S_IFREG;
259 fattr->cf_dtype = DT_REG;
262 fattr->cf_mode |= S_IFLNK;
263 fattr->cf_dtype = DT_LNK;
266 fattr->cf_mode |= S_IFDIR;
267 fattr->cf_dtype = DT_DIR;
270 fattr->cf_mode |= S_IFCHR;
271 fattr->cf_dtype = DT_CHR;
272 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
273 le64_to_cpu(info->DevMinor) & MINORMASK);
276 fattr->cf_mode |= S_IFBLK;
277 fattr->cf_dtype = DT_BLK;
278 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
279 le64_to_cpu(info->DevMinor) & MINORMASK);
282 fattr->cf_mode |= S_IFIFO;
283 fattr->cf_dtype = DT_FIFO;
286 fattr->cf_mode |= S_IFSOCK;
287 fattr->cf_dtype = DT_SOCK;
290 /* safest to call it a file if we do not know */
291 fattr->cf_mode |= S_IFREG;
292 fattr->cf_dtype = DT_REG;
293 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
297 fattr->cf_uid = cifs_sb->mnt_uid;
298 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
299 u64 id = le64_to_cpu(info->Uid);
300 if (id < ((uid_t)-1)) {
301 kuid_t uid = make_kuid(&init_user_ns, id);
307 fattr->cf_gid = cifs_sb->mnt_gid;
308 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
309 u64 id = le64_to_cpu(info->Gid);
310 if (id < ((gid_t)-1)) {
311 kgid_t gid = make_kgid(&init_user_ns, id);
317 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
321 * Fill a cifs_fattr struct with fake inode info.
323 * Needed to setup cifs_fattr data for the directory which is the
324 * junction to the new submount (ie to setup the fake directory
325 * which represents a DFS referral).
328 cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
330 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
332 cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
334 memset(fattr, 0, sizeof(*fattr));
335 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
336 fattr->cf_uid = cifs_sb->mnt_uid;
337 fattr->cf_gid = cifs_sb->mnt_gid;
338 ktime_get_coarse_real_ts64(&fattr->cf_mtime);
339 fattr->cf_atime = fattr->cf_ctime = fattr->cf_mtime;
341 fattr->cf_flags = CIFS_FATTR_DFS_REFERRAL;
345 cifs_get_file_info_unix(struct file *filp)
349 FILE_UNIX_BASIC_INFO find_data;
350 struct cifs_fattr fattr;
351 struct inode *inode = file_inode(filp);
352 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
353 struct cifsFileInfo *cfile = filp->private_data;
354 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
357 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
359 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
360 } else if (rc == -EREMOTE) {
361 cifs_create_dfs_fattr(&fattr, inode->i_sb);
365 cifs_fattr_to_inode(inode, &fattr);
370 int cifs_get_inode_info_unix(struct inode **pinode,
371 const unsigned char *full_path,
372 struct super_block *sb, unsigned int xid)
375 FILE_UNIX_BASIC_INFO find_data;
376 struct cifs_fattr fattr;
377 struct cifs_tcon *tcon;
378 struct tcon_link *tlink;
379 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
381 cifs_dbg(FYI, "Getting info on %s\n", full_path);
383 tlink = cifs_sb_tlink(cifs_sb);
385 return PTR_ERR(tlink);
386 tcon = tlink_tcon(tlink);
388 /* could have done a find first instead but this returns more info */
389 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
390 cifs_sb->local_nls, cifs_remap(cifs_sb));
391 cifs_put_tlink(tlink);
394 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
395 } else if (rc == -EREMOTE) {
396 cifs_create_dfs_fattr(&fattr, sb);
402 /* check for Minshall+French symlinks */
403 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
404 int tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
407 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
410 if (*pinode == NULL) {
412 cifs_fill_uniqueid(sb, &fattr);
413 *pinode = cifs_iget(sb, &fattr);
417 /* we already have inode, update it */
419 /* if uniqueid is different, return error */
420 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
421 CIFS_I(*pinode)->uniqueid != fattr.cf_uniqueid)) {
422 CIFS_I(*pinode)->time = 0; /* force reval */
427 /* if filetype is different, return error */
428 if (unlikely(((*pinode)->i_mode & S_IFMT) !=
429 (fattr.cf_mode & S_IFMT))) {
430 CIFS_I(*pinode)->time = 0; /* force reval */
435 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->mnt_uid; /* TODO: map uid and gid from SID */
648 fattr->cf_gid = cifs_sb->mnt_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,
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);
689 fattr->cf_mode = S_IFLNK;
690 fattr->cf_dtype = DT_LNK;
691 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
692 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
693 fattr->cf_dtype = DT_DIR;
695 * Server can return wrong NumberOfLinks value for directories
696 * when Unix extensions are disabled - fake it.
699 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
701 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
702 fattr->cf_dtype = DT_REG;
704 /* clear write bits if ATTR_READONLY is set */
705 if (fattr->cf_cifsattrs & ATTR_READONLY)
706 fattr->cf_mode &= ~(S_IWUGO);
709 * Don't accept zero nlink from non-unix servers unless
710 * delete is pending. Instead mark it as unknown.
712 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
713 !info->DeletePending) {
714 cifs_dbg(VFS, "bogus file nlink value %u\n",
716 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
720 fattr->cf_uid = cifs_sb->mnt_uid;
721 fattr->cf_gid = cifs_sb->mnt_gid;
725 cifs_get_file_info(struct file *filp)
729 FILE_ALL_INFO find_data;
730 struct cifs_fattr fattr;
731 struct inode *inode = file_inode(filp);
732 struct cifsFileInfo *cfile = filp->private_data;
733 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
734 struct TCP_Server_Info *server = tcon->ses->server;
736 if (!server->ops->query_file_info)
740 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
743 cifs_all_info_to_fattr(&fattr, &find_data, inode->i_sb, false,
747 cifs_create_dfs_fattr(&fattr, inode->i_sb);
753 * FIXME: legacy server -- fall back to path-based call?
754 * for now, just skip revalidating and mark inode for
758 CIFS_I(inode)->time = 0;
764 * don't bother with SFU junk here -- just mark inode as needing
767 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
768 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
769 cifs_fattr_to_inode(inode, &fattr);
775 /* Simple function to return a 64 bit hash of string. Rarely called */
776 static __u64 simple_hashstr(const char *str)
778 const __u64 hash_mult = 1125899906842597ULL; /* a big enough prime */
782 hash = (hash + (__u64) *str++) * hash_mult;
788 * cifs_backup_query_path_info - SMB1 fallback code to get ino
790 * Fallback code to get file metadata when we don't have access to
791 * @full_path (EACCES) and have backup creds.
793 * @data will be set to search info result buffer
794 * @resp_buf will be set to cifs resp buf and needs to be freed with
795 * cifs_buf_release() when done with @data.
798 cifs_backup_query_path_info(int xid,
799 struct cifs_tcon *tcon,
800 struct super_block *sb,
801 const char *full_path,
803 FILE_ALL_INFO **data)
805 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
806 struct cifs_search_info info = {0};
811 info.endOfSearch = false;
813 info.info_level = SMB_FIND_FILE_UNIX;
814 else if ((tcon->ses->capabilities &
815 tcon->ses->server->vals->cap_nt_find) == 0)
816 info.info_level = SMB_FIND_FILE_INFO_STANDARD;
817 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
818 info.info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
819 else /* no srvino useful for fallback to some netapp */
820 info.info_level = SMB_FIND_FILE_DIRECTORY_INFO;
822 flags = CIFS_SEARCH_CLOSE_ALWAYS |
823 CIFS_SEARCH_CLOSE_AT_END |
824 CIFS_SEARCH_BACKUP_SEARCH;
826 rc = CIFSFindFirst(xid, tcon, full_path,
827 cifs_sb, NULL, flags, &info, false);
831 *resp_buf = (void *)info.ntwrk_buf_start;
832 *data = (FILE_ALL_INFO *)info.srch_entries_start;
837 cifs_set_fattr_ino(int xid,
838 struct cifs_tcon *tcon,
839 struct super_block *sb,
840 struct inode **inode,
841 const char *full_path,
843 struct cifs_fattr *fattr)
845 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
846 struct TCP_Server_Info *server = tcon->ses->server;
849 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
851 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
853 fattr->cf_uniqueid = iunique(sb, ROOT_I);
858 * If we have an inode pass a NULL tcon to ensure we don't
859 * make a round trip to the server. This only works for SMB2+.
861 rc = server->ops->get_srv_inum(xid,
862 *inode ? NULL : tcon,
868 * If that fails reuse existing ino or generate one
869 * and disable server ones
872 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
874 fattr->cf_uniqueid = iunique(sb, ROOT_I);
875 cifs_autodisable_serverino(cifs_sb);
880 /* If no errors, check for zero root inode (invalid) */
881 if (fattr->cf_uniqueid == 0 && strlen(full_path) == 0) {
882 cifs_dbg(FYI, "Invalid (0) inodenum\n");
885 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
887 /* make an ino by hashing the UNC */
888 fattr->cf_flags |= CIFS_FATTR_FAKE_ROOT_INO;
889 fattr->cf_uniqueid = simple_hashstr(tcon->treeName);
894 static inline bool is_inode_cache_good(struct inode *ino)
896 return ino && CIFS_CACHE_READ(CIFS_I(ino)) && CIFS_I(ino)->time != 0;
900 cifs_get_inode_info(struct inode **inode,
901 const char *full_path,
902 FILE_ALL_INFO *in_data,
903 struct super_block *sb, int xid,
904 const struct cifs_fid *fid)
907 struct cifs_tcon *tcon;
908 struct TCP_Server_Info *server;
909 struct tcon_link *tlink;
910 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
911 bool adjust_tz = false;
912 struct cifs_fattr fattr = {0};
913 bool symlink = false;
914 FILE_ALL_INFO *data = in_data;
915 FILE_ALL_INFO *tmp_data = NULL;
916 void *smb1_backup_rsp_buf = NULL;
920 tlink = cifs_sb_tlink(cifs_sb);
922 return PTR_ERR(tlink);
923 tcon = tlink_tcon(tlink);
924 server = tcon->ses->server;
927 * 1. Fetch file metadata if not provided (data)
931 if (is_inode_cache_good(*inode)) {
932 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
935 tmp_data = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
940 rc = server->ops->query_path_info(xid, tcon, cifs_sb,
942 &adjust_tz, &symlink);
947 * 2. Convert it to internal cifs metadata (fattr)
952 cifs_all_info_to_fattr(&fattr, data, sb, adjust_tz, symlink);
955 /* DFS link, no metadata available on this server */
956 cifs_create_dfs_fattr(&fattr, sb);
961 * perm errors, try again with backup flags if possible
963 * For SMB2 and later the backup intent flag
964 * is already sent if needed on open and there
965 * is no path based FindFirst operation to use
968 if (backup_cred(cifs_sb) && is_smb1_server(server)) {
969 /* for easier reading */
970 FILE_DIRECTORY_INFO *fdi;
971 SEARCH_ID_FULL_DIR_INFO *si;
973 rc = cifs_backup_query_path_info(xid, tcon, sb,
975 &smb1_backup_rsp_buf,
980 fdi = (FILE_DIRECTORY_INFO *)data;
981 si = (SEARCH_ID_FULL_DIR_INFO *)data;
983 cifs_dir_info_to_fattr(&fattr, fdi, cifs_sb);
984 fattr.cf_uniqueid = le64_to_cpu(si->UniqueId);
985 /* uniqueid set, skip get inum step */
988 /* nothing we can do, bail out */
993 cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc);
998 * 3. Get or update inode number (fattr.cf_uniqueid)
1001 cifs_set_fattr_ino(xid, tcon, sb, inode, full_path, data, &fattr);
1004 * 4. Tweak fattr based on mount options
1008 /* query for SFU type info if supported and needed */
1009 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
1010 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
1011 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
1013 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
1016 /* fill in 0777 bits from ACL */
1017 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID) {
1018 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, true,
1023 cifs_dbg(FYI, "%s: Get mode from SID failed. rc=%d\n",
1027 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
1028 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, false,
1033 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
1039 /* fill in remaining high mode bits e.g. SUID, VTX */
1040 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
1041 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
1043 /* check for Minshall+French symlinks */
1044 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
1045 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
1048 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
1052 * 5. Update inode with final fattr data
1056 *inode = cifs_iget(sb, &fattr);
1060 /* we already have inode, update it */
1062 /* if uniqueid is different, return error */
1063 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
1064 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
1065 CIFS_I(*inode)->time = 0; /* force reval */
1070 /* if filetype is different, return error */
1071 if (unlikely(((*inode)->i_mode & S_IFMT) !=
1072 (fattr.cf_mode & S_IFMT))) {
1073 CIFS_I(*inode)->time = 0; /* force reval */
1078 cifs_fattr_to_inode(*inode, &fattr);
1081 cifs_buf_release(smb1_backup_rsp_buf);
1082 cifs_put_tlink(tlink);
1088 smb311_posix_get_inode_info(struct inode **inode,
1089 const char *full_path,
1090 struct super_block *sb, unsigned int xid)
1092 struct cifs_tcon *tcon;
1093 struct tcon_link *tlink;
1094 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1095 bool adjust_tz = false;
1096 struct cifs_fattr fattr = {0};
1097 bool symlink = false;
1098 struct smb311_posix_qinfo *data = NULL;
1102 tlink = cifs_sb_tlink(cifs_sb);
1104 return PTR_ERR(tlink);
1105 tcon = tlink_tcon(tlink);
1108 * 1. Fetch file metadata
1111 if (is_inode_cache_good(*inode)) {
1112 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
1115 data = kmalloc(sizeof(struct smb311_posix_qinfo), GFP_KERNEL);
1121 rc = smb311_posix_query_path_info(xid, tcon, cifs_sb,
1123 &adjust_tz, &symlink);
1126 * 2. Convert it to internal cifs metadata (fattr)
1131 smb311_posix_info_to_fattr(&fattr, data, sb, adjust_tz, symlink);
1134 /* DFS link, no metadata available on this server */
1135 cifs_create_dfs_fattr(&fattr, sb);
1140 * For SMB2 and later the backup intent flag
1141 * is already sent if needed on open and there
1142 * is no path based FindFirst operation to use
1143 * to retry with so nothing we can do, bail out
1147 cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc);
1153 * 3. Tweak fattr based on mount options
1156 /* check for Minshall+French symlinks */
1157 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
1158 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
1161 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
1165 * 4. Update inode with final fattr data
1169 *inode = cifs_iget(sb, &fattr);
1173 /* we already have inode, update it */
1175 /* if uniqueid is different, return error */
1176 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
1177 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
1178 CIFS_I(*inode)->time = 0; /* force reval */
1183 /* if filetype is different, return error */
1184 if (unlikely(((*inode)->i_mode & S_IFMT) !=
1185 (fattr.cf_mode & S_IFMT))) {
1186 CIFS_I(*inode)->time = 0; /* force reval */
1191 cifs_fattr_to_inode(*inode, &fattr);
1194 cifs_put_tlink(tlink);
1200 static const struct inode_operations cifs_ipc_inode_ops = {
1201 .lookup = cifs_lookup,
1205 cifs_find_inode(struct inode *inode, void *opaque)
1207 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
1209 /* don't match inode with different uniqueid */
1210 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
1213 /* use createtime like an i_generation field */
1214 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
1217 /* don't match inode of different type */
1218 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
1221 /* if it's not a directory or has no dentries, then flag it */
1222 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
1223 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
1229 cifs_init_inode(struct inode *inode, void *opaque)
1231 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
1233 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
1234 CIFS_I(inode)->createtime = fattr->cf_createtime;
1239 * walk dentry list for an inode and report whether it has aliases that
1240 * are hashed. We use this to determine if a directory inode can actually
1244 inode_has_hashed_dentries(struct inode *inode)
1246 struct dentry *dentry;
1248 spin_lock(&inode->i_lock);
1249 hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
1250 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
1251 spin_unlock(&inode->i_lock);
1255 spin_unlock(&inode->i_lock);
1259 /* Given fattrs, get a corresponding inode */
1261 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
1264 struct inode *inode;
1267 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
1269 /* hash down to 32-bits on 32-bit arch */
1270 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
1272 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
1274 /* was there a potentially problematic inode collision? */
1275 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
1276 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
1278 if (inode_has_hashed_dentries(inode)) {
1279 cifs_autodisable_serverino(CIFS_SB(sb));
1281 fattr->cf_uniqueid = iunique(sb, ROOT_I);
1282 goto retry_iget5_locked;
1286 cifs_fattr_to_inode(inode, fattr);
1287 if (sb->s_flags & SB_NOATIME)
1288 inode->i_flags |= S_NOATIME | S_NOCMTIME;
1289 if (inode->i_state & I_NEW) {
1290 inode->i_ino = hash;
1291 #ifdef CONFIG_CIFS_FSCACHE
1292 /* initialize per-inode cache cookie pointer */
1293 CIFS_I(inode)->fscache = NULL;
1295 unlock_new_inode(inode);
1302 /* gets root inode */
1303 struct inode *cifs_root_iget(struct super_block *sb)
1306 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1307 struct inode *inode = NULL;
1309 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1313 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
1314 && cifs_sb->prepath) {
1315 len = strlen(cifs_sb->prepath);
1316 path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
1318 return ERR_PTR(-ENOMEM);
1320 memcpy(path+1, cifs_sb->prepath, len);
1322 path = kstrdup("", GFP_KERNEL);
1324 return ERR_PTR(-ENOMEM);
1328 if (tcon->unix_ext) {
1329 rc = cifs_get_inode_info_unix(&inode, path, sb, xid);
1330 /* some servers mistakenly claim POSIX support */
1331 if (rc != -EOPNOTSUPP)
1333 cifs_dbg(VFS, "server does not support POSIX extensions\n");
1334 tcon->unix_ext = false;
1337 convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
1338 if (tcon->posix_extensions)
1339 rc = smb311_posix_get_inode_info(&inode, path, sb, xid);
1341 rc = cifs_get_inode_info(&inode, path, NULL, sb, xid, NULL);
1345 inode = ERR_PTR(rc);
1349 #ifdef CONFIG_CIFS_FSCACHE
1350 /* populate tcon->resource_id */
1351 tcon->resource_id = CIFS_I(inode)->uniqueid;
1354 if (rc && tcon->pipe) {
1355 cifs_dbg(FYI, "ipc connection - fake read inode\n");
1356 spin_lock(&inode->i_lock);
1357 inode->i_mode |= S_IFDIR;
1358 set_nlink(inode, 2);
1359 inode->i_op = &cifs_ipc_inode_ops;
1360 inode->i_fop = &simple_dir_operations;
1361 inode->i_uid = cifs_sb->mnt_uid;
1362 inode->i_gid = cifs_sb->mnt_gid;
1363 spin_unlock(&inode->i_lock);
1366 inode = ERR_PTR(rc);
1376 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1377 char *full_path, __u32 dosattr)
1379 bool set_time = false;
1380 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1381 struct TCP_Server_Info *server;
1382 FILE_BASIC_INFO info_buf;
1387 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1388 if (!server->ops->set_file_info)
1393 if (attrs->ia_valid & ATTR_ATIME) {
1395 info_buf.LastAccessTime =
1396 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1398 info_buf.LastAccessTime = 0;
1400 if (attrs->ia_valid & ATTR_MTIME) {
1402 info_buf.LastWriteTime =
1403 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1405 info_buf.LastWriteTime = 0;
1408 * Samba throws this field away, but windows may actually use it.
1409 * Do not set ctime unless other time stamps are changed explicitly
1410 * (i.e. by utimes()) since we would then have a mix of client and
1413 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1414 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1415 info_buf.ChangeTime =
1416 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1418 info_buf.ChangeTime = 0;
1420 info_buf.CreationTime = 0; /* don't change */
1421 info_buf.Attributes = cpu_to_le32(dosattr);
1423 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1427 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1428 * and rename it to a random name that hopefully won't conflict with
1432 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1433 const unsigned int xid)
1437 struct cifs_fid fid;
1438 struct cifs_open_parms oparms;
1439 struct inode *inode = d_inode(dentry);
1440 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1441 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1442 struct tcon_link *tlink;
1443 struct cifs_tcon *tcon;
1444 __u32 dosattr, origattr;
1445 FILE_BASIC_INFO *info_buf = NULL;
1447 tlink = cifs_sb_tlink(cifs_sb);
1449 return PTR_ERR(tlink);
1450 tcon = tlink_tcon(tlink);
1453 * We cannot rename the file if the server doesn't support
1454 * CAP_INFOLEVEL_PASSTHRU
1456 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1462 oparms.cifs_sb = cifs_sb;
1463 oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1464 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
1465 oparms.disposition = FILE_OPEN;
1466 oparms.path = full_path;
1468 oparms.reconnect = false;
1470 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1474 origattr = cifsInode->cifsAttrs;
1476 origattr |= ATTR_NORMAL;
1478 dosattr = origattr & ~ATTR_READONLY;
1480 dosattr |= ATTR_NORMAL;
1481 dosattr |= ATTR_HIDDEN;
1483 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1484 if (dosattr != origattr) {
1485 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1486 if (info_buf == NULL) {
1490 info_buf->Attributes = cpu_to_le32(dosattr);
1491 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1493 /* although we would like to mark the file hidden
1494 if that fails we will still try to rename it */
1496 cifsInode->cifsAttrs = dosattr;
1498 dosattr = origattr; /* since not able to change them */
1501 /* rename the file */
1502 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1504 cifs_remap(cifs_sb));
1510 /* try to set DELETE_ON_CLOSE */
1511 if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1512 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1515 * some samba versions return -ENOENT when we try to set the
1516 * file disposition here. Likely a samba bug, but work around
1517 * it for now. This means that some cifsXXX files may hang
1518 * around after they shouldn't.
1520 * BB: remove this hack after more servers have the fix
1528 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1532 CIFSSMBClose(xid, tcon, fid.netfid);
1535 cifs_put_tlink(tlink);
1539 * reset everything back to the original state. Don't bother
1540 * dealing with errors here since we can't do anything about
1544 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1545 cifs_sb->local_nls, cifs_remap(cifs_sb));
1547 if (dosattr != origattr) {
1548 info_buf->Attributes = cpu_to_le32(origattr);
1549 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1551 cifsInode->cifsAttrs = origattr;
1557 /* copied from fs/nfs/dir.c with small changes */
1559 cifs_drop_nlink(struct inode *inode)
1561 spin_lock(&inode->i_lock);
1562 if (inode->i_nlink > 0)
1564 spin_unlock(&inode->i_lock);
1568 * If d_inode(dentry) is null (usually meaning the cached dentry
1569 * is a negative dentry) then we would attempt a standard SMB delete, but
1570 * if that fails we can not attempt the fall back mechanisms on EACCES
1571 * but will return the EACCES to the caller. Note that the VFS does not call
1572 * unlink on negative dentries currently.
1574 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1578 char *full_path = NULL;
1579 struct inode *inode = d_inode(dentry);
1580 struct cifsInodeInfo *cifs_inode;
1581 struct super_block *sb = dir->i_sb;
1582 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1583 struct tcon_link *tlink;
1584 struct cifs_tcon *tcon;
1585 struct TCP_Server_Info *server;
1586 struct iattr *attrs = NULL;
1587 __u32 dosattr = 0, origattr = 0;
1589 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1591 tlink = cifs_sb_tlink(cifs_sb);
1593 return PTR_ERR(tlink);
1594 tcon = tlink_tcon(tlink);
1595 server = tcon->ses->server;
1599 if (tcon->nodelete) {
1604 /* Unlink can be called from rename so we can not take the
1605 * sb->s_vfs_rename_mutex here */
1606 full_path = build_path_from_dentry(dentry);
1607 if (full_path == NULL) {
1612 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1613 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1614 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1615 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1616 cifs_remap(cifs_sb));
1617 cifs_dbg(FYI, "posix del rc %d\n", rc);
1618 if ((rc == 0) || (rc == -ENOENT))
1619 goto psx_del_no_retry;
1623 if (!server->ops->unlink) {
1625 goto psx_del_no_retry;
1628 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1633 cifs_drop_nlink(inode);
1634 } else if (rc == -ENOENT) {
1636 } else if (rc == -EBUSY) {
1637 if (server->ops->rename_pending_delete) {
1638 rc = server->ops->rename_pending_delete(full_path,
1641 cifs_drop_nlink(inode);
1643 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1644 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1645 if (attrs == NULL) {
1650 /* try to reset dos attributes */
1651 cifs_inode = CIFS_I(inode);
1652 origattr = cifs_inode->cifsAttrs;
1654 origattr |= ATTR_NORMAL;
1655 dosattr = origattr & ~ATTR_READONLY;
1657 dosattr |= ATTR_NORMAL;
1658 dosattr |= ATTR_HIDDEN;
1660 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1664 goto retry_std_delete;
1667 /* undo the setattr if we errored out and it's needed */
1668 if (rc != 0 && dosattr != 0)
1669 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1673 cifs_inode = CIFS_I(inode);
1674 cifs_inode->time = 0; /* will force revalidate to get info
1676 inode->i_ctime = current_time(inode);
1678 dir->i_ctime = dir->i_mtime = current_time(dir);
1679 cifs_inode = CIFS_I(dir);
1680 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1685 cifs_put_tlink(tlink);
1690 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1691 const char *full_path, struct cifs_sb_info *cifs_sb,
1692 struct cifs_tcon *tcon, const unsigned int xid)
1695 struct inode *inode = NULL;
1697 if (tcon->posix_extensions)
1698 rc = smb311_posix_get_inode_info(&inode, full_path, parent->i_sb, xid);
1699 else if (tcon->unix_ext)
1700 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1703 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1710 * setting nlink not necessary except in cases where we failed to get it
1711 * from the server or was set bogus. Also, since this is a brand new
1712 * inode, no need to grab the i_lock before setting the i_nlink.
1714 if (inode->i_nlink < 2)
1715 set_nlink(inode, 2);
1716 mode &= ~current_umask();
1717 /* must turn on setgid bit if parent dir has it */
1718 if (parent->i_mode & S_ISGID)
1721 if (tcon->unix_ext) {
1722 struct cifs_unix_set_info_args args = {
1724 .ctime = NO_CHANGE_64,
1725 .atime = NO_CHANGE_64,
1726 .mtime = NO_CHANGE_64,
1729 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1730 args.uid = current_fsuid();
1731 if (parent->i_mode & S_ISGID)
1732 args.gid = parent->i_gid;
1734 args.gid = current_fsgid();
1736 args.uid = INVALID_UID; /* no change */
1737 args.gid = INVALID_GID; /* no change */
1739 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1741 cifs_remap(cifs_sb));
1743 struct TCP_Server_Info *server = tcon->ses->server;
1744 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1745 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1746 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1748 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1749 inode->i_mode = (mode | S_IFDIR);
1751 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1752 inode->i_uid = current_fsuid();
1753 if (inode->i_mode & S_ISGID)
1754 inode->i_gid = parent->i_gid;
1756 inode->i_gid = current_fsgid();
1759 d_instantiate(dentry, inode);
1764 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1765 const char *full_path, struct cifs_sb_info *cifs_sb,
1766 struct cifs_tcon *tcon, const unsigned int xid)
1770 FILE_UNIX_BASIC_INFO *info = NULL;
1771 struct inode *newinode = NULL;
1772 struct cifs_fattr fattr;
1774 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1777 goto posix_mkdir_out;
1780 mode &= ~current_umask();
1781 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1782 NULL /* netfid */, info, &oplock, full_path,
1783 cifs_sb->local_nls, cifs_remap(cifs_sb));
1784 if (rc == -EOPNOTSUPP)
1785 goto posix_mkdir_out;
1787 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1789 goto posix_mkdir_out;
1792 if (info->Type == cpu_to_le32(-1))
1793 /* no return info, go query for it */
1794 goto posix_mkdir_get_info;
1796 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1797 * need to set uid/gid.
1800 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1801 cifs_fill_uniqueid(inode->i_sb, &fattr);
1802 newinode = cifs_iget(inode->i_sb, &fattr);
1804 goto posix_mkdir_get_info;
1806 d_instantiate(dentry, newinode);
1808 #ifdef CONFIG_CIFS_DEBUG2
1809 cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1810 dentry, dentry, newinode);
1812 if (newinode->i_nlink != 2)
1813 cifs_dbg(FYI, "unexpected number of links %d\n",
1820 posix_mkdir_get_info:
1821 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1823 goto posix_mkdir_out;
1826 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1830 struct cifs_sb_info *cifs_sb;
1831 struct tcon_link *tlink;
1832 struct cifs_tcon *tcon;
1833 struct TCP_Server_Info *server;
1836 cifs_dbg(FYI, "In cifs_mkdir, mode = %04ho inode = 0x%p\n",
1839 cifs_sb = CIFS_SB(inode->i_sb);
1840 tlink = cifs_sb_tlink(cifs_sb);
1842 return PTR_ERR(tlink);
1843 tcon = tlink_tcon(tlink);
1847 full_path = build_path_from_dentry(direntry);
1848 if (full_path == NULL) {
1853 server = tcon->ses->server;
1855 if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) {
1856 rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,
1858 d_drop(direntry); /* for time being always refresh inode info */
1862 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1863 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1864 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1866 if (rc != -EOPNOTSUPP)
1870 if (!server->ops->mkdir) {
1875 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1876 rc = server->ops->mkdir(xid, inode, mode, tcon, full_path, cifs_sb);
1878 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1883 /* TODO: skip this for smb2/smb3 */
1884 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1888 * Force revalidate to get parent dir info when needed since cached
1889 * attributes are invalid now.
1891 CIFS_I(inode)->time = 0;
1894 cifs_put_tlink(tlink);
1898 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1902 struct cifs_sb_info *cifs_sb;
1903 struct tcon_link *tlink;
1904 struct cifs_tcon *tcon;
1905 struct TCP_Server_Info *server;
1906 char *full_path = NULL;
1907 struct cifsInodeInfo *cifsInode;
1909 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1913 full_path = build_path_from_dentry(direntry);
1914 if (full_path == NULL) {
1919 cifs_sb = CIFS_SB(inode->i_sb);
1920 tlink = cifs_sb_tlink(cifs_sb);
1921 if (IS_ERR(tlink)) {
1922 rc = PTR_ERR(tlink);
1925 tcon = tlink_tcon(tlink);
1926 server = tcon->ses->server;
1928 if (!server->ops->rmdir) {
1930 cifs_put_tlink(tlink);
1934 if (tcon->nodelete) {
1936 cifs_put_tlink(tlink);
1940 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1941 cifs_put_tlink(tlink);
1944 spin_lock(&d_inode(direntry)->i_lock);
1945 i_size_write(d_inode(direntry), 0);
1946 clear_nlink(d_inode(direntry));
1947 spin_unlock(&d_inode(direntry)->i_lock);
1950 cifsInode = CIFS_I(d_inode(direntry));
1951 /* force revalidate to go get info when needed */
1952 cifsInode->time = 0;
1954 cifsInode = CIFS_I(inode);
1956 * Force revalidate to get parent dir info when needed since cached
1957 * attributes are invalid now.
1959 cifsInode->time = 0;
1961 d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
1962 current_time(inode);
1971 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1972 const char *from_path, struct dentry *to_dentry,
1973 const char *to_path)
1975 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1976 struct tcon_link *tlink;
1977 struct cifs_tcon *tcon;
1978 struct TCP_Server_Info *server;
1979 struct cifs_fid fid;
1980 struct cifs_open_parms oparms;
1983 tlink = cifs_sb_tlink(cifs_sb);
1985 return PTR_ERR(tlink);
1986 tcon = tlink_tcon(tlink);
1987 server = tcon->ses->server;
1989 if (!server->ops->rename)
1992 /* try path-based rename first */
1993 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1996 * Don't bother with rename by filehandle unless file is busy and
1997 * source. Note that cross directory moves do not work with
1998 * rename by filehandle to various Windows servers.
2000 if (rc == 0 || rc != -EBUSY)
2001 goto do_rename_exit;
2003 /* Don't fall back to using SMB on SMB 2+ mount */
2004 if (server->vals->protocol_id != 0)
2005 goto do_rename_exit;
2007 /* open-file renames don't work across directories */
2008 if (to_dentry->d_parent != from_dentry->d_parent)
2009 goto do_rename_exit;
2012 oparms.cifs_sb = cifs_sb;
2013 /* open the file to be renamed -- we need DELETE perms */
2014 oparms.desired_access = DELETE;
2015 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
2016 oparms.disposition = FILE_OPEN;
2017 oparms.path = from_path;
2019 oparms.reconnect = false;
2021 rc = CIFS_open(xid, &oparms, &oplock, NULL);
2023 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
2024 (const char *) to_dentry->d_name.name,
2025 cifs_sb->local_nls, cifs_remap(cifs_sb));
2026 CIFSSMBClose(xid, tcon, fid.netfid);
2030 d_move(from_dentry, to_dentry);
2031 cifs_put_tlink(tlink);
2036 cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
2037 struct inode *target_dir, struct dentry *target_dentry,
2040 char *from_name = NULL;
2041 char *to_name = NULL;
2042 struct cifs_sb_info *cifs_sb;
2043 struct tcon_link *tlink;
2044 struct cifs_tcon *tcon;
2045 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
2046 FILE_UNIX_BASIC_INFO *info_buf_target;
2050 if (flags & ~RENAME_NOREPLACE)
2053 cifs_sb = CIFS_SB(source_dir->i_sb);
2054 tlink = cifs_sb_tlink(cifs_sb);
2056 return PTR_ERR(tlink);
2057 tcon = tlink_tcon(tlink);
2062 * we already have the rename sem so we do not need to
2063 * grab it again here to protect the path integrity
2065 from_name = build_path_from_dentry(source_dentry);
2066 if (from_name == NULL) {
2068 goto cifs_rename_exit;
2071 to_name = build_path_from_dentry(target_dentry);
2072 if (to_name == NULL) {
2074 goto cifs_rename_exit;
2077 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2081 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
2083 if (flags & RENAME_NOREPLACE)
2084 goto cifs_rename_exit;
2086 if (rc == -EEXIST && tcon->unix_ext) {
2088 * Are src and dst hardlinks of same inode? We can only tell
2089 * with unix extensions enabled.
2092 kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
2094 if (info_buf_source == NULL) {
2096 goto cifs_rename_exit;
2099 info_buf_target = info_buf_source + 1;
2100 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
2103 cifs_remap(cifs_sb));
2107 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
2110 cifs_remap(cifs_sb));
2112 if (tmprc == 0 && (info_buf_source->UniqueId ==
2113 info_buf_target->UniqueId)) {
2114 /* same file, POSIX says that this is a noop */
2116 goto cifs_rename_exit;
2120 * else ... BB we could add the same check for Windows by
2121 * checking the UniqueId via FILE_INTERNAL_INFO
2125 /* Try unlinking the target dentry if it's not negative */
2126 if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
2127 if (d_is_dir(target_dentry))
2128 tmprc = cifs_rmdir(target_dir, target_dentry);
2130 tmprc = cifs_unlink(target_dir, target_dentry);
2132 goto cifs_rename_exit;
2133 rc = cifs_do_rename(xid, source_dentry, from_name,
2134 target_dentry, to_name);
2137 /* force revalidate to go get info when needed */
2138 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
2140 source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
2141 target_dir->i_mtime = current_time(source_dir);
2144 kfree(info_buf_source);
2148 cifs_put_tlink(tlink);
2153 cifs_inode_needs_reval(struct inode *inode)
2155 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2156 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2158 if (cifs_i->time == 0)
2161 if (CIFS_CACHE_READ(cifs_i))
2164 if (!lookupCacheEnabled)
2167 if (!cifs_sb->actimeo)
2170 if (!time_in_range(jiffies, cifs_i->time,
2171 cifs_i->time + cifs_sb->actimeo))
2174 /* hardlinked files w/ noserverino get "special" treatment */
2175 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
2176 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
2183 * Zap the cache. Called when invalid_mapping flag is set.
2186 cifs_invalidate_mapping(struct inode *inode)
2190 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
2191 rc = invalidate_inode_pages2(inode->i_mapping);
2193 cifs_dbg(VFS, "%s: Could not invalidate inode %p\n",
2197 cifs_fscache_reset_inode_cookie(inode);
2202 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
2203 * @word: long word containing the bit lock
2206 cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
2208 freezable_schedule_unsafe();
2209 if (signal_pending_state(mode, current))
2210 return -ERESTARTSYS;
2215 cifs_revalidate_mapping(struct inode *inode)
2218 unsigned long *flags = &CIFS_I(inode)->flags;
2220 /* swapfiles are not supposed to be shared */
2221 if (IS_SWAPFILE(inode))
2224 rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
2229 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
2230 rc = cifs_invalidate_mapping(inode);
2232 set_bit(CIFS_INO_INVALID_MAPPING, flags);
2235 clear_bit_unlock(CIFS_INO_LOCK, flags);
2236 smp_mb__after_atomic();
2237 wake_up_bit(flags, CIFS_INO_LOCK);
2243 cifs_zap_mapping(struct inode *inode)
2245 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
2246 return cifs_revalidate_mapping(inode);
2249 int cifs_revalidate_file_attr(struct file *filp)
2252 struct inode *inode = file_inode(filp);
2253 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
2255 if (!cifs_inode_needs_reval(inode))
2258 if (tlink_tcon(cfile->tlink)->unix_ext)
2259 rc = cifs_get_file_info_unix(filp);
2261 rc = cifs_get_file_info(filp);
2266 int cifs_revalidate_dentry_attr(struct dentry *dentry)
2270 struct inode *inode = d_inode(dentry);
2271 struct super_block *sb = dentry->d_sb;
2272 char *full_path = NULL;
2278 if (!cifs_inode_needs_reval(inode))
2283 /* can not safely grab the rename sem here if rename calls revalidate
2284 since that would deadlock */
2285 full_path = build_path_from_dentry(dentry);
2286 if (full_path == NULL) {
2291 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2292 full_path, inode, inode->i_count.counter,
2293 dentry, cifs_get_time(dentry), jiffies);
2296 if (cifs_sb_master_tcon(CIFS_SB(sb))->posix_extensions)
2297 rc = smb311_posix_get_inode_info(&inode, full_path, sb, xid);
2298 else if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
2299 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2301 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2303 if (rc == -EAGAIN && count++ < 10)
2312 int cifs_revalidate_file(struct file *filp)
2315 struct inode *inode = file_inode(filp);
2317 rc = cifs_revalidate_file_attr(filp);
2321 return cifs_revalidate_mapping(inode);
2324 /* revalidate a dentry's inode attributes */
2325 int cifs_revalidate_dentry(struct dentry *dentry)
2328 struct inode *inode = d_inode(dentry);
2330 rc = cifs_revalidate_dentry_attr(dentry);
2334 return cifs_revalidate_mapping(inode);
2337 int cifs_getattr(const struct path *path, struct kstat *stat,
2338 u32 request_mask, unsigned int flags)
2340 struct dentry *dentry = path->dentry;
2341 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2342 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2343 struct inode *inode = d_inode(dentry);
2347 * We need to be sure that all dirty pages are written and the server
2348 * has actual ctime, mtime and file length.
2350 if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_SIZE)) &&
2351 !CIFS_CACHE_READ(CIFS_I(inode)) &&
2352 inode->i_mapping && inode->i_mapping->nrpages != 0) {
2353 rc = filemap_fdatawait(inode->i_mapping);
2355 mapping_set_error(inode->i_mapping, rc);
2360 if ((flags & AT_STATX_SYNC_TYPE) == AT_STATX_FORCE_SYNC)
2361 CIFS_I(inode)->time = 0; /* force revalidate */
2364 * If the caller doesn't require syncing, only sync if
2365 * necessary (e.g. due to earlier truncate or setattr
2366 * invalidating the cached metadata)
2368 if (((flags & AT_STATX_SYNC_TYPE) != AT_STATX_DONT_SYNC) ||
2369 (CIFS_I(inode)->time == 0)) {
2370 rc = cifs_revalidate_dentry_attr(dentry);
2375 generic_fillattr(inode, stat);
2376 stat->blksize = cifs_sb->bsize;
2377 stat->ino = CIFS_I(inode)->uniqueid;
2379 /* old CIFS Unix Extensions doesn't return create time */
2380 if (CIFS_I(inode)->createtime) {
2381 stat->result_mask |= STATX_BTIME;
2383 cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
2386 stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2387 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2388 stat->attributes |= STATX_ATTR_COMPRESSED;
2389 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2390 stat->attributes |= STATX_ATTR_ENCRYPTED;
2393 * If on a multiuser mount without unix extensions or cifsacl being
2394 * enabled, and the admin hasn't overridden them, set the ownership
2395 * to the fsuid/fsgid of the current process.
2397 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2398 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2400 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2401 stat->uid = current_fsuid();
2402 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2403 stat->gid = current_fsgid();
2408 int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start,
2411 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2412 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_i->vfs_inode.i_sb);
2413 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2414 struct TCP_Server_Info *server = tcon->ses->server;
2415 struct cifsFileInfo *cfile;
2419 * We need to be sure that all dirty pages are written as they
2420 * might fill holes on the server.
2422 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2423 inode->i_mapping->nrpages != 0) {
2424 rc = filemap_fdatawait(inode->i_mapping);
2426 mapping_set_error(inode->i_mapping, rc);
2431 cfile = find_readable_file(cifs_i, false);
2435 if (server->ops->fiemap) {
2436 rc = server->ops->fiemap(tcon, cfile, fei, start, len);
2437 cifsFileInfo_put(cfile);
2441 cifsFileInfo_put(cfile);
2445 int cifs_truncate_page(struct address_space *mapping, loff_t from)
2447 pgoff_t index = from >> PAGE_SHIFT;
2448 unsigned offset = from & (PAGE_SIZE - 1);
2452 page = grab_cache_page(mapping, index);
2456 zero_user_segment(page, offset, PAGE_SIZE);
2462 void cifs_setsize(struct inode *inode, loff_t offset)
2464 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2466 spin_lock(&inode->i_lock);
2467 i_size_write(inode, offset);
2468 spin_unlock(&inode->i_lock);
2470 /* Cached inode must be refreshed on truncate */
2472 truncate_pagecache(inode, offset);
2476 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2477 unsigned int xid, char *full_path)
2480 struct cifsFileInfo *open_file;
2481 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2482 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2483 struct tcon_link *tlink = NULL;
2484 struct cifs_tcon *tcon = NULL;
2485 struct TCP_Server_Info *server;
2488 * To avoid spurious oplock breaks from server, in the case of
2489 * inodes that we already have open, avoid doing path based
2490 * setting of file size if we can do it by handle.
2491 * This keeps our caching token (oplock) and avoids timeouts
2492 * when the local oplock break takes longer to flush
2493 * writebehind data than the SMB timeout for the SetPathInfo
2494 * request would allow
2496 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2498 tcon = tlink_tcon(open_file->tlink);
2499 server = tcon->ses->server;
2500 if (server->ops->set_file_size)
2501 rc = server->ops->set_file_size(xid, tcon, open_file,
2502 attrs->ia_size, false);
2505 cifsFileInfo_put(open_file);
2506 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2514 tlink = cifs_sb_tlink(cifs_sb);
2516 return PTR_ERR(tlink);
2517 tcon = tlink_tcon(tlink);
2518 server = tcon->ses->server;
2522 * Set file size by pathname rather than by handle either because no
2523 * valid, writeable file handle for it was found or because there was
2524 * an error setting it by handle.
2526 if (server->ops->set_path_size)
2527 rc = server->ops->set_path_size(xid, tcon, full_path,
2528 attrs->ia_size, cifs_sb, false);
2531 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2534 cifs_put_tlink(tlink);
2538 cifsInode->server_eof = attrs->ia_size;
2539 cifs_setsize(inode, attrs->ia_size);
2542 * The man page of truncate says if the size changed,
2543 * then the st_ctime and st_mtime fields for the file
2546 attrs->ia_ctime = attrs->ia_mtime = current_time(inode);
2547 attrs->ia_valid |= ATTR_CTIME | ATTR_MTIME;
2549 cifs_truncate_page(inode->i_mapping, inode->i_size);
2556 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2560 char *full_path = NULL;
2561 struct inode *inode = d_inode(direntry);
2562 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2563 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2564 struct tcon_link *tlink;
2565 struct cifs_tcon *pTcon;
2566 struct cifs_unix_set_info_args *args = NULL;
2567 struct cifsFileInfo *open_file;
2569 cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2570 direntry, attrs->ia_valid);
2574 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2575 attrs->ia_valid |= ATTR_FORCE;
2577 rc = setattr_prepare(direntry, attrs);
2581 full_path = build_path_from_dentry(direntry);
2582 if (full_path == NULL) {
2588 * Attempt to flush data before changing attributes. We need to do
2589 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2590 * ownership or mode then we may also need to do this. Here, we take
2591 * the safe way out and just do the flush on all setattr requests. If
2592 * the flush returns error, store it to report later and continue.
2594 * BB: This should be smarter. Why bother flushing pages that
2595 * will be truncated anyway? Also, should we error out here if
2596 * the flush returns error?
2598 rc = filemap_write_and_wait(inode->i_mapping);
2599 if (is_interrupt_error(rc)) {
2604 mapping_set_error(inode->i_mapping, rc);
2607 if (attrs->ia_valid & ATTR_SIZE) {
2608 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2613 /* skip mode change if it's just for clearing setuid/setgid */
2614 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2615 attrs->ia_valid &= ~ATTR_MODE;
2617 args = kmalloc(sizeof(*args), GFP_KERNEL);
2623 /* set up the struct */
2624 if (attrs->ia_valid & ATTR_MODE)
2625 args->mode = attrs->ia_mode;
2627 args->mode = NO_CHANGE_64;
2629 if (attrs->ia_valid & ATTR_UID)
2630 args->uid = attrs->ia_uid;
2632 args->uid = INVALID_UID; /* no change */
2634 if (attrs->ia_valid & ATTR_GID)
2635 args->gid = attrs->ia_gid;
2637 args->gid = INVALID_GID; /* no change */
2639 if (attrs->ia_valid & ATTR_ATIME)
2640 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2642 args->atime = NO_CHANGE_64;
2644 if (attrs->ia_valid & ATTR_MTIME)
2645 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2647 args->mtime = NO_CHANGE_64;
2649 if (attrs->ia_valid & ATTR_CTIME)
2650 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2652 args->ctime = NO_CHANGE_64;
2655 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2657 u16 nfid = open_file->fid.netfid;
2658 u32 npid = open_file->pid;
2659 pTcon = tlink_tcon(open_file->tlink);
2660 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2661 cifsFileInfo_put(open_file);
2663 tlink = cifs_sb_tlink(cifs_sb);
2664 if (IS_ERR(tlink)) {
2665 rc = PTR_ERR(tlink);
2668 pTcon = tlink_tcon(tlink);
2669 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2671 cifs_remap(cifs_sb));
2672 cifs_put_tlink(tlink);
2678 if ((attrs->ia_valid & ATTR_SIZE) &&
2679 attrs->ia_size != i_size_read(inode))
2680 truncate_setsize(inode, attrs->ia_size);
2682 setattr_copy(inode, attrs);
2683 mark_inode_dirty(inode);
2685 /* force revalidate when any of these times are set since some
2686 of the fs types (eg ext3, fat) do not have fine enough
2687 time granularity to match protocol, and we do not have a
2688 a way (yet) to query the server fs's time granularity (and
2689 whether it rounds times down).
2691 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2692 cifsInode->time = 0;
2701 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2704 kuid_t uid = INVALID_UID;
2705 kgid_t gid = INVALID_GID;
2706 struct inode *inode = d_inode(direntry);
2707 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2708 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2709 struct cifsFileInfo *wfile;
2710 struct cifs_tcon *tcon;
2711 char *full_path = NULL;
2714 __u64 mode = NO_CHANGE_64;
2718 cifs_dbg(FYI, "setattr on file %pd attrs->ia_valid 0x%x\n",
2719 direntry, attrs->ia_valid);
2721 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2722 attrs->ia_valid |= ATTR_FORCE;
2724 rc = setattr_prepare(direntry, attrs);
2730 full_path = build_path_from_dentry(direntry);
2731 if (full_path == NULL) {
2738 * Attempt to flush data before changing attributes. We need to do
2739 * this for ATTR_SIZE and ATTR_MTIME. If the flush of the data
2740 * returns error, store it to report later and continue.
2742 * BB: This should be smarter. Why bother flushing pages that
2743 * will be truncated anyway? Also, should we error out here if
2744 * the flush returns error? Do we need to check for ATTR_MTIME_SET flag?
2746 if (attrs->ia_valid & (ATTR_MTIME | ATTR_SIZE | ATTR_CTIME)) {
2747 rc = filemap_write_and_wait(inode->i_mapping);
2748 if (is_interrupt_error(rc)) {
2750 goto cifs_setattr_exit;
2752 mapping_set_error(inode->i_mapping, rc);
2757 if ((attrs->ia_valid & ATTR_MTIME) &&
2758 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2759 rc = cifs_get_writable_file(cifsInode, FIND_WR_ANY, &wfile);
2761 tcon = tlink_tcon(wfile->tlink);
2762 rc = tcon->ses->server->ops->flush(xid, tcon, &wfile->fid);
2763 cifsFileInfo_put(wfile);
2765 goto cifs_setattr_exit;
2766 } else if (rc != -EBADF)
2767 goto cifs_setattr_exit;
2772 if (attrs->ia_valid & ATTR_SIZE) {
2773 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2775 goto cifs_setattr_exit;
2778 if (attrs->ia_valid & ATTR_UID)
2779 uid = attrs->ia_uid;
2781 if (attrs->ia_valid & ATTR_GID)
2782 gid = attrs->ia_gid;
2784 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2785 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2786 if (uid_valid(uid) || gid_valid(gid)) {
2787 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2790 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2792 goto cifs_setattr_exit;
2796 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2797 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2799 /* skip mode change if it's just for clearing setuid/setgid */
2800 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2801 attrs->ia_valid &= ~ATTR_MODE;
2803 if (attrs->ia_valid & ATTR_MODE) {
2804 mode = attrs->ia_mode;
2806 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2807 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2808 rc = id_mode_to_cifs_acl(inode, full_path, mode,
2809 INVALID_UID, INVALID_GID);
2811 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2813 goto cifs_setattr_exit;
2816 if (((mode & S_IWUGO) == 0) &&
2817 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2819 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2821 /* fix up mode if we're not using dynperm */
2822 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2823 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2824 } else if ((mode & S_IWUGO) &&
2825 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2827 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2828 /* Attributes of 0 are ignored */
2830 dosattr |= ATTR_NORMAL;
2832 /* reset local inode permissions to normal */
2833 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2834 attrs->ia_mode &= ~(S_IALLUGO);
2835 if (S_ISDIR(inode->i_mode))
2837 cifs_sb->mnt_dir_mode;
2840 cifs_sb->mnt_file_mode;
2842 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2843 /* ignore mode change - ATTR_READONLY hasn't changed */
2844 attrs->ia_valid &= ~ATTR_MODE;
2848 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2849 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2850 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2851 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2853 /* Even if error on time set, no sense failing the call if
2854 the server would set the time to a reasonable value anyway,
2855 and this check ensures that we are not being called from
2856 sys_utimes in which case we ought to fail the call back to
2857 the user when the server rejects the call */
2858 if ((rc) && (attrs->ia_valid &
2859 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2863 /* do not need local check to inode_check_ok since the server does
2866 goto cifs_setattr_exit;
2868 if ((attrs->ia_valid & ATTR_SIZE) &&
2869 attrs->ia_size != i_size_read(inode))
2870 truncate_setsize(inode, attrs->ia_size);
2872 setattr_copy(inode, attrs);
2873 mark_inode_dirty(inode);
2882 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2884 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
2885 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2887 if (pTcon->unix_ext)
2888 return cifs_setattr_unix(direntry, attrs);
2890 return cifs_setattr_nounix(direntry, attrs);
2892 /* BB: add cifs_setattr_legacy for really old servers */
2896 void cifs_delete_inode(struct inode *inode)
2898 cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2899 /* may have to add back in if and when safe distributed caching of
2900 directories added e.g. via FindNotify */