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->maxBuf <
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);
100 cifs_dbg(FYI, "%s: revalidating inode %llu\n",
101 __func__, cifs_i->uniqueid);
103 if (inode->i_state & I_NEW) {
104 cifs_dbg(FYI, "%s: inode %llu is new\n",
105 __func__, cifs_i->uniqueid);
109 /* don't bother with revalidation if we have an oplock */
110 if (CIFS_CACHE_READ(cifs_i)) {
111 cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
112 __func__, cifs_i->uniqueid);
116 /* revalidate if mtime or size have changed */
117 ts = timespec64_to_timespec(inode->i_mtime);
118 if (timespec_equal(&ts, &fattr->cf_mtime) &&
119 cifs_i->server_eof == fattr->cf_eof) {
120 cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
121 __func__, cifs_i->uniqueid);
125 cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
126 __func__, cifs_i->uniqueid);
127 set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags);
131 * copy nlink to the inode, unless it wasn't provided. Provide
132 * sane values if we don't have an existing one and none was provided
135 cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
138 * if we're in a situation where we can't trust what we
139 * got from the server (readdir, some non-unix cases)
140 * fake reasonable values
142 if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
143 /* only provide fake values on a new inode */
144 if (inode->i_state & I_NEW) {
145 if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
153 /* we trust the server, so update it */
154 set_nlink(inode, fattr->cf_nlink);
157 /* populate an inode with info from a cifs_fattr struct */
159 cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
161 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
162 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
164 cifs_revalidate_cache(inode, fattr);
166 spin_lock(&inode->i_lock);
167 inode->i_atime = timespec_to_timespec64(fattr->cf_atime);
168 inode->i_mtime = timespec_to_timespec64(fattr->cf_mtime);
169 inode->i_ctime = timespec_to_timespec64(fattr->cf_ctime);
170 inode->i_rdev = fattr->cf_rdev;
171 cifs_nlink_fattr_to_inode(inode, fattr);
172 inode->i_uid = fattr->cf_uid;
173 inode->i_gid = fattr->cf_gid;
175 /* if dynperm is set, don't clobber existing mode */
176 if (inode->i_state & I_NEW ||
177 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
178 inode->i_mode = fattr->cf_mode;
180 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
182 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
185 cifs_i->time = jiffies;
187 if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING)
188 set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
190 clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
192 cifs_i->server_eof = fattr->cf_eof;
194 * Can't safely change the file size here if the client is writing to
195 * it due to potential races.
197 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
198 i_size_write(inode, fattr->cf_eof);
201 * i_blocks is not related to (i_size / i_blksize),
202 * but instead 512 byte (2**9) size is required for
203 * calculating num blocks.
205 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
207 spin_unlock(&inode->i_lock);
209 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
210 inode->i_flags |= S_AUTOMOUNT;
211 if (inode->i_state & I_NEW)
216 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
218 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
220 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
223 fattr->cf_uniqueid = iunique(sb, ROOT_I);
226 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
228 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
229 struct cifs_sb_info *cifs_sb)
231 memset(fattr, 0, sizeof(*fattr));
232 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
233 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
234 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
236 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
237 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
238 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
239 /* old POSIX extensions don't get create time */
241 fattr->cf_mode = le64_to_cpu(info->Permissions);
244 * Since we set the inode type below we need to mask off
245 * to avoid strange results if bits set above.
247 fattr->cf_mode &= ~S_IFMT;
248 switch (le32_to_cpu(info->Type)) {
250 fattr->cf_mode |= S_IFREG;
251 fattr->cf_dtype = DT_REG;
254 fattr->cf_mode |= S_IFLNK;
255 fattr->cf_dtype = DT_LNK;
258 fattr->cf_mode |= S_IFDIR;
259 fattr->cf_dtype = DT_DIR;
262 fattr->cf_mode |= S_IFCHR;
263 fattr->cf_dtype = DT_CHR;
264 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
265 le64_to_cpu(info->DevMinor) & MINORMASK);
268 fattr->cf_mode |= S_IFBLK;
269 fattr->cf_dtype = DT_BLK;
270 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
271 le64_to_cpu(info->DevMinor) & MINORMASK);
274 fattr->cf_mode |= S_IFIFO;
275 fattr->cf_dtype = DT_FIFO;
278 fattr->cf_mode |= S_IFSOCK;
279 fattr->cf_dtype = DT_SOCK;
282 /* safest to call it a file if we do not know */
283 fattr->cf_mode |= S_IFREG;
284 fattr->cf_dtype = DT_REG;
285 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
289 fattr->cf_uid = cifs_sb->mnt_uid;
290 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
291 u64 id = le64_to_cpu(info->Uid);
292 if (id < ((uid_t)-1)) {
293 kuid_t uid = make_kuid(&init_user_ns, id);
299 fattr->cf_gid = cifs_sb->mnt_gid;
300 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
301 u64 id = le64_to_cpu(info->Gid);
302 if (id < ((gid_t)-1)) {
303 kgid_t gid = make_kgid(&init_user_ns, id);
309 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
313 * Fill a cifs_fattr struct with fake inode info.
315 * Needed to setup cifs_fattr data for the directory which is the
316 * junction to the new submount (ie to setup the fake directory
317 * which represents a DFS referral).
320 cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
322 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
324 cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
326 memset(fattr, 0, sizeof(*fattr));
327 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
328 fattr->cf_uid = cifs_sb->mnt_uid;
329 fattr->cf_gid = cifs_sb->mnt_gid;
330 ktime_get_real_ts(&fattr->cf_mtime);
331 fattr->cf_mtime = timespec_trunc(fattr->cf_mtime, sb->s_time_gran);
332 fattr->cf_atime = fattr->cf_ctime = fattr->cf_mtime;
334 fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
338 cifs_get_file_info_unix(struct file *filp)
342 FILE_UNIX_BASIC_INFO find_data;
343 struct cifs_fattr fattr;
344 struct inode *inode = file_inode(filp);
345 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
346 struct cifsFileInfo *cfile = filp->private_data;
347 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
350 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
352 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
353 } else if (rc == -EREMOTE) {
354 cifs_create_dfs_fattr(&fattr, inode->i_sb);
358 cifs_fattr_to_inode(inode, &fattr);
363 int cifs_get_inode_info_unix(struct inode **pinode,
364 const unsigned char *full_path,
365 struct super_block *sb, unsigned int xid)
368 FILE_UNIX_BASIC_INFO find_data;
369 struct cifs_fattr fattr;
370 struct cifs_tcon *tcon;
371 struct tcon_link *tlink;
372 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
374 cifs_dbg(FYI, "Getting info on %s\n", full_path);
376 tlink = cifs_sb_tlink(cifs_sb);
378 return PTR_ERR(tlink);
379 tcon = tlink_tcon(tlink);
381 /* could have done a find first instead but this returns more info */
382 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
383 cifs_sb->local_nls, cifs_remap(cifs_sb));
384 cifs_put_tlink(tlink);
387 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
388 } else if (rc == -EREMOTE) {
389 cifs_create_dfs_fattr(&fattr, sb);
395 /* check for Minshall+French symlinks */
396 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
397 int tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
400 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
403 if (*pinode == NULL) {
405 cifs_fill_uniqueid(sb, &fattr);
406 *pinode = cifs_iget(sb, &fattr);
410 /* we already have inode, update it */
412 /* if uniqueid is different, return error */
413 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
414 CIFS_I(*pinode)->uniqueid != fattr.cf_uniqueid)) {
419 /* if filetype is different, return error */
420 if (unlikely(((*pinode)->i_mode & S_IFMT) !=
421 (fattr.cf_mode & S_IFMT))) {
426 cifs_fattr_to_inode(*pinode, &fattr);
434 cifs_sfu_type(struct cifs_fattr *fattr, const char *path,
435 struct cifs_sb_info *cifs_sb, unsigned int xid)
439 struct tcon_link *tlink;
440 struct cifs_tcon *tcon;
442 struct cifs_open_parms oparms;
443 struct cifs_io_parms io_parms;
445 unsigned int bytes_read;
447 int buf_type = CIFS_NO_BUFFER;
451 fattr->cf_mode &= ~S_IFMT;
453 if (fattr->cf_eof == 0) {
454 fattr->cf_mode |= S_IFIFO;
455 fattr->cf_dtype = DT_FIFO;
457 } else if (fattr->cf_eof < 8) {
458 fattr->cf_mode |= S_IFREG;
459 fattr->cf_dtype = DT_REG;
460 return -EINVAL; /* EOPNOTSUPP? */
463 tlink = cifs_sb_tlink(cifs_sb);
465 return PTR_ERR(tlink);
466 tcon = tlink_tcon(tlink);
469 oparms.cifs_sb = cifs_sb;
470 oparms.desired_access = GENERIC_READ;
471 oparms.create_options = CREATE_NOT_DIR;
472 oparms.disposition = FILE_OPEN;
475 oparms.reconnect = false;
477 if (tcon->ses->server->oplocks)
481 rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);
483 cifs_dbg(FYI, "check sfu type of %s, open rc = %d\n", path, rc);
484 cifs_put_tlink(tlink);
489 io_parms.netfid = fid.netfid;
490 io_parms.pid = current->tgid;
491 io_parms.tcon = tcon;
493 io_parms.length = 24;
495 rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,
496 &bytes_read, &pbuf, &buf_type);
497 if ((rc == 0) && (bytes_read >= 8)) {
498 if (memcmp("IntxBLK", pbuf, 8) == 0) {
499 cifs_dbg(FYI, "Block device\n");
500 fattr->cf_mode |= S_IFBLK;
501 fattr->cf_dtype = DT_BLK;
502 if (bytes_read == 24) {
503 /* we have enough to decode dev num */
504 __u64 mjr; /* major */
505 __u64 mnr; /* minor */
506 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
507 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
508 fattr->cf_rdev = MKDEV(mjr, mnr);
510 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
511 cifs_dbg(FYI, "Char device\n");
512 fattr->cf_mode |= S_IFCHR;
513 fattr->cf_dtype = DT_CHR;
514 if (bytes_read == 24) {
515 /* we have enough to decode dev num */
516 __u64 mjr; /* major */
517 __u64 mnr; /* minor */
518 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
519 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
520 fattr->cf_rdev = MKDEV(mjr, mnr);
522 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
523 cifs_dbg(FYI, "Symlink\n");
524 fattr->cf_mode |= S_IFLNK;
525 fattr->cf_dtype = DT_LNK;
527 fattr->cf_mode |= S_IFREG; /* file? */
528 fattr->cf_dtype = DT_REG;
532 fattr->cf_mode |= S_IFREG; /* then it is a file */
533 fattr->cf_dtype = DT_REG;
534 rc = -EOPNOTSUPP; /* or some unknown SFU type */
537 tcon->ses->server->ops->close(xid, tcon, &fid);
538 cifs_put_tlink(tlink);
542 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
545 * Fetch mode bits as provided by SFU.
547 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
549 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
550 struct cifs_sb_info *cifs_sb, unsigned int xid)
552 #ifdef CONFIG_CIFS_XATTR
556 struct tcon_link *tlink;
557 struct cifs_tcon *tcon;
559 tlink = cifs_sb_tlink(cifs_sb);
561 return PTR_ERR(tlink);
562 tcon = tlink_tcon(tlink);
564 if (tcon->ses->server->ops->query_all_EAs == NULL) {
565 cifs_put_tlink(tlink);
569 rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
570 "SETFILEBITS", ea_value, 4 /* size of buf */,
572 cifs_put_tlink(tlink);
576 mode = le32_to_cpu(*((__le32 *)ea_value));
577 fattr->cf_mode &= ~SFBITS_MASK;
578 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
579 mode, fattr->cf_mode);
580 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
581 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
590 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
592 cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
593 struct super_block *sb, bool adjust_tz,
596 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
597 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
599 memset(fattr, 0, sizeof(*fattr));
600 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
601 if (info->DeletePending)
602 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
604 if (info->LastAccessTime)
605 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
607 ktime_get_real_ts(&fattr->cf_atime);
608 fattr->cf_atime = timespec_trunc(fattr->cf_atime, sb->s_time_gran);
611 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
612 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
615 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
616 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
619 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
620 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
621 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
623 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
626 fattr->cf_mode = S_IFLNK;
627 fattr->cf_dtype = DT_LNK;
628 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
629 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
630 fattr->cf_dtype = DT_DIR;
632 * Server can return wrong NumberOfLinks value for directories
633 * when Unix extensions are disabled - fake it.
636 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
638 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
639 fattr->cf_dtype = DT_REG;
641 /* clear write bits if ATTR_READONLY is set */
642 if (fattr->cf_cifsattrs & ATTR_READONLY)
643 fattr->cf_mode &= ~(S_IWUGO);
646 * Don't accept zero nlink from non-unix servers unless
647 * delete is pending. Instead mark it as unknown.
649 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
650 !info->DeletePending) {
651 cifs_dbg(1, "bogus file nlink value %u\n",
653 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
657 fattr->cf_uid = cifs_sb->mnt_uid;
658 fattr->cf_gid = cifs_sb->mnt_gid;
662 cifs_get_file_info(struct file *filp)
666 FILE_ALL_INFO find_data;
667 struct cifs_fattr fattr;
668 struct inode *inode = file_inode(filp);
669 struct cifsFileInfo *cfile = filp->private_data;
670 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
671 struct TCP_Server_Info *server = tcon->ses->server;
673 if (!server->ops->query_file_info)
677 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
680 cifs_all_info_to_fattr(&fattr, &find_data, inode->i_sb, false,
684 cifs_create_dfs_fattr(&fattr, inode->i_sb);
690 * FIXME: legacy server -- fall back to path-based call?
691 * for now, just skip revalidating and mark inode for
695 CIFS_I(inode)->time = 0;
701 * don't bother with SFU junk here -- just mark inode as needing
704 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
705 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
706 cifs_fattr_to_inode(inode, &fattr);
712 /* Simple function to return a 64 bit hash of string. Rarely called */
713 static __u64 simple_hashstr(const char *str)
715 const __u64 hash_mult = 1125899906842597ULL; /* a big enough prime */
719 hash = (hash + (__u64) *str++) * hash_mult;
725 cifs_get_inode_info(struct inode **inode, const char *full_path,
726 FILE_ALL_INFO *data, struct super_block *sb, int xid,
727 const struct cifs_fid *fid)
729 bool validinum = false;
731 int rc = 0, tmprc = ENOSYS;
732 struct cifs_tcon *tcon;
733 struct TCP_Server_Info *server;
734 struct tcon_link *tlink;
735 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
737 bool adjust_tz = false;
738 struct cifs_fattr fattr;
739 struct cifs_search_info *srchinf = NULL;
740 bool symlink = false;
742 tlink = cifs_sb_tlink(cifs_sb);
744 return PTR_ERR(tlink);
745 tcon = tlink_tcon(tlink);
746 server = tcon->ses->server;
748 cifs_dbg(FYI, "Getting info on %s\n", full_path);
750 if ((data == NULL) && (*inode != NULL)) {
751 if (CIFS_CACHE_READ(CIFS_I(*inode)) &&
752 CIFS_I(*inode)->time != 0) {
753 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
758 /* if inode info is not passed, get it from server */
760 if (!server->ops->query_path_info) {
764 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
769 data = (FILE_ALL_INFO *)buf;
770 rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path,
771 data, &adjust_tz, &symlink);
775 cifs_all_info_to_fattr(&fattr, data, sb, adjust_tz,
777 } else if (rc == -EREMOTE) {
778 cifs_create_dfs_fattr(&fattr, sb);
780 } else if (rc == -EACCES && backup_cred(cifs_sb)) {
781 srchinf = kzalloc(sizeof(struct cifs_search_info),
783 if (srchinf == NULL) {
788 srchinf->endOfSearch = false;
789 srchinf->info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
791 srchflgs = CIFS_SEARCH_CLOSE_ALWAYS |
792 CIFS_SEARCH_CLOSE_AT_END |
793 CIFS_SEARCH_BACKUP_SEARCH;
795 rc = CIFSFindFirst(xid, tcon, full_path,
796 cifs_sb, NULL, srchflgs, srchinf, false);
799 (FILE_ALL_INFO *)srchinf->srch_entries_start;
801 cifs_dir_info_to_fattr(&fattr,
802 (FILE_DIRECTORY_INFO *)data, cifs_sb);
803 fattr.cf_uniqueid = le64_to_cpu(
804 ((SEARCH_ID_FULL_DIR_INFO *)data)->UniqueId);
807 cifs_buf_release(srchinf->ntwrk_buf_start);
816 * If an inode wasn't passed in, then get the inode number
818 * Is an i_ino of zero legal? Can we use that to check if the server
819 * supports returning inode numbers? Are there other sanity checks we
820 * can use to ensure that the server is really filling in that field?
822 if (*inode == NULL) {
823 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
824 if (validinum == false) {
825 if (server->ops->get_srv_inum)
826 tmprc = server->ops->get_srv_inum(xid,
827 tcon, cifs_sb, full_path,
828 &fattr.cf_uniqueid, data);
830 cifs_dbg(FYI, "GetSrvInodeNum rc %d\n",
832 fattr.cf_uniqueid = iunique(sb, ROOT_I);
833 cifs_autodisable_serverino(cifs_sb);
834 } else if ((fattr.cf_uniqueid == 0) &&
835 strlen(full_path) == 0) {
836 /* some servers ret bad root ino ie 0 */
837 cifs_dbg(FYI, "Invalid (0) inodenum\n");
839 CIFS_FATTR_FAKE_ROOT_INO;
841 simple_hashstr(tcon->treeName);
845 fattr.cf_uniqueid = iunique(sb, ROOT_I);
847 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
848 validinum == false && server->ops->get_srv_inum) {
850 * Pass a NULL tcon to ensure we don't make a round
851 * trip to the server. This only works for SMB2+.
853 tmprc = server->ops->get_srv_inum(xid,
854 NULL, cifs_sb, full_path,
855 &fattr.cf_uniqueid, data);
857 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
858 else if ((fattr.cf_uniqueid == 0) &&
859 strlen(full_path) == 0) {
861 * Reuse existing root inode num since
862 * inum zero for root causes ls of . and .. to
865 cifs_dbg(FYI, "Srv ret 0 inode num for root\n");
866 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
869 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
872 /* query for SFU type info if supported and needed */
873 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
874 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
875 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
877 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
880 #ifdef CONFIG_CIFS_ACL
881 /* fill in 0777 bits from ACL */
882 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
883 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, full_path, fid);
885 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
890 #endif /* CONFIG_CIFS_ACL */
892 /* fill in remaining high mode bits e.g. SUID, VTX */
893 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
894 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
896 /* check for Minshall+French symlinks */
897 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
898 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
901 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
905 *inode = cifs_iget(sb, &fattr);
909 /* we already have inode, update it */
911 /* if uniqueid is different, return error */
912 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
913 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
918 /* if filetype is different, return error */
919 if (unlikely(((*inode)->i_mode & S_IFMT) !=
920 (fattr.cf_mode & S_IFMT))) {
925 cifs_fattr_to_inode(*inode, &fattr);
929 if ((*inode) && ((*inode)->i_ino == 0))
930 cifs_dbg(FYI, "inode number of zero returned\n");
933 cifs_put_tlink(tlink);
937 static const struct inode_operations cifs_ipc_inode_ops = {
938 .lookup = cifs_lookup,
942 cifs_find_inode(struct inode *inode, void *opaque)
944 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
946 /* don't match inode with different uniqueid */
947 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
950 /* use createtime like an i_generation field */
951 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
954 /* don't match inode of different type */
955 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
958 /* if it's not a directory or has no dentries, then flag it */
959 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
960 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
966 cifs_init_inode(struct inode *inode, void *opaque)
968 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
970 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
971 CIFS_I(inode)->createtime = fattr->cf_createtime;
976 * walk dentry list for an inode and report whether it has aliases that
977 * are hashed. We use this to determine if a directory inode can actually
981 inode_has_hashed_dentries(struct inode *inode)
983 struct dentry *dentry;
985 spin_lock(&inode->i_lock);
986 hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
987 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
988 spin_unlock(&inode->i_lock);
992 spin_unlock(&inode->i_lock);
996 /* Given fattrs, get a corresponding inode */
998 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
1001 struct inode *inode;
1004 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
1006 /* hash down to 32-bits on 32-bit arch */
1007 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
1009 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
1011 /* was there a potentially problematic inode collision? */
1012 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
1013 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
1015 if (inode_has_hashed_dentries(inode)) {
1016 cifs_autodisable_serverino(CIFS_SB(sb));
1018 fattr->cf_uniqueid = iunique(sb, ROOT_I);
1019 goto retry_iget5_locked;
1023 cifs_fattr_to_inode(inode, fattr);
1024 if (sb->s_flags & SB_NOATIME)
1025 inode->i_flags |= S_NOATIME | S_NOCMTIME;
1026 if (inode->i_state & I_NEW) {
1027 inode->i_ino = hash;
1028 #ifdef CONFIG_CIFS_FSCACHE
1029 /* initialize per-inode cache cookie pointer */
1030 CIFS_I(inode)->fscache = NULL;
1032 unlock_new_inode(inode);
1039 /* gets root inode */
1040 struct inode *cifs_root_iget(struct super_block *sb)
1043 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1044 struct inode *inode = NULL;
1046 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1050 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
1051 && cifs_sb->prepath) {
1052 len = strlen(cifs_sb->prepath);
1053 path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
1055 return ERR_PTR(-ENOMEM);
1057 memcpy(path+1, cifs_sb->prepath, len);
1059 path = kstrdup("", GFP_KERNEL);
1061 return ERR_PTR(-ENOMEM);
1065 if (tcon->unix_ext) {
1066 rc = cifs_get_inode_info_unix(&inode, path, sb, xid);
1067 /* some servers mistakenly claim POSIX support */
1068 if (rc != -EOPNOTSUPP)
1070 cifs_dbg(VFS, "server does not support POSIX extensions");
1071 tcon->unix_ext = false;
1074 convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
1075 rc = cifs_get_inode_info(&inode, path, NULL, sb, xid, NULL);
1079 inode = ERR_PTR(rc);
1083 #ifdef CONFIG_CIFS_FSCACHE
1084 /* populate tcon->resource_id */
1085 tcon->resource_id = CIFS_I(inode)->uniqueid;
1088 if (rc && tcon->pipe) {
1089 cifs_dbg(FYI, "ipc connection - fake read inode\n");
1090 spin_lock(&inode->i_lock);
1091 inode->i_mode |= S_IFDIR;
1092 set_nlink(inode, 2);
1093 inode->i_op = &cifs_ipc_inode_ops;
1094 inode->i_fop = &simple_dir_operations;
1095 inode->i_uid = cifs_sb->mnt_uid;
1096 inode->i_gid = cifs_sb->mnt_gid;
1097 spin_unlock(&inode->i_lock);
1100 inode = ERR_PTR(rc);
1110 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1111 char *full_path, __u32 dosattr)
1113 bool set_time = false;
1114 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1115 struct TCP_Server_Info *server;
1116 FILE_BASIC_INFO info_buf;
1121 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1122 if (!server->ops->set_file_info)
1125 if (attrs->ia_valid & ATTR_ATIME) {
1127 info_buf.LastAccessTime =
1128 cpu_to_le64(cifs_UnixTimeToNT(timespec64_to_timespec(attrs->ia_atime)));
1130 info_buf.LastAccessTime = 0;
1132 if (attrs->ia_valid & ATTR_MTIME) {
1134 info_buf.LastWriteTime =
1135 cpu_to_le64(cifs_UnixTimeToNT(timespec64_to_timespec(attrs->ia_mtime)));
1137 info_buf.LastWriteTime = 0;
1140 * Samba throws this field away, but windows may actually use it.
1141 * Do not set ctime unless other time stamps are changed explicitly
1142 * (i.e. by utimes()) since we would then have a mix of client and
1145 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1146 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1147 info_buf.ChangeTime =
1148 cpu_to_le64(cifs_UnixTimeToNT(timespec64_to_timespec(attrs->ia_ctime)));
1150 info_buf.ChangeTime = 0;
1152 info_buf.CreationTime = 0; /* don't change */
1153 info_buf.Attributes = cpu_to_le32(dosattr);
1155 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1159 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1160 * and rename it to a random name that hopefully won't conflict with
1164 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1165 const unsigned int xid)
1169 struct cifs_fid fid;
1170 struct cifs_open_parms oparms;
1171 struct inode *inode = d_inode(dentry);
1172 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1173 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1174 struct tcon_link *tlink;
1175 struct cifs_tcon *tcon;
1176 __u32 dosattr, origattr;
1177 FILE_BASIC_INFO *info_buf = NULL;
1179 tlink = cifs_sb_tlink(cifs_sb);
1181 return PTR_ERR(tlink);
1182 tcon = tlink_tcon(tlink);
1185 * We cannot rename the file if the server doesn't support
1186 * CAP_INFOLEVEL_PASSTHRU
1188 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1194 oparms.cifs_sb = cifs_sb;
1195 oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1196 oparms.create_options = CREATE_NOT_DIR;
1197 oparms.disposition = FILE_OPEN;
1198 oparms.path = full_path;
1200 oparms.reconnect = false;
1202 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1206 origattr = cifsInode->cifsAttrs;
1208 origattr |= ATTR_NORMAL;
1210 dosattr = origattr & ~ATTR_READONLY;
1212 dosattr |= ATTR_NORMAL;
1213 dosattr |= ATTR_HIDDEN;
1215 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1216 if (dosattr != origattr) {
1217 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1218 if (info_buf == NULL) {
1222 info_buf->Attributes = cpu_to_le32(dosattr);
1223 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1225 /* although we would like to mark the file hidden
1226 if that fails we will still try to rename it */
1228 cifsInode->cifsAttrs = dosattr;
1230 dosattr = origattr; /* since not able to change them */
1233 /* rename the file */
1234 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1236 cifs_remap(cifs_sb));
1242 /* try to set DELETE_ON_CLOSE */
1243 if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1244 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1247 * some samba versions return -ENOENT when we try to set the
1248 * file disposition here. Likely a samba bug, but work around
1249 * it for now. This means that some cifsXXX files may hang
1250 * around after they shouldn't.
1252 * BB: remove this hack after more servers have the fix
1260 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1264 CIFSSMBClose(xid, tcon, fid.netfid);
1267 cifs_put_tlink(tlink);
1271 * reset everything back to the original state. Don't bother
1272 * dealing with errors here since we can't do anything about
1276 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1277 cifs_sb->local_nls, cifs_remap(cifs_sb));
1279 if (dosattr != origattr) {
1280 info_buf->Attributes = cpu_to_le32(origattr);
1281 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1283 cifsInode->cifsAttrs = origattr;
1289 /* copied from fs/nfs/dir.c with small changes */
1291 cifs_drop_nlink(struct inode *inode)
1293 spin_lock(&inode->i_lock);
1294 if (inode->i_nlink > 0)
1296 spin_unlock(&inode->i_lock);
1300 * If d_inode(dentry) is null (usually meaning the cached dentry
1301 * is a negative dentry) then we would attempt a standard SMB delete, but
1302 * if that fails we can not attempt the fall back mechanisms on EACCESS
1303 * but will return the EACCESS to the caller. Note that the VFS does not call
1304 * unlink on negative dentries currently.
1306 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1310 char *full_path = NULL;
1311 struct inode *inode = d_inode(dentry);
1312 struct cifsInodeInfo *cifs_inode;
1313 struct super_block *sb = dir->i_sb;
1314 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1315 struct tcon_link *tlink;
1316 struct cifs_tcon *tcon;
1317 struct TCP_Server_Info *server;
1318 struct iattr *attrs = NULL;
1319 __u32 dosattr = 0, origattr = 0;
1321 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1323 tlink = cifs_sb_tlink(cifs_sb);
1325 return PTR_ERR(tlink);
1326 tcon = tlink_tcon(tlink);
1327 server = tcon->ses->server;
1331 /* Unlink can be called from rename so we can not take the
1332 * sb->s_vfs_rename_mutex here */
1333 full_path = build_path_from_dentry(dentry);
1334 if (full_path == NULL) {
1339 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1340 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1341 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1342 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1343 cifs_remap(cifs_sb));
1344 cifs_dbg(FYI, "posix del rc %d\n", rc);
1345 if ((rc == 0) || (rc == -ENOENT))
1346 goto psx_del_no_retry;
1350 if (!server->ops->unlink) {
1352 goto psx_del_no_retry;
1355 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1360 cifs_drop_nlink(inode);
1361 } else if (rc == -ENOENT) {
1363 } else if (rc == -EBUSY) {
1364 if (server->ops->rename_pending_delete) {
1365 rc = server->ops->rename_pending_delete(full_path,
1368 cifs_drop_nlink(inode);
1370 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1371 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1372 if (attrs == NULL) {
1377 /* try to reset dos attributes */
1378 cifs_inode = CIFS_I(inode);
1379 origattr = cifs_inode->cifsAttrs;
1381 origattr |= ATTR_NORMAL;
1382 dosattr = origattr & ~ATTR_READONLY;
1384 dosattr |= ATTR_NORMAL;
1385 dosattr |= ATTR_HIDDEN;
1387 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1391 goto retry_std_delete;
1394 /* undo the setattr if we errored out and it's needed */
1395 if (rc != 0 && dosattr != 0)
1396 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1400 cifs_inode = CIFS_I(inode);
1401 cifs_inode->time = 0; /* will force revalidate to get info
1403 inode->i_ctime = current_time(inode);
1405 dir->i_ctime = dir->i_mtime = current_time(dir);
1406 cifs_inode = CIFS_I(dir);
1407 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1412 cifs_put_tlink(tlink);
1417 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1418 const char *full_path, struct cifs_sb_info *cifs_sb,
1419 struct cifs_tcon *tcon, const unsigned int xid)
1422 struct inode *inode = NULL;
1425 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1428 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1435 * setting nlink not necessary except in cases where we failed to get it
1436 * from the server or was set bogus. Also, since this is a brand new
1437 * inode, no need to grab the i_lock before setting the i_nlink.
1439 if (inode->i_nlink < 2)
1440 set_nlink(inode, 2);
1441 mode &= ~current_umask();
1442 /* must turn on setgid bit if parent dir has it */
1443 if (parent->i_mode & S_ISGID)
1446 if (tcon->unix_ext) {
1447 struct cifs_unix_set_info_args args = {
1449 .ctime = NO_CHANGE_64,
1450 .atime = NO_CHANGE_64,
1451 .mtime = NO_CHANGE_64,
1454 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1455 args.uid = current_fsuid();
1456 if (parent->i_mode & S_ISGID)
1457 args.gid = parent->i_gid;
1459 args.gid = current_fsgid();
1461 args.uid = INVALID_UID; /* no change */
1462 args.gid = INVALID_GID; /* no change */
1464 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1466 cifs_remap(cifs_sb));
1468 struct TCP_Server_Info *server = tcon->ses->server;
1469 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1470 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1471 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1473 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1474 inode->i_mode = (mode | S_IFDIR);
1476 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1477 inode->i_uid = current_fsuid();
1478 if (inode->i_mode & S_ISGID)
1479 inode->i_gid = parent->i_gid;
1481 inode->i_gid = current_fsgid();
1484 d_instantiate(dentry, inode);
1489 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1490 const char *full_path, struct cifs_sb_info *cifs_sb,
1491 struct cifs_tcon *tcon, const unsigned int xid)
1495 FILE_UNIX_BASIC_INFO *info = NULL;
1496 struct inode *newinode = NULL;
1497 struct cifs_fattr fattr;
1499 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1502 goto posix_mkdir_out;
1505 mode &= ~current_umask();
1506 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1507 NULL /* netfid */, info, &oplock, full_path,
1508 cifs_sb->local_nls, cifs_remap(cifs_sb));
1509 if (rc == -EOPNOTSUPP)
1510 goto posix_mkdir_out;
1512 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1514 goto posix_mkdir_out;
1517 if (info->Type == cpu_to_le32(-1))
1518 /* no return info, go query for it */
1519 goto posix_mkdir_get_info;
1521 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1522 * need to set uid/gid.
1525 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1526 cifs_fill_uniqueid(inode->i_sb, &fattr);
1527 newinode = cifs_iget(inode->i_sb, &fattr);
1529 goto posix_mkdir_get_info;
1531 d_instantiate(dentry, newinode);
1533 #ifdef CONFIG_CIFS_DEBUG2
1534 cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1535 dentry, dentry, newinode);
1537 if (newinode->i_nlink != 2)
1538 cifs_dbg(FYI, "unexpected number of links %d\n",
1545 posix_mkdir_get_info:
1546 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1548 goto posix_mkdir_out;
1551 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1555 struct cifs_sb_info *cifs_sb;
1556 struct tcon_link *tlink;
1557 struct cifs_tcon *tcon;
1558 struct TCP_Server_Info *server;
1561 cifs_dbg(FYI, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1564 cifs_sb = CIFS_SB(inode->i_sb);
1565 tlink = cifs_sb_tlink(cifs_sb);
1567 return PTR_ERR(tlink);
1568 tcon = tlink_tcon(tlink);
1572 full_path = build_path_from_dentry(direntry);
1573 if (full_path == NULL) {
1578 server = tcon->ses->server;
1580 #ifdef CONFIG_CIFS_SMB311
1581 if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) {
1582 rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,
1584 d_drop(direntry); /* for time being always refresh inode info */
1589 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1590 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1591 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1593 if (rc != -EOPNOTSUPP)
1597 if (!server->ops->mkdir) {
1602 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1603 rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
1605 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1610 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1614 * Force revalidate to get parent dir info when needed since cached
1615 * attributes are invalid now.
1617 CIFS_I(inode)->time = 0;
1620 cifs_put_tlink(tlink);
1624 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1628 struct cifs_sb_info *cifs_sb;
1629 struct tcon_link *tlink;
1630 struct cifs_tcon *tcon;
1631 struct TCP_Server_Info *server;
1632 char *full_path = NULL;
1633 struct cifsInodeInfo *cifsInode;
1635 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1639 full_path = build_path_from_dentry(direntry);
1640 if (full_path == NULL) {
1645 cifs_sb = CIFS_SB(inode->i_sb);
1646 tlink = cifs_sb_tlink(cifs_sb);
1647 if (IS_ERR(tlink)) {
1648 rc = PTR_ERR(tlink);
1651 tcon = tlink_tcon(tlink);
1652 server = tcon->ses->server;
1654 if (!server->ops->rmdir) {
1656 cifs_put_tlink(tlink);
1660 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1661 cifs_put_tlink(tlink);
1664 spin_lock(&d_inode(direntry)->i_lock);
1665 i_size_write(d_inode(direntry), 0);
1666 clear_nlink(d_inode(direntry));
1667 spin_unlock(&d_inode(direntry)->i_lock);
1670 cifsInode = CIFS_I(d_inode(direntry));
1671 /* force revalidate to go get info when needed */
1672 cifsInode->time = 0;
1674 cifsInode = CIFS_I(inode);
1676 * Force revalidate to get parent dir info when needed since cached
1677 * attributes are invalid now.
1679 cifsInode->time = 0;
1681 d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
1682 current_time(inode);
1691 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1692 const char *from_path, struct dentry *to_dentry,
1693 const char *to_path)
1695 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1696 struct tcon_link *tlink;
1697 struct cifs_tcon *tcon;
1698 struct TCP_Server_Info *server;
1699 struct cifs_fid fid;
1700 struct cifs_open_parms oparms;
1703 tlink = cifs_sb_tlink(cifs_sb);
1705 return PTR_ERR(tlink);
1706 tcon = tlink_tcon(tlink);
1707 server = tcon->ses->server;
1709 if (!server->ops->rename)
1712 /* try path-based rename first */
1713 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1716 * Don't bother with rename by filehandle unless file is busy and
1717 * source. Note that cross directory moves do not work with
1718 * rename by filehandle to various Windows servers.
1720 if (rc == 0 || rc != -EBUSY)
1721 goto do_rename_exit;
1723 /* open-file renames don't work across directories */
1724 if (to_dentry->d_parent != from_dentry->d_parent)
1725 goto do_rename_exit;
1728 oparms.cifs_sb = cifs_sb;
1729 /* open the file to be renamed -- we need DELETE perms */
1730 oparms.desired_access = DELETE;
1731 oparms.create_options = CREATE_NOT_DIR;
1732 oparms.disposition = FILE_OPEN;
1733 oparms.path = from_path;
1735 oparms.reconnect = false;
1737 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1739 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
1740 (const char *) to_dentry->d_name.name,
1741 cifs_sb->local_nls, cifs_remap(cifs_sb));
1742 CIFSSMBClose(xid, tcon, fid.netfid);
1745 cifs_put_tlink(tlink);
1750 cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
1751 struct inode *target_dir, struct dentry *target_dentry,
1754 char *from_name = NULL;
1755 char *to_name = NULL;
1756 struct cifs_sb_info *cifs_sb;
1757 struct tcon_link *tlink;
1758 struct cifs_tcon *tcon;
1759 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1760 FILE_UNIX_BASIC_INFO *info_buf_target;
1764 if (flags & ~RENAME_NOREPLACE)
1767 cifs_sb = CIFS_SB(source_dir->i_sb);
1768 tlink = cifs_sb_tlink(cifs_sb);
1770 return PTR_ERR(tlink);
1771 tcon = tlink_tcon(tlink);
1776 * we already have the rename sem so we do not need to
1777 * grab it again here to protect the path integrity
1779 from_name = build_path_from_dentry(source_dentry);
1780 if (from_name == NULL) {
1782 goto cifs_rename_exit;
1785 to_name = build_path_from_dentry(target_dentry);
1786 if (to_name == NULL) {
1788 goto cifs_rename_exit;
1791 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1795 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1797 if (flags & RENAME_NOREPLACE)
1798 goto cifs_rename_exit;
1800 if (rc == -EEXIST && tcon->unix_ext) {
1802 * Are src and dst hardlinks of same inode? We can only tell
1803 * with unix extensions enabled.
1806 kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
1808 if (info_buf_source == NULL) {
1810 goto cifs_rename_exit;
1813 info_buf_target = info_buf_source + 1;
1814 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1817 cifs_remap(cifs_sb));
1821 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1824 cifs_remap(cifs_sb));
1826 if (tmprc == 0 && (info_buf_source->UniqueId ==
1827 info_buf_target->UniqueId)) {
1828 /* same file, POSIX says that this is a noop */
1830 goto cifs_rename_exit;
1834 * else ... BB we could add the same check for Windows by
1835 * checking the UniqueId via FILE_INTERNAL_INFO
1839 /* Try unlinking the target dentry if it's not negative */
1840 if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
1841 if (d_is_dir(target_dentry))
1842 tmprc = cifs_rmdir(target_dir, target_dentry);
1844 tmprc = cifs_unlink(target_dir, target_dentry);
1846 goto cifs_rename_exit;
1847 rc = cifs_do_rename(xid, source_dentry, from_name,
1848 target_dentry, to_name);
1851 /* force revalidate to go get info when needed */
1852 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
1854 source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
1855 target_dir->i_mtime = current_time(source_dir);
1858 kfree(info_buf_source);
1862 cifs_put_tlink(tlink);
1867 cifs_inode_needs_reval(struct inode *inode)
1869 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1870 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1872 if (cifs_i->time == 0)
1875 if (CIFS_CACHE_READ(cifs_i))
1878 if (!lookupCacheEnabled)
1881 if (!cifs_sb->actimeo)
1884 if (!time_in_range(jiffies, cifs_i->time,
1885 cifs_i->time + cifs_sb->actimeo))
1888 /* hardlinked files w/ noserverino get "special" treatment */
1889 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1890 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1897 * Zap the cache. Called when invalid_mapping flag is set.
1900 cifs_invalidate_mapping(struct inode *inode)
1904 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1905 rc = invalidate_inode_pages2(inode->i_mapping);
1907 cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1911 cifs_fscache_reset_inode_cookie(inode);
1916 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
1917 * @word: long word containing the bit lock
1920 cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
1922 freezable_schedule_unsafe();
1923 if (signal_pending_state(mode, current))
1924 return -ERESTARTSYS;
1929 cifs_revalidate_mapping(struct inode *inode)
1932 unsigned long *flags = &CIFS_I(inode)->flags;
1934 rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
1939 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
1940 rc = cifs_invalidate_mapping(inode);
1942 set_bit(CIFS_INO_INVALID_MAPPING, flags);
1945 clear_bit_unlock(CIFS_INO_LOCK, flags);
1946 smp_mb__after_atomic();
1947 wake_up_bit(flags, CIFS_INO_LOCK);
1953 cifs_zap_mapping(struct inode *inode)
1955 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
1956 return cifs_revalidate_mapping(inode);
1959 int cifs_revalidate_file_attr(struct file *filp)
1962 struct inode *inode = file_inode(filp);
1963 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1965 if (!cifs_inode_needs_reval(inode))
1968 if (tlink_tcon(cfile->tlink)->unix_ext)
1969 rc = cifs_get_file_info_unix(filp);
1971 rc = cifs_get_file_info(filp);
1976 int cifs_revalidate_dentry_attr(struct dentry *dentry)
1980 struct inode *inode = d_inode(dentry);
1981 struct super_block *sb = dentry->d_sb;
1982 char *full_path = NULL;
1987 if (!cifs_inode_needs_reval(inode))
1992 /* can not safely grab the rename sem here if rename calls revalidate
1993 since that would deadlock */
1994 full_path = build_path_from_dentry(dentry);
1995 if (full_path == NULL) {
2000 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2001 full_path, inode, inode->i_count.counter,
2002 dentry, cifs_get_time(dentry), jiffies);
2004 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
2005 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2007 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2016 int cifs_revalidate_file(struct file *filp)
2019 struct inode *inode = file_inode(filp);
2021 rc = cifs_revalidate_file_attr(filp);
2025 return cifs_revalidate_mapping(inode);
2028 /* revalidate a dentry's inode attributes */
2029 int cifs_revalidate_dentry(struct dentry *dentry)
2032 struct inode *inode = d_inode(dentry);
2034 rc = cifs_revalidate_dentry_attr(dentry);
2038 return cifs_revalidate_mapping(inode);
2041 int cifs_getattr(const struct path *path, struct kstat *stat,
2042 u32 request_mask, unsigned int flags)
2044 struct dentry *dentry = path->dentry;
2045 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2046 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2047 struct inode *inode = d_inode(dentry);
2051 * We need to be sure that all dirty pages are written and the server
2052 * has actual ctime, mtime and file length.
2054 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2055 inode->i_mapping->nrpages != 0) {
2056 rc = filemap_fdatawait(inode->i_mapping);
2058 mapping_set_error(inode->i_mapping, rc);
2063 rc = cifs_revalidate_dentry_attr(dentry);
2067 generic_fillattr(inode, stat);
2068 stat->blksize = CIFS_MAX_MSGSIZE;
2069 stat->ino = CIFS_I(inode)->uniqueid;
2071 /* old CIFS Unix Extensions doesn't return create time */
2072 if (CIFS_I(inode)->createtime) {
2073 stat->result_mask |= STATX_BTIME;
2074 stat->btime = timespec_to_timespec64(
2075 cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime)));
2078 stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2079 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2080 stat->attributes |= STATX_ATTR_COMPRESSED;
2081 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2082 stat->attributes |= STATX_ATTR_ENCRYPTED;
2085 * If on a multiuser mount without unix extensions or cifsacl being
2086 * enabled, and the admin hasn't overridden them, set the ownership
2087 * to the fsuid/fsgid of the current process.
2089 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2090 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2092 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2093 stat->uid = current_fsuid();
2094 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2095 stat->gid = current_fsgid();
2100 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
2102 pgoff_t index = from >> PAGE_SHIFT;
2103 unsigned offset = from & (PAGE_SIZE - 1);
2107 page = grab_cache_page(mapping, index);
2111 zero_user_segment(page, offset, PAGE_SIZE);
2117 static void cifs_setsize(struct inode *inode, loff_t offset)
2119 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2121 spin_lock(&inode->i_lock);
2122 i_size_write(inode, offset);
2123 spin_unlock(&inode->i_lock);
2125 /* Cached inode must be refreshed on truncate */
2127 truncate_pagecache(inode, offset);
2131 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2132 unsigned int xid, char *full_path)
2135 struct cifsFileInfo *open_file;
2136 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2137 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2138 struct tcon_link *tlink = NULL;
2139 struct cifs_tcon *tcon = NULL;
2140 struct TCP_Server_Info *server;
2143 * To avoid spurious oplock breaks from server, in the case of
2144 * inodes that we already have open, avoid doing path based
2145 * setting of file size if we can do it by handle.
2146 * This keeps our caching token (oplock) and avoids timeouts
2147 * when the local oplock break takes longer to flush
2148 * writebehind data than the SMB timeout for the SetPathInfo
2149 * request would allow
2151 open_file = find_writable_file(cifsInode, true);
2153 tcon = tlink_tcon(open_file->tlink);
2154 server = tcon->ses->server;
2155 if (server->ops->set_file_size)
2156 rc = server->ops->set_file_size(xid, tcon, open_file,
2157 attrs->ia_size, false);
2160 cifsFileInfo_put(open_file);
2161 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2169 tlink = cifs_sb_tlink(cifs_sb);
2171 return PTR_ERR(tlink);
2172 tcon = tlink_tcon(tlink);
2173 server = tcon->ses->server;
2177 * Set file size by pathname rather than by handle either because no
2178 * valid, writeable file handle for it was found or because there was
2179 * an error setting it by handle.
2181 if (server->ops->set_path_size)
2182 rc = server->ops->set_path_size(xid, tcon, full_path,
2183 attrs->ia_size, cifs_sb, false);
2186 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2189 cifs_put_tlink(tlink);
2193 cifsInode->server_eof = attrs->ia_size;
2194 cifs_setsize(inode, attrs->ia_size);
2195 cifs_truncate_page(inode->i_mapping, inode->i_size);
2202 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2206 char *full_path = NULL;
2207 struct inode *inode = d_inode(direntry);
2208 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2209 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2210 struct tcon_link *tlink;
2211 struct cifs_tcon *pTcon;
2212 struct cifs_unix_set_info_args *args = NULL;
2213 struct cifsFileInfo *open_file;
2215 cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2216 direntry, attrs->ia_valid);
2220 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2221 attrs->ia_valid |= ATTR_FORCE;
2223 rc = setattr_prepare(direntry, attrs);
2227 full_path = build_path_from_dentry(direntry);
2228 if (full_path == NULL) {
2234 * Attempt to flush data before changing attributes. We need to do
2235 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2236 * ownership or mode then we may also need to do this. Here, we take
2237 * the safe way out and just do the flush on all setattr requests. If
2238 * the flush returns error, store it to report later and continue.
2240 * BB: This should be smarter. Why bother flushing pages that
2241 * will be truncated anyway? Also, should we error out here if
2242 * the flush returns error?
2244 rc = filemap_write_and_wait(inode->i_mapping);
2245 mapping_set_error(inode->i_mapping, rc);
2248 if (attrs->ia_valid & ATTR_SIZE) {
2249 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2254 /* skip mode change if it's just for clearing setuid/setgid */
2255 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2256 attrs->ia_valid &= ~ATTR_MODE;
2258 args = kmalloc(sizeof(*args), GFP_KERNEL);
2264 /* set up the struct */
2265 if (attrs->ia_valid & ATTR_MODE)
2266 args->mode = attrs->ia_mode;
2268 args->mode = NO_CHANGE_64;
2270 if (attrs->ia_valid & ATTR_UID)
2271 args->uid = attrs->ia_uid;
2273 args->uid = INVALID_UID; /* no change */
2275 if (attrs->ia_valid & ATTR_GID)
2276 args->gid = attrs->ia_gid;
2278 args->gid = INVALID_GID; /* no change */
2280 if (attrs->ia_valid & ATTR_ATIME)
2281 args->atime = cifs_UnixTimeToNT(timespec64_to_timespec(attrs->ia_atime));
2283 args->atime = NO_CHANGE_64;
2285 if (attrs->ia_valid & ATTR_MTIME)
2286 args->mtime = cifs_UnixTimeToNT(timespec64_to_timespec(attrs->ia_mtime));
2288 args->mtime = NO_CHANGE_64;
2290 if (attrs->ia_valid & ATTR_CTIME)
2291 args->ctime = cifs_UnixTimeToNT(timespec64_to_timespec(attrs->ia_ctime));
2293 args->ctime = NO_CHANGE_64;
2296 open_file = find_writable_file(cifsInode, true);
2298 u16 nfid = open_file->fid.netfid;
2299 u32 npid = open_file->pid;
2300 pTcon = tlink_tcon(open_file->tlink);
2301 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2302 cifsFileInfo_put(open_file);
2304 tlink = cifs_sb_tlink(cifs_sb);
2305 if (IS_ERR(tlink)) {
2306 rc = PTR_ERR(tlink);
2309 pTcon = tlink_tcon(tlink);
2310 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2312 cifs_remap(cifs_sb));
2313 cifs_put_tlink(tlink);
2319 if ((attrs->ia_valid & ATTR_SIZE) &&
2320 attrs->ia_size != i_size_read(inode))
2321 truncate_setsize(inode, attrs->ia_size);
2323 setattr_copy(inode, attrs);
2324 mark_inode_dirty(inode);
2326 /* force revalidate when any of these times are set since some
2327 of the fs types (eg ext3, fat) do not have fine enough
2328 time granularity to match protocol, and we do not have a
2329 a way (yet) to query the server fs's time granularity (and
2330 whether it rounds times down).
2332 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2333 cifsInode->time = 0;
2342 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2345 kuid_t uid = INVALID_UID;
2346 kgid_t gid = INVALID_GID;
2347 struct inode *inode = d_inode(direntry);
2348 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2349 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2350 char *full_path = NULL;
2353 __u64 mode = NO_CHANGE_64;
2357 cifs_dbg(FYI, "setattr on file %pd attrs->iavalid 0x%x\n",
2358 direntry, attrs->ia_valid);
2360 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2361 attrs->ia_valid |= ATTR_FORCE;
2363 rc = setattr_prepare(direntry, attrs);
2369 full_path = build_path_from_dentry(direntry);
2370 if (full_path == NULL) {
2377 * Attempt to flush data before changing attributes. We need to do
2378 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2379 * ownership or mode then we may also need to do this. Here, we take
2380 * the safe way out and just do the flush on all setattr requests. If
2381 * the flush returns error, store it to report later and continue.
2383 * BB: This should be smarter. Why bother flushing pages that
2384 * will be truncated anyway? Also, should we error out here if
2385 * the flush returns error?
2387 rc = filemap_write_and_wait(inode->i_mapping);
2388 mapping_set_error(inode->i_mapping, rc);
2391 if (attrs->ia_valid & ATTR_SIZE) {
2392 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2394 goto cifs_setattr_exit;
2397 if (attrs->ia_valid & ATTR_UID)
2398 uid = attrs->ia_uid;
2400 if (attrs->ia_valid & ATTR_GID)
2401 gid = attrs->ia_gid;
2403 #ifdef CONFIG_CIFS_ACL
2404 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2405 if (uid_valid(uid) || gid_valid(gid)) {
2406 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2409 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2411 goto cifs_setattr_exit;
2415 #endif /* CONFIG_CIFS_ACL */
2416 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2417 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2419 /* skip mode change if it's just for clearing setuid/setgid */
2420 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2421 attrs->ia_valid &= ~ATTR_MODE;
2423 if (attrs->ia_valid & ATTR_MODE) {
2424 mode = attrs->ia_mode;
2426 #ifdef CONFIG_CIFS_ACL
2427 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2428 rc = id_mode_to_cifs_acl(inode, full_path, mode,
2429 INVALID_UID, INVALID_GID);
2431 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2433 goto cifs_setattr_exit;
2436 #endif /* CONFIG_CIFS_ACL */
2437 if (((mode & S_IWUGO) == 0) &&
2438 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2440 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2442 /* fix up mode if we're not using dynperm */
2443 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2444 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2445 } else if ((mode & S_IWUGO) &&
2446 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2448 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2449 /* Attributes of 0 are ignored */
2451 dosattr |= ATTR_NORMAL;
2453 /* reset local inode permissions to normal */
2454 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2455 attrs->ia_mode &= ~(S_IALLUGO);
2456 if (S_ISDIR(inode->i_mode))
2458 cifs_sb->mnt_dir_mode;
2461 cifs_sb->mnt_file_mode;
2463 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2464 /* ignore mode change - ATTR_READONLY hasn't changed */
2465 attrs->ia_valid &= ~ATTR_MODE;
2469 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2470 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2471 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2472 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2474 /* Even if error on time set, no sense failing the call if
2475 the server would set the time to a reasonable value anyway,
2476 and this check ensures that we are not being called from
2477 sys_utimes in which case we ought to fail the call back to
2478 the user when the server rejects the call */
2479 if ((rc) && (attrs->ia_valid &
2480 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2484 /* do not need local check to inode_check_ok since the server does
2487 goto cifs_setattr_exit;
2489 if ((attrs->ia_valid & ATTR_SIZE) &&
2490 attrs->ia_size != i_size_read(inode))
2491 truncate_setsize(inode, attrs->ia_size);
2493 setattr_copy(inode, attrs);
2494 mark_inode_dirty(inode);
2503 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2505 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
2506 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2508 if (pTcon->unix_ext)
2509 return cifs_setattr_unix(direntry, attrs);
2511 return cifs_setattr_nounix(direntry, attrs);
2513 /* BB: add cifs_setattr_legacy for really old servers */
2517 void cifs_delete_inode(struct inode *inode)
2519 cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2520 /* may have to add back in if and when safe distributed caching of
2521 directories added e.g. via FindNotify */