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 <asm/div64.h>
30 #include "cifsproto.h"
31 #include "cifs_debug.h"
32 #include "cifs_fs_sb.h"
33 #include "cifs_unicode.h"
37 static void cifs_set_ops(struct inode *inode)
39 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
41 switch (inode->i_mode & S_IFMT) {
43 inode->i_op = &cifs_file_inode_ops;
44 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
45 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
46 inode->i_fop = &cifs_file_direct_nobrl_ops;
48 inode->i_fop = &cifs_file_direct_ops;
49 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
50 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
51 inode->i_fop = &cifs_file_strict_nobrl_ops;
53 inode->i_fop = &cifs_file_strict_ops;
54 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
55 inode->i_fop = &cifs_file_nobrl_ops;
56 else { /* not direct, send byte range locks */
57 inode->i_fop = &cifs_file_ops;
60 /* check if server can support readpages */
61 if (cifs_sb_master_tcon(cifs_sb)->ses->server->maxBuf <
62 PAGE_SIZE + MAX_CIFS_HDR_SIZE)
63 inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
65 inode->i_data.a_ops = &cifs_addr_ops;
68 #ifdef CONFIG_CIFS_DFS_UPCALL
69 if (IS_AUTOMOUNT(inode)) {
70 inode->i_op = &cifs_dfs_referral_inode_operations;
72 #else /* NO DFS support, treat as a directory */
75 inode->i_op = &cifs_dir_inode_ops;
76 inode->i_fop = &cifs_dir_ops;
80 inode->i_op = &cifs_symlink_inode_ops;
83 init_special_inode(inode, inode->i_mode, inode->i_rdev);
88 /* check inode attributes against fattr. If they don't match, tag the
89 * inode for cache invalidation
92 cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
94 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
96 cifs_dbg(FYI, "%s: revalidating inode %llu\n",
97 __func__, cifs_i->uniqueid);
99 if (inode->i_state & I_NEW) {
100 cifs_dbg(FYI, "%s: inode %llu is new\n",
101 __func__, cifs_i->uniqueid);
105 /* don't bother with revalidation if we have an oplock */
106 if (CIFS_CACHE_READ(cifs_i)) {
107 cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
108 __func__, cifs_i->uniqueid);
112 /* revalidate if mtime or size have changed */
113 if (timespec_equal(&inode->i_mtime, &fattr->cf_mtime) &&
114 cifs_i->server_eof == fattr->cf_eof) {
115 cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
116 __func__, cifs_i->uniqueid);
120 cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
121 __func__, cifs_i->uniqueid);
122 set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags);
126 * copy nlink to the inode, unless it wasn't provided. Provide
127 * sane values if we don't have an existing one and none was provided
130 cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
133 * if we're in a situation where we can't trust what we
134 * got from the server (readdir, some non-unix cases)
135 * fake reasonable values
137 if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
138 /* only provide fake values on a new inode */
139 if (inode->i_state & I_NEW) {
140 if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
148 /* we trust the server, so update it */
149 set_nlink(inode, fattr->cf_nlink);
152 /* populate an inode with info from a cifs_fattr struct */
154 cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
156 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
157 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
159 cifs_revalidate_cache(inode, fattr);
161 spin_lock(&inode->i_lock);
162 inode->i_atime = fattr->cf_atime;
163 inode->i_mtime = fattr->cf_mtime;
164 inode->i_ctime = fattr->cf_ctime;
165 inode->i_rdev = fattr->cf_rdev;
166 cifs_nlink_fattr_to_inode(inode, fattr);
167 inode->i_uid = fattr->cf_uid;
168 inode->i_gid = fattr->cf_gid;
170 /* if dynperm is set, don't clobber existing mode */
171 if (inode->i_state & I_NEW ||
172 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
173 inode->i_mode = fattr->cf_mode;
175 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
177 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
180 cifs_i->time = jiffies;
182 if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING)
183 set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
185 clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
187 cifs_i->server_eof = fattr->cf_eof;
189 * Can't safely change the file size here if the client is writing to
190 * it due to potential races.
192 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
193 i_size_write(inode, fattr->cf_eof);
196 * i_blocks is not related to (i_size / i_blksize),
197 * but instead 512 byte (2**9) size is required for
198 * calculating num blocks.
200 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
202 spin_unlock(&inode->i_lock);
204 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
205 inode->i_flags |= S_AUTOMOUNT;
206 if (inode->i_state & I_NEW)
211 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
213 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
215 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
218 fattr->cf_uniqueid = iunique(sb, ROOT_I);
221 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
223 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
224 struct cifs_sb_info *cifs_sb)
226 memset(fattr, 0, sizeof(*fattr));
227 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
228 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
229 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
231 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
232 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
233 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
234 fattr->cf_mode = le64_to_cpu(info->Permissions);
237 * Since we set the inode type below we need to mask off
238 * to avoid strange results if bits set above.
240 fattr->cf_mode &= ~S_IFMT;
241 switch (le32_to_cpu(info->Type)) {
243 fattr->cf_mode |= S_IFREG;
244 fattr->cf_dtype = DT_REG;
247 fattr->cf_mode |= S_IFLNK;
248 fattr->cf_dtype = DT_LNK;
251 fattr->cf_mode |= S_IFDIR;
252 fattr->cf_dtype = DT_DIR;
255 fattr->cf_mode |= S_IFCHR;
256 fattr->cf_dtype = DT_CHR;
257 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
258 le64_to_cpu(info->DevMinor) & MINORMASK);
261 fattr->cf_mode |= S_IFBLK;
262 fattr->cf_dtype = DT_BLK;
263 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
264 le64_to_cpu(info->DevMinor) & MINORMASK);
267 fattr->cf_mode |= S_IFIFO;
268 fattr->cf_dtype = DT_FIFO;
271 fattr->cf_mode |= S_IFSOCK;
272 fattr->cf_dtype = DT_SOCK;
275 /* safest to call it a file if we do not know */
276 fattr->cf_mode |= S_IFREG;
277 fattr->cf_dtype = DT_REG;
278 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
282 fattr->cf_uid = cifs_sb->mnt_uid;
283 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
284 u64 id = le64_to_cpu(info->Uid);
285 if (id < ((uid_t)-1)) {
286 kuid_t uid = make_kuid(&init_user_ns, id);
292 fattr->cf_gid = cifs_sb->mnt_gid;
293 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
294 u64 id = le64_to_cpu(info->Gid);
295 if (id < ((gid_t)-1)) {
296 kgid_t gid = make_kgid(&init_user_ns, id);
302 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
306 * Fill a cifs_fattr struct with fake inode info.
308 * Needed to setup cifs_fattr data for the directory which is the
309 * junction to the new submount (ie to setup the fake directory
310 * which represents a DFS referral).
313 cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
315 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
317 cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
319 memset(fattr, 0, sizeof(*fattr));
320 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
321 fattr->cf_uid = cifs_sb->mnt_uid;
322 fattr->cf_gid = cifs_sb->mnt_gid;
323 fattr->cf_atime = CURRENT_TIME;
324 fattr->cf_ctime = CURRENT_TIME;
325 fattr->cf_mtime = CURRENT_TIME;
327 fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
331 cifs_get_file_info_unix(struct file *filp)
335 FILE_UNIX_BASIC_INFO find_data;
336 struct cifs_fattr fattr;
337 struct inode *inode = file_inode(filp);
338 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
339 struct cifsFileInfo *cfile = filp->private_data;
340 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
343 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
345 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
346 } else if (rc == -EREMOTE) {
347 cifs_create_dfs_fattr(&fattr, inode->i_sb);
351 cifs_fattr_to_inode(inode, &fattr);
356 int cifs_get_inode_info_unix(struct inode **pinode,
357 const unsigned char *full_path,
358 struct super_block *sb, unsigned int xid)
361 FILE_UNIX_BASIC_INFO find_data;
362 struct cifs_fattr fattr;
363 struct cifs_tcon *tcon;
364 struct tcon_link *tlink;
365 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
367 cifs_dbg(FYI, "Getting info on %s\n", full_path);
369 tlink = cifs_sb_tlink(cifs_sb);
371 return PTR_ERR(tlink);
372 tcon = tlink_tcon(tlink);
374 /* could have done a find first instead but this returns more info */
375 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
376 cifs_sb->local_nls, cifs_remap(cifs_sb));
377 cifs_put_tlink(tlink);
380 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
381 } else if (rc == -EREMOTE) {
382 cifs_create_dfs_fattr(&fattr, sb);
388 /* check for Minshall+French symlinks */
389 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
390 int tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
393 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
396 if (*pinode == NULL) {
398 cifs_fill_uniqueid(sb, &fattr);
399 *pinode = cifs_iget(sb, &fattr);
403 /* we already have inode, update it */
405 /* if uniqueid is different, return error */
406 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
407 CIFS_I(*pinode)->uniqueid != fattr.cf_uniqueid)) {
408 CIFS_I(*pinode)->time = 0; /* force reval */
413 /* if filetype is different, return error */
414 if (unlikely(((*pinode)->i_mode & S_IFMT) !=
415 (fattr.cf_mode & S_IFMT))) {
416 CIFS_I(*pinode)->time = 0; /* force reval */
421 cifs_fattr_to_inode(*pinode, &fattr);
429 cifs_sfu_type(struct cifs_fattr *fattr, const char *path,
430 struct cifs_sb_info *cifs_sb, unsigned int xid)
434 struct tcon_link *tlink;
435 struct cifs_tcon *tcon;
437 struct cifs_open_parms oparms;
438 struct cifs_io_parms io_parms;
440 unsigned int bytes_read;
442 int buf_type = CIFS_NO_BUFFER;
446 fattr->cf_mode &= ~S_IFMT;
448 if (fattr->cf_eof == 0) {
449 fattr->cf_mode |= S_IFIFO;
450 fattr->cf_dtype = DT_FIFO;
452 } else if (fattr->cf_eof < 8) {
453 fattr->cf_mode |= S_IFREG;
454 fattr->cf_dtype = DT_REG;
455 return -EINVAL; /* EOPNOTSUPP? */
458 tlink = cifs_sb_tlink(cifs_sb);
460 return PTR_ERR(tlink);
461 tcon = tlink_tcon(tlink);
464 oparms.cifs_sb = cifs_sb;
465 oparms.desired_access = GENERIC_READ;
466 oparms.create_options = CREATE_NOT_DIR;
467 oparms.disposition = FILE_OPEN;
470 oparms.reconnect = false;
472 if (tcon->ses->server->oplocks)
476 rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);
478 cifs_dbg(FYI, "check sfu type of %s, open rc = %d\n", path, rc);
479 cifs_put_tlink(tlink);
484 io_parms.netfid = fid.netfid;
485 io_parms.pid = current->tgid;
486 io_parms.tcon = tcon;
488 io_parms.length = 24;
490 rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,
491 &bytes_read, &pbuf, &buf_type);
492 if ((rc == 0) && (bytes_read >= 8)) {
493 if (memcmp("IntxBLK", pbuf, 8) == 0) {
494 cifs_dbg(FYI, "Block device\n");
495 fattr->cf_mode |= S_IFBLK;
496 fattr->cf_dtype = DT_BLK;
497 if (bytes_read == 24) {
498 /* we have enough to decode dev num */
499 __u64 mjr; /* major */
500 __u64 mnr; /* minor */
501 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
502 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
503 fattr->cf_rdev = MKDEV(mjr, mnr);
505 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
506 cifs_dbg(FYI, "Char device\n");
507 fattr->cf_mode |= S_IFCHR;
508 fattr->cf_dtype = DT_CHR;
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("IntxLNK", pbuf, 7) == 0) {
518 cifs_dbg(FYI, "Symlink\n");
519 fattr->cf_mode |= S_IFLNK;
520 fattr->cf_dtype = DT_LNK;
522 fattr->cf_mode |= S_IFREG; /* file? */
523 fattr->cf_dtype = DT_REG;
527 fattr->cf_mode |= S_IFREG; /* then it is a file */
528 fattr->cf_dtype = DT_REG;
529 rc = -EOPNOTSUPP; /* or some unknown SFU type */
532 tcon->ses->server->ops->close(xid, tcon, &fid);
533 cifs_put_tlink(tlink);
537 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
540 * Fetch mode bits as provided by SFU.
542 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
544 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
545 struct cifs_sb_info *cifs_sb, unsigned int xid)
547 #ifdef CONFIG_CIFS_XATTR
551 struct tcon_link *tlink;
552 struct cifs_tcon *tcon;
554 tlink = cifs_sb_tlink(cifs_sb);
556 return PTR_ERR(tlink);
557 tcon = tlink_tcon(tlink);
559 if (tcon->ses->server->ops->query_all_EAs == NULL) {
560 cifs_put_tlink(tlink);
564 rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
565 "SETFILEBITS", ea_value, 4 /* size of buf */,
567 cifs_remap(cifs_sb));
568 cifs_put_tlink(tlink);
572 mode = le32_to_cpu(*((__le32 *)ea_value));
573 fattr->cf_mode &= ~SFBITS_MASK;
574 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
575 mode, fattr->cf_mode);
576 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
577 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
586 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
588 cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
589 struct cifs_sb_info *cifs_sb, bool adjust_tz,
592 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
594 memset(fattr, 0, sizeof(*fattr));
595 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
596 if (info->DeletePending)
597 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
599 if (info->LastAccessTime)
600 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
602 fattr->cf_atime = CURRENT_TIME;
604 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
605 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
608 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
609 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
612 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
613 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
614 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
616 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
619 fattr->cf_mode = S_IFLNK;
620 fattr->cf_dtype = DT_LNK;
621 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
622 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
623 fattr->cf_dtype = DT_DIR;
625 * Server can return wrong NumberOfLinks value for directories
626 * when Unix extensions are disabled - fake it.
629 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
631 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
632 fattr->cf_dtype = DT_REG;
634 /* clear write bits if ATTR_READONLY is set */
635 if (fattr->cf_cifsattrs & ATTR_READONLY)
636 fattr->cf_mode &= ~(S_IWUGO);
639 * Don't accept zero nlink from non-unix servers unless
640 * delete is pending. Instead mark it as unknown.
642 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
643 !info->DeletePending) {
644 cifs_dbg(1, "bogus file nlink value %u\n",
646 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
650 fattr->cf_uid = cifs_sb->mnt_uid;
651 fattr->cf_gid = cifs_sb->mnt_gid;
655 cifs_get_file_info(struct file *filp)
659 FILE_ALL_INFO find_data;
660 struct cifs_fattr fattr;
661 struct inode *inode = file_inode(filp);
662 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
663 struct cifsFileInfo *cfile = filp->private_data;
664 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
665 struct TCP_Server_Info *server = tcon->ses->server;
667 if (!server->ops->query_file_info)
671 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
674 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false,
678 cifs_create_dfs_fattr(&fattr, inode->i_sb);
684 * FIXME: legacy server -- fall back to path-based call?
685 * for now, just skip revalidating and mark inode for
689 CIFS_I(inode)->time = 0;
695 * don't bother with SFU junk here -- just mark inode as needing
698 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
699 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
700 cifs_fattr_to_inode(inode, &fattr);
706 /* Simple function to return a 64 bit hash of string. Rarely called */
707 static __u64 simple_hashstr(const char *str)
709 const __u64 hash_mult = 1125899906842597ULL; /* a big enough prime */
713 hash = (hash + (__u64) *str++) * hash_mult;
719 cifs_get_inode_info(struct inode **inode, const char *full_path,
720 FILE_ALL_INFO *data, struct super_block *sb, int xid,
721 const struct cifs_fid *fid)
723 bool validinum = false;
725 int rc = 0, tmprc = ENOSYS;
726 struct cifs_tcon *tcon;
727 struct TCP_Server_Info *server;
728 struct tcon_link *tlink;
729 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
731 bool adjust_tz = false;
732 struct cifs_fattr fattr;
733 struct cifs_search_info *srchinf = NULL;
734 bool symlink = false;
736 tlink = cifs_sb_tlink(cifs_sb);
738 return PTR_ERR(tlink);
739 tcon = tlink_tcon(tlink);
740 server = tcon->ses->server;
742 cifs_dbg(FYI, "Getting info on %s\n", full_path);
744 if ((data == NULL) && (*inode != NULL)) {
745 if (CIFS_CACHE_READ(CIFS_I(*inode))) {
746 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
751 /* if inode info is not passed, get it from server */
753 if (!server->ops->query_path_info) {
757 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
762 data = (FILE_ALL_INFO *)buf;
763 rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path,
764 data, &adjust_tz, &symlink);
768 cifs_all_info_to_fattr(&fattr, data, cifs_sb, adjust_tz,
770 } else if (rc == -EREMOTE) {
771 cifs_create_dfs_fattr(&fattr, sb);
773 } else if ((rc == -EACCES) && backup_cred(cifs_sb) &&
774 (strcmp(server->vals->version_string, SMB1_VERSION_STRING)
777 * For SMB2 and later the backup intent flag is already
778 * sent if needed on open and there is no path based
779 * FindFirst operation to use to retry with
782 srchinf = kzalloc(sizeof(struct cifs_search_info),
784 if (srchinf == NULL) {
789 srchinf->endOfSearch = false;
791 srchinf->info_level = SMB_FIND_FILE_UNIX;
792 else if ((tcon->ses->capabilities &
793 tcon->ses->server->vals->cap_nt_find) == 0)
794 srchinf->info_level = SMB_FIND_FILE_INFO_STANDARD;
795 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
796 srchinf->info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
797 else /* no srvino useful for fallback to some netapp */
798 srchinf->info_level = SMB_FIND_FILE_DIRECTORY_INFO;
800 srchflgs = CIFS_SEARCH_CLOSE_ALWAYS |
801 CIFS_SEARCH_CLOSE_AT_END |
802 CIFS_SEARCH_BACKUP_SEARCH;
804 rc = CIFSFindFirst(xid, tcon, full_path,
805 cifs_sb, NULL, srchflgs, srchinf, false);
807 data = (FILE_ALL_INFO *)srchinf->srch_entries_start;
809 cifs_dir_info_to_fattr(&fattr,
810 (FILE_DIRECTORY_INFO *)data, cifs_sb);
811 fattr.cf_uniqueid = le64_to_cpu(
812 ((SEARCH_ID_FULL_DIR_INFO *)data)->UniqueId);
815 cifs_buf_release(srchinf->ntwrk_buf_start);
824 * If an inode wasn't passed in, then get the inode number
826 * Is an i_ino of zero legal? Can we use that to check if the server
827 * supports returning inode numbers? Are there other sanity checks we
828 * can use to ensure that the server is really filling in that field?
830 if (*inode == NULL) {
831 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
832 if (validinum == false) {
833 if (server->ops->get_srv_inum)
834 tmprc = server->ops->get_srv_inum(xid,
835 tcon, cifs_sb, full_path,
836 &fattr.cf_uniqueid, data);
838 cifs_dbg(FYI, "GetSrvInodeNum rc %d\n",
840 fattr.cf_uniqueid = iunique(sb, ROOT_I);
841 cifs_autodisable_serverino(cifs_sb);
842 } else if ((fattr.cf_uniqueid == 0) &&
843 strlen(full_path) == 0) {
844 /* some servers ret bad root ino ie 0 */
845 cifs_dbg(FYI, "Invalid (0) inodenum\n");
847 CIFS_FATTR_FAKE_ROOT_INO;
849 simple_hashstr(tcon->treeName);
853 fattr.cf_uniqueid = iunique(sb, ROOT_I);
855 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
856 validinum == false && server->ops->get_srv_inum) {
858 * Pass a NULL tcon to ensure we don't make a round
859 * trip to the server. This only works for SMB2+.
861 tmprc = server->ops->get_srv_inum(xid,
862 NULL, cifs_sb, full_path,
863 &fattr.cf_uniqueid, data);
865 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
866 else if ((fattr.cf_uniqueid == 0) &&
867 strlen(full_path) == 0) {
869 * Reuse existing root inode num since
870 * inum zero for root causes ls of . and .. to
873 cifs_dbg(FYI, "Srv ret 0 inode num for root\n");
874 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
877 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
880 /* query for SFU type info if supported and needed */
881 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
882 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
883 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
885 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
888 #ifdef CONFIG_CIFS_ACL
889 /* fill in 0777 bits from ACL */
890 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
891 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, full_path, fid);
893 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
898 #endif /* CONFIG_CIFS_ACL */
900 /* fill in remaining high mode bits e.g. SUID, VTX */
901 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
902 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
904 /* check for Minshall+French symlinks */
905 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
906 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
909 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
913 *inode = cifs_iget(sb, &fattr);
917 /* we already have inode, update it */
919 /* if uniqueid is different, return error */
920 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
921 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
922 CIFS_I(*inode)->time = 0; /* force reval */
927 /* if filetype is different, return error */
928 if (unlikely(((*inode)->i_mode & S_IFMT) !=
929 (fattr.cf_mode & S_IFMT))) {
930 CIFS_I(*inode)->time = 0; /* force reval */
935 cifs_fattr_to_inode(*inode, &fattr);
939 if ((*inode) && ((*inode)->i_ino == 0))
940 cifs_dbg(FYI, "inode number of zero returned\n");
943 cifs_put_tlink(tlink);
947 static const struct inode_operations cifs_ipc_inode_ops = {
948 .lookup = cifs_lookup,
952 cifs_find_inode(struct inode *inode, void *opaque)
954 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
956 /* don't match inode with different uniqueid */
957 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
960 /* use createtime like an i_generation field */
961 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
964 /* don't match inode of different type */
965 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
968 /* if it's not a directory or has no dentries, then flag it */
969 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
970 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
976 cifs_init_inode(struct inode *inode, void *opaque)
978 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
980 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
981 CIFS_I(inode)->createtime = fattr->cf_createtime;
986 * walk dentry list for an inode and report whether it has aliases that
987 * are hashed. We use this to determine if a directory inode can actually
991 inode_has_hashed_dentries(struct inode *inode)
993 struct dentry *dentry;
995 spin_lock(&inode->i_lock);
996 hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
997 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
998 spin_unlock(&inode->i_lock);
1002 spin_unlock(&inode->i_lock);
1006 /* Given fattrs, get a corresponding inode */
1008 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
1011 struct inode *inode;
1014 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
1016 /* hash down to 32-bits on 32-bit arch */
1017 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
1019 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
1021 /* was there a potentially problematic inode collision? */
1022 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
1023 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
1025 if (inode_has_hashed_dentries(inode)) {
1026 cifs_autodisable_serverino(CIFS_SB(sb));
1028 fattr->cf_uniqueid = iunique(sb, ROOT_I);
1029 goto retry_iget5_locked;
1033 cifs_fattr_to_inode(inode, fattr);
1034 if (sb->s_flags & MS_NOATIME)
1035 inode->i_flags |= S_NOATIME | S_NOCMTIME;
1036 if (inode->i_state & I_NEW) {
1037 inode->i_ino = hash;
1038 #ifdef CONFIG_CIFS_FSCACHE
1039 /* initialize per-inode cache cookie pointer */
1040 CIFS_I(inode)->fscache = NULL;
1042 unlock_new_inode(inode);
1049 /* gets root inode */
1050 struct inode *cifs_root_iget(struct super_block *sb)
1053 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1054 struct inode *inode = NULL;
1056 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1060 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
1061 && cifs_sb->prepath) {
1062 len = strlen(cifs_sb->prepath);
1063 path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
1065 return ERR_PTR(-ENOMEM);
1067 memcpy(path+1, cifs_sb->prepath, len);
1069 path = kstrdup("", GFP_KERNEL);
1071 return ERR_PTR(-ENOMEM);
1075 if (tcon->unix_ext) {
1076 rc = cifs_get_inode_info_unix(&inode, path, sb, xid);
1077 /* some servers mistakenly claim POSIX support */
1078 if (rc != -EOPNOTSUPP)
1080 cifs_dbg(VFS, "server does not support POSIX extensions");
1081 tcon->unix_ext = false;
1084 convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
1085 rc = cifs_get_inode_info(&inode, path, NULL, sb, xid, NULL);
1089 inode = ERR_PTR(rc);
1093 #ifdef CONFIG_CIFS_FSCACHE
1094 /* populate tcon->resource_id */
1095 tcon->resource_id = CIFS_I(inode)->uniqueid;
1098 if (rc && tcon->ipc) {
1099 cifs_dbg(FYI, "ipc connection - fake read inode\n");
1100 spin_lock(&inode->i_lock);
1101 inode->i_mode |= S_IFDIR;
1102 set_nlink(inode, 2);
1103 inode->i_op = &cifs_ipc_inode_ops;
1104 inode->i_fop = &simple_dir_operations;
1105 inode->i_uid = cifs_sb->mnt_uid;
1106 inode->i_gid = cifs_sb->mnt_gid;
1107 spin_unlock(&inode->i_lock);
1110 inode = ERR_PTR(rc);
1115 /* can not call macro free_xid here since in a void func
1116 * TODO: This is no longer true
1123 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1124 char *full_path, __u32 dosattr)
1126 bool set_time = false;
1127 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1128 struct TCP_Server_Info *server;
1129 FILE_BASIC_INFO info_buf;
1134 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1135 if (!server->ops->set_file_info)
1140 if (attrs->ia_valid & ATTR_ATIME) {
1142 info_buf.LastAccessTime =
1143 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1145 info_buf.LastAccessTime = 0;
1147 if (attrs->ia_valid & ATTR_MTIME) {
1149 info_buf.LastWriteTime =
1150 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1152 info_buf.LastWriteTime = 0;
1155 * Samba throws this field away, but windows may actually use it.
1156 * Do not set ctime unless other time stamps are changed explicitly
1157 * (i.e. by utimes()) since we would then have a mix of client and
1160 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1161 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1162 info_buf.ChangeTime =
1163 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1165 info_buf.ChangeTime = 0;
1167 info_buf.CreationTime = 0; /* don't change */
1168 info_buf.Attributes = cpu_to_le32(dosattr);
1170 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1174 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1175 * and rename it to a random name that hopefully won't conflict with
1179 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1180 const unsigned int xid)
1184 struct cifs_fid fid;
1185 struct cifs_open_parms oparms;
1186 struct inode *inode = d_inode(dentry);
1187 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1188 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1189 struct tcon_link *tlink;
1190 struct cifs_tcon *tcon;
1191 __u32 dosattr, origattr;
1192 FILE_BASIC_INFO *info_buf = NULL;
1194 tlink = cifs_sb_tlink(cifs_sb);
1196 return PTR_ERR(tlink);
1197 tcon = tlink_tcon(tlink);
1200 * We cannot rename the file if the server doesn't support
1201 * CAP_INFOLEVEL_PASSTHRU
1203 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1209 oparms.cifs_sb = cifs_sb;
1210 oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1211 oparms.create_options = CREATE_NOT_DIR;
1212 oparms.disposition = FILE_OPEN;
1213 oparms.path = full_path;
1215 oparms.reconnect = false;
1217 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1221 origattr = cifsInode->cifsAttrs;
1223 origattr |= ATTR_NORMAL;
1225 dosattr = origattr & ~ATTR_READONLY;
1227 dosattr |= ATTR_NORMAL;
1228 dosattr |= ATTR_HIDDEN;
1230 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1231 if (dosattr != origattr) {
1232 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1233 if (info_buf == NULL) {
1237 info_buf->Attributes = cpu_to_le32(dosattr);
1238 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1240 /* although we would like to mark the file hidden
1241 if that fails we will still try to rename it */
1243 cifsInode->cifsAttrs = dosattr;
1245 dosattr = origattr; /* since not able to change them */
1248 /* rename the file */
1249 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1251 cifs_remap(cifs_sb));
1257 /* try to set DELETE_ON_CLOSE */
1258 if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1259 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1262 * some samba versions return -ENOENT when we try to set the
1263 * file disposition here. Likely a samba bug, but work around
1264 * it for now. This means that some cifsXXX files may hang
1265 * around after they shouldn't.
1267 * BB: remove this hack after more servers have the fix
1275 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1279 CIFSSMBClose(xid, tcon, fid.netfid);
1282 cifs_put_tlink(tlink);
1286 * reset everything back to the original state. Don't bother
1287 * dealing with errors here since we can't do anything about
1291 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1292 cifs_sb->local_nls, cifs_remap(cifs_sb));
1294 if (dosattr != origattr) {
1295 info_buf->Attributes = cpu_to_le32(origattr);
1296 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1298 cifsInode->cifsAttrs = origattr;
1304 /* copied from fs/nfs/dir.c with small changes */
1306 cifs_drop_nlink(struct inode *inode)
1308 spin_lock(&inode->i_lock);
1309 if (inode->i_nlink > 0)
1311 spin_unlock(&inode->i_lock);
1315 * If d_inode(dentry) is null (usually meaning the cached dentry
1316 * is a negative dentry) then we would attempt a standard SMB delete, but
1317 * if that fails we can not attempt the fall back mechanisms on EACCESS
1318 * but will return the EACCESS to the caller. Note that the VFS does not call
1319 * unlink on negative dentries currently.
1321 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1325 char *full_path = NULL;
1326 struct inode *inode = d_inode(dentry);
1327 struct cifsInodeInfo *cifs_inode;
1328 struct super_block *sb = dir->i_sb;
1329 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1330 struct tcon_link *tlink;
1331 struct cifs_tcon *tcon;
1332 struct TCP_Server_Info *server;
1333 struct iattr *attrs = NULL;
1334 __u32 dosattr = 0, origattr = 0;
1336 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1338 tlink = cifs_sb_tlink(cifs_sb);
1340 return PTR_ERR(tlink);
1341 tcon = tlink_tcon(tlink);
1342 server = tcon->ses->server;
1346 /* Unlink can be called from rename so we can not take the
1347 * sb->s_vfs_rename_mutex here */
1348 full_path = build_path_from_dentry(dentry);
1349 if (full_path == NULL) {
1354 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1355 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1356 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1357 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1358 cifs_remap(cifs_sb));
1359 cifs_dbg(FYI, "posix del rc %d\n", rc);
1360 if ((rc == 0) || (rc == -ENOENT))
1361 goto psx_del_no_retry;
1365 if (!server->ops->unlink) {
1367 goto psx_del_no_retry;
1370 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1375 cifs_drop_nlink(inode);
1376 } else if (rc == -ENOENT) {
1378 } else if (rc == -EBUSY) {
1379 if (server->ops->rename_pending_delete) {
1380 rc = server->ops->rename_pending_delete(full_path,
1383 cifs_drop_nlink(inode);
1385 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1386 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1387 if (attrs == NULL) {
1392 /* try to reset dos attributes */
1393 cifs_inode = CIFS_I(inode);
1394 origattr = cifs_inode->cifsAttrs;
1396 origattr |= ATTR_NORMAL;
1397 dosattr = origattr & ~ATTR_READONLY;
1399 dosattr |= ATTR_NORMAL;
1400 dosattr |= ATTR_HIDDEN;
1402 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1406 goto retry_std_delete;
1409 /* undo the setattr if we errored out and it's needed */
1410 if (rc != 0 && dosattr != 0)
1411 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1415 cifs_inode = CIFS_I(inode);
1416 cifs_inode->time = 0; /* will force revalidate to get info
1418 inode->i_ctime = current_fs_time(sb);
1420 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1421 cifs_inode = CIFS_I(dir);
1422 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1427 cifs_put_tlink(tlink);
1432 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1433 const char *full_path, struct cifs_sb_info *cifs_sb,
1434 struct cifs_tcon *tcon, const unsigned int xid)
1437 struct inode *inode = NULL;
1440 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1443 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1450 * setting nlink not necessary except in cases where we failed to get it
1451 * from the server or was set bogus. Also, since this is a brand new
1452 * inode, no need to grab the i_lock before setting the i_nlink.
1454 if (inode->i_nlink < 2)
1455 set_nlink(inode, 2);
1456 mode &= ~current_umask();
1457 /* must turn on setgid bit if parent dir has it */
1458 if (parent->i_mode & S_ISGID)
1461 if (tcon->unix_ext) {
1462 struct cifs_unix_set_info_args args = {
1464 .ctime = NO_CHANGE_64,
1465 .atime = NO_CHANGE_64,
1466 .mtime = NO_CHANGE_64,
1469 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1470 args.uid = current_fsuid();
1471 if (parent->i_mode & S_ISGID)
1472 args.gid = parent->i_gid;
1474 args.gid = current_fsgid();
1476 args.uid = INVALID_UID; /* no change */
1477 args.gid = INVALID_GID; /* no change */
1479 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1481 cifs_remap(cifs_sb));
1483 struct TCP_Server_Info *server = tcon->ses->server;
1484 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1485 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1486 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1488 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1489 inode->i_mode = (mode | S_IFDIR);
1491 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1492 inode->i_uid = current_fsuid();
1493 if (inode->i_mode & S_ISGID)
1494 inode->i_gid = parent->i_gid;
1496 inode->i_gid = current_fsgid();
1499 d_instantiate(dentry, inode);
1504 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1505 const char *full_path, struct cifs_sb_info *cifs_sb,
1506 struct cifs_tcon *tcon, const unsigned int xid)
1510 FILE_UNIX_BASIC_INFO *info = NULL;
1511 struct inode *newinode = NULL;
1512 struct cifs_fattr fattr;
1514 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1517 goto posix_mkdir_out;
1520 mode &= ~current_umask();
1521 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1522 NULL /* netfid */, info, &oplock, full_path,
1523 cifs_sb->local_nls, cifs_remap(cifs_sb));
1524 if (rc == -EOPNOTSUPP)
1525 goto posix_mkdir_out;
1527 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1529 goto posix_mkdir_out;
1532 if (info->Type == cpu_to_le32(-1))
1533 /* no return info, go query for it */
1534 goto posix_mkdir_get_info;
1536 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1537 * need to set uid/gid.
1540 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1541 cifs_fill_uniqueid(inode->i_sb, &fattr);
1542 newinode = cifs_iget(inode->i_sb, &fattr);
1544 goto posix_mkdir_get_info;
1546 d_instantiate(dentry, newinode);
1548 #ifdef CONFIG_CIFS_DEBUG2
1549 cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1550 dentry, dentry, newinode);
1552 if (newinode->i_nlink != 2)
1553 cifs_dbg(FYI, "unexpected number of links %d\n",
1560 posix_mkdir_get_info:
1561 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1563 goto posix_mkdir_out;
1566 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1570 struct cifs_sb_info *cifs_sb;
1571 struct tcon_link *tlink;
1572 struct cifs_tcon *tcon;
1573 struct TCP_Server_Info *server;
1576 cifs_dbg(FYI, "In cifs_mkdir, mode = %04ho inode = 0x%p\n",
1579 cifs_sb = CIFS_SB(inode->i_sb);
1580 tlink = cifs_sb_tlink(cifs_sb);
1582 return PTR_ERR(tlink);
1583 tcon = tlink_tcon(tlink);
1587 full_path = build_path_from_dentry(direntry);
1588 if (full_path == NULL) {
1593 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1594 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1595 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1597 if (rc != -EOPNOTSUPP)
1601 server = tcon->ses->server;
1603 if (!server->ops->mkdir) {
1608 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1609 rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
1611 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1616 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1620 * Force revalidate to get parent dir info when needed since cached
1621 * attributes are invalid now.
1623 CIFS_I(inode)->time = 0;
1626 cifs_put_tlink(tlink);
1630 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1634 struct cifs_sb_info *cifs_sb;
1635 struct tcon_link *tlink;
1636 struct cifs_tcon *tcon;
1637 struct TCP_Server_Info *server;
1638 char *full_path = NULL;
1639 struct cifsInodeInfo *cifsInode;
1641 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1645 full_path = build_path_from_dentry(direntry);
1646 if (full_path == NULL) {
1651 cifs_sb = CIFS_SB(inode->i_sb);
1652 tlink = cifs_sb_tlink(cifs_sb);
1653 if (IS_ERR(tlink)) {
1654 rc = PTR_ERR(tlink);
1657 tcon = tlink_tcon(tlink);
1658 server = tcon->ses->server;
1660 if (!server->ops->rmdir) {
1662 cifs_put_tlink(tlink);
1666 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1667 cifs_put_tlink(tlink);
1670 spin_lock(&d_inode(direntry)->i_lock);
1671 i_size_write(d_inode(direntry), 0);
1672 clear_nlink(d_inode(direntry));
1673 spin_unlock(&d_inode(direntry)->i_lock);
1676 cifsInode = CIFS_I(d_inode(direntry));
1677 /* force revalidate to go get info when needed */
1678 cifsInode->time = 0;
1680 cifsInode = CIFS_I(inode);
1682 * Force revalidate to get parent dir info when needed since cached
1683 * attributes are invalid now.
1685 cifsInode->time = 0;
1687 d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
1688 current_fs_time(inode->i_sb);
1697 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1698 const char *from_path, struct dentry *to_dentry,
1699 const char *to_path)
1701 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1702 struct tcon_link *tlink;
1703 struct cifs_tcon *tcon;
1704 struct TCP_Server_Info *server;
1705 struct cifs_fid fid;
1706 struct cifs_open_parms oparms;
1709 tlink = cifs_sb_tlink(cifs_sb);
1711 return PTR_ERR(tlink);
1712 tcon = tlink_tcon(tlink);
1713 server = tcon->ses->server;
1715 if (!server->ops->rename)
1718 /* try path-based rename first */
1719 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1722 * Don't bother with rename by filehandle unless file is busy and
1723 * source. Note that cross directory moves do not work with
1724 * rename by filehandle to various Windows servers.
1726 if (rc == 0 || rc != -EBUSY)
1727 goto do_rename_exit;
1729 /* Don't fall back to using SMB on SMB 2+ mount */
1730 if (server->vals->protocol_id != 0)
1731 goto do_rename_exit;
1733 /* open-file renames don't work across directories */
1734 if (to_dentry->d_parent != from_dentry->d_parent)
1735 goto do_rename_exit;
1738 oparms.cifs_sb = cifs_sb;
1739 /* open the file to be renamed -- we need DELETE perms */
1740 oparms.desired_access = DELETE;
1741 oparms.create_options = CREATE_NOT_DIR;
1742 oparms.disposition = FILE_OPEN;
1743 oparms.path = from_path;
1745 oparms.reconnect = false;
1747 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1749 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
1750 (const char *) to_dentry->d_name.name,
1751 cifs_sb->local_nls, cifs_remap(cifs_sb));
1752 CIFSSMBClose(xid, tcon, fid.netfid);
1755 cifs_put_tlink(tlink);
1760 cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
1761 struct inode *target_dir, struct dentry *target_dentry,
1764 char *from_name = NULL;
1765 char *to_name = NULL;
1766 struct cifs_sb_info *cifs_sb;
1767 struct tcon_link *tlink;
1768 struct cifs_tcon *tcon;
1769 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1770 FILE_UNIX_BASIC_INFO *info_buf_target;
1774 if (flags & ~RENAME_NOREPLACE)
1777 cifs_sb = CIFS_SB(source_dir->i_sb);
1778 tlink = cifs_sb_tlink(cifs_sb);
1780 return PTR_ERR(tlink);
1781 tcon = tlink_tcon(tlink);
1786 * we already have the rename sem so we do not need to
1787 * grab it again here to protect the path integrity
1789 from_name = build_path_from_dentry(source_dentry);
1790 if (from_name == NULL) {
1792 goto cifs_rename_exit;
1795 to_name = build_path_from_dentry(target_dentry);
1796 if (to_name == NULL) {
1798 goto cifs_rename_exit;
1801 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1805 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1807 if (flags & RENAME_NOREPLACE)
1808 goto cifs_rename_exit;
1810 if (rc == -EEXIST && tcon->unix_ext) {
1812 * Are src and dst hardlinks of same inode? We can only tell
1813 * with unix extensions enabled.
1816 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1818 if (info_buf_source == NULL) {
1820 goto cifs_rename_exit;
1823 info_buf_target = info_buf_source + 1;
1824 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1827 cifs_remap(cifs_sb));
1831 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1834 cifs_remap(cifs_sb));
1836 if (tmprc == 0 && (info_buf_source->UniqueId ==
1837 info_buf_target->UniqueId)) {
1838 /* same file, POSIX says that this is a noop */
1840 goto cifs_rename_exit;
1844 * else ... BB we could add the same check for Windows by
1845 * checking the UniqueId via FILE_INTERNAL_INFO
1849 /* Try unlinking the target dentry if it's not negative */
1850 if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
1851 if (d_is_dir(target_dentry))
1852 tmprc = cifs_rmdir(target_dir, target_dentry);
1854 tmprc = cifs_unlink(target_dir, target_dentry);
1856 goto cifs_rename_exit;
1857 rc = cifs_do_rename(xid, source_dentry, from_name,
1858 target_dentry, to_name);
1861 /* force revalidate to go get info when needed */
1862 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
1864 source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
1865 target_dir->i_mtime = current_fs_time(source_dir->i_sb);
1868 kfree(info_buf_source);
1872 cifs_put_tlink(tlink);
1877 cifs_inode_needs_reval(struct inode *inode)
1879 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1880 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1882 if (CIFS_CACHE_READ(cifs_i))
1885 if (!lookupCacheEnabled)
1888 if (cifs_i->time == 0)
1891 if (!cifs_sb->actimeo)
1894 if (!time_in_range(jiffies, cifs_i->time,
1895 cifs_i->time + cifs_sb->actimeo))
1898 /* hardlinked files w/ noserverino get "special" treatment */
1899 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1900 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1907 * Zap the cache. Called when invalid_mapping flag is set.
1910 cifs_invalidate_mapping(struct inode *inode)
1914 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1915 rc = invalidate_inode_pages2(inode->i_mapping);
1917 cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1921 cifs_fscache_reset_inode_cookie(inode);
1926 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
1927 * @word: long word containing the bit lock
1930 cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
1932 freezable_schedule_unsafe();
1933 if (signal_pending_state(mode, current))
1934 return -ERESTARTSYS;
1939 cifs_revalidate_mapping(struct inode *inode)
1942 unsigned long *flags = &CIFS_I(inode)->flags;
1944 rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
1949 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
1950 rc = cifs_invalidate_mapping(inode);
1952 set_bit(CIFS_INO_INVALID_MAPPING, flags);
1955 clear_bit_unlock(CIFS_INO_LOCK, flags);
1956 smp_mb__after_atomic();
1957 wake_up_bit(flags, CIFS_INO_LOCK);
1963 cifs_zap_mapping(struct inode *inode)
1965 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
1966 return cifs_revalidate_mapping(inode);
1969 int cifs_revalidate_file_attr(struct file *filp)
1972 struct inode *inode = file_inode(filp);
1973 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1975 if (!cifs_inode_needs_reval(inode))
1978 if (tlink_tcon(cfile->tlink)->unix_ext)
1979 rc = cifs_get_file_info_unix(filp);
1981 rc = cifs_get_file_info(filp);
1986 int cifs_revalidate_dentry_attr(struct dentry *dentry)
1990 struct inode *inode = d_inode(dentry);
1991 struct super_block *sb = dentry->d_sb;
1992 char *full_path = NULL;
1998 if (!cifs_inode_needs_reval(inode))
2003 /* can not safely grab the rename sem here if rename calls revalidate
2004 since that would deadlock */
2005 full_path = build_path_from_dentry(dentry);
2006 if (full_path == NULL) {
2011 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2012 full_path, inode, inode->i_count.counter,
2013 dentry, cifs_get_time(dentry), jiffies);
2016 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
2017 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2019 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2021 if (rc == -EAGAIN && count++ < 10)
2030 int cifs_revalidate_file(struct file *filp)
2033 struct inode *inode = file_inode(filp);
2035 rc = cifs_revalidate_file_attr(filp);
2039 return cifs_revalidate_mapping(inode);
2042 /* revalidate a dentry's inode attributes */
2043 int cifs_revalidate_dentry(struct dentry *dentry)
2046 struct inode *inode = d_inode(dentry);
2048 rc = cifs_revalidate_dentry_attr(dentry);
2052 return cifs_revalidate_mapping(inode);
2055 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
2058 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2059 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2060 struct inode *inode = d_inode(dentry);
2064 * We need to be sure that all dirty pages are written and the server
2065 * has actual ctime, mtime and file length.
2067 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2068 inode->i_mapping->nrpages != 0) {
2069 rc = filemap_fdatawait(inode->i_mapping);
2071 mapping_set_error(inode->i_mapping, rc);
2076 rc = cifs_revalidate_dentry_attr(dentry);
2080 generic_fillattr(inode, stat);
2081 stat->blksize = CIFS_MAX_MSGSIZE;
2082 stat->ino = CIFS_I(inode)->uniqueid;
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 spin_lock(&inode->i_lock);
2120 i_size_write(inode, offset);
2121 spin_unlock(&inode->i_lock);
2123 truncate_pagecache(inode, offset);
2127 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2128 unsigned int xid, char *full_path)
2131 struct cifsFileInfo *open_file;
2132 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2133 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2134 struct tcon_link *tlink = NULL;
2135 struct cifs_tcon *tcon = NULL;
2136 struct TCP_Server_Info *server;
2139 * To avoid spurious oplock breaks from server, in the case of
2140 * inodes that we already have open, avoid doing path based
2141 * setting of file size if we can do it by handle.
2142 * This keeps our caching token (oplock) and avoids timeouts
2143 * when the local oplock break takes longer to flush
2144 * writebehind data than the SMB timeout for the SetPathInfo
2145 * request would allow
2147 open_file = find_writable_file(cifsInode, true);
2149 tcon = tlink_tcon(open_file->tlink);
2150 server = tcon->ses->server;
2151 if (server->ops->set_file_size)
2152 rc = server->ops->set_file_size(xid, tcon, open_file,
2153 attrs->ia_size, false);
2156 cifsFileInfo_put(open_file);
2157 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2165 tlink = cifs_sb_tlink(cifs_sb);
2167 return PTR_ERR(tlink);
2168 tcon = tlink_tcon(tlink);
2169 server = tcon->ses->server;
2173 * Set file size by pathname rather than by handle either because no
2174 * valid, writeable file handle for it was found or because there was
2175 * an error setting it by handle.
2177 if (server->ops->set_path_size)
2178 rc = server->ops->set_path_size(xid, tcon, full_path,
2179 attrs->ia_size, cifs_sb, false);
2182 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2185 cifs_put_tlink(tlink);
2189 cifsInode->server_eof = attrs->ia_size;
2190 cifs_setsize(inode, attrs->ia_size);
2193 * The man page of truncate says if the size changed,
2194 * then the st_ctime and st_mtime fields for the file
2197 attrs->ia_ctime = attrs->ia_mtime = current_time(inode);
2198 attrs->ia_valid |= ATTR_CTIME | ATTR_MTIME;
2200 cifs_truncate_page(inode->i_mapping, inode->i_size);
2207 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2211 char *full_path = NULL;
2212 struct inode *inode = d_inode(direntry);
2213 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2214 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2215 struct tcon_link *tlink;
2216 struct cifs_tcon *pTcon;
2217 struct cifs_unix_set_info_args *args = NULL;
2218 struct cifsFileInfo *open_file;
2220 cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2221 direntry, attrs->ia_valid);
2225 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2226 attrs->ia_valid |= ATTR_FORCE;
2228 rc = setattr_prepare(direntry, attrs);
2232 full_path = build_path_from_dentry(direntry);
2233 if (full_path == NULL) {
2239 * Attempt to flush data before changing attributes. We need to do
2240 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2241 * ownership or mode then we may also need to do this. Here, we take
2242 * the safe way out and just do the flush on all setattr requests. If
2243 * the flush returns error, store it to report later and continue.
2245 * BB: This should be smarter. Why bother flushing pages that
2246 * will be truncated anyway? Also, should we error out here if
2247 * the flush returns error?
2249 rc = filemap_write_and_wait(inode->i_mapping);
2250 mapping_set_error(inode->i_mapping, rc);
2253 if (attrs->ia_valid & ATTR_SIZE) {
2254 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2259 /* skip mode change if it's just for clearing setuid/setgid */
2260 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2261 attrs->ia_valid &= ~ATTR_MODE;
2263 args = kmalloc(sizeof(*args), GFP_KERNEL);
2269 /* set up the struct */
2270 if (attrs->ia_valid & ATTR_MODE)
2271 args->mode = attrs->ia_mode;
2273 args->mode = NO_CHANGE_64;
2275 if (attrs->ia_valid & ATTR_UID)
2276 args->uid = attrs->ia_uid;
2278 args->uid = INVALID_UID; /* no change */
2280 if (attrs->ia_valid & ATTR_GID)
2281 args->gid = attrs->ia_gid;
2283 args->gid = INVALID_GID; /* no change */
2285 if (attrs->ia_valid & ATTR_ATIME)
2286 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2288 args->atime = NO_CHANGE_64;
2290 if (attrs->ia_valid & ATTR_MTIME)
2291 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2293 args->mtime = NO_CHANGE_64;
2295 if (attrs->ia_valid & ATTR_CTIME)
2296 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2298 args->ctime = NO_CHANGE_64;
2301 open_file = find_writable_file(cifsInode, true);
2303 u16 nfid = open_file->fid.netfid;
2304 u32 npid = open_file->pid;
2305 pTcon = tlink_tcon(open_file->tlink);
2306 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2307 cifsFileInfo_put(open_file);
2309 tlink = cifs_sb_tlink(cifs_sb);
2310 if (IS_ERR(tlink)) {
2311 rc = PTR_ERR(tlink);
2314 pTcon = tlink_tcon(tlink);
2315 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2317 cifs_remap(cifs_sb));
2318 cifs_put_tlink(tlink);
2324 if ((attrs->ia_valid & ATTR_SIZE) &&
2325 attrs->ia_size != i_size_read(inode))
2326 truncate_setsize(inode, attrs->ia_size);
2328 setattr_copy(inode, attrs);
2329 mark_inode_dirty(inode);
2331 /* force revalidate when any of these times are set since some
2332 of the fs types (eg ext3, fat) do not have fine enough
2333 time granularity to match protocol, and we do not have a
2334 a way (yet) to query the server fs's time granularity (and
2335 whether it rounds times down).
2337 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2338 cifsInode->time = 0;
2347 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2350 kuid_t uid = INVALID_UID;
2351 kgid_t gid = INVALID_GID;
2352 struct inode *inode = d_inode(direntry);
2353 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2354 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2355 char *full_path = NULL;
2358 __u64 mode = NO_CHANGE_64;
2362 cifs_dbg(FYI, "setattr on file %pd attrs->iavalid 0x%x\n",
2363 direntry, attrs->ia_valid);
2365 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2366 attrs->ia_valid |= ATTR_FORCE;
2368 rc = setattr_prepare(direntry, attrs);
2374 full_path = build_path_from_dentry(direntry);
2375 if (full_path == NULL) {
2382 * Attempt to flush data before changing attributes. We need to do
2383 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2384 * ownership or mode then we may also need to do this. Here, we take
2385 * the safe way out and just do the flush on all setattr requests. If
2386 * the flush returns error, store it to report later and continue.
2388 * BB: This should be smarter. Why bother flushing pages that
2389 * will be truncated anyway? Also, should we error out here if
2390 * the flush returns error?
2392 rc = filemap_write_and_wait(inode->i_mapping);
2393 mapping_set_error(inode->i_mapping, rc);
2396 if (attrs->ia_valid & ATTR_SIZE) {
2397 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2399 goto cifs_setattr_exit;
2402 if (attrs->ia_valid & ATTR_UID)
2403 uid = attrs->ia_uid;
2405 if (attrs->ia_valid & ATTR_GID)
2406 gid = attrs->ia_gid;
2408 #ifdef CONFIG_CIFS_ACL
2409 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2410 if (uid_valid(uid) || gid_valid(gid)) {
2411 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2414 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2416 goto cifs_setattr_exit;
2420 #endif /* CONFIG_CIFS_ACL */
2421 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2422 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2424 /* skip mode change if it's just for clearing setuid/setgid */
2425 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2426 attrs->ia_valid &= ~ATTR_MODE;
2428 if (attrs->ia_valid & ATTR_MODE) {
2429 mode = attrs->ia_mode;
2431 #ifdef CONFIG_CIFS_ACL
2432 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2433 rc = id_mode_to_cifs_acl(inode, full_path, mode,
2434 INVALID_UID, INVALID_GID);
2436 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2438 goto cifs_setattr_exit;
2441 #endif /* CONFIG_CIFS_ACL */
2442 if (((mode & S_IWUGO) == 0) &&
2443 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2445 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2447 /* fix up mode if we're not using dynperm */
2448 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2449 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2450 } else if ((mode & S_IWUGO) &&
2451 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2453 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2454 /* Attributes of 0 are ignored */
2456 dosattr |= ATTR_NORMAL;
2458 /* reset local inode permissions to normal */
2459 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2460 attrs->ia_mode &= ~(S_IALLUGO);
2461 if (S_ISDIR(inode->i_mode))
2463 cifs_sb->mnt_dir_mode;
2466 cifs_sb->mnt_file_mode;
2468 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2469 /* ignore mode change - ATTR_READONLY hasn't changed */
2470 attrs->ia_valid &= ~ATTR_MODE;
2474 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2475 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2476 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2477 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2479 /* Even if error on time set, no sense failing the call if
2480 the server would set the time to a reasonable value anyway,
2481 and this check ensures that we are not being called from
2482 sys_utimes in which case we ought to fail the call back to
2483 the user when the server rejects the call */
2484 if ((rc) && (attrs->ia_valid &
2485 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2489 /* do not need local check to inode_check_ok since the server does
2492 goto cifs_setattr_exit;
2494 if ((attrs->ia_valid & ATTR_SIZE) &&
2495 attrs->ia_size != i_size_read(inode))
2496 truncate_setsize(inode, attrs->ia_size);
2498 setattr_copy(inode, attrs);
2499 mark_inode_dirty(inode);
2508 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2510 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
2511 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2513 if (pTcon->unix_ext)
2514 return cifs_setattr_unix(direntry, attrs);
2516 return cifs_setattr_nounix(direntry, attrs);
2518 /* BB: add cifs_setattr_legacy for really old servers */
2522 void cifs_delete_inode(struct inode *inode)
2524 cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2525 /* may have to add back in if and when safe distributed caching of
2526 directories added e.g. via FindNotify */