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);
99 cifs_dbg(FYI, "%s: revalidating inode %llu\n",
100 __func__, cifs_i->uniqueid);
102 if (inode->i_state & I_NEW) {
103 cifs_dbg(FYI, "%s: inode %llu is new\n",
104 __func__, cifs_i->uniqueid);
108 /* don't bother with revalidation if we have an oplock */
109 if (CIFS_CACHE_READ(cifs_i)) {
110 cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
111 __func__, cifs_i->uniqueid);
115 /* revalidate if mtime or size have changed */
116 if (timespec_equal(&inode->i_mtime, &fattr->cf_mtime) &&
117 cifs_i->server_eof == fattr->cf_eof) {
118 cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
119 __func__, cifs_i->uniqueid);
123 cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
124 __func__, cifs_i->uniqueid);
125 set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags);
129 * copy nlink to the inode, unless it wasn't provided. Provide
130 * sane values if we don't have an existing one and none was provided
133 cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
136 * if we're in a situation where we can't trust what we
137 * got from the server (readdir, some non-unix cases)
138 * fake reasonable values
140 if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
141 /* only provide fake values on a new inode */
142 if (inode->i_state & I_NEW) {
143 if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
151 /* we trust the server, so update it */
152 set_nlink(inode, fattr->cf_nlink);
155 /* populate an inode with info from a cifs_fattr struct */
157 cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
159 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
160 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
162 cifs_revalidate_cache(inode, fattr);
164 spin_lock(&inode->i_lock);
165 inode->i_atime = fattr->cf_atime;
166 inode->i_mtime = fattr->cf_mtime;
167 inode->i_ctime = fattr->cf_ctime;
168 inode->i_rdev = fattr->cf_rdev;
169 cifs_nlink_fattr_to_inode(inode, fattr);
170 inode->i_uid = fattr->cf_uid;
171 inode->i_gid = fattr->cf_gid;
173 /* if dynperm is set, don't clobber existing mode */
174 if (inode->i_state & I_NEW ||
175 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
176 inode->i_mode = fattr->cf_mode;
178 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
180 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
183 cifs_i->time = jiffies;
185 if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING)
186 set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
188 clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
190 cifs_i->server_eof = fattr->cf_eof;
192 * Can't safely change the file size here if the client is writing to
193 * it due to potential races.
195 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
196 i_size_write(inode, fattr->cf_eof);
199 * i_blocks is not related to (i_size / i_blksize),
200 * but instead 512 byte (2**9) size is required for
201 * calculating num blocks.
203 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
205 spin_unlock(&inode->i_lock);
207 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
208 inode->i_flags |= S_AUTOMOUNT;
209 if (inode->i_state & I_NEW)
214 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
216 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
218 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
221 fattr->cf_uniqueid = iunique(sb, ROOT_I);
224 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
226 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
227 struct cifs_sb_info *cifs_sb)
229 memset(fattr, 0, sizeof(*fattr));
230 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
231 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
232 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
234 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
235 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
236 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
237 /* old POSIX extensions don't get create time */
239 fattr->cf_mode = le64_to_cpu(info->Permissions);
242 * Since we set the inode type below we need to mask off
243 * to avoid strange results if bits set above.
245 fattr->cf_mode &= ~S_IFMT;
246 switch (le32_to_cpu(info->Type)) {
248 fattr->cf_mode |= S_IFREG;
249 fattr->cf_dtype = DT_REG;
252 fattr->cf_mode |= S_IFLNK;
253 fattr->cf_dtype = DT_LNK;
256 fattr->cf_mode |= S_IFDIR;
257 fattr->cf_dtype = DT_DIR;
260 fattr->cf_mode |= S_IFCHR;
261 fattr->cf_dtype = DT_CHR;
262 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
263 le64_to_cpu(info->DevMinor) & MINORMASK);
266 fattr->cf_mode |= S_IFBLK;
267 fattr->cf_dtype = DT_BLK;
268 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
269 le64_to_cpu(info->DevMinor) & MINORMASK);
272 fattr->cf_mode |= S_IFIFO;
273 fattr->cf_dtype = DT_FIFO;
276 fattr->cf_mode |= S_IFSOCK;
277 fattr->cf_dtype = DT_SOCK;
280 /* safest to call it a file if we do not know */
281 fattr->cf_mode |= S_IFREG;
282 fattr->cf_dtype = DT_REG;
283 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
287 fattr->cf_uid = cifs_sb->mnt_uid;
288 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
289 u64 id = le64_to_cpu(info->Uid);
290 if (id < ((uid_t)-1)) {
291 kuid_t uid = make_kuid(&init_user_ns, id);
297 fattr->cf_gid = cifs_sb->mnt_gid;
298 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
299 u64 id = le64_to_cpu(info->Gid);
300 if (id < ((gid_t)-1)) {
301 kgid_t gid = make_kgid(&init_user_ns, id);
307 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
311 * Fill a cifs_fattr struct with fake inode info.
313 * Needed to setup cifs_fattr data for the directory which is the
314 * junction to the new submount (ie to setup the fake directory
315 * which represents a DFS referral).
318 cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
320 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
322 cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
324 memset(fattr, 0, sizeof(*fattr));
325 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
326 fattr->cf_uid = cifs_sb->mnt_uid;
327 fattr->cf_gid = cifs_sb->mnt_gid;
328 ktime_get_real_ts(&fattr->cf_mtime);
329 fattr->cf_mtime = timespec_trunc(fattr->cf_mtime, sb->s_time_gran);
330 fattr->cf_atime = fattr->cf_ctime = fattr->cf_mtime;
332 fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
336 cifs_get_file_info_unix(struct file *filp)
340 FILE_UNIX_BASIC_INFO find_data;
341 struct cifs_fattr fattr;
342 struct inode *inode = file_inode(filp);
343 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
344 struct cifsFileInfo *cfile = filp->private_data;
345 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
348 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
350 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
351 } else if (rc == -EREMOTE) {
352 cifs_create_dfs_fattr(&fattr, inode->i_sb);
356 cifs_fattr_to_inode(inode, &fattr);
361 int cifs_get_inode_info_unix(struct inode **pinode,
362 const unsigned char *full_path,
363 struct super_block *sb, unsigned int xid)
366 FILE_UNIX_BASIC_INFO find_data;
367 struct cifs_fattr fattr;
368 struct cifs_tcon *tcon;
369 struct tcon_link *tlink;
370 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
372 cifs_dbg(FYI, "Getting info on %s\n", full_path);
374 tlink = cifs_sb_tlink(cifs_sb);
376 return PTR_ERR(tlink);
377 tcon = tlink_tcon(tlink);
379 /* could have done a find first instead but this returns more info */
380 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
381 cifs_sb->local_nls, cifs_remap(cifs_sb));
382 cifs_put_tlink(tlink);
385 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
386 } else if (rc == -EREMOTE) {
387 cifs_create_dfs_fattr(&fattr, sb);
393 /* check for Minshall+French symlinks */
394 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
395 int tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
398 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
401 if (*pinode == NULL) {
403 cifs_fill_uniqueid(sb, &fattr);
404 *pinode = cifs_iget(sb, &fattr);
408 /* we already have inode, update it */
410 /* if uniqueid is different, return error */
411 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
412 CIFS_I(*pinode)->uniqueid != fattr.cf_uniqueid)) {
417 /* if filetype is different, return error */
418 if (unlikely(((*pinode)->i_mode & S_IFMT) !=
419 (fattr.cf_mode & S_IFMT))) {
424 cifs_fattr_to_inode(*pinode, &fattr);
432 cifs_sfu_type(struct cifs_fattr *fattr, const char *path,
433 struct cifs_sb_info *cifs_sb, unsigned int xid)
437 struct tcon_link *tlink;
438 struct cifs_tcon *tcon;
440 struct cifs_open_parms oparms;
441 struct cifs_io_parms io_parms;
443 unsigned int bytes_read;
445 int buf_type = CIFS_NO_BUFFER;
449 fattr->cf_mode &= ~S_IFMT;
451 if (fattr->cf_eof == 0) {
452 fattr->cf_mode |= S_IFIFO;
453 fattr->cf_dtype = DT_FIFO;
455 } else if (fattr->cf_eof < 8) {
456 fattr->cf_mode |= S_IFREG;
457 fattr->cf_dtype = DT_REG;
458 return -EINVAL; /* EOPNOTSUPP? */
461 tlink = cifs_sb_tlink(cifs_sb);
463 return PTR_ERR(tlink);
464 tcon = tlink_tcon(tlink);
467 oparms.cifs_sb = cifs_sb;
468 oparms.desired_access = GENERIC_READ;
469 oparms.create_options = CREATE_NOT_DIR;
470 oparms.disposition = FILE_OPEN;
473 oparms.reconnect = false;
475 if (tcon->ses->server->oplocks)
479 rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);
481 cifs_dbg(FYI, "check sfu type of %s, open rc = %d\n", path, rc);
482 cifs_put_tlink(tlink);
487 io_parms.netfid = fid.netfid;
488 io_parms.pid = current->tgid;
489 io_parms.tcon = tcon;
491 io_parms.length = 24;
493 rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,
494 &bytes_read, &pbuf, &buf_type);
495 if ((rc == 0) && (bytes_read >= 8)) {
496 if (memcmp("IntxBLK", pbuf, 8) == 0) {
497 cifs_dbg(FYI, "Block device\n");
498 fattr->cf_mode |= S_IFBLK;
499 fattr->cf_dtype = DT_BLK;
500 if (bytes_read == 24) {
501 /* we have enough to decode dev num */
502 __u64 mjr; /* major */
503 __u64 mnr; /* minor */
504 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
505 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
506 fattr->cf_rdev = MKDEV(mjr, mnr);
508 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
509 cifs_dbg(FYI, "Char device\n");
510 fattr->cf_mode |= S_IFCHR;
511 fattr->cf_dtype = DT_CHR;
512 if (bytes_read == 24) {
513 /* we have enough to decode dev num */
514 __u64 mjr; /* major */
515 __u64 mnr; /* minor */
516 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
517 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
518 fattr->cf_rdev = MKDEV(mjr, mnr);
520 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
521 cifs_dbg(FYI, "Symlink\n");
522 fattr->cf_mode |= S_IFLNK;
523 fattr->cf_dtype = DT_LNK;
525 fattr->cf_mode |= S_IFREG; /* file? */
526 fattr->cf_dtype = DT_REG;
530 fattr->cf_mode |= S_IFREG; /* then it is a file */
531 fattr->cf_dtype = DT_REG;
532 rc = -EOPNOTSUPP; /* or some unknown SFU type */
535 tcon->ses->server->ops->close(xid, tcon, &fid);
536 cifs_put_tlink(tlink);
540 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
543 * Fetch mode bits as provided by SFU.
545 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
547 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
548 struct cifs_sb_info *cifs_sb, unsigned int xid)
550 #ifdef CONFIG_CIFS_XATTR
554 struct tcon_link *tlink;
555 struct cifs_tcon *tcon;
557 tlink = cifs_sb_tlink(cifs_sb);
559 return PTR_ERR(tlink);
560 tcon = tlink_tcon(tlink);
562 if (tcon->ses->server->ops->query_all_EAs == NULL) {
563 cifs_put_tlink(tlink);
567 rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
568 "SETFILEBITS", ea_value, 4 /* size of buf */,
570 cifs_put_tlink(tlink);
574 mode = le32_to_cpu(*((__le32 *)ea_value));
575 fattr->cf_mode &= ~SFBITS_MASK;
576 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
577 mode, fattr->cf_mode);
578 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
579 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
588 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
590 cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
591 struct super_block *sb, bool adjust_tz,
594 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
595 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
597 memset(fattr, 0, sizeof(*fattr));
598 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
599 if (info->DeletePending)
600 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
602 if (info->LastAccessTime)
603 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
605 ktime_get_real_ts(&fattr->cf_atime);
606 fattr->cf_atime = timespec_trunc(fattr->cf_atime, sb->s_time_gran);
609 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
610 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
613 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
614 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
617 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
618 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
619 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
621 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
624 fattr->cf_mode = S_IFLNK;
625 fattr->cf_dtype = DT_LNK;
626 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
627 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
628 fattr->cf_dtype = DT_DIR;
630 * Server can return wrong NumberOfLinks value for directories
631 * when Unix extensions are disabled - fake it.
634 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
636 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
637 fattr->cf_dtype = DT_REG;
639 /* clear write bits if ATTR_READONLY is set */
640 if (fattr->cf_cifsattrs & ATTR_READONLY)
641 fattr->cf_mode &= ~(S_IWUGO);
644 * Don't accept zero nlink from non-unix servers unless
645 * delete is pending. Instead mark it as unknown.
647 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
648 !info->DeletePending) {
649 cifs_dbg(1, "bogus file nlink value %u\n",
651 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
655 fattr->cf_uid = cifs_sb->mnt_uid;
656 fattr->cf_gid = cifs_sb->mnt_gid;
660 cifs_get_file_info(struct file *filp)
664 FILE_ALL_INFO find_data;
665 struct cifs_fattr fattr;
666 struct inode *inode = file_inode(filp);
667 struct cifsFileInfo *cfile = filp->private_data;
668 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
669 struct TCP_Server_Info *server = tcon->ses->server;
671 if (!server->ops->query_file_info)
675 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
678 cifs_all_info_to_fattr(&fattr, &find_data, inode->i_sb, false,
682 cifs_create_dfs_fattr(&fattr, inode->i_sb);
688 * FIXME: legacy server -- fall back to path-based call?
689 * for now, just skip revalidating and mark inode for
693 CIFS_I(inode)->time = 0;
699 * don't bother with SFU junk here -- just mark inode as needing
702 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
703 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
704 cifs_fattr_to_inode(inode, &fattr);
710 /* Simple function to return a 64 bit hash of string. Rarely called */
711 static __u64 simple_hashstr(const char *str)
713 const __u64 hash_mult = 1125899906842597ULL; /* a big enough prime */
717 hash = (hash + (__u64) *str++) * hash_mult;
723 cifs_get_inode_info(struct inode **inode, const char *full_path,
724 FILE_ALL_INFO *data, struct super_block *sb, int xid,
725 const struct cifs_fid *fid)
727 bool validinum = false;
729 int rc = 0, tmprc = ENOSYS;
730 struct cifs_tcon *tcon;
731 struct TCP_Server_Info *server;
732 struct tcon_link *tlink;
733 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
735 bool adjust_tz = false;
736 struct cifs_fattr fattr;
737 struct cifs_search_info *srchinf = NULL;
738 bool symlink = false;
740 tlink = cifs_sb_tlink(cifs_sb);
742 return PTR_ERR(tlink);
743 tcon = tlink_tcon(tlink);
744 server = tcon->ses->server;
746 cifs_dbg(FYI, "Getting info on %s\n", full_path);
748 if ((data == NULL) && (*inode != NULL)) {
749 if (CIFS_CACHE_READ(CIFS_I(*inode)) &&
750 CIFS_I(*inode)->time != 0) {
751 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
756 /* if inode info is not passed, get it from server */
758 if (!server->ops->query_path_info) {
762 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
767 data = (FILE_ALL_INFO *)buf;
768 rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path,
769 data, &adjust_tz, &symlink);
773 cifs_all_info_to_fattr(&fattr, data, sb, adjust_tz,
775 } else if (rc == -EREMOTE) {
776 cifs_create_dfs_fattr(&fattr, sb);
778 } else if (rc == -EACCES && backup_cred(cifs_sb)) {
779 srchinf = kzalloc(sizeof(struct cifs_search_info),
781 if (srchinf == NULL) {
786 srchinf->endOfSearch = false;
787 srchinf->info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
789 srchflgs = CIFS_SEARCH_CLOSE_ALWAYS |
790 CIFS_SEARCH_CLOSE_AT_END |
791 CIFS_SEARCH_BACKUP_SEARCH;
793 rc = CIFSFindFirst(xid, tcon, full_path,
794 cifs_sb, NULL, srchflgs, srchinf, false);
797 (FILE_ALL_INFO *)srchinf->srch_entries_start;
799 cifs_dir_info_to_fattr(&fattr,
800 (FILE_DIRECTORY_INFO *)data, cifs_sb);
801 fattr.cf_uniqueid = le64_to_cpu(
802 ((SEARCH_ID_FULL_DIR_INFO *)data)->UniqueId);
805 cifs_buf_release(srchinf->ntwrk_buf_start);
814 * If an inode wasn't passed in, then get the inode number
816 * Is an i_ino of zero legal? Can we use that to check if the server
817 * supports returning inode numbers? Are there other sanity checks we
818 * can use to ensure that the server is really filling in that field?
820 if (*inode == NULL) {
821 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
822 if (validinum == false) {
823 if (server->ops->get_srv_inum)
824 tmprc = server->ops->get_srv_inum(xid,
825 tcon, cifs_sb, full_path,
826 &fattr.cf_uniqueid, data);
828 cifs_dbg(FYI, "GetSrvInodeNum rc %d\n",
830 fattr.cf_uniqueid = iunique(sb, ROOT_I);
831 cifs_autodisable_serverino(cifs_sb);
832 } else if ((fattr.cf_uniqueid == 0) &&
833 strlen(full_path) == 0) {
834 /* some servers ret bad root ino ie 0 */
835 cifs_dbg(FYI, "Invalid (0) inodenum\n");
837 CIFS_FATTR_FAKE_ROOT_INO;
839 simple_hashstr(tcon->treeName);
843 fattr.cf_uniqueid = iunique(sb, ROOT_I);
845 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
846 validinum == false && server->ops->get_srv_inum) {
848 * Pass a NULL tcon to ensure we don't make a round
849 * trip to the server. This only works for SMB2+.
851 tmprc = server->ops->get_srv_inum(xid,
852 NULL, cifs_sb, full_path,
853 &fattr.cf_uniqueid, data);
855 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
856 else if ((fattr.cf_uniqueid == 0) &&
857 strlen(full_path) == 0) {
859 * Reuse existing root inode num since
860 * inum zero for root causes ls of . and .. to
863 cifs_dbg(FYI, "Srv ret 0 inode num for root\n");
864 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
867 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
870 /* query for SFU type info if supported and needed */
871 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
872 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
873 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
875 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
878 #ifdef CONFIG_CIFS_ACL
879 /* fill in 0777 bits from ACL */
880 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
881 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, full_path, fid);
883 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
888 #endif /* CONFIG_CIFS_ACL */
890 /* fill in remaining high mode bits e.g. SUID, VTX */
891 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
892 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
894 /* check for Minshall+French symlinks */
895 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
896 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
899 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
903 *inode = cifs_iget(sb, &fattr);
907 /* we already have inode, update it */
909 /* if uniqueid is different, return error */
910 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
911 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
916 /* if filetype is different, return error */
917 if (unlikely(((*inode)->i_mode & S_IFMT) !=
918 (fattr.cf_mode & S_IFMT))) {
923 cifs_fattr_to_inode(*inode, &fattr);
927 if ((*inode) && ((*inode)->i_ino == 0))
928 cifs_dbg(FYI, "inode number of zero returned\n");
931 cifs_put_tlink(tlink);
935 static const struct inode_operations cifs_ipc_inode_ops = {
936 .lookup = cifs_lookup,
940 cifs_find_inode(struct inode *inode, void *opaque)
942 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
944 /* don't match inode with different uniqueid */
945 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
948 /* use createtime like an i_generation field */
949 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
952 /* don't match inode of different type */
953 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
956 /* if it's not a directory or has no dentries, then flag it */
957 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
958 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
964 cifs_init_inode(struct inode *inode, void *opaque)
966 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
968 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
969 CIFS_I(inode)->createtime = fattr->cf_createtime;
974 * walk dentry list for an inode and report whether it has aliases that
975 * are hashed. We use this to determine if a directory inode can actually
979 inode_has_hashed_dentries(struct inode *inode)
981 struct dentry *dentry;
983 spin_lock(&inode->i_lock);
984 hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
985 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
986 spin_unlock(&inode->i_lock);
990 spin_unlock(&inode->i_lock);
994 /* Given fattrs, get a corresponding inode */
996 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
1002 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
1004 /* hash down to 32-bits on 32-bit arch */
1005 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
1007 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
1009 /* was there a potentially problematic inode collision? */
1010 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
1011 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
1013 if (inode_has_hashed_dentries(inode)) {
1014 cifs_autodisable_serverino(CIFS_SB(sb));
1016 fattr->cf_uniqueid = iunique(sb, ROOT_I);
1017 goto retry_iget5_locked;
1021 cifs_fattr_to_inode(inode, fattr);
1022 if (sb->s_flags & SB_NOATIME)
1023 inode->i_flags |= S_NOATIME | S_NOCMTIME;
1024 if (inode->i_state & I_NEW) {
1025 inode->i_ino = hash;
1026 #ifdef CONFIG_CIFS_FSCACHE
1027 /* initialize per-inode cache cookie pointer */
1028 CIFS_I(inode)->fscache = NULL;
1030 unlock_new_inode(inode);
1037 /* gets root inode */
1038 struct inode *cifs_root_iget(struct super_block *sb)
1041 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1042 struct inode *inode = NULL;
1044 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1048 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
1049 && cifs_sb->prepath) {
1050 len = strlen(cifs_sb->prepath);
1051 path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
1053 return ERR_PTR(-ENOMEM);
1055 memcpy(path+1, cifs_sb->prepath, len);
1057 path = kstrdup("", GFP_KERNEL);
1059 return ERR_PTR(-ENOMEM);
1063 if (tcon->unix_ext) {
1064 rc = cifs_get_inode_info_unix(&inode, path, sb, xid);
1065 /* some servers mistakenly claim POSIX support */
1066 if (rc != -EOPNOTSUPP)
1068 cifs_dbg(VFS, "server does not support POSIX extensions");
1069 tcon->unix_ext = false;
1072 convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
1073 rc = cifs_get_inode_info(&inode, path, NULL, sb, xid, NULL);
1077 inode = ERR_PTR(rc);
1081 #ifdef CONFIG_CIFS_FSCACHE
1082 /* populate tcon->resource_id */
1083 tcon->resource_id = CIFS_I(inode)->uniqueid;
1086 if (rc && tcon->pipe) {
1087 cifs_dbg(FYI, "ipc connection - fake read inode\n");
1088 spin_lock(&inode->i_lock);
1089 inode->i_mode |= S_IFDIR;
1090 set_nlink(inode, 2);
1091 inode->i_op = &cifs_ipc_inode_ops;
1092 inode->i_fop = &simple_dir_operations;
1093 inode->i_uid = cifs_sb->mnt_uid;
1094 inode->i_gid = cifs_sb->mnt_gid;
1095 spin_unlock(&inode->i_lock);
1098 inode = ERR_PTR(rc);
1108 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1109 char *full_path, __u32 dosattr)
1111 bool set_time = false;
1112 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1113 struct TCP_Server_Info *server;
1114 FILE_BASIC_INFO info_buf;
1119 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1120 if (!server->ops->set_file_info)
1123 if (attrs->ia_valid & ATTR_ATIME) {
1125 info_buf.LastAccessTime =
1126 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1128 info_buf.LastAccessTime = 0;
1130 if (attrs->ia_valid & ATTR_MTIME) {
1132 info_buf.LastWriteTime =
1133 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1135 info_buf.LastWriteTime = 0;
1138 * Samba throws this field away, but windows may actually use it.
1139 * Do not set ctime unless other time stamps are changed explicitly
1140 * (i.e. by utimes()) since we would then have a mix of client and
1143 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1144 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1145 info_buf.ChangeTime =
1146 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1148 info_buf.ChangeTime = 0;
1150 info_buf.CreationTime = 0; /* don't change */
1151 info_buf.Attributes = cpu_to_le32(dosattr);
1153 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1157 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1158 * and rename it to a random name that hopefully won't conflict with
1162 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1163 const unsigned int xid)
1167 struct cifs_fid fid;
1168 struct cifs_open_parms oparms;
1169 struct inode *inode = d_inode(dentry);
1170 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1171 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1172 struct tcon_link *tlink;
1173 struct cifs_tcon *tcon;
1174 __u32 dosattr, origattr;
1175 FILE_BASIC_INFO *info_buf = NULL;
1177 tlink = cifs_sb_tlink(cifs_sb);
1179 return PTR_ERR(tlink);
1180 tcon = tlink_tcon(tlink);
1183 * We cannot rename the file if the server doesn't support
1184 * CAP_INFOLEVEL_PASSTHRU
1186 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1192 oparms.cifs_sb = cifs_sb;
1193 oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1194 oparms.create_options = CREATE_NOT_DIR;
1195 oparms.disposition = FILE_OPEN;
1196 oparms.path = full_path;
1198 oparms.reconnect = false;
1200 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1204 origattr = cifsInode->cifsAttrs;
1206 origattr |= ATTR_NORMAL;
1208 dosattr = origattr & ~ATTR_READONLY;
1210 dosattr |= ATTR_NORMAL;
1211 dosattr |= ATTR_HIDDEN;
1213 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1214 if (dosattr != origattr) {
1215 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1216 if (info_buf == NULL) {
1220 info_buf->Attributes = cpu_to_le32(dosattr);
1221 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1223 /* although we would like to mark the file hidden
1224 if that fails we will still try to rename it */
1226 cifsInode->cifsAttrs = dosattr;
1228 dosattr = origattr; /* since not able to change them */
1231 /* rename the file */
1232 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1234 cifs_remap(cifs_sb));
1240 /* try to set DELETE_ON_CLOSE */
1241 if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1242 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1245 * some samba versions return -ENOENT when we try to set the
1246 * file disposition here. Likely a samba bug, but work around
1247 * it for now. This means that some cifsXXX files may hang
1248 * around after they shouldn't.
1250 * BB: remove this hack after more servers have the fix
1258 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1262 CIFSSMBClose(xid, tcon, fid.netfid);
1265 cifs_put_tlink(tlink);
1269 * reset everything back to the original state. Don't bother
1270 * dealing with errors here since we can't do anything about
1274 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1275 cifs_sb->local_nls, cifs_remap(cifs_sb));
1277 if (dosattr != origattr) {
1278 info_buf->Attributes = cpu_to_le32(origattr);
1279 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1281 cifsInode->cifsAttrs = origattr;
1287 /* copied from fs/nfs/dir.c with small changes */
1289 cifs_drop_nlink(struct inode *inode)
1291 spin_lock(&inode->i_lock);
1292 if (inode->i_nlink > 0)
1294 spin_unlock(&inode->i_lock);
1298 * If d_inode(dentry) is null (usually meaning the cached dentry
1299 * is a negative dentry) then we would attempt a standard SMB delete, but
1300 * if that fails we can not attempt the fall back mechanisms on EACCESS
1301 * but will return the EACCESS to the caller. Note that the VFS does not call
1302 * unlink on negative dentries currently.
1304 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1308 char *full_path = NULL;
1309 struct inode *inode = d_inode(dentry);
1310 struct cifsInodeInfo *cifs_inode;
1311 struct super_block *sb = dir->i_sb;
1312 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1313 struct tcon_link *tlink;
1314 struct cifs_tcon *tcon;
1315 struct TCP_Server_Info *server;
1316 struct iattr *attrs = NULL;
1317 __u32 dosattr = 0, origattr = 0;
1319 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1321 tlink = cifs_sb_tlink(cifs_sb);
1323 return PTR_ERR(tlink);
1324 tcon = tlink_tcon(tlink);
1325 server = tcon->ses->server;
1329 /* Unlink can be called from rename so we can not take the
1330 * sb->s_vfs_rename_mutex here */
1331 full_path = build_path_from_dentry(dentry);
1332 if (full_path == NULL) {
1337 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1338 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1339 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1340 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1341 cifs_remap(cifs_sb));
1342 cifs_dbg(FYI, "posix del rc %d\n", rc);
1343 if ((rc == 0) || (rc == -ENOENT))
1344 goto psx_del_no_retry;
1348 if (!server->ops->unlink) {
1350 goto psx_del_no_retry;
1353 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1358 cifs_drop_nlink(inode);
1359 } else if (rc == -ENOENT) {
1361 } else if (rc == -EBUSY) {
1362 if (server->ops->rename_pending_delete) {
1363 rc = server->ops->rename_pending_delete(full_path,
1366 cifs_drop_nlink(inode);
1368 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1369 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1370 if (attrs == NULL) {
1375 /* try to reset dos attributes */
1376 cifs_inode = CIFS_I(inode);
1377 origattr = cifs_inode->cifsAttrs;
1379 origattr |= ATTR_NORMAL;
1380 dosattr = origattr & ~ATTR_READONLY;
1382 dosattr |= ATTR_NORMAL;
1383 dosattr |= ATTR_HIDDEN;
1385 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1389 goto retry_std_delete;
1392 /* undo the setattr if we errored out and it's needed */
1393 if (rc != 0 && dosattr != 0)
1394 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1398 cifs_inode = CIFS_I(inode);
1399 cifs_inode->time = 0; /* will force revalidate to get info
1401 inode->i_ctime = current_time(inode);
1403 dir->i_ctime = dir->i_mtime = current_time(dir);
1404 cifs_inode = CIFS_I(dir);
1405 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1410 cifs_put_tlink(tlink);
1415 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1416 const char *full_path, struct cifs_sb_info *cifs_sb,
1417 struct cifs_tcon *tcon, const unsigned int xid)
1420 struct inode *inode = NULL;
1423 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1426 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1433 * setting nlink not necessary except in cases where we failed to get it
1434 * from the server or was set bogus. Also, since this is a brand new
1435 * inode, no need to grab the i_lock before setting the i_nlink.
1437 if (inode->i_nlink < 2)
1438 set_nlink(inode, 2);
1439 mode &= ~current_umask();
1440 /* must turn on setgid bit if parent dir has it */
1441 if (parent->i_mode & S_ISGID)
1444 if (tcon->unix_ext) {
1445 struct cifs_unix_set_info_args args = {
1447 .ctime = NO_CHANGE_64,
1448 .atime = NO_CHANGE_64,
1449 .mtime = NO_CHANGE_64,
1452 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1453 args.uid = current_fsuid();
1454 if (parent->i_mode & S_ISGID)
1455 args.gid = parent->i_gid;
1457 args.gid = current_fsgid();
1459 args.uid = INVALID_UID; /* no change */
1460 args.gid = INVALID_GID; /* no change */
1462 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1464 cifs_remap(cifs_sb));
1466 struct TCP_Server_Info *server = tcon->ses->server;
1467 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1468 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1469 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1471 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1472 inode->i_mode = (mode | S_IFDIR);
1474 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1475 inode->i_uid = current_fsuid();
1476 if (inode->i_mode & S_ISGID)
1477 inode->i_gid = parent->i_gid;
1479 inode->i_gid = current_fsgid();
1482 d_instantiate(dentry, inode);
1487 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1488 const char *full_path, struct cifs_sb_info *cifs_sb,
1489 struct cifs_tcon *tcon, const unsigned int xid)
1493 FILE_UNIX_BASIC_INFO *info = NULL;
1494 struct inode *newinode = NULL;
1495 struct cifs_fattr fattr;
1497 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1500 goto posix_mkdir_out;
1503 mode &= ~current_umask();
1504 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1505 NULL /* netfid */, info, &oplock, full_path,
1506 cifs_sb->local_nls, cifs_remap(cifs_sb));
1507 if (rc == -EOPNOTSUPP)
1508 goto posix_mkdir_out;
1510 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1512 goto posix_mkdir_out;
1515 if (info->Type == cpu_to_le32(-1))
1516 /* no return info, go query for it */
1517 goto posix_mkdir_get_info;
1519 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1520 * need to set uid/gid.
1523 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1524 cifs_fill_uniqueid(inode->i_sb, &fattr);
1525 newinode = cifs_iget(inode->i_sb, &fattr);
1527 goto posix_mkdir_get_info;
1529 d_instantiate(dentry, newinode);
1531 #ifdef CONFIG_CIFS_DEBUG2
1532 cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1533 dentry, dentry, newinode);
1535 if (newinode->i_nlink != 2)
1536 cifs_dbg(FYI, "unexpected number of links %d\n",
1543 posix_mkdir_get_info:
1544 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1546 goto posix_mkdir_out;
1549 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1553 struct cifs_sb_info *cifs_sb;
1554 struct tcon_link *tlink;
1555 struct cifs_tcon *tcon;
1556 struct TCP_Server_Info *server;
1559 cifs_dbg(FYI, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1562 cifs_sb = CIFS_SB(inode->i_sb);
1563 tlink = cifs_sb_tlink(cifs_sb);
1565 return PTR_ERR(tlink);
1566 tcon = tlink_tcon(tlink);
1570 full_path = build_path_from_dentry(direntry);
1571 if (full_path == NULL) {
1576 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1577 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1578 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1580 if (rc != -EOPNOTSUPP)
1584 server = tcon->ses->server;
1586 if (!server->ops->mkdir) {
1591 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1592 rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
1594 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1599 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1603 * Force revalidate to get parent dir info when needed since cached
1604 * attributes are invalid now.
1606 CIFS_I(inode)->time = 0;
1609 cifs_put_tlink(tlink);
1613 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1617 struct cifs_sb_info *cifs_sb;
1618 struct tcon_link *tlink;
1619 struct cifs_tcon *tcon;
1620 struct TCP_Server_Info *server;
1621 char *full_path = NULL;
1622 struct cifsInodeInfo *cifsInode;
1624 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1628 full_path = build_path_from_dentry(direntry);
1629 if (full_path == NULL) {
1634 cifs_sb = CIFS_SB(inode->i_sb);
1635 tlink = cifs_sb_tlink(cifs_sb);
1636 if (IS_ERR(tlink)) {
1637 rc = PTR_ERR(tlink);
1640 tcon = tlink_tcon(tlink);
1641 server = tcon->ses->server;
1643 if (!server->ops->rmdir) {
1645 cifs_put_tlink(tlink);
1649 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1650 cifs_put_tlink(tlink);
1653 spin_lock(&d_inode(direntry)->i_lock);
1654 i_size_write(d_inode(direntry), 0);
1655 clear_nlink(d_inode(direntry));
1656 spin_unlock(&d_inode(direntry)->i_lock);
1659 cifsInode = CIFS_I(d_inode(direntry));
1660 /* force revalidate to go get info when needed */
1661 cifsInode->time = 0;
1663 cifsInode = CIFS_I(inode);
1665 * Force revalidate to get parent dir info when needed since cached
1666 * attributes are invalid now.
1668 cifsInode->time = 0;
1670 d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
1671 current_time(inode);
1680 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1681 const char *from_path, struct dentry *to_dentry,
1682 const char *to_path)
1684 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1685 struct tcon_link *tlink;
1686 struct cifs_tcon *tcon;
1687 struct TCP_Server_Info *server;
1688 struct cifs_fid fid;
1689 struct cifs_open_parms oparms;
1692 tlink = cifs_sb_tlink(cifs_sb);
1694 return PTR_ERR(tlink);
1695 tcon = tlink_tcon(tlink);
1696 server = tcon->ses->server;
1698 if (!server->ops->rename)
1701 /* try path-based rename first */
1702 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1705 * Don't bother with rename by filehandle unless file is busy and
1706 * source. Note that cross directory moves do not work with
1707 * rename by filehandle to various Windows servers.
1709 if (rc == 0 || rc != -EBUSY)
1710 goto do_rename_exit;
1712 /* open-file renames don't work across directories */
1713 if (to_dentry->d_parent != from_dentry->d_parent)
1714 goto do_rename_exit;
1717 oparms.cifs_sb = cifs_sb;
1718 /* open the file to be renamed -- we need DELETE perms */
1719 oparms.desired_access = DELETE;
1720 oparms.create_options = CREATE_NOT_DIR;
1721 oparms.disposition = FILE_OPEN;
1722 oparms.path = from_path;
1724 oparms.reconnect = false;
1726 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1728 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
1729 (const char *) to_dentry->d_name.name,
1730 cifs_sb->local_nls, cifs_remap(cifs_sb));
1731 CIFSSMBClose(xid, tcon, fid.netfid);
1734 cifs_put_tlink(tlink);
1739 cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
1740 struct inode *target_dir, struct dentry *target_dentry,
1743 char *from_name = NULL;
1744 char *to_name = NULL;
1745 struct cifs_sb_info *cifs_sb;
1746 struct tcon_link *tlink;
1747 struct cifs_tcon *tcon;
1748 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1749 FILE_UNIX_BASIC_INFO *info_buf_target;
1753 if (flags & ~RENAME_NOREPLACE)
1756 cifs_sb = CIFS_SB(source_dir->i_sb);
1757 tlink = cifs_sb_tlink(cifs_sb);
1759 return PTR_ERR(tlink);
1760 tcon = tlink_tcon(tlink);
1765 * we already have the rename sem so we do not need to
1766 * grab it again here to protect the path integrity
1768 from_name = build_path_from_dentry(source_dentry);
1769 if (from_name == NULL) {
1771 goto cifs_rename_exit;
1774 to_name = build_path_from_dentry(target_dentry);
1775 if (to_name == NULL) {
1777 goto cifs_rename_exit;
1780 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1784 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1786 if (flags & RENAME_NOREPLACE)
1787 goto cifs_rename_exit;
1789 if (rc == -EEXIST && tcon->unix_ext) {
1791 * Are src and dst hardlinks of same inode? We can only tell
1792 * with unix extensions enabled.
1795 kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
1797 if (info_buf_source == NULL) {
1799 goto cifs_rename_exit;
1802 info_buf_target = info_buf_source + 1;
1803 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1806 cifs_remap(cifs_sb));
1810 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1813 cifs_remap(cifs_sb));
1815 if (tmprc == 0 && (info_buf_source->UniqueId ==
1816 info_buf_target->UniqueId)) {
1817 /* same file, POSIX says that this is a noop */
1819 goto cifs_rename_exit;
1823 * else ... BB we could add the same check for Windows by
1824 * checking the UniqueId via FILE_INTERNAL_INFO
1828 /* Try unlinking the target dentry if it's not negative */
1829 if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
1830 if (d_is_dir(target_dentry))
1831 tmprc = cifs_rmdir(target_dir, target_dentry);
1833 tmprc = cifs_unlink(target_dir, target_dentry);
1835 goto cifs_rename_exit;
1836 rc = cifs_do_rename(xid, source_dentry, from_name,
1837 target_dentry, to_name);
1840 /* force revalidate to go get info when needed */
1841 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
1843 source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
1844 target_dir->i_mtime = current_time(source_dir);
1847 kfree(info_buf_source);
1851 cifs_put_tlink(tlink);
1856 cifs_inode_needs_reval(struct inode *inode)
1858 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1859 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1861 if (cifs_i->time == 0)
1864 if (CIFS_CACHE_READ(cifs_i))
1867 if (!lookupCacheEnabled)
1870 if (!cifs_sb->actimeo)
1873 if (!time_in_range(jiffies, cifs_i->time,
1874 cifs_i->time + cifs_sb->actimeo))
1877 /* hardlinked files w/ noserverino get "special" treatment */
1878 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1879 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1886 * Zap the cache. Called when invalid_mapping flag is set.
1889 cifs_invalidate_mapping(struct inode *inode)
1893 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1894 rc = invalidate_inode_pages2(inode->i_mapping);
1896 cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1900 cifs_fscache_reset_inode_cookie(inode);
1905 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
1906 * @word: long word containing the bit lock
1909 cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
1911 freezable_schedule_unsafe();
1912 if (signal_pending_state(mode, current))
1913 return -ERESTARTSYS;
1918 cifs_revalidate_mapping(struct inode *inode)
1921 unsigned long *flags = &CIFS_I(inode)->flags;
1923 rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
1928 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
1929 rc = cifs_invalidate_mapping(inode);
1931 set_bit(CIFS_INO_INVALID_MAPPING, flags);
1934 clear_bit_unlock(CIFS_INO_LOCK, flags);
1935 smp_mb__after_atomic();
1936 wake_up_bit(flags, CIFS_INO_LOCK);
1942 cifs_zap_mapping(struct inode *inode)
1944 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
1945 return cifs_revalidate_mapping(inode);
1948 int cifs_revalidate_file_attr(struct file *filp)
1951 struct inode *inode = file_inode(filp);
1952 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1954 if (!cifs_inode_needs_reval(inode))
1957 if (tlink_tcon(cfile->tlink)->unix_ext)
1958 rc = cifs_get_file_info_unix(filp);
1960 rc = cifs_get_file_info(filp);
1965 int cifs_revalidate_dentry_attr(struct dentry *dentry)
1969 struct inode *inode = d_inode(dentry);
1970 struct super_block *sb = dentry->d_sb;
1971 char *full_path = NULL;
1976 if (!cifs_inode_needs_reval(inode))
1981 /* can not safely grab the rename sem here if rename calls revalidate
1982 since that would deadlock */
1983 full_path = build_path_from_dentry(dentry);
1984 if (full_path == NULL) {
1989 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1990 full_path, inode, inode->i_count.counter,
1991 dentry, cifs_get_time(dentry), jiffies);
1993 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1994 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1996 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2005 int cifs_revalidate_file(struct file *filp)
2008 struct inode *inode = file_inode(filp);
2010 rc = cifs_revalidate_file_attr(filp);
2014 return cifs_revalidate_mapping(inode);
2017 /* revalidate a dentry's inode attributes */
2018 int cifs_revalidate_dentry(struct dentry *dentry)
2021 struct inode *inode = d_inode(dentry);
2023 rc = cifs_revalidate_dentry_attr(dentry);
2027 return cifs_revalidate_mapping(inode);
2030 int cifs_getattr(const struct path *path, struct kstat *stat,
2031 u32 request_mask, unsigned int flags)
2033 struct dentry *dentry = path->dentry;
2034 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2035 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2036 struct inode *inode = d_inode(dentry);
2040 * We need to be sure that all dirty pages are written and the server
2041 * has actual ctime, mtime and file length.
2043 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2044 inode->i_mapping->nrpages != 0) {
2045 rc = filemap_fdatawait(inode->i_mapping);
2047 mapping_set_error(inode->i_mapping, rc);
2052 rc = cifs_revalidate_dentry_attr(dentry);
2056 generic_fillattr(inode, stat);
2057 stat->blksize = CIFS_MAX_MSGSIZE;
2058 stat->ino = CIFS_I(inode)->uniqueid;
2060 /* old CIFS Unix Extensions doesn't return create time */
2061 if (CIFS_I(inode)->createtime) {
2062 stat->result_mask |= STATX_BTIME;
2064 cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
2067 stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2068 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2069 stat->attributes |= STATX_ATTR_COMPRESSED;
2070 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2071 stat->attributes |= STATX_ATTR_ENCRYPTED;
2074 * If on a multiuser mount without unix extensions or cifsacl being
2075 * enabled, and the admin hasn't overridden them, set the ownership
2076 * to the fsuid/fsgid of the current process.
2078 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2079 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2081 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2082 stat->uid = current_fsuid();
2083 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2084 stat->gid = current_fsgid();
2089 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
2091 pgoff_t index = from >> PAGE_SHIFT;
2092 unsigned offset = from & (PAGE_SIZE - 1);
2096 page = grab_cache_page(mapping, index);
2100 zero_user_segment(page, offset, PAGE_SIZE);
2106 static void cifs_setsize(struct inode *inode, loff_t offset)
2108 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2110 spin_lock(&inode->i_lock);
2111 i_size_write(inode, offset);
2112 spin_unlock(&inode->i_lock);
2114 /* Cached inode must be refreshed on truncate */
2116 truncate_pagecache(inode, offset);
2120 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2121 unsigned int xid, char *full_path)
2124 struct cifsFileInfo *open_file;
2125 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2126 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2127 struct tcon_link *tlink = NULL;
2128 struct cifs_tcon *tcon = NULL;
2129 struct TCP_Server_Info *server;
2132 * To avoid spurious oplock breaks from server, in the case of
2133 * inodes that we already have open, avoid doing path based
2134 * setting of file size if we can do it by handle.
2135 * This keeps our caching token (oplock) and avoids timeouts
2136 * when the local oplock break takes longer to flush
2137 * writebehind data than the SMB timeout for the SetPathInfo
2138 * request would allow
2140 open_file = find_writable_file(cifsInode, true);
2142 tcon = tlink_tcon(open_file->tlink);
2143 server = tcon->ses->server;
2144 if (server->ops->set_file_size)
2145 rc = server->ops->set_file_size(xid, tcon, open_file,
2146 attrs->ia_size, false);
2149 cifsFileInfo_put(open_file);
2150 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2158 tlink = cifs_sb_tlink(cifs_sb);
2160 return PTR_ERR(tlink);
2161 tcon = tlink_tcon(tlink);
2162 server = tcon->ses->server;
2166 * Set file size by pathname rather than by handle either because no
2167 * valid, writeable file handle for it was found or because there was
2168 * an error setting it by handle.
2170 if (server->ops->set_path_size)
2171 rc = server->ops->set_path_size(xid, tcon, full_path,
2172 attrs->ia_size, cifs_sb, false);
2175 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2178 cifs_put_tlink(tlink);
2182 cifsInode->server_eof = attrs->ia_size;
2183 cifs_setsize(inode, attrs->ia_size);
2184 cifs_truncate_page(inode->i_mapping, inode->i_size);
2191 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2195 char *full_path = NULL;
2196 struct inode *inode = d_inode(direntry);
2197 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2198 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2199 struct tcon_link *tlink;
2200 struct cifs_tcon *pTcon;
2201 struct cifs_unix_set_info_args *args = NULL;
2202 struct cifsFileInfo *open_file;
2204 cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2205 direntry, attrs->ia_valid);
2209 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2210 attrs->ia_valid |= ATTR_FORCE;
2212 rc = setattr_prepare(direntry, attrs);
2216 full_path = build_path_from_dentry(direntry);
2217 if (full_path == NULL) {
2223 * Attempt to flush data before changing attributes. We need to do
2224 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2225 * ownership or mode then we may also need to do this. Here, we take
2226 * the safe way out and just do the flush on all setattr requests. If
2227 * the flush returns error, store it to report later and continue.
2229 * BB: This should be smarter. Why bother flushing pages that
2230 * will be truncated anyway? Also, should we error out here if
2231 * the flush returns error?
2233 rc = filemap_write_and_wait(inode->i_mapping);
2234 mapping_set_error(inode->i_mapping, rc);
2237 if (attrs->ia_valid & ATTR_SIZE) {
2238 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2243 /* skip mode change if it's just for clearing setuid/setgid */
2244 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2245 attrs->ia_valid &= ~ATTR_MODE;
2247 args = kmalloc(sizeof(*args), GFP_KERNEL);
2253 /* set up the struct */
2254 if (attrs->ia_valid & ATTR_MODE)
2255 args->mode = attrs->ia_mode;
2257 args->mode = NO_CHANGE_64;
2259 if (attrs->ia_valid & ATTR_UID)
2260 args->uid = attrs->ia_uid;
2262 args->uid = INVALID_UID; /* no change */
2264 if (attrs->ia_valid & ATTR_GID)
2265 args->gid = attrs->ia_gid;
2267 args->gid = INVALID_GID; /* no change */
2269 if (attrs->ia_valid & ATTR_ATIME)
2270 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2272 args->atime = NO_CHANGE_64;
2274 if (attrs->ia_valid & ATTR_MTIME)
2275 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2277 args->mtime = NO_CHANGE_64;
2279 if (attrs->ia_valid & ATTR_CTIME)
2280 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2282 args->ctime = NO_CHANGE_64;
2285 open_file = find_writable_file(cifsInode, true);
2287 u16 nfid = open_file->fid.netfid;
2288 u32 npid = open_file->pid;
2289 pTcon = tlink_tcon(open_file->tlink);
2290 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2291 cifsFileInfo_put(open_file);
2293 tlink = cifs_sb_tlink(cifs_sb);
2294 if (IS_ERR(tlink)) {
2295 rc = PTR_ERR(tlink);
2298 pTcon = tlink_tcon(tlink);
2299 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2301 cifs_remap(cifs_sb));
2302 cifs_put_tlink(tlink);
2308 if ((attrs->ia_valid & ATTR_SIZE) &&
2309 attrs->ia_size != i_size_read(inode))
2310 truncate_setsize(inode, attrs->ia_size);
2312 setattr_copy(inode, attrs);
2313 mark_inode_dirty(inode);
2315 /* force revalidate when any of these times are set since some
2316 of the fs types (eg ext3, fat) do not have fine enough
2317 time granularity to match protocol, and we do not have a
2318 a way (yet) to query the server fs's time granularity (and
2319 whether it rounds times down).
2321 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2322 cifsInode->time = 0;
2331 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2334 kuid_t uid = INVALID_UID;
2335 kgid_t gid = INVALID_GID;
2336 struct inode *inode = d_inode(direntry);
2337 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2338 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2339 char *full_path = NULL;
2342 __u64 mode = NO_CHANGE_64;
2346 cifs_dbg(FYI, "setattr on file %pd attrs->iavalid 0x%x\n",
2347 direntry, attrs->ia_valid);
2349 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2350 attrs->ia_valid |= ATTR_FORCE;
2352 rc = setattr_prepare(direntry, attrs);
2358 full_path = build_path_from_dentry(direntry);
2359 if (full_path == NULL) {
2366 * Attempt to flush data before changing attributes. We need to do
2367 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2368 * ownership or mode then we may also need to do this. Here, we take
2369 * the safe way out and just do the flush on all setattr requests. If
2370 * the flush returns error, store it to report later and continue.
2372 * BB: This should be smarter. Why bother flushing pages that
2373 * will be truncated anyway? Also, should we error out here if
2374 * the flush returns error?
2376 rc = filemap_write_and_wait(inode->i_mapping);
2377 mapping_set_error(inode->i_mapping, rc);
2380 if (attrs->ia_valid & ATTR_SIZE) {
2381 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2383 goto cifs_setattr_exit;
2386 if (attrs->ia_valid & ATTR_UID)
2387 uid = attrs->ia_uid;
2389 if (attrs->ia_valid & ATTR_GID)
2390 gid = attrs->ia_gid;
2392 #ifdef CONFIG_CIFS_ACL
2393 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2394 if (uid_valid(uid) || gid_valid(gid)) {
2395 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2398 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2400 goto cifs_setattr_exit;
2404 #endif /* CONFIG_CIFS_ACL */
2405 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2406 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2408 /* skip mode change if it's just for clearing setuid/setgid */
2409 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2410 attrs->ia_valid &= ~ATTR_MODE;
2412 if (attrs->ia_valid & ATTR_MODE) {
2413 mode = attrs->ia_mode;
2415 #ifdef CONFIG_CIFS_ACL
2416 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2417 rc = id_mode_to_cifs_acl(inode, full_path, mode,
2418 INVALID_UID, INVALID_GID);
2420 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2422 goto cifs_setattr_exit;
2425 #endif /* CONFIG_CIFS_ACL */
2426 if (((mode & S_IWUGO) == 0) &&
2427 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2429 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2431 /* fix up mode if we're not using dynperm */
2432 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2433 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2434 } else if ((mode & S_IWUGO) &&
2435 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2437 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2438 /* Attributes of 0 are ignored */
2440 dosattr |= ATTR_NORMAL;
2442 /* reset local inode permissions to normal */
2443 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2444 attrs->ia_mode &= ~(S_IALLUGO);
2445 if (S_ISDIR(inode->i_mode))
2447 cifs_sb->mnt_dir_mode;
2450 cifs_sb->mnt_file_mode;
2452 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2453 /* ignore mode change - ATTR_READONLY hasn't changed */
2454 attrs->ia_valid &= ~ATTR_MODE;
2458 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2459 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2460 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2461 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2463 /* Even if error on time set, no sense failing the call if
2464 the server would set the time to a reasonable value anyway,
2465 and this check ensures that we are not being called from
2466 sys_utimes in which case we ought to fail the call back to
2467 the user when the server rejects the call */
2468 if ((rc) && (attrs->ia_valid &
2469 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2473 /* do not need local check to inode_check_ok since the server does
2476 goto cifs_setattr_exit;
2478 if ((attrs->ia_valid & ATTR_SIZE) &&
2479 attrs->ia_size != i_size_read(inode))
2480 truncate_setsize(inode, attrs->ia_size);
2482 setattr_copy(inode, attrs);
2483 mark_inode_dirty(inode);
2492 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2494 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
2495 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2497 if (pTcon->unix_ext)
2498 return cifs_setattr_unix(direntry, attrs);
2500 return cifs_setattr_nounix(direntry, attrs);
2502 /* BB: add cifs_setattr_legacy for really old servers */
2506 void cifs_delete_inode(struct inode *inode)
2508 cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2509 /* may have to add back in if and when safe distributed caching of
2510 directories added e.g. via FindNotify */