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>
29 #include <asm/div64.h>
33 #include "cifsproto.h"
34 #include "cifs_debug.h"
35 #include "cifs_fs_sb.h"
36 #include "cifs_unicode.h"
40 static void cifs_set_ops(struct inode *inode)
42 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
44 switch (inode->i_mode & S_IFMT) {
46 inode->i_op = &cifs_file_inode_ops;
47 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
48 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
49 inode->i_fop = &cifs_file_direct_nobrl_ops;
51 inode->i_fop = &cifs_file_direct_ops;
52 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
53 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
54 inode->i_fop = &cifs_file_strict_nobrl_ops;
56 inode->i_fop = &cifs_file_strict_ops;
57 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
58 inode->i_fop = &cifs_file_nobrl_ops;
59 else { /* not direct, send byte range locks */
60 inode->i_fop = &cifs_file_ops;
63 /* check if server can support readpages */
64 if (cifs_sb_master_tcon(cifs_sb)->ses->server->max_read <
65 PAGE_SIZE + MAX_CIFS_HDR_SIZE)
66 inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
68 inode->i_data.a_ops = &cifs_addr_ops;
71 #ifdef CONFIG_CIFS_DFS_UPCALL
72 if (IS_AUTOMOUNT(inode)) {
73 inode->i_op = &cifs_dfs_referral_inode_operations;
75 #else /* NO DFS support, treat as a directory */
78 inode->i_op = &cifs_dir_inode_ops;
79 inode->i_fop = &cifs_dir_ops;
83 inode->i_op = &cifs_symlink_inode_ops;
86 init_special_inode(inode, inode->i_mode, inode->i_rdev);
91 /* check inode attributes against fattr. If they don't match, tag the
92 * inode for cache invalidation
95 cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
97 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
99 cifs_dbg(FYI, "%s: revalidating inode %llu\n",
100 __func__, cifs_i->uniqueid);
102 if (inode->i_state & I_NEW) {
103 cifs_dbg(FYI, "%s: inode %llu is new\n",
104 __func__, cifs_i->uniqueid);
108 /* don't bother with revalidation if we have an oplock */
109 if (CIFS_CACHE_READ(cifs_i)) {
110 cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
111 __func__, cifs_i->uniqueid);
115 /* revalidate if mtime or size have changed */
116 fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);
117 if (timespec64_equal(&inode->i_mtime, &fattr->cf_mtime) &&
118 cifs_i->server_eof == fattr->cf_eof) {
119 cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
120 __func__, cifs_i->uniqueid);
124 cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
125 __func__, cifs_i->uniqueid);
126 set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags);
130 * copy nlink to the inode, unless it wasn't provided. Provide
131 * sane values if we don't have an existing one and none was provided
134 cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
137 * if we're in a situation where we can't trust what we
138 * got from the server (readdir, some non-unix cases)
139 * fake reasonable values
141 if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
142 /* only provide fake values on a new inode */
143 if (inode->i_state & I_NEW) {
144 if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
152 /* we trust the server, so update it */
153 set_nlink(inode, fattr->cf_nlink);
156 /* populate an inode with info from a cifs_fattr struct */
158 cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
160 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
161 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
163 cifs_revalidate_cache(inode, fattr);
165 spin_lock(&inode->i_lock);
166 fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);
167 fattr->cf_atime = timestamp_truncate(fattr->cf_atime, inode);
168 fattr->cf_ctime = timestamp_truncate(fattr->cf_ctime, inode);
169 /* we do not want atime to be less than mtime, it broke some apps */
170 if (timespec64_compare(&fattr->cf_atime, &fattr->cf_mtime) < 0)
171 inode->i_atime = fattr->cf_mtime;
173 inode->i_atime = fattr->cf_atime;
174 inode->i_mtime = fattr->cf_mtime;
175 inode->i_ctime = fattr->cf_ctime;
176 inode->i_rdev = fattr->cf_rdev;
177 cifs_nlink_fattr_to_inode(inode, fattr);
178 inode->i_uid = fattr->cf_uid;
179 inode->i_gid = fattr->cf_gid;
181 /* if dynperm is set, don't clobber existing mode */
182 if (inode->i_state & I_NEW ||
183 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
184 inode->i_mode = fattr->cf_mode;
186 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
188 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
191 cifs_i->time = jiffies;
193 if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING)
194 set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
196 clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
198 cifs_i->server_eof = fattr->cf_eof;
200 * Can't safely change the file size here if the client is writing to
201 * it due to potential races.
203 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
204 i_size_write(inode, fattr->cf_eof);
207 * i_blocks is not related to (i_size / i_blksize),
208 * but instead 512 byte (2**9) size is required for
209 * calculating num blocks.
211 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
213 spin_unlock(&inode->i_lock);
215 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
216 inode->i_flags |= S_AUTOMOUNT;
217 if (inode->i_state & I_NEW)
222 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
224 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
226 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
229 fattr->cf_uniqueid = iunique(sb, ROOT_I);
232 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
234 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
235 struct cifs_sb_info *cifs_sb)
237 memset(fattr, 0, sizeof(*fattr));
238 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
239 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
240 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
242 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
243 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
244 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
245 /* old POSIX extensions don't get create time */
247 fattr->cf_mode = le64_to_cpu(info->Permissions);
250 * Since we set the inode type below we need to mask off
251 * to avoid strange results if bits set above.
253 fattr->cf_mode &= ~S_IFMT;
254 switch (le32_to_cpu(info->Type)) {
256 fattr->cf_mode |= S_IFREG;
257 fattr->cf_dtype = DT_REG;
260 fattr->cf_mode |= S_IFLNK;
261 fattr->cf_dtype = DT_LNK;
264 fattr->cf_mode |= S_IFDIR;
265 fattr->cf_dtype = DT_DIR;
268 fattr->cf_mode |= S_IFCHR;
269 fattr->cf_dtype = DT_CHR;
270 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
271 le64_to_cpu(info->DevMinor) & MINORMASK);
274 fattr->cf_mode |= S_IFBLK;
275 fattr->cf_dtype = DT_BLK;
276 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
277 le64_to_cpu(info->DevMinor) & MINORMASK);
280 fattr->cf_mode |= S_IFIFO;
281 fattr->cf_dtype = DT_FIFO;
284 fattr->cf_mode |= S_IFSOCK;
285 fattr->cf_dtype = DT_SOCK;
288 /* safest to call it a file if we do not know */
289 fattr->cf_mode |= S_IFREG;
290 fattr->cf_dtype = DT_REG;
291 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
295 fattr->cf_uid = cifs_sb->mnt_uid;
296 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
297 u64 id = le64_to_cpu(info->Uid);
298 if (id < ((uid_t)-1)) {
299 kuid_t uid = make_kuid(&init_user_ns, id);
305 fattr->cf_gid = cifs_sb->mnt_gid;
306 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
307 u64 id = le64_to_cpu(info->Gid);
308 if (id < ((gid_t)-1)) {
309 kgid_t gid = make_kgid(&init_user_ns, id);
315 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
319 * Fill a cifs_fattr struct with fake inode info.
321 * Needed to setup cifs_fattr data for the directory which is the
322 * junction to the new submount (ie to setup the fake directory
323 * which represents a DFS referral).
326 cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
328 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
330 cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
332 memset(fattr, 0, sizeof(*fattr));
333 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
334 fattr->cf_uid = cifs_sb->mnt_uid;
335 fattr->cf_gid = cifs_sb->mnt_gid;
336 ktime_get_coarse_real_ts64(&fattr->cf_mtime);
337 fattr->cf_atime = fattr->cf_ctime = fattr->cf_mtime;
339 fattr->cf_flags = CIFS_FATTR_DFS_REFERRAL;
343 cifs_get_file_info_unix(struct file *filp)
347 FILE_UNIX_BASIC_INFO find_data;
348 struct cifs_fattr fattr;
349 struct inode *inode = file_inode(filp);
350 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
351 struct cifsFileInfo *cfile = filp->private_data;
352 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
355 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
357 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
358 } else if (rc == -EREMOTE) {
359 cifs_create_dfs_fattr(&fattr, inode->i_sb);
363 cifs_fattr_to_inode(inode, &fattr);
368 int cifs_get_inode_info_unix(struct inode **pinode,
369 const unsigned char *full_path,
370 struct super_block *sb, unsigned int xid)
373 FILE_UNIX_BASIC_INFO find_data;
374 struct cifs_fattr fattr;
375 struct cifs_tcon *tcon;
376 struct tcon_link *tlink;
377 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
379 cifs_dbg(FYI, "Getting info on %s\n", full_path);
381 tlink = cifs_sb_tlink(cifs_sb);
383 return PTR_ERR(tlink);
384 tcon = tlink_tcon(tlink);
386 /* could have done a find first instead but this returns more info */
387 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
388 cifs_sb->local_nls, cifs_remap(cifs_sb));
389 cifs_put_tlink(tlink);
392 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
393 } else if (rc == -EREMOTE) {
394 cifs_create_dfs_fattr(&fattr, sb);
400 /* check for Minshall+French symlinks */
401 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
402 int tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
405 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
408 if (*pinode == NULL) {
410 cifs_fill_uniqueid(sb, &fattr);
411 *pinode = cifs_iget(sb, &fattr);
415 /* we already have inode, update it */
417 /* if uniqueid is different, return error */
418 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
419 CIFS_I(*pinode)->uniqueid != fattr.cf_uniqueid)) {
420 CIFS_I(*pinode)->time = 0; /* force reval */
425 /* if filetype is different, return error */
426 if (unlikely(((*pinode)->i_mode & S_IFMT) !=
427 (fattr.cf_mode & S_IFMT))) {
428 CIFS_I(*pinode)->time = 0; /* force reval */
433 cifs_fattr_to_inode(*pinode, &fattr);
441 cifs_sfu_type(struct cifs_fattr *fattr, const char *path,
442 struct cifs_sb_info *cifs_sb, unsigned int xid)
446 struct tcon_link *tlink;
447 struct cifs_tcon *tcon;
449 struct cifs_open_parms oparms;
450 struct cifs_io_parms io_parms;
452 unsigned int bytes_read;
454 int buf_type = CIFS_NO_BUFFER;
458 fattr->cf_mode &= ~S_IFMT;
460 if (fattr->cf_eof == 0) {
461 fattr->cf_mode |= S_IFIFO;
462 fattr->cf_dtype = DT_FIFO;
464 } else if (fattr->cf_eof < 8) {
465 fattr->cf_mode |= S_IFREG;
466 fattr->cf_dtype = DT_REG;
467 return -EINVAL; /* EOPNOTSUPP? */
470 tlink = cifs_sb_tlink(cifs_sb);
472 return PTR_ERR(tlink);
473 tcon = tlink_tcon(tlink);
476 oparms.cifs_sb = cifs_sb;
477 oparms.desired_access = GENERIC_READ;
478 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
479 oparms.disposition = FILE_OPEN;
482 oparms.reconnect = false;
484 if (tcon->ses->server->oplocks)
488 rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);
490 cifs_dbg(FYI, "check sfu type of %s, open rc = %d\n", path, rc);
491 cifs_put_tlink(tlink);
496 io_parms.netfid = fid.netfid;
497 io_parms.pid = current->tgid;
498 io_parms.tcon = tcon;
500 io_parms.length = 24;
502 rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,
503 &bytes_read, &pbuf, &buf_type);
504 if ((rc == 0) && (bytes_read >= 8)) {
505 if (memcmp("IntxBLK", pbuf, 8) == 0) {
506 cifs_dbg(FYI, "Block device\n");
507 fattr->cf_mode |= S_IFBLK;
508 fattr->cf_dtype = DT_BLK;
509 if (bytes_read == 24) {
510 /* we have enough to decode dev num */
511 __u64 mjr; /* major */
512 __u64 mnr; /* minor */
513 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
514 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
515 fattr->cf_rdev = MKDEV(mjr, mnr);
517 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
518 cifs_dbg(FYI, "Char device\n");
519 fattr->cf_mode |= S_IFCHR;
520 fattr->cf_dtype = DT_CHR;
521 if (bytes_read == 24) {
522 /* we have enough to decode dev num */
523 __u64 mjr; /* major */
524 __u64 mnr; /* minor */
525 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
526 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
527 fattr->cf_rdev = MKDEV(mjr, mnr);
529 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
530 cifs_dbg(FYI, "Symlink\n");
531 fattr->cf_mode |= S_IFLNK;
532 fattr->cf_dtype = DT_LNK;
534 fattr->cf_mode |= S_IFREG; /* file? */
535 fattr->cf_dtype = DT_REG;
539 fattr->cf_mode |= S_IFREG; /* then it is a file */
540 fattr->cf_dtype = DT_REG;
541 rc = -EOPNOTSUPP; /* or some unknown SFU type */
544 tcon->ses->server->ops->close(xid, tcon, &fid);
545 cifs_put_tlink(tlink);
549 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
552 * Fetch mode bits as provided by SFU.
554 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
556 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
557 struct cifs_sb_info *cifs_sb, unsigned int xid)
559 #ifdef CONFIG_CIFS_XATTR
563 struct tcon_link *tlink;
564 struct cifs_tcon *tcon;
566 tlink = cifs_sb_tlink(cifs_sb);
568 return PTR_ERR(tlink);
569 tcon = tlink_tcon(tlink);
571 if (tcon->ses->server->ops->query_all_EAs == NULL) {
572 cifs_put_tlink(tlink);
576 rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
577 "SETFILEBITS", ea_value, 4 /* size of buf */,
579 cifs_put_tlink(tlink);
583 mode = le32_to_cpu(*((__le32 *)ea_value));
584 fattr->cf_mode &= ~SFBITS_MASK;
585 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
586 mode, fattr->cf_mode);
587 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
588 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
597 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
599 cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
600 struct super_block *sb, bool adjust_tz,
603 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
604 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
606 memset(fattr, 0, sizeof(*fattr));
607 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
608 if (info->DeletePending)
609 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
611 if (info->LastAccessTime)
612 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
614 ktime_get_coarse_real_ts64(&fattr->cf_atime);
616 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
617 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
620 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
621 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
624 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
625 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
626 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
628 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
631 fattr->cf_mode = S_IFLNK;
632 fattr->cf_dtype = DT_LNK;
633 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
634 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
635 fattr->cf_dtype = DT_DIR;
637 * Server can return wrong NumberOfLinks value for directories
638 * when Unix extensions are disabled - fake it.
641 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
643 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
644 fattr->cf_dtype = DT_REG;
646 /* clear write bits if ATTR_READONLY is set */
647 if (fattr->cf_cifsattrs & ATTR_READONLY)
648 fattr->cf_mode &= ~(S_IWUGO);
651 * Don't accept zero nlink from non-unix servers unless
652 * delete is pending. Instead mark it as unknown.
654 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
655 !info->DeletePending) {
656 cifs_dbg(VFS, "bogus file nlink value %u\n",
658 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
662 fattr->cf_uid = cifs_sb->mnt_uid;
663 fattr->cf_gid = cifs_sb->mnt_gid;
667 cifs_get_file_info(struct file *filp)
671 FILE_ALL_INFO find_data;
672 struct cifs_fattr fattr;
673 struct inode *inode = file_inode(filp);
674 struct cifsFileInfo *cfile = filp->private_data;
675 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
676 struct TCP_Server_Info *server = tcon->ses->server;
678 if (!server->ops->query_file_info)
682 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
685 cifs_all_info_to_fattr(&fattr, &find_data, inode->i_sb, false,
689 cifs_create_dfs_fattr(&fattr, inode->i_sb);
695 * FIXME: legacy server -- fall back to path-based call?
696 * for now, just skip revalidating and mark inode for
700 CIFS_I(inode)->time = 0;
706 * don't bother with SFU junk here -- just mark inode as needing
709 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
710 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
711 cifs_fattr_to_inode(inode, &fattr);
717 /* Simple function to return a 64 bit hash of string. Rarely called */
718 static __u64 simple_hashstr(const char *str)
720 const __u64 hash_mult = 1125899906842597ULL; /* a big enough prime */
724 hash = (hash + (__u64) *str++) * hash_mult;
730 * cifs_backup_query_path_info - SMB1 fallback code to get ino
732 * Fallback code to get file metadata when we don't have access to
733 * @full_path (EACCES) and have backup creds.
735 * @data will be set to search info result buffer
736 * @resp_buf will be set to cifs resp buf and needs to be freed with
737 * cifs_buf_release() when done with @data.
740 cifs_backup_query_path_info(int xid,
741 struct cifs_tcon *tcon,
742 struct super_block *sb,
743 const char *full_path,
745 FILE_ALL_INFO **data)
747 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
748 struct cifs_search_info info = {0};
753 info.endOfSearch = false;
755 info.info_level = SMB_FIND_FILE_UNIX;
756 else if ((tcon->ses->capabilities &
757 tcon->ses->server->vals->cap_nt_find) == 0)
758 info.info_level = SMB_FIND_FILE_INFO_STANDARD;
759 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
760 info.info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
761 else /* no srvino useful for fallback to some netapp */
762 info.info_level = SMB_FIND_FILE_DIRECTORY_INFO;
764 flags = CIFS_SEARCH_CLOSE_ALWAYS |
765 CIFS_SEARCH_CLOSE_AT_END |
766 CIFS_SEARCH_BACKUP_SEARCH;
768 rc = CIFSFindFirst(xid, tcon, full_path,
769 cifs_sb, NULL, flags, &info, false);
773 *resp_buf = (void *)info.ntwrk_buf_start;
774 *data = (FILE_ALL_INFO *)info.srch_entries_start;
779 cifs_set_fattr_ino(int xid,
780 struct cifs_tcon *tcon,
781 struct super_block *sb,
782 struct inode **inode,
783 const char *full_path,
785 struct cifs_fattr *fattr)
787 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
788 struct TCP_Server_Info *server = tcon->ses->server;
791 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
793 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
795 fattr->cf_uniqueid = iunique(sb, ROOT_I);
800 * If we have an inode pass a NULL tcon to ensure we don't
801 * make a round trip to the server. This only works for SMB2+.
803 rc = server->ops->get_srv_inum(xid,
804 *inode ? NULL : tcon,
810 * If that fails reuse existing ino or generate one
811 * and disable server ones
814 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
816 fattr->cf_uniqueid = iunique(sb, ROOT_I);
817 cifs_autodisable_serverino(cifs_sb);
822 /* If no errors, check for zero root inode (invalid) */
823 if (fattr->cf_uniqueid == 0 && strlen(full_path) == 0) {
824 cifs_dbg(FYI, "Invalid (0) inodenum\n");
827 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
829 /* make an ino by hashing the UNC */
830 fattr->cf_flags |= CIFS_FATTR_FAKE_ROOT_INO;
831 fattr->cf_uniqueid = simple_hashstr(tcon->treeName);
836 static inline bool is_inode_cache_good(struct inode *ino)
838 return ino && CIFS_CACHE_READ(CIFS_I(ino)) && CIFS_I(ino)->time != 0;
842 cifs_get_inode_info(struct inode **inode,
843 const char *full_path,
844 FILE_ALL_INFO *in_data,
845 struct super_block *sb, int xid,
846 const struct cifs_fid *fid)
849 struct cifs_tcon *tcon;
850 struct TCP_Server_Info *server;
851 struct tcon_link *tlink;
852 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
853 bool adjust_tz = false;
854 struct cifs_fattr fattr = {0};
855 bool symlink = false;
856 FILE_ALL_INFO *data = in_data;
857 FILE_ALL_INFO *tmp_data = NULL;
858 void *smb1_backup_rsp_buf = NULL;
862 tlink = cifs_sb_tlink(cifs_sb);
864 return PTR_ERR(tlink);
865 tcon = tlink_tcon(tlink);
866 server = tcon->ses->server;
869 * 1. Fetch file metadata if not provided (data)
873 if (is_inode_cache_good(*inode)) {
874 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
877 tmp_data = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
882 rc = server->ops->query_path_info(xid, tcon, cifs_sb,
884 &adjust_tz, &symlink);
889 * 2. Convert it to internal cifs metadata (fattr)
894 cifs_all_info_to_fattr(&fattr, data, sb, adjust_tz, symlink);
897 /* DFS link, no metadata available on this server */
898 cifs_create_dfs_fattr(&fattr, sb);
903 * perm errors, try again with backup flags if possible
905 * For SMB2 and later the backup intent flag
906 * is already sent if needed on open and there
907 * is no path based FindFirst operation to use
910 if (backup_cred(cifs_sb) && is_smb1_server(server)) {
911 /* for easier reading */
912 FILE_DIRECTORY_INFO *fdi;
913 SEARCH_ID_FULL_DIR_INFO *si;
915 rc = cifs_backup_query_path_info(xid, tcon, sb,
917 &smb1_backup_rsp_buf,
922 fdi = (FILE_DIRECTORY_INFO *)data;
923 si = (SEARCH_ID_FULL_DIR_INFO *)data;
925 cifs_dir_info_to_fattr(&fattr, fdi, cifs_sb);
926 fattr.cf_uniqueid = le64_to_cpu(si->UniqueId);
927 /* uniqueid set, skip get inum step */
930 /* nothing we can do, bail out */
935 cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc);
940 * 3. Get or update inode number (fattr.cf_uniqueid)
943 cifs_set_fattr_ino(xid, tcon, sb, inode, full_path, data, &fattr);
946 * 4. Tweak fattr based on mount options
950 /* query for SFU type info if supported and needed */
951 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
952 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
953 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
955 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
958 /* fill in 0777 bits from ACL */
959 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID) {
960 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, true,
963 cifs_dbg(FYI, "%s: Get mode from SID failed. rc=%d\n",
967 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
968 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, false,
971 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
977 /* fill in remaining high mode bits e.g. SUID, VTX */
978 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
979 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
981 /* check for Minshall+French symlinks */
982 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
983 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
986 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
990 * 5. Update inode with final fattr data
994 *inode = cifs_iget(sb, &fattr);
998 /* we already have inode, update it */
1000 /* if uniqueid is different, return error */
1001 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
1002 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
1003 CIFS_I(*inode)->time = 0; /* force reval */
1008 /* if filetype is different, return error */
1009 if (unlikely(((*inode)->i_mode & S_IFMT) !=
1010 (fattr.cf_mode & S_IFMT))) {
1011 CIFS_I(*inode)->time = 0; /* force reval */
1016 cifs_fattr_to_inode(*inode, &fattr);
1019 cifs_buf_release(smb1_backup_rsp_buf);
1020 cifs_put_tlink(tlink);
1025 static const struct inode_operations cifs_ipc_inode_ops = {
1026 .lookup = cifs_lookup,
1030 cifs_find_inode(struct inode *inode, void *opaque)
1032 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
1034 /* don't match inode with different uniqueid */
1035 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
1038 /* use createtime like an i_generation field */
1039 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
1042 /* don't match inode of different type */
1043 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
1046 /* if it's not a directory or has no dentries, then flag it */
1047 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
1048 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
1054 cifs_init_inode(struct inode *inode, void *opaque)
1056 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
1058 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
1059 CIFS_I(inode)->createtime = fattr->cf_createtime;
1064 * walk dentry list for an inode and report whether it has aliases that
1065 * are hashed. We use this to determine if a directory inode can actually
1069 inode_has_hashed_dentries(struct inode *inode)
1071 struct dentry *dentry;
1073 spin_lock(&inode->i_lock);
1074 hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
1075 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
1076 spin_unlock(&inode->i_lock);
1080 spin_unlock(&inode->i_lock);
1084 /* Given fattrs, get a corresponding inode */
1086 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
1089 struct inode *inode;
1092 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
1094 /* hash down to 32-bits on 32-bit arch */
1095 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
1097 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
1099 /* was there a potentially problematic inode collision? */
1100 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
1101 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
1103 if (inode_has_hashed_dentries(inode)) {
1104 cifs_autodisable_serverino(CIFS_SB(sb));
1106 fattr->cf_uniqueid = iunique(sb, ROOT_I);
1107 goto retry_iget5_locked;
1111 cifs_fattr_to_inode(inode, fattr);
1112 if (sb->s_flags & SB_NOATIME)
1113 inode->i_flags |= S_NOATIME | S_NOCMTIME;
1114 if (inode->i_state & I_NEW) {
1115 inode->i_ino = hash;
1116 #ifdef CONFIG_CIFS_FSCACHE
1117 /* initialize per-inode cache cookie pointer */
1118 CIFS_I(inode)->fscache = NULL;
1120 unlock_new_inode(inode);
1127 /* gets root inode */
1128 struct inode *cifs_root_iget(struct super_block *sb)
1131 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1132 struct inode *inode = NULL;
1134 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1138 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
1139 && cifs_sb->prepath) {
1140 len = strlen(cifs_sb->prepath);
1141 path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
1143 return ERR_PTR(-ENOMEM);
1145 memcpy(path+1, cifs_sb->prepath, len);
1147 path = kstrdup("", GFP_KERNEL);
1149 return ERR_PTR(-ENOMEM);
1153 if (tcon->unix_ext) {
1154 rc = cifs_get_inode_info_unix(&inode, path, sb, xid);
1155 /* some servers mistakenly claim POSIX support */
1156 if (rc != -EOPNOTSUPP)
1158 cifs_dbg(VFS, "server does not support POSIX extensions\n");
1159 tcon->unix_ext = false;
1162 convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
1163 rc = cifs_get_inode_info(&inode, path, NULL, sb, xid, NULL);
1167 inode = ERR_PTR(rc);
1171 #ifdef CONFIG_CIFS_FSCACHE
1172 /* populate tcon->resource_id */
1173 tcon->resource_id = CIFS_I(inode)->uniqueid;
1176 if (rc && tcon->pipe) {
1177 cifs_dbg(FYI, "ipc connection - fake read inode\n");
1178 spin_lock(&inode->i_lock);
1179 inode->i_mode |= S_IFDIR;
1180 set_nlink(inode, 2);
1181 inode->i_op = &cifs_ipc_inode_ops;
1182 inode->i_fop = &simple_dir_operations;
1183 inode->i_uid = cifs_sb->mnt_uid;
1184 inode->i_gid = cifs_sb->mnt_gid;
1185 spin_unlock(&inode->i_lock);
1188 inode = ERR_PTR(rc);
1198 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1199 char *full_path, __u32 dosattr)
1201 bool set_time = false;
1202 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1203 struct TCP_Server_Info *server;
1204 FILE_BASIC_INFO info_buf;
1209 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1210 if (!server->ops->set_file_info)
1215 if (attrs->ia_valid & ATTR_ATIME) {
1217 info_buf.LastAccessTime =
1218 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1220 info_buf.LastAccessTime = 0;
1222 if (attrs->ia_valid & ATTR_MTIME) {
1224 info_buf.LastWriteTime =
1225 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1227 info_buf.LastWriteTime = 0;
1230 * Samba throws this field away, but windows may actually use it.
1231 * Do not set ctime unless other time stamps are changed explicitly
1232 * (i.e. by utimes()) since we would then have a mix of client and
1235 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1236 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1237 info_buf.ChangeTime =
1238 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1240 info_buf.ChangeTime = 0;
1242 info_buf.CreationTime = 0; /* don't change */
1243 info_buf.Attributes = cpu_to_le32(dosattr);
1245 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1249 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1250 * and rename it to a random name that hopefully won't conflict with
1254 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1255 const unsigned int xid)
1259 struct cifs_fid fid;
1260 struct cifs_open_parms oparms;
1261 struct inode *inode = d_inode(dentry);
1262 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1263 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1264 struct tcon_link *tlink;
1265 struct cifs_tcon *tcon;
1266 __u32 dosattr, origattr;
1267 FILE_BASIC_INFO *info_buf = NULL;
1269 tlink = cifs_sb_tlink(cifs_sb);
1271 return PTR_ERR(tlink);
1272 tcon = tlink_tcon(tlink);
1275 * We cannot rename the file if the server doesn't support
1276 * CAP_INFOLEVEL_PASSTHRU
1278 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1284 oparms.cifs_sb = cifs_sb;
1285 oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1286 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
1287 oparms.disposition = FILE_OPEN;
1288 oparms.path = full_path;
1290 oparms.reconnect = false;
1292 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1296 origattr = cifsInode->cifsAttrs;
1298 origattr |= ATTR_NORMAL;
1300 dosattr = origattr & ~ATTR_READONLY;
1302 dosattr |= ATTR_NORMAL;
1303 dosattr |= ATTR_HIDDEN;
1305 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1306 if (dosattr != origattr) {
1307 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1308 if (info_buf == NULL) {
1312 info_buf->Attributes = cpu_to_le32(dosattr);
1313 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1315 /* although we would like to mark the file hidden
1316 if that fails we will still try to rename it */
1318 cifsInode->cifsAttrs = dosattr;
1320 dosattr = origattr; /* since not able to change them */
1323 /* rename the file */
1324 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1326 cifs_remap(cifs_sb));
1332 /* try to set DELETE_ON_CLOSE */
1333 if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1334 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1337 * some samba versions return -ENOENT when we try to set the
1338 * file disposition here. Likely a samba bug, but work around
1339 * it for now. This means that some cifsXXX files may hang
1340 * around after they shouldn't.
1342 * BB: remove this hack after more servers have the fix
1350 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1354 CIFSSMBClose(xid, tcon, fid.netfid);
1357 cifs_put_tlink(tlink);
1361 * reset everything back to the original state. Don't bother
1362 * dealing with errors here since we can't do anything about
1366 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1367 cifs_sb->local_nls, cifs_remap(cifs_sb));
1369 if (dosattr != origattr) {
1370 info_buf->Attributes = cpu_to_le32(origattr);
1371 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1373 cifsInode->cifsAttrs = origattr;
1379 /* copied from fs/nfs/dir.c with small changes */
1381 cifs_drop_nlink(struct inode *inode)
1383 spin_lock(&inode->i_lock);
1384 if (inode->i_nlink > 0)
1386 spin_unlock(&inode->i_lock);
1390 * If d_inode(dentry) is null (usually meaning the cached dentry
1391 * is a negative dentry) then we would attempt a standard SMB delete, but
1392 * if that fails we can not attempt the fall back mechanisms on EACCES
1393 * but will return the EACCES to the caller. Note that the VFS does not call
1394 * unlink on negative dentries currently.
1396 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1400 char *full_path = NULL;
1401 struct inode *inode = d_inode(dentry);
1402 struct cifsInodeInfo *cifs_inode;
1403 struct super_block *sb = dir->i_sb;
1404 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1405 struct tcon_link *tlink;
1406 struct cifs_tcon *tcon;
1407 struct TCP_Server_Info *server;
1408 struct iattr *attrs = NULL;
1409 __u32 dosattr = 0, origattr = 0;
1411 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1413 tlink = cifs_sb_tlink(cifs_sb);
1415 return PTR_ERR(tlink);
1416 tcon = tlink_tcon(tlink);
1417 server = tcon->ses->server;
1421 if (tcon->nodelete) {
1426 /* Unlink can be called from rename so we can not take the
1427 * sb->s_vfs_rename_mutex here */
1428 full_path = build_path_from_dentry(dentry);
1429 if (full_path == NULL) {
1434 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1435 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1436 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1437 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1438 cifs_remap(cifs_sb));
1439 cifs_dbg(FYI, "posix del rc %d\n", rc);
1440 if ((rc == 0) || (rc == -ENOENT))
1441 goto psx_del_no_retry;
1445 if (!server->ops->unlink) {
1447 goto psx_del_no_retry;
1450 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1455 cifs_drop_nlink(inode);
1456 } else if (rc == -ENOENT) {
1458 } else if (rc == -EBUSY) {
1459 if (server->ops->rename_pending_delete) {
1460 rc = server->ops->rename_pending_delete(full_path,
1463 cifs_drop_nlink(inode);
1465 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1466 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1467 if (attrs == NULL) {
1472 /* try to reset dos attributes */
1473 cifs_inode = CIFS_I(inode);
1474 origattr = cifs_inode->cifsAttrs;
1476 origattr |= ATTR_NORMAL;
1477 dosattr = origattr & ~ATTR_READONLY;
1479 dosattr |= ATTR_NORMAL;
1480 dosattr |= ATTR_HIDDEN;
1482 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1486 goto retry_std_delete;
1489 /* undo the setattr if we errored out and it's needed */
1490 if (rc != 0 && dosattr != 0)
1491 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1495 cifs_inode = CIFS_I(inode);
1496 cifs_inode->time = 0; /* will force revalidate to get info
1498 inode->i_ctime = current_time(inode);
1500 dir->i_ctime = dir->i_mtime = current_time(dir);
1501 cifs_inode = CIFS_I(dir);
1502 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1507 cifs_put_tlink(tlink);
1512 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1513 const char *full_path, struct cifs_sb_info *cifs_sb,
1514 struct cifs_tcon *tcon, const unsigned int xid)
1517 struct inode *inode = NULL;
1520 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1523 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1530 * setting nlink not necessary except in cases where we failed to get it
1531 * from the server or was set bogus. Also, since this is a brand new
1532 * inode, no need to grab the i_lock before setting the i_nlink.
1534 if (inode->i_nlink < 2)
1535 set_nlink(inode, 2);
1536 mode &= ~current_umask();
1537 /* must turn on setgid bit if parent dir has it */
1538 if (parent->i_mode & S_ISGID)
1541 if (tcon->unix_ext) {
1542 struct cifs_unix_set_info_args args = {
1544 .ctime = NO_CHANGE_64,
1545 .atime = NO_CHANGE_64,
1546 .mtime = NO_CHANGE_64,
1549 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1550 args.uid = current_fsuid();
1551 if (parent->i_mode & S_ISGID)
1552 args.gid = parent->i_gid;
1554 args.gid = current_fsgid();
1556 args.uid = INVALID_UID; /* no change */
1557 args.gid = INVALID_GID; /* no change */
1559 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1561 cifs_remap(cifs_sb));
1563 struct TCP_Server_Info *server = tcon->ses->server;
1564 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1565 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1566 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1568 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1569 inode->i_mode = (mode | S_IFDIR);
1571 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1572 inode->i_uid = current_fsuid();
1573 if (inode->i_mode & S_ISGID)
1574 inode->i_gid = parent->i_gid;
1576 inode->i_gid = current_fsgid();
1579 d_instantiate(dentry, inode);
1584 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1585 const char *full_path, struct cifs_sb_info *cifs_sb,
1586 struct cifs_tcon *tcon, const unsigned int xid)
1590 FILE_UNIX_BASIC_INFO *info = NULL;
1591 struct inode *newinode = NULL;
1592 struct cifs_fattr fattr;
1594 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1597 goto posix_mkdir_out;
1600 mode &= ~current_umask();
1601 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1602 NULL /* netfid */, info, &oplock, full_path,
1603 cifs_sb->local_nls, cifs_remap(cifs_sb));
1604 if (rc == -EOPNOTSUPP)
1605 goto posix_mkdir_out;
1607 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1609 goto posix_mkdir_out;
1612 if (info->Type == cpu_to_le32(-1))
1613 /* no return info, go query for it */
1614 goto posix_mkdir_get_info;
1616 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1617 * need to set uid/gid.
1620 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1621 cifs_fill_uniqueid(inode->i_sb, &fattr);
1622 newinode = cifs_iget(inode->i_sb, &fattr);
1624 goto posix_mkdir_get_info;
1626 d_instantiate(dentry, newinode);
1628 #ifdef CONFIG_CIFS_DEBUG2
1629 cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1630 dentry, dentry, newinode);
1632 if (newinode->i_nlink != 2)
1633 cifs_dbg(FYI, "unexpected number of links %d\n",
1640 posix_mkdir_get_info:
1641 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1643 goto posix_mkdir_out;
1646 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1650 struct cifs_sb_info *cifs_sb;
1651 struct tcon_link *tlink;
1652 struct cifs_tcon *tcon;
1653 struct TCP_Server_Info *server;
1656 cifs_dbg(FYI, "In cifs_mkdir, mode = %04ho inode = 0x%p\n",
1659 cifs_sb = CIFS_SB(inode->i_sb);
1660 tlink = cifs_sb_tlink(cifs_sb);
1662 return PTR_ERR(tlink);
1663 tcon = tlink_tcon(tlink);
1667 full_path = build_path_from_dentry(direntry);
1668 if (full_path == NULL) {
1673 server = tcon->ses->server;
1675 if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) {
1676 rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,
1678 d_drop(direntry); /* for time being always refresh inode info */
1682 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1683 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1684 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1686 if (rc != -EOPNOTSUPP)
1690 if (!server->ops->mkdir) {
1695 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1696 rc = server->ops->mkdir(xid, inode, mode, tcon, full_path, cifs_sb);
1698 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1703 /* TODO: skip this for smb2/smb3 */
1704 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1708 * Force revalidate to get parent dir info when needed since cached
1709 * attributes are invalid now.
1711 CIFS_I(inode)->time = 0;
1714 cifs_put_tlink(tlink);
1718 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1722 struct cifs_sb_info *cifs_sb;
1723 struct tcon_link *tlink;
1724 struct cifs_tcon *tcon;
1725 struct TCP_Server_Info *server;
1726 char *full_path = NULL;
1727 struct cifsInodeInfo *cifsInode;
1729 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1733 full_path = build_path_from_dentry(direntry);
1734 if (full_path == NULL) {
1739 cifs_sb = CIFS_SB(inode->i_sb);
1740 tlink = cifs_sb_tlink(cifs_sb);
1741 if (IS_ERR(tlink)) {
1742 rc = PTR_ERR(tlink);
1745 tcon = tlink_tcon(tlink);
1746 server = tcon->ses->server;
1748 if (!server->ops->rmdir) {
1750 cifs_put_tlink(tlink);
1754 if (tcon->nodelete) {
1756 cifs_put_tlink(tlink);
1760 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1761 cifs_put_tlink(tlink);
1764 spin_lock(&d_inode(direntry)->i_lock);
1765 i_size_write(d_inode(direntry), 0);
1766 clear_nlink(d_inode(direntry));
1767 spin_unlock(&d_inode(direntry)->i_lock);
1770 cifsInode = CIFS_I(d_inode(direntry));
1771 /* force revalidate to go get info when needed */
1772 cifsInode->time = 0;
1774 cifsInode = CIFS_I(inode);
1776 * Force revalidate to get parent dir info when needed since cached
1777 * attributes are invalid now.
1779 cifsInode->time = 0;
1781 d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
1782 current_time(inode);
1791 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1792 const char *from_path, struct dentry *to_dentry,
1793 const char *to_path)
1795 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1796 struct tcon_link *tlink;
1797 struct cifs_tcon *tcon;
1798 struct TCP_Server_Info *server;
1799 struct cifs_fid fid;
1800 struct cifs_open_parms oparms;
1803 tlink = cifs_sb_tlink(cifs_sb);
1805 return PTR_ERR(tlink);
1806 tcon = tlink_tcon(tlink);
1807 server = tcon->ses->server;
1809 if (!server->ops->rename)
1812 /* try path-based rename first */
1813 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1816 * Don't bother with rename by filehandle unless file is busy and
1817 * source. Note that cross directory moves do not work with
1818 * rename by filehandle to various Windows servers.
1820 if (rc == 0 || rc != -EBUSY)
1821 goto do_rename_exit;
1823 /* Don't fall back to using SMB on SMB 2+ mount */
1824 if (server->vals->protocol_id != 0)
1825 goto do_rename_exit;
1827 /* open-file renames don't work across directories */
1828 if (to_dentry->d_parent != from_dentry->d_parent)
1829 goto do_rename_exit;
1832 oparms.cifs_sb = cifs_sb;
1833 /* open the file to be renamed -- we need DELETE perms */
1834 oparms.desired_access = DELETE;
1835 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
1836 oparms.disposition = FILE_OPEN;
1837 oparms.path = from_path;
1839 oparms.reconnect = false;
1841 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1843 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
1844 (const char *) to_dentry->d_name.name,
1845 cifs_sb->local_nls, cifs_remap(cifs_sb));
1846 CIFSSMBClose(xid, tcon, fid.netfid);
1850 d_move(from_dentry, to_dentry);
1851 cifs_put_tlink(tlink);
1856 cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
1857 struct inode *target_dir, struct dentry *target_dentry,
1860 char *from_name = NULL;
1861 char *to_name = NULL;
1862 struct cifs_sb_info *cifs_sb;
1863 struct tcon_link *tlink;
1864 struct cifs_tcon *tcon;
1865 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1866 FILE_UNIX_BASIC_INFO *info_buf_target;
1870 if (flags & ~RENAME_NOREPLACE)
1873 cifs_sb = CIFS_SB(source_dir->i_sb);
1874 tlink = cifs_sb_tlink(cifs_sb);
1876 return PTR_ERR(tlink);
1877 tcon = tlink_tcon(tlink);
1882 * we already have the rename sem so we do not need to
1883 * grab it again here to protect the path integrity
1885 from_name = build_path_from_dentry(source_dentry);
1886 if (from_name == NULL) {
1888 goto cifs_rename_exit;
1891 to_name = build_path_from_dentry(target_dentry);
1892 if (to_name == NULL) {
1894 goto cifs_rename_exit;
1897 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1901 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1903 if (flags & RENAME_NOREPLACE)
1904 goto cifs_rename_exit;
1906 if (rc == -EEXIST && tcon->unix_ext) {
1908 * Are src and dst hardlinks of same inode? We can only tell
1909 * with unix extensions enabled.
1912 kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
1914 if (info_buf_source == NULL) {
1916 goto cifs_rename_exit;
1919 info_buf_target = info_buf_source + 1;
1920 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1923 cifs_remap(cifs_sb));
1927 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1930 cifs_remap(cifs_sb));
1932 if (tmprc == 0 && (info_buf_source->UniqueId ==
1933 info_buf_target->UniqueId)) {
1934 /* same file, POSIX says that this is a noop */
1936 goto cifs_rename_exit;
1940 * else ... BB we could add the same check for Windows by
1941 * checking the UniqueId via FILE_INTERNAL_INFO
1945 /* Try unlinking the target dentry if it's not negative */
1946 if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
1947 if (d_is_dir(target_dentry))
1948 tmprc = cifs_rmdir(target_dir, target_dentry);
1950 tmprc = cifs_unlink(target_dir, target_dentry);
1952 goto cifs_rename_exit;
1953 rc = cifs_do_rename(xid, source_dentry, from_name,
1954 target_dentry, to_name);
1957 /* force revalidate to go get info when needed */
1958 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
1960 source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
1961 target_dir->i_mtime = current_time(source_dir);
1964 kfree(info_buf_source);
1968 cifs_put_tlink(tlink);
1973 cifs_inode_needs_reval(struct inode *inode)
1975 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1976 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1978 if (cifs_i->time == 0)
1981 if (CIFS_CACHE_READ(cifs_i))
1984 if (!lookupCacheEnabled)
1987 if (!cifs_sb->actimeo)
1990 if (!time_in_range(jiffies, cifs_i->time,
1991 cifs_i->time + cifs_sb->actimeo))
1994 /* hardlinked files w/ noserverino get "special" treatment */
1995 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1996 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
2003 * Zap the cache. Called when invalid_mapping flag is set.
2006 cifs_invalidate_mapping(struct inode *inode)
2010 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
2011 rc = invalidate_inode_pages2(inode->i_mapping);
2013 cifs_dbg(VFS, "%s: Could not invalidate inode %p\n",
2017 cifs_fscache_reset_inode_cookie(inode);
2022 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
2023 * @word: long word containing the bit lock
2026 cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
2028 freezable_schedule_unsafe();
2029 if (signal_pending_state(mode, current))
2030 return -ERESTARTSYS;
2035 cifs_revalidate_mapping(struct inode *inode)
2038 unsigned long *flags = &CIFS_I(inode)->flags;
2040 /* swapfiles are not supposed to be shared */
2041 if (IS_SWAPFILE(inode))
2044 rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
2049 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
2050 rc = cifs_invalidate_mapping(inode);
2052 set_bit(CIFS_INO_INVALID_MAPPING, flags);
2055 clear_bit_unlock(CIFS_INO_LOCK, flags);
2056 smp_mb__after_atomic();
2057 wake_up_bit(flags, CIFS_INO_LOCK);
2063 cifs_zap_mapping(struct inode *inode)
2065 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
2066 return cifs_revalidate_mapping(inode);
2069 int cifs_revalidate_file_attr(struct file *filp)
2072 struct inode *inode = file_inode(filp);
2073 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
2075 if (!cifs_inode_needs_reval(inode))
2078 if (tlink_tcon(cfile->tlink)->unix_ext)
2079 rc = cifs_get_file_info_unix(filp);
2081 rc = cifs_get_file_info(filp);
2086 int cifs_revalidate_dentry_attr(struct dentry *dentry)
2090 struct inode *inode = d_inode(dentry);
2091 struct super_block *sb = dentry->d_sb;
2092 char *full_path = NULL;
2098 if (!cifs_inode_needs_reval(inode))
2103 /* can not safely grab the rename sem here if rename calls revalidate
2104 since that would deadlock */
2105 full_path = build_path_from_dentry(dentry);
2106 if (full_path == NULL) {
2111 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2112 full_path, inode, inode->i_count.counter,
2113 dentry, cifs_get_time(dentry), jiffies);
2116 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
2117 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2119 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2121 if (rc == -EAGAIN && count++ < 10)
2130 int cifs_revalidate_file(struct file *filp)
2133 struct inode *inode = file_inode(filp);
2135 rc = cifs_revalidate_file_attr(filp);
2139 return cifs_revalidate_mapping(inode);
2142 /* revalidate a dentry's inode attributes */
2143 int cifs_revalidate_dentry(struct dentry *dentry)
2146 struct inode *inode = d_inode(dentry);
2148 rc = cifs_revalidate_dentry_attr(dentry);
2152 return cifs_revalidate_mapping(inode);
2155 int cifs_getattr(const struct path *path, struct kstat *stat,
2156 u32 request_mask, unsigned int flags)
2158 struct dentry *dentry = path->dentry;
2159 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2160 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2161 struct inode *inode = d_inode(dentry);
2165 * We need to be sure that all dirty pages are written and the server
2166 * has actual ctime, mtime and file length.
2168 if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_SIZE)) &&
2169 !CIFS_CACHE_READ(CIFS_I(inode)) &&
2170 inode->i_mapping && inode->i_mapping->nrpages != 0) {
2171 rc = filemap_fdatawait(inode->i_mapping);
2173 mapping_set_error(inode->i_mapping, rc);
2178 if ((flags & AT_STATX_SYNC_TYPE) == AT_STATX_FORCE_SYNC)
2179 CIFS_I(inode)->time = 0; /* force revalidate */
2182 * If the caller doesn't require syncing, only sync if
2183 * necessary (e.g. due to earlier truncate or setattr
2184 * invalidating the cached metadata)
2186 if (((flags & AT_STATX_SYNC_TYPE) != AT_STATX_DONT_SYNC) ||
2187 (CIFS_I(inode)->time == 0)) {
2188 rc = cifs_revalidate_dentry_attr(dentry);
2193 generic_fillattr(inode, stat);
2194 stat->blksize = cifs_sb->bsize;
2195 stat->ino = CIFS_I(inode)->uniqueid;
2197 /* old CIFS Unix Extensions doesn't return create time */
2198 if (CIFS_I(inode)->createtime) {
2199 stat->result_mask |= STATX_BTIME;
2201 cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
2204 stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2205 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2206 stat->attributes |= STATX_ATTR_COMPRESSED;
2207 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2208 stat->attributes |= STATX_ATTR_ENCRYPTED;
2211 * If on a multiuser mount without unix extensions or cifsacl being
2212 * enabled, and the admin hasn't overridden them, set the ownership
2213 * to the fsuid/fsgid of the current process.
2215 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2216 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2218 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2219 stat->uid = current_fsuid();
2220 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2221 stat->gid = current_fsgid();
2226 int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start,
2229 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2230 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_i->vfs_inode.i_sb);
2231 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2232 struct TCP_Server_Info *server = tcon->ses->server;
2233 struct cifsFileInfo *cfile;
2237 * We need to be sure that all dirty pages are written as they
2238 * might fill holes on the server.
2240 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2241 inode->i_mapping->nrpages != 0) {
2242 rc = filemap_fdatawait(inode->i_mapping);
2244 mapping_set_error(inode->i_mapping, rc);
2249 cfile = find_readable_file(cifs_i, false);
2253 if (server->ops->fiemap) {
2254 rc = server->ops->fiemap(tcon, cfile, fei, start, len);
2255 cifsFileInfo_put(cfile);
2259 cifsFileInfo_put(cfile);
2263 int cifs_truncate_page(struct address_space *mapping, loff_t from)
2265 pgoff_t index = from >> PAGE_SHIFT;
2266 unsigned offset = from & (PAGE_SIZE - 1);
2270 page = grab_cache_page(mapping, index);
2274 zero_user_segment(page, offset, PAGE_SIZE);
2280 void cifs_setsize(struct inode *inode, loff_t offset)
2282 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2284 spin_lock(&inode->i_lock);
2285 i_size_write(inode, offset);
2286 spin_unlock(&inode->i_lock);
2288 /* Cached inode must be refreshed on truncate */
2290 truncate_pagecache(inode, offset);
2294 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2295 unsigned int xid, char *full_path)
2298 struct cifsFileInfo *open_file;
2299 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2300 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2301 struct tcon_link *tlink = NULL;
2302 struct cifs_tcon *tcon = NULL;
2303 struct TCP_Server_Info *server;
2306 * To avoid spurious oplock breaks from server, in the case of
2307 * inodes that we already have open, avoid doing path based
2308 * setting of file size if we can do it by handle.
2309 * This keeps our caching token (oplock) and avoids timeouts
2310 * when the local oplock break takes longer to flush
2311 * writebehind data than the SMB timeout for the SetPathInfo
2312 * request would allow
2314 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2316 tcon = tlink_tcon(open_file->tlink);
2317 server = tcon->ses->server;
2318 if (server->ops->set_file_size)
2319 rc = server->ops->set_file_size(xid, tcon, open_file,
2320 attrs->ia_size, false);
2323 cifsFileInfo_put(open_file);
2324 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2332 tlink = cifs_sb_tlink(cifs_sb);
2334 return PTR_ERR(tlink);
2335 tcon = tlink_tcon(tlink);
2336 server = tcon->ses->server;
2340 * Set file size by pathname rather than by handle either because no
2341 * valid, writeable file handle for it was found or because there was
2342 * an error setting it by handle.
2344 if (server->ops->set_path_size)
2345 rc = server->ops->set_path_size(xid, tcon, full_path,
2346 attrs->ia_size, cifs_sb, false);
2349 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2352 cifs_put_tlink(tlink);
2356 cifsInode->server_eof = attrs->ia_size;
2357 cifs_setsize(inode, attrs->ia_size);
2358 cifs_truncate_page(inode->i_mapping, inode->i_size);
2365 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2369 char *full_path = NULL;
2370 struct inode *inode = d_inode(direntry);
2371 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2372 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2373 struct tcon_link *tlink;
2374 struct cifs_tcon *pTcon;
2375 struct cifs_unix_set_info_args *args = NULL;
2376 struct cifsFileInfo *open_file;
2378 cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2379 direntry, attrs->ia_valid);
2383 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2384 attrs->ia_valid |= ATTR_FORCE;
2386 rc = setattr_prepare(direntry, attrs);
2390 full_path = build_path_from_dentry(direntry);
2391 if (full_path == NULL) {
2397 * Attempt to flush data before changing attributes. We need to do
2398 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2399 * ownership or mode then we may also need to do this. Here, we take
2400 * the safe way out and just do the flush on all setattr requests. If
2401 * the flush returns error, store it to report later and continue.
2403 * BB: This should be smarter. Why bother flushing pages that
2404 * will be truncated anyway? Also, should we error out here if
2405 * the flush returns error?
2407 rc = filemap_write_and_wait(inode->i_mapping);
2408 if (is_interrupt_error(rc)) {
2413 mapping_set_error(inode->i_mapping, rc);
2416 if (attrs->ia_valid & ATTR_SIZE) {
2417 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2422 /* skip mode change if it's just for clearing setuid/setgid */
2423 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2424 attrs->ia_valid &= ~ATTR_MODE;
2426 args = kmalloc(sizeof(*args), GFP_KERNEL);
2432 /* set up the struct */
2433 if (attrs->ia_valid & ATTR_MODE)
2434 args->mode = attrs->ia_mode;
2436 args->mode = NO_CHANGE_64;
2438 if (attrs->ia_valid & ATTR_UID)
2439 args->uid = attrs->ia_uid;
2441 args->uid = INVALID_UID; /* no change */
2443 if (attrs->ia_valid & ATTR_GID)
2444 args->gid = attrs->ia_gid;
2446 args->gid = INVALID_GID; /* no change */
2448 if (attrs->ia_valid & ATTR_ATIME)
2449 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2451 args->atime = NO_CHANGE_64;
2453 if (attrs->ia_valid & ATTR_MTIME)
2454 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2456 args->mtime = NO_CHANGE_64;
2458 if (attrs->ia_valid & ATTR_CTIME)
2459 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2461 args->ctime = NO_CHANGE_64;
2464 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2466 u16 nfid = open_file->fid.netfid;
2467 u32 npid = open_file->pid;
2468 pTcon = tlink_tcon(open_file->tlink);
2469 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2470 cifsFileInfo_put(open_file);
2472 tlink = cifs_sb_tlink(cifs_sb);
2473 if (IS_ERR(tlink)) {
2474 rc = PTR_ERR(tlink);
2477 pTcon = tlink_tcon(tlink);
2478 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2480 cifs_remap(cifs_sb));
2481 cifs_put_tlink(tlink);
2487 if ((attrs->ia_valid & ATTR_SIZE) &&
2488 attrs->ia_size != i_size_read(inode))
2489 truncate_setsize(inode, attrs->ia_size);
2491 setattr_copy(inode, attrs);
2492 mark_inode_dirty(inode);
2494 /* force revalidate when any of these times are set since some
2495 of the fs types (eg ext3, fat) do not have fine enough
2496 time granularity to match protocol, and we do not have a
2497 a way (yet) to query the server fs's time granularity (and
2498 whether it rounds times down).
2500 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2501 cifsInode->time = 0;
2510 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2513 kuid_t uid = INVALID_UID;
2514 kgid_t gid = INVALID_GID;
2515 struct inode *inode = d_inode(direntry);
2516 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2517 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2518 struct cifsFileInfo *wfile;
2519 struct cifs_tcon *tcon;
2520 char *full_path = NULL;
2523 __u64 mode = NO_CHANGE_64;
2527 cifs_dbg(FYI, "setattr on file %pd attrs->ia_valid 0x%x\n",
2528 direntry, attrs->ia_valid);
2530 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2531 attrs->ia_valid |= ATTR_FORCE;
2533 rc = setattr_prepare(direntry, attrs);
2539 full_path = build_path_from_dentry(direntry);
2540 if (full_path == NULL) {
2547 * Attempt to flush data before changing attributes. We need to do
2548 * this for ATTR_SIZE and ATTR_MTIME. If the flush of the data
2549 * returns error, store it to report later and continue.
2551 * BB: This should be smarter. Why bother flushing pages that
2552 * will be truncated anyway? Also, should we error out here if
2553 * the flush returns error? Do we need to check for ATTR_MTIME_SET flag?
2555 if (attrs->ia_valid & (ATTR_MTIME | ATTR_SIZE | ATTR_CTIME)) {
2556 rc = filemap_write_and_wait(inode->i_mapping);
2557 if (is_interrupt_error(rc)) {
2559 goto cifs_setattr_exit;
2561 mapping_set_error(inode->i_mapping, rc);
2566 if ((attrs->ia_valid & ATTR_MTIME) &&
2567 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2568 rc = cifs_get_writable_file(cifsInode, FIND_WR_ANY, &wfile);
2570 tcon = tlink_tcon(wfile->tlink);
2571 rc = tcon->ses->server->ops->flush(xid, tcon, &wfile->fid);
2572 cifsFileInfo_put(wfile);
2574 goto cifs_setattr_exit;
2575 } else if (rc != -EBADF)
2576 goto cifs_setattr_exit;
2581 if (attrs->ia_valid & ATTR_SIZE) {
2582 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2584 goto cifs_setattr_exit;
2587 if (attrs->ia_valid & ATTR_UID)
2588 uid = attrs->ia_uid;
2590 if (attrs->ia_valid & ATTR_GID)
2591 gid = attrs->ia_gid;
2593 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2594 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2595 if (uid_valid(uid) || gid_valid(gid)) {
2596 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2599 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2601 goto cifs_setattr_exit;
2605 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2606 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2608 /* skip mode change if it's just for clearing setuid/setgid */
2609 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2610 attrs->ia_valid &= ~ATTR_MODE;
2612 if (attrs->ia_valid & ATTR_MODE) {
2613 mode = attrs->ia_mode;
2615 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2616 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2617 rc = id_mode_to_cifs_acl(inode, full_path, mode,
2618 INVALID_UID, INVALID_GID);
2620 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2622 goto cifs_setattr_exit;
2625 if (((mode & S_IWUGO) == 0) &&
2626 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2628 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2630 /* fix up mode if we're not using dynperm */
2631 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2632 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2633 } else if ((mode & S_IWUGO) &&
2634 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2636 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2637 /* Attributes of 0 are ignored */
2639 dosattr |= ATTR_NORMAL;
2641 /* reset local inode permissions to normal */
2642 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2643 attrs->ia_mode &= ~(S_IALLUGO);
2644 if (S_ISDIR(inode->i_mode))
2646 cifs_sb->mnt_dir_mode;
2649 cifs_sb->mnt_file_mode;
2651 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2652 /* ignore mode change - ATTR_READONLY hasn't changed */
2653 attrs->ia_valid &= ~ATTR_MODE;
2657 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2658 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2659 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2660 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2662 /* Even if error on time set, no sense failing the call if
2663 the server would set the time to a reasonable value anyway,
2664 and this check ensures that we are not being called from
2665 sys_utimes in which case we ought to fail the call back to
2666 the user when the server rejects the call */
2667 if ((rc) && (attrs->ia_valid &
2668 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2672 /* do not need local check to inode_check_ok since the server does
2675 goto cifs_setattr_exit;
2677 if ((attrs->ia_valid & ATTR_SIZE) &&
2678 attrs->ia_size != i_size_read(inode))
2679 truncate_setsize(inode, attrs->ia_size);
2681 setattr_copy(inode, attrs);
2682 mark_inode_dirty(inode);
2691 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2693 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
2694 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2696 if (pTcon->unix_ext)
2697 return cifs_setattr_unix(direntry, attrs);
2699 return cifs_setattr_nounix(direntry, attrs);
2701 /* BB: add cifs_setattr_legacy for really old servers */
2705 void cifs_delete_inode(struct inode *inode)
2707 cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2708 /* may have to add back in if and when safe distributed caching of
2709 directories added e.g. via FindNotify */