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 (timespec64_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_ts64(&fattr->cf_mtime);
329 fattr->cf_mtime = timespec64_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)) {
413 CIFS_I(*pinode)->time = 0; /* force reval */
418 /* if filetype is different, return error */
419 if (unlikely(((*pinode)->i_mode & S_IFMT) !=
420 (fattr.cf_mode & S_IFMT))) {
421 CIFS_I(*pinode)->time = 0; /* force reval */
426 cifs_fattr_to_inode(*pinode, &fattr);
434 cifs_sfu_type(struct cifs_fattr *fattr, const char *path,
435 struct cifs_sb_info *cifs_sb, unsigned int xid)
439 struct tcon_link *tlink;
440 struct cifs_tcon *tcon;
442 struct cifs_open_parms oparms;
443 struct cifs_io_parms io_parms;
445 unsigned int bytes_read;
447 int buf_type = CIFS_NO_BUFFER;
451 fattr->cf_mode &= ~S_IFMT;
453 if (fattr->cf_eof == 0) {
454 fattr->cf_mode |= S_IFIFO;
455 fattr->cf_dtype = DT_FIFO;
457 } else if (fattr->cf_eof < 8) {
458 fattr->cf_mode |= S_IFREG;
459 fattr->cf_dtype = DT_REG;
460 return -EINVAL; /* EOPNOTSUPP? */
463 tlink = cifs_sb_tlink(cifs_sb);
465 return PTR_ERR(tlink);
466 tcon = tlink_tcon(tlink);
469 oparms.cifs_sb = cifs_sb;
470 oparms.desired_access = GENERIC_READ;
471 oparms.create_options = CREATE_NOT_DIR;
472 if (backup_cred(cifs_sb))
473 oparms.create_options |= CREATE_OPEN_BACKUP_INTENT;
474 oparms.disposition = FILE_OPEN;
477 oparms.reconnect = false;
479 if (tcon->ses->server->oplocks)
483 rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);
485 cifs_dbg(FYI, "check sfu type of %s, open rc = %d\n", path, rc);
486 cifs_put_tlink(tlink);
491 io_parms.netfid = fid.netfid;
492 io_parms.pid = current->tgid;
493 io_parms.tcon = tcon;
495 io_parms.length = 24;
497 rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,
498 &bytes_read, &pbuf, &buf_type);
499 if ((rc == 0) && (bytes_read >= 8)) {
500 if (memcmp("IntxBLK", pbuf, 8) == 0) {
501 cifs_dbg(FYI, "Block device\n");
502 fattr->cf_mode |= S_IFBLK;
503 fattr->cf_dtype = DT_BLK;
504 if (bytes_read == 24) {
505 /* we have enough to decode dev num */
506 __u64 mjr; /* major */
507 __u64 mnr; /* minor */
508 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
509 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
510 fattr->cf_rdev = MKDEV(mjr, mnr);
512 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
513 cifs_dbg(FYI, "Char device\n");
514 fattr->cf_mode |= S_IFCHR;
515 fattr->cf_dtype = DT_CHR;
516 if (bytes_read == 24) {
517 /* we have enough to decode dev num */
518 __u64 mjr; /* major */
519 __u64 mnr; /* minor */
520 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
521 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
522 fattr->cf_rdev = MKDEV(mjr, mnr);
524 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
525 cifs_dbg(FYI, "Symlink\n");
526 fattr->cf_mode |= S_IFLNK;
527 fattr->cf_dtype = DT_LNK;
529 fattr->cf_mode |= S_IFREG; /* file? */
530 fattr->cf_dtype = DT_REG;
534 fattr->cf_mode |= S_IFREG; /* then it is a file */
535 fattr->cf_dtype = DT_REG;
536 rc = -EOPNOTSUPP; /* or some unknown SFU type */
539 tcon->ses->server->ops->close(xid, tcon, &fid);
540 cifs_put_tlink(tlink);
544 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
547 * Fetch mode bits as provided by SFU.
549 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
551 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
552 struct cifs_sb_info *cifs_sb, unsigned int xid)
554 #ifdef CONFIG_CIFS_XATTR
558 struct tcon_link *tlink;
559 struct cifs_tcon *tcon;
561 tlink = cifs_sb_tlink(cifs_sb);
563 return PTR_ERR(tlink);
564 tcon = tlink_tcon(tlink);
566 if (tcon->ses->server->ops->query_all_EAs == NULL) {
567 cifs_put_tlink(tlink);
571 rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
572 "SETFILEBITS", ea_value, 4 /* size of buf */,
574 cifs_put_tlink(tlink);
578 mode = le32_to_cpu(*((__le32 *)ea_value));
579 fattr->cf_mode &= ~SFBITS_MASK;
580 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
581 mode, fattr->cf_mode);
582 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
583 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
592 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
594 cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
595 struct super_block *sb, bool adjust_tz,
598 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
599 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
601 memset(fattr, 0, sizeof(*fattr));
602 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
603 if (info->DeletePending)
604 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
606 if (info->LastAccessTime)
607 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
609 ktime_get_real_ts64(&fattr->cf_atime);
610 fattr->cf_atime = timespec64_trunc(fattr->cf_atime, sb->s_time_gran);
613 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
614 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
617 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
618 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
621 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
622 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
623 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
625 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
628 fattr->cf_mode = S_IFLNK;
629 fattr->cf_dtype = DT_LNK;
630 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
631 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
632 fattr->cf_dtype = DT_DIR;
634 * Server can return wrong NumberOfLinks value for directories
635 * when Unix extensions are disabled - fake it.
638 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
640 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
641 fattr->cf_dtype = DT_REG;
643 /* clear write bits if ATTR_READONLY is set */
644 if (fattr->cf_cifsattrs & ATTR_READONLY)
645 fattr->cf_mode &= ~(S_IWUGO);
648 * Don't accept zero nlink from non-unix servers unless
649 * delete is pending. Instead mark it as unknown.
651 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
652 !info->DeletePending) {
653 cifs_dbg(1, "bogus file nlink value %u\n",
655 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
659 fattr->cf_uid = cifs_sb->mnt_uid;
660 fattr->cf_gid = cifs_sb->mnt_gid;
664 cifs_get_file_info(struct file *filp)
668 FILE_ALL_INFO find_data;
669 struct cifs_fattr fattr;
670 struct inode *inode = file_inode(filp);
671 struct cifsFileInfo *cfile = filp->private_data;
672 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
673 struct TCP_Server_Info *server = tcon->ses->server;
675 if (!server->ops->query_file_info)
679 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
682 cifs_all_info_to_fattr(&fattr, &find_data, inode->i_sb, false,
686 cifs_create_dfs_fattr(&fattr, inode->i_sb);
692 * FIXME: legacy server -- fall back to path-based call?
693 * for now, just skip revalidating and mark inode for
697 CIFS_I(inode)->time = 0;
703 * don't bother with SFU junk here -- just mark inode as needing
706 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
707 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
708 cifs_fattr_to_inode(inode, &fattr);
714 /* Simple function to return a 64 bit hash of string. Rarely called */
715 static __u64 simple_hashstr(const char *str)
717 const __u64 hash_mult = 1125899906842597ULL; /* a big enough prime */
721 hash = (hash + (__u64) *str++) * hash_mult;
727 cifs_get_inode_info(struct inode **inode, const char *full_path,
728 FILE_ALL_INFO *data, struct super_block *sb, int xid,
729 const struct cifs_fid *fid)
731 bool validinum = false;
733 int rc = 0, tmprc = ENOSYS;
734 struct cifs_tcon *tcon;
735 struct TCP_Server_Info *server;
736 struct tcon_link *tlink;
737 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
739 bool adjust_tz = false;
740 struct cifs_fattr fattr;
741 struct cifs_search_info *srchinf = NULL;
742 bool symlink = false;
744 tlink = cifs_sb_tlink(cifs_sb);
746 return PTR_ERR(tlink);
747 tcon = tlink_tcon(tlink);
748 server = tcon->ses->server;
750 cifs_dbg(FYI, "Getting info on %s\n", full_path);
752 if ((data == NULL) && (*inode != NULL)) {
753 if (CIFS_CACHE_READ(CIFS_I(*inode)) &&
754 CIFS_I(*inode)->time != 0) {
755 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
760 /* if inode info is not passed, get it from server */
762 if (!server->ops->query_path_info) {
766 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
771 data = (FILE_ALL_INFO *)buf;
772 rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path,
773 data, &adjust_tz, &symlink);
777 cifs_all_info_to_fattr(&fattr, data, sb, adjust_tz,
779 } else if (rc == -EREMOTE) {
780 cifs_create_dfs_fattr(&fattr, sb);
782 } else if ((rc == -EACCES) && backup_cred(cifs_sb) &&
783 (strcmp(server->vals->version_string, SMB1_VERSION_STRING)
786 * For SMB2 and later the backup intent flag is already
787 * sent if needed on open and there is no path based
788 * FindFirst operation to use to retry with
791 srchinf = kzalloc(sizeof(struct cifs_search_info),
793 if (srchinf == NULL) {
798 srchinf->endOfSearch = false;
800 srchinf->info_level = SMB_FIND_FILE_UNIX;
801 else if ((tcon->ses->capabilities &
802 tcon->ses->server->vals->cap_nt_find) == 0)
803 srchinf->info_level = SMB_FIND_FILE_INFO_STANDARD;
804 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
805 srchinf->info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
806 else /* no srvino useful for fallback to some netapp */
807 srchinf->info_level = SMB_FIND_FILE_DIRECTORY_INFO;
809 srchflgs = CIFS_SEARCH_CLOSE_ALWAYS |
810 CIFS_SEARCH_CLOSE_AT_END |
811 CIFS_SEARCH_BACKUP_SEARCH;
813 rc = CIFSFindFirst(xid, tcon, full_path,
814 cifs_sb, NULL, srchflgs, srchinf, false);
816 data = (FILE_ALL_INFO *)srchinf->srch_entries_start;
818 cifs_dir_info_to_fattr(&fattr,
819 (FILE_DIRECTORY_INFO *)data, cifs_sb);
820 fattr.cf_uniqueid = le64_to_cpu(
821 ((SEARCH_ID_FULL_DIR_INFO *)data)->UniqueId);
824 cifs_buf_release(srchinf->ntwrk_buf_start);
833 * If an inode wasn't passed in, then get the inode number
835 * Is an i_ino of zero legal? Can we use that to check if the server
836 * supports returning inode numbers? Are there other sanity checks we
837 * can use to ensure that the server is really filling in that field?
839 if (*inode == NULL) {
840 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
841 if (validinum == false) {
842 if (server->ops->get_srv_inum)
843 tmprc = server->ops->get_srv_inum(xid,
844 tcon, cifs_sb, full_path,
845 &fattr.cf_uniqueid, data);
847 cifs_dbg(FYI, "GetSrvInodeNum rc %d\n",
849 fattr.cf_uniqueid = iunique(sb, ROOT_I);
850 cifs_autodisable_serverino(cifs_sb);
851 } else if ((fattr.cf_uniqueid == 0) &&
852 strlen(full_path) == 0) {
853 /* some servers ret bad root ino ie 0 */
854 cifs_dbg(FYI, "Invalid (0) inodenum\n");
856 CIFS_FATTR_FAKE_ROOT_INO;
858 simple_hashstr(tcon->treeName);
862 fattr.cf_uniqueid = iunique(sb, ROOT_I);
864 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
865 validinum == false && server->ops->get_srv_inum) {
867 * Pass a NULL tcon to ensure we don't make a round
868 * trip to the server. This only works for SMB2+.
870 tmprc = server->ops->get_srv_inum(xid,
871 NULL, cifs_sb, full_path,
872 &fattr.cf_uniqueid, data);
874 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
875 else if ((fattr.cf_uniqueid == 0) &&
876 strlen(full_path) == 0) {
878 * Reuse existing root inode num since
879 * inum zero for root causes ls of . and .. to
882 cifs_dbg(FYI, "Srv ret 0 inode num for root\n");
883 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
886 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
889 /* query for SFU type info if supported and needed */
890 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
891 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
892 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
894 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
897 #ifdef CONFIG_CIFS_ACL
898 /* fill in 0777 bits from ACL */
899 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
900 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, full_path, fid);
902 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
907 #endif /* CONFIG_CIFS_ACL */
909 /* fill in remaining high mode bits e.g. SUID, VTX */
910 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
911 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
913 /* check for Minshall+French symlinks */
914 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
915 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
918 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
922 *inode = cifs_iget(sb, &fattr);
926 /* we already have inode, update it */
928 /* if uniqueid is different, return error */
929 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
930 CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
931 CIFS_I(*inode)->time = 0; /* force reval */
936 /* if filetype is different, return error */
937 if (unlikely(((*inode)->i_mode & S_IFMT) !=
938 (fattr.cf_mode & S_IFMT))) {
939 CIFS_I(*inode)->time = 0; /* force reval */
944 cifs_fattr_to_inode(*inode, &fattr);
948 if ((*inode) && ((*inode)->i_ino == 0))
949 cifs_dbg(FYI, "inode number of zero returned\n");
952 cifs_put_tlink(tlink);
956 static const struct inode_operations cifs_ipc_inode_ops = {
957 .lookup = cifs_lookup,
961 cifs_find_inode(struct inode *inode, void *opaque)
963 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
965 /* don't match inode with different uniqueid */
966 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
969 /* use createtime like an i_generation field */
970 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
973 /* don't match inode of different type */
974 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
977 /* if it's not a directory or has no dentries, then flag it */
978 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
979 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
985 cifs_init_inode(struct inode *inode, void *opaque)
987 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
989 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
990 CIFS_I(inode)->createtime = fattr->cf_createtime;
995 * walk dentry list for an inode and report whether it has aliases that
996 * are hashed. We use this to determine if a directory inode can actually
1000 inode_has_hashed_dentries(struct inode *inode)
1002 struct dentry *dentry;
1004 spin_lock(&inode->i_lock);
1005 hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
1006 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
1007 spin_unlock(&inode->i_lock);
1011 spin_unlock(&inode->i_lock);
1015 /* Given fattrs, get a corresponding inode */
1017 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
1020 struct inode *inode;
1023 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
1025 /* hash down to 32-bits on 32-bit arch */
1026 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
1028 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
1030 /* was there a potentially problematic inode collision? */
1031 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
1032 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
1034 if (inode_has_hashed_dentries(inode)) {
1035 cifs_autodisable_serverino(CIFS_SB(sb));
1037 fattr->cf_uniqueid = iunique(sb, ROOT_I);
1038 goto retry_iget5_locked;
1042 cifs_fattr_to_inode(inode, fattr);
1043 if (sb->s_flags & SB_NOATIME)
1044 inode->i_flags |= S_NOATIME | S_NOCMTIME;
1045 if (inode->i_state & I_NEW) {
1046 inode->i_ino = hash;
1047 #ifdef CONFIG_CIFS_FSCACHE
1048 /* initialize per-inode cache cookie pointer */
1049 CIFS_I(inode)->fscache = NULL;
1051 unlock_new_inode(inode);
1058 /* gets root inode */
1059 struct inode *cifs_root_iget(struct super_block *sb)
1062 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1063 struct inode *inode = NULL;
1065 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1069 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
1070 && cifs_sb->prepath) {
1071 len = strlen(cifs_sb->prepath);
1072 path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
1074 return ERR_PTR(-ENOMEM);
1076 memcpy(path+1, cifs_sb->prepath, len);
1078 path = kstrdup("", GFP_KERNEL);
1080 return ERR_PTR(-ENOMEM);
1084 if (tcon->unix_ext) {
1085 rc = cifs_get_inode_info_unix(&inode, path, sb, xid);
1086 /* some servers mistakenly claim POSIX support */
1087 if (rc != -EOPNOTSUPP)
1089 cifs_dbg(VFS, "server does not support POSIX extensions");
1090 tcon->unix_ext = false;
1093 convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
1094 rc = cifs_get_inode_info(&inode, path, NULL, sb, xid, NULL);
1098 inode = ERR_PTR(rc);
1102 #ifdef CONFIG_CIFS_FSCACHE
1103 /* populate tcon->resource_id */
1104 tcon->resource_id = CIFS_I(inode)->uniqueid;
1107 if (rc && tcon->pipe) {
1108 cifs_dbg(FYI, "ipc connection - fake read inode\n");
1109 spin_lock(&inode->i_lock);
1110 inode->i_mode |= S_IFDIR;
1111 set_nlink(inode, 2);
1112 inode->i_op = &cifs_ipc_inode_ops;
1113 inode->i_fop = &simple_dir_operations;
1114 inode->i_uid = cifs_sb->mnt_uid;
1115 inode->i_gid = cifs_sb->mnt_gid;
1116 spin_unlock(&inode->i_lock);
1119 inode = ERR_PTR(rc);
1129 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1130 char *full_path, __u32 dosattr)
1132 bool set_time = false;
1133 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1134 struct TCP_Server_Info *server;
1135 FILE_BASIC_INFO info_buf;
1140 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1141 if (!server->ops->set_file_info)
1146 if (attrs->ia_valid & ATTR_ATIME) {
1148 info_buf.LastAccessTime =
1149 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1151 info_buf.LastAccessTime = 0;
1153 if (attrs->ia_valid & ATTR_MTIME) {
1155 info_buf.LastWriteTime =
1156 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1158 info_buf.LastWriteTime = 0;
1161 * Samba throws this field away, but windows may actually use it.
1162 * Do not set ctime unless other time stamps are changed explicitly
1163 * (i.e. by utimes()) since we would then have a mix of client and
1166 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1167 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1168 info_buf.ChangeTime =
1169 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1171 info_buf.ChangeTime = 0;
1173 info_buf.CreationTime = 0; /* don't change */
1174 info_buf.Attributes = cpu_to_le32(dosattr);
1176 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1180 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1181 * and rename it to a random name that hopefully won't conflict with
1185 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1186 const unsigned int xid)
1190 struct cifs_fid fid;
1191 struct cifs_open_parms oparms;
1192 struct inode *inode = d_inode(dentry);
1193 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1194 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1195 struct tcon_link *tlink;
1196 struct cifs_tcon *tcon;
1197 __u32 dosattr, origattr;
1198 FILE_BASIC_INFO *info_buf = NULL;
1200 tlink = cifs_sb_tlink(cifs_sb);
1202 return PTR_ERR(tlink);
1203 tcon = tlink_tcon(tlink);
1206 * We cannot rename the file if the server doesn't support
1207 * CAP_INFOLEVEL_PASSTHRU
1209 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1215 oparms.cifs_sb = cifs_sb;
1216 oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1217 oparms.create_options = CREATE_NOT_DIR;
1218 oparms.disposition = FILE_OPEN;
1219 oparms.path = full_path;
1221 oparms.reconnect = false;
1223 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1227 origattr = cifsInode->cifsAttrs;
1229 origattr |= ATTR_NORMAL;
1231 dosattr = origattr & ~ATTR_READONLY;
1233 dosattr |= ATTR_NORMAL;
1234 dosattr |= ATTR_HIDDEN;
1236 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1237 if (dosattr != origattr) {
1238 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1239 if (info_buf == NULL) {
1243 info_buf->Attributes = cpu_to_le32(dosattr);
1244 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1246 /* although we would like to mark the file hidden
1247 if that fails we will still try to rename it */
1249 cifsInode->cifsAttrs = dosattr;
1251 dosattr = origattr; /* since not able to change them */
1254 /* rename the file */
1255 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1257 cifs_remap(cifs_sb));
1263 /* try to set DELETE_ON_CLOSE */
1264 if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1265 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1268 * some samba versions return -ENOENT when we try to set the
1269 * file disposition here. Likely a samba bug, but work around
1270 * it for now. This means that some cifsXXX files may hang
1271 * around after they shouldn't.
1273 * BB: remove this hack after more servers have the fix
1281 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1285 CIFSSMBClose(xid, tcon, fid.netfid);
1288 cifs_put_tlink(tlink);
1292 * reset everything back to the original state. Don't bother
1293 * dealing with errors here since we can't do anything about
1297 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1298 cifs_sb->local_nls, cifs_remap(cifs_sb));
1300 if (dosattr != origattr) {
1301 info_buf->Attributes = cpu_to_le32(origattr);
1302 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1304 cifsInode->cifsAttrs = origattr;
1310 /* copied from fs/nfs/dir.c with small changes */
1312 cifs_drop_nlink(struct inode *inode)
1314 spin_lock(&inode->i_lock);
1315 if (inode->i_nlink > 0)
1317 spin_unlock(&inode->i_lock);
1321 * If d_inode(dentry) is null (usually meaning the cached dentry
1322 * is a negative dentry) then we would attempt a standard SMB delete, but
1323 * if that fails we can not attempt the fall back mechanisms on EACCESS
1324 * but will return the EACCESS to the caller. Note that the VFS does not call
1325 * unlink on negative dentries currently.
1327 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1331 char *full_path = NULL;
1332 struct inode *inode = d_inode(dentry);
1333 struct cifsInodeInfo *cifs_inode;
1334 struct super_block *sb = dir->i_sb;
1335 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1336 struct tcon_link *tlink;
1337 struct cifs_tcon *tcon;
1338 struct TCP_Server_Info *server;
1339 struct iattr *attrs = NULL;
1340 __u32 dosattr = 0, origattr = 0;
1342 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1344 tlink = cifs_sb_tlink(cifs_sb);
1346 return PTR_ERR(tlink);
1347 tcon = tlink_tcon(tlink);
1348 server = tcon->ses->server;
1352 /* Unlink can be called from rename so we can not take the
1353 * sb->s_vfs_rename_mutex here */
1354 full_path = build_path_from_dentry(dentry);
1355 if (full_path == NULL) {
1360 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1361 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1362 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1363 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1364 cifs_remap(cifs_sb));
1365 cifs_dbg(FYI, "posix del rc %d\n", rc);
1366 if ((rc == 0) || (rc == -ENOENT))
1367 goto psx_del_no_retry;
1371 if (!server->ops->unlink) {
1373 goto psx_del_no_retry;
1376 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1381 cifs_drop_nlink(inode);
1382 } else if (rc == -ENOENT) {
1384 } else if (rc == -EBUSY) {
1385 if (server->ops->rename_pending_delete) {
1386 rc = server->ops->rename_pending_delete(full_path,
1389 cifs_drop_nlink(inode);
1391 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1392 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1393 if (attrs == NULL) {
1398 /* try to reset dos attributes */
1399 cifs_inode = CIFS_I(inode);
1400 origattr = cifs_inode->cifsAttrs;
1402 origattr |= ATTR_NORMAL;
1403 dosattr = origattr & ~ATTR_READONLY;
1405 dosattr |= ATTR_NORMAL;
1406 dosattr |= ATTR_HIDDEN;
1408 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1412 goto retry_std_delete;
1415 /* undo the setattr if we errored out and it's needed */
1416 if (rc != 0 && dosattr != 0)
1417 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1421 cifs_inode = CIFS_I(inode);
1422 cifs_inode->time = 0; /* will force revalidate to get info
1424 inode->i_ctime = current_time(inode);
1426 dir->i_ctime = dir->i_mtime = current_time(dir);
1427 cifs_inode = CIFS_I(dir);
1428 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1433 cifs_put_tlink(tlink);
1438 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1439 const char *full_path, struct cifs_sb_info *cifs_sb,
1440 struct cifs_tcon *tcon, const unsigned int xid)
1443 struct inode *inode = NULL;
1446 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1449 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1456 * setting nlink not necessary except in cases where we failed to get it
1457 * from the server or was set bogus. Also, since this is a brand new
1458 * inode, no need to grab the i_lock before setting the i_nlink.
1460 if (inode->i_nlink < 2)
1461 set_nlink(inode, 2);
1462 mode &= ~current_umask();
1463 /* must turn on setgid bit if parent dir has it */
1464 if (parent->i_mode & S_ISGID)
1467 if (tcon->unix_ext) {
1468 struct cifs_unix_set_info_args args = {
1470 .ctime = NO_CHANGE_64,
1471 .atime = NO_CHANGE_64,
1472 .mtime = NO_CHANGE_64,
1475 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1476 args.uid = current_fsuid();
1477 if (parent->i_mode & S_ISGID)
1478 args.gid = parent->i_gid;
1480 args.gid = current_fsgid();
1482 args.uid = INVALID_UID; /* no change */
1483 args.gid = INVALID_GID; /* no change */
1485 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1487 cifs_remap(cifs_sb));
1489 struct TCP_Server_Info *server = tcon->ses->server;
1490 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1491 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1492 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1494 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1495 inode->i_mode = (mode | S_IFDIR);
1497 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1498 inode->i_uid = current_fsuid();
1499 if (inode->i_mode & S_ISGID)
1500 inode->i_gid = parent->i_gid;
1502 inode->i_gid = current_fsgid();
1505 d_instantiate(dentry, inode);
1510 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1511 const char *full_path, struct cifs_sb_info *cifs_sb,
1512 struct cifs_tcon *tcon, const unsigned int xid)
1516 FILE_UNIX_BASIC_INFO *info = NULL;
1517 struct inode *newinode = NULL;
1518 struct cifs_fattr fattr;
1520 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1523 goto posix_mkdir_out;
1526 mode &= ~current_umask();
1527 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1528 NULL /* netfid */, info, &oplock, full_path,
1529 cifs_sb->local_nls, cifs_remap(cifs_sb));
1530 if (rc == -EOPNOTSUPP)
1531 goto posix_mkdir_out;
1533 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1535 goto posix_mkdir_out;
1538 if (info->Type == cpu_to_le32(-1))
1539 /* no return info, go query for it */
1540 goto posix_mkdir_get_info;
1542 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1543 * need to set uid/gid.
1546 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1547 cifs_fill_uniqueid(inode->i_sb, &fattr);
1548 newinode = cifs_iget(inode->i_sb, &fattr);
1550 goto posix_mkdir_get_info;
1552 d_instantiate(dentry, newinode);
1554 #ifdef CONFIG_CIFS_DEBUG2
1555 cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1556 dentry, dentry, newinode);
1558 if (newinode->i_nlink != 2)
1559 cifs_dbg(FYI, "unexpected number of links %d\n",
1566 posix_mkdir_get_info:
1567 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1569 goto posix_mkdir_out;
1572 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1576 struct cifs_sb_info *cifs_sb;
1577 struct tcon_link *tlink;
1578 struct cifs_tcon *tcon;
1579 struct TCP_Server_Info *server;
1582 cifs_dbg(FYI, "In cifs_mkdir, mode = %04ho inode = 0x%p\n",
1585 cifs_sb = CIFS_SB(inode->i_sb);
1586 tlink = cifs_sb_tlink(cifs_sb);
1588 return PTR_ERR(tlink);
1589 tcon = tlink_tcon(tlink);
1593 full_path = build_path_from_dentry(direntry);
1594 if (full_path == NULL) {
1599 server = tcon->ses->server;
1601 if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) {
1602 rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,
1604 d_drop(direntry); /* for time being always refresh inode info */
1608 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1609 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1610 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1612 if (rc != -EOPNOTSUPP)
1616 if (!server->ops->mkdir) {
1621 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1622 rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
1624 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1629 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1633 * Force revalidate to get parent dir info when needed since cached
1634 * attributes are invalid now.
1636 CIFS_I(inode)->time = 0;
1639 cifs_put_tlink(tlink);
1643 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1647 struct cifs_sb_info *cifs_sb;
1648 struct tcon_link *tlink;
1649 struct cifs_tcon *tcon;
1650 struct TCP_Server_Info *server;
1651 char *full_path = NULL;
1652 struct cifsInodeInfo *cifsInode;
1654 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1658 full_path = build_path_from_dentry(direntry);
1659 if (full_path == NULL) {
1664 cifs_sb = CIFS_SB(inode->i_sb);
1665 tlink = cifs_sb_tlink(cifs_sb);
1666 if (IS_ERR(tlink)) {
1667 rc = PTR_ERR(tlink);
1670 tcon = tlink_tcon(tlink);
1671 server = tcon->ses->server;
1673 if (!server->ops->rmdir) {
1675 cifs_put_tlink(tlink);
1679 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1680 cifs_put_tlink(tlink);
1683 spin_lock(&d_inode(direntry)->i_lock);
1684 i_size_write(d_inode(direntry), 0);
1685 clear_nlink(d_inode(direntry));
1686 spin_unlock(&d_inode(direntry)->i_lock);
1689 cifsInode = CIFS_I(d_inode(direntry));
1690 /* force revalidate to go get info when needed */
1691 cifsInode->time = 0;
1693 cifsInode = CIFS_I(inode);
1695 * Force revalidate to get parent dir info when needed since cached
1696 * attributes are invalid now.
1698 cifsInode->time = 0;
1700 d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
1701 current_time(inode);
1710 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1711 const char *from_path, struct dentry *to_dentry,
1712 const char *to_path)
1714 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1715 struct tcon_link *tlink;
1716 struct cifs_tcon *tcon;
1717 struct TCP_Server_Info *server;
1718 struct cifs_fid fid;
1719 struct cifs_open_parms oparms;
1722 tlink = cifs_sb_tlink(cifs_sb);
1724 return PTR_ERR(tlink);
1725 tcon = tlink_tcon(tlink);
1726 server = tcon->ses->server;
1728 if (!server->ops->rename)
1731 /* try path-based rename first */
1732 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1735 * Don't bother with rename by filehandle unless file is busy and
1736 * source. Note that cross directory moves do not work with
1737 * rename by filehandle to various Windows servers.
1739 if (rc == 0 || rc != -EBUSY)
1740 goto do_rename_exit;
1742 /* Don't fall back to using SMB on SMB 2+ mount */
1743 if (server->vals->protocol_id != 0)
1744 goto do_rename_exit;
1746 /* open-file renames don't work across directories */
1747 if (to_dentry->d_parent != from_dentry->d_parent)
1748 goto do_rename_exit;
1751 oparms.cifs_sb = cifs_sb;
1752 /* open the file to be renamed -- we need DELETE perms */
1753 oparms.desired_access = DELETE;
1754 oparms.create_options = CREATE_NOT_DIR;
1755 oparms.disposition = FILE_OPEN;
1756 oparms.path = from_path;
1758 oparms.reconnect = false;
1760 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1762 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
1763 (const char *) to_dentry->d_name.name,
1764 cifs_sb->local_nls, cifs_remap(cifs_sb));
1765 CIFSSMBClose(xid, tcon, fid.netfid);
1768 cifs_put_tlink(tlink);
1773 cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
1774 struct inode *target_dir, struct dentry *target_dentry,
1777 char *from_name = NULL;
1778 char *to_name = NULL;
1779 struct cifs_sb_info *cifs_sb;
1780 struct tcon_link *tlink;
1781 struct cifs_tcon *tcon;
1782 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1783 FILE_UNIX_BASIC_INFO *info_buf_target;
1787 if (flags & ~RENAME_NOREPLACE)
1790 cifs_sb = CIFS_SB(source_dir->i_sb);
1791 tlink = cifs_sb_tlink(cifs_sb);
1793 return PTR_ERR(tlink);
1794 tcon = tlink_tcon(tlink);
1799 * we already have the rename sem so we do not need to
1800 * grab it again here to protect the path integrity
1802 from_name = build_path_from_dentry(source_dentry);
1803 if (from_name == NULL) {
1805 goto cifs_rename_exit;
1808 to_name = build_path_from_dentry(target_dentry);
1809 if (to_name == NULL) {
1811 goto cifs_rename_exit;
1814 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1818 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1820 if (flags & RENAME_NOREPLACE)
1821 goto cifs_rename_exit;
1823 if (rc == -EEXIST && tcon->unix_ext) {
1825 * Are src and dst hardlinks of same inode? We can only tell
1826 * with unix extensions enabled.
1829 kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
1831 if (info_buf_source == NULL) {
1833 goto cifs_rename_exit;
1836 info_buf_target = info_buf_source + 1;
1837 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1840 cifs_remap(cifs_sb));
1844 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1847 cifs_remap(cifs_sb));
1849 if (tmprc == 0 && (info_buf_source->UniqueId ==
1850 info_buf_target->UniqueId)) {
1851 /* same file, POSIX says that this is a noop */
1853 goto cifs_rename_exit;
1857 * else ... BB we could add the same check for Windows by
1858 * checking the UniqueId via FILE_INTERNAL_INFO
1862 /* Try unlinking the target dentry if it's not negative */
1863 if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
1864 if (d_is_dir(target_dentry))
1865 tmprc = cifs_rmdir(target_dir, target_dentry);
1867 tmprc = cifs_unlink(target_dir, target_dentry);
1869 goto cifs_rename_exit;
1870 rc = cifs_do_rename(xid, source_dentry, from_name,
1871 target_dentry, to_name);
1874 /* force revalidate to go get info when needed */
1875 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
1877 source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
1878 target_dir->i_mtime = current_time(source_dir);
1881 kfree(info_buf_source);
1885 cifs_put_tlink(tlink);
1890 cifs_inode_needs_reval(struct inode *inode)
1892 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1893 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1895 if (cifs_i->time == 0)
1898 if (CIFS_CACHE_READ(cifs_i))
1901 if (!lookupCacheEnabled)
1904 if (!cifs_sb->actimeo)
1907 if (!time_in_range(jiffies, cifs_i->time,
1908 cifs_i->time + cifs_sb->actimeo))
1911 /* hardlinked files w/ noserverino get "special" treatment */
1912 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1913 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1920 * Zap the cache. Called when invalid_mapping flag is set.
1923 cifs_invalidate_mapping(struct inode *inode)
1927 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1928 rc = invalidate_inode_pages2(inode->i_mapping);
1930 cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1934 cifs_fscache_reset_inode_cookie(inode);
1939 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
1940 * @word: long word containing the bit lock
1943 cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
1945 freezable_schedule_unsafe();
1946 if (signal_pending_state(mode, current))
1947 return -ERESTARTSYS;
1952 cifs_revalidate_mapping(struct inode *inode)
1955 unsigned long *flags = &CIFS_I(inode)->flags;
1957 rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
1962 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
1963 rc = cifs_invalidate_mapping(inode);
1965 set_bit(CIFS_INO_INVALID_MAPPING, flags);
1968 clear_bit_unlock(CIFS_INO_LOCK, flags);
1969 smp_mb__after_atomic();
1970 wake_up_bit(flags, CIFS_INO_LOCK);
1976 cifs_zap_mapping(struct inode *inode)
1978 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
1979 return cifs_revalidate_mapping(inode);
1982 int cifs_revalidate_file_attr(struct file *filp)
1985 struct inode *inode = file_inode(filp);
1986 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1988 if (!cifs_inode_needs_reval(inode))
1991 if (tlink_tcon(cfile->tlink)->unix_ext)
1992 rc = cifs_get_file_info_unix(filp);
1994 rc = cifs_get_file_info(filp);
1999 int cifs_revalidate_dentry_attr(struct dentry *dentry)
2003 struct inode *inode = d_inode(dentry);
2004 struct super_block *sb = dentry->d_sb;
2005 char *full_path = NULL;
2011 if (!cifs_inode_needs_reval(inode))
2016 /* can not safely grab the rename sem here if rename calls revalidate
2017 since that would deadlock */
2018 full_path = build_path_from_dentry(dentry);
2019 if (full_path == NULL) {
2024 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2025 full_path, inode, inode->i_count.counter,
2026 dentry, cifs_get_time(dentry), jiffies);
2029 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
2030 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2032 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2034 if (rc == -EAGAIN && count++ < 10)
2043 int cifs_revalidate_file(struct file *filp)
2046 struct inode *inode = file_inode(filp);
2048 rc = cifs_revalidate_file_attr(filp);
2052 return cifs_revalidate_mapping(inode);
2055 /* revalidate a dentry's inode attributes */
2056 int cifs_revalidate_dentry(struct dentry *dentry)
2059 struct inode *inode = d_inode(dentry);
2061 rc = cifs_revalidate_dentry_attr(dentry);
2065 return cifs_revalidate_mapping(inode);
2068 int cifs_getattr(const struct path *path, struct kstat *stat,
2069 u32 request_mask, unsigned int flags)
2071 struct dentry *dentry = path->dentry;
2072 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2073 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2074 struct inode *inode = d_inode(dentry);
2078 * We need to be sure that all dirty pages are written and the server
2079 * has actual ctime, mtime and file length.
2081 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2082 inode->i_mapping->nrpages != 0) {
2083 rc = filemap_fdatawait(inode->i_mapping);
2085 mapping_set_error(inode->i_mapping, rc);
2090 rc = cifs_revalidate_dentry_attr(dentry);
2094 generic_fillattr(inode, stat);
2095 stat->blksize = CIFS_MAX_MSGSIZE;
2096 stat->ino = CIFS_I(inode)->uniqueid;
2098 /* old CIFS Unix Extensions doesn't return create time */
2099 if (CIFS_I(inode)->createtime) {
2100 stat->result_mask |= STATX_BTIME;
2102 cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
2105 stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2106 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2107 stat->attributes |= STATX_ATTR_COMPRESSED;
2108 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2109 stat->attributes |= STATX_ATTR_ENCRYPTED;
2112 * If on a multiuser mount without unix extensions or cifsacl being
2113 * enabled, and the admin hasn't overridden them, set the ownership
2114 * to the fsuid/fsgid of the current process.
2116 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2117 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2119 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2120 stat->uid = current_fsuid();
2121 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2122 stat->gid = current_fsgid();
2127 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
2129 pgoff_t index = from >> PAGE_SHIFT;
2130 unsigned offset = from & (PAGE_SIZE - 1);
2134 page = grab_cache_page(mapping, index);
2138 zero_user_segment(page, offset, PAGE_SIZE);
2144 static void cifs_setsize(struct inode *inode, loff_t offset)
2146 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2148 spin_lock(&inode->i_lock);
2149 i_size_write(inode, offset);
2150 spin_unlock(&inode->i_lock);
2152 /* Cached inode must be refreshed on truncate */
2154 truncate_pagecache(inode, offset);
2158 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2159 unsigned int xid, char *full_path)
2162 struct cifsFileInfo *open_file;
2163 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2164 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2165 struct tcon_link *tlink = NULL;
2166 struct cifs_tcon *tcon = NULL;
2167 struct TCP_Server_Info *server;
2170 * To avoid spurious oplock breaks from server, in the case of
2171 * inodes that we already have open, avoid doing path based
2172 * setting of file size if we can do it by handle.
2173 * This keeps our caching token (oplock) and avoids timeouts
2174 * when the local oplock break takes longer to flush
2175 * writebehind data than the SMB timeout for the SetPathInfo
2176 * request would allow
2178 open_file = find_writable_file(cifsInode, true);
2180 tcon = tlink_tcon(open_file->tlink);
2181 server = tcon->ses->server;
2182 if (server->ops->set_file_size)
2183 rc = server->ops->set_file_size(xid, tcon, open_file,
2184 attrs->ia_size, false);
2187 cifsFileInfo_put(open_file);
2188 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2196 tlink = cifs_sb_tlink(cifs_sb);
2198 return PTR_ERR(tlink);
2199 tcon = tlink_tcon(tlink);
2200 server = tcon->ses->server;
2204 * Set file size by pathname rather than by handle either because no
2205 * valid, writeable file handle for it was found or because there was
2206 * an error setting it by handle.
2208 if (server->ops->set_path_size)
2209 rc = server->ops->set_path_size(xid, tcon, full_path,
2210 attrs->ia_size, cifs_sb, false);
2213 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2216 cifs_put_tlink(tlink);
2220 cifsInode->server_eof = attrs->ia_size;
2221 cifs_setsize(inode, attrs->ia_size);
2224 * The man page of truncate says if the size changed,
2225 * then the st_ctime and st_mtime fields for the file
2228 attrs->ia_ctime = attrs->ia_mtime = current_time(inode);
2229 attrs->ia_valid |= ATTR_CTIME | ATTR_MTIME;
2231 cifs_truncate_page(inode->i_mapping, inode->i_size);
2238 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2242 char *full_path = NULL;
2243 struct inode *inode = d_inode(direntry);
2244 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2245 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2246 struct tcon_link *tlink;
2247 struct cifs_tcon *pTcon;
2248 struct cifs_unix_set_info_args *args = NULL;
2249 struct cifsFileInfo *open_file;
2251 cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2252 direntry, attrs->ia_valid);
2256 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2257 attrs->ia_valid |= ATTR_FORCE;
2259 rc = setattr_prepare(direntry, attrs);
2263 full_path = build_path_from_dentry(direntry);
2264 if (full_path == NULL) {
2270 * Attempt to flush data before changing attributes. We need to do
2271 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2272 * ownership or mode then we may also need to do this. Here, we take
2273 * the safe way out and just do the flush on all setattr requests. If
2274 * the flush returns error, store it to report later and continue.
2276 * BB: This should be smarter. Why bother flushing pages that
2277 * will be truncated anyway? Also, should we error out here if
2278 * the flush returns error?
2280 rc = filemap_write_and_wait(inode->i_mapping);
2281 if (is_interrupt_error(rc)) {
2286 mapping_set_error(inode->i_mapping, rc);
2289 if (attrs->ia_valid & ATTR_SIZE) {
2290 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2295 /* skip mode change if it's just for clearing setuid/setgid */
2296 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2297 attrs->ia_valid &= ~ATTR_MODE;
2299 args = kmalloc(sizeof(*args), GFP_KERNEL);
2305 /* set up the struct */
2306 if (attrs->ia_valid & ATTR_MODE)
2307 args->mode = attrs->ia_mode;
2309 args->mode = NO_CHANGE_64;
2311 if (attrs->ia_valid & ATTR_UID)
2312 args->uid = attrs->ia_uid;
2314 args->uid = INVALID_UID; /* no change */
2316 if (attrs->ia_valid & ATTR_GID)
2317 args->gid = attrs->ia_gid;
2319 args->gid = INVALID_GID; /* no change */
2321 if (attrs->ia_valid & ATTR_ATIME)
2322 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2324 args->atime = NO_CHANGE_64;
2326 if (attrs->ia_valid & ATTR_MTIME)
2327 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2329 args->mtime = NO_CHANGE_64;
2331 if (attrs->ia_valid & ATTR_CTIME)
2332 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2334 args->ctime = NO_CHANGE_64;
2337 open_file = find_writable_file(cifsInode, true);
2339 u16 nfid = open_file->fid.netfid;
2340 u32 npid = open_file->pid;
2341 pTcon = tlink_tcon(open_file->tlink);
2342 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2343 cifsFileInfo_put(open_file);
2345 tlink = cifs_sb_tlink(cifs_sb);
2346 if (IS_ERR(tlink)) {
2347 rc = PTR_ERR(tlink);
2350 pTcon = tlink_tcon(tlink);
2351 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2353 cifs_remap(cifs_sb));
2354 cifs_put_tlink(tlink);
2360 if ((attrs->ia_valid & ATTR_SIZE) &&
2361 attrs->ia_size != i_size_read(inode))
2362 truncate_setsize(inode, attrs->ia_size);
2364 setattr_copy(inode, attrs);
2365 mark_inode_dirty(inode);
2367 /* force revalidate when any of these times are set since some
2368 of the fs types (eg ext3, fat) do not have fine enough
2369 time granularity to match protocol, and we do not have a
2370 a way (yet) to query the server fs's time granularity (and
2371 whether it rounds times down).
2373 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2374 cifsInode->time = 0;
2383 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2386 kuid_t uid = INVALID_UID;
2387 kgid_t gid = INVALID_GID;
2388 struct inode *inode = d_inode(direntry);
2389 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2390 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2391 char *full_path = NULL;
2394 __u64 mode = NO_CHANGE_64;
2398 cifs_dbg(FYI, "setattr on file %pd attrs->iavalid 0x%x\n",
2399 direntry, attrs->ia_valid);
2401 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2402 attrs->ia_valid |= ATTR_FORCE;
2404 rc = setattr_prepare(direntry, attrs);
2410 full_path = build_path_from_dentry(direntry);
2411 if (full_path == NULL) {
2418 * Attempt to flush data before changing attributes. We need to do
2419 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2420 * ownership or mode then we may also need to do this. Here, we take
2421 * the safe way out and just do the flush on all setattr requests. If
2422 * the flush returns error, store it to report later and continue.
2424 * BB: This should be smarter. Why bother flushing pages that
2425 * will be truncated anyway? Also, should we error out here if
2426 * the flush returns error?
2428 rc = filemap_write_and_wait(inode->i_mapping);
2429 if (is_interrupt_error(rc)) {
2431 goto cifs_setattr_exit;
2434 mapping_set_error(inode->i_mapping, rc);
2437 if (attrs->ia_valid & ATTR_SIZE) {
2438 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2440 goto cifs_setattr_exit;
2443 if (attrs->ia_valid & ATTR_UID)
2444 uid = attrs->ia_uid;
2446 if (attrs->ia_valid & ATTR_GID)
2447 gid = attrs->ia_gid;
2449 #ifdef CONFIG_CIFS_ACL
2450 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2451 if (uid_valid(uid) || gid_valid(gid)) {
2452 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2455 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2457 goto cifs_setattr_exit;
2461 #endif /* CONFIG_CIFS_ACL */
2462 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2463 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2465 /* skip mode change if it's just for clearing setuid/setgid */
2466 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2467 attrs->ia_valid &= ~ATTR_MODE;
2469 if (attrs->ia_valid & ATTR_MODE) {
2470 mode = attrs->ia_mode;
2472 #ifdef CONFIG_CIFS_ACL
2473 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2474 rc = id_mode_to_cifs_acl(inode, full_path, mode,
2475 INVALID_UID, INVALID_GID);
2477 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2479 goto cifs_setattr_exit;
2482 #endif /* CONFIG_CIFS_ACL */
2483 if (((mode & S_IWUGO) == 0) &&
2484 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2486 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2488 /* fix up mode if we're not using dynperm */
2489 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2490 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2491 } else if ((mode & S_IWUGO) &&
2492 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2494 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2495 /* Attributes of 0 are ignored */
2497 dosattr |= ATTR_NORMAL;
2499 /* reset local inode permissions to normal */
2500 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2501 attrs->ia_mode &= ~(S_IALLUGO);
2502 if (S_ISDIR(inode->i_mode))
2504 cifs_sb->mnt_dir_mode;
2507 cifs_sb->mnt_file_mode;
2509 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2510 /* ignore mode change - ATTR_READONLY hasn't changed */
2511 attrs->ia_valid &= ~ATTR_MODE;
2515 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2516 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2517 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2518 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2520 /* Even if error on time set, no sense failing the call if
2521 the server would set the time to a reasonable value anyway,
2522 and this check ensures that we are not being called from
2523 sys_utimes in which case we ought to fail the call back to
2524 the user when the server rejects the call */
2525 if ((rc) && (attrs->ia_valid &
2526 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2530 /* do not need local check to inode_check_ok since the server does
2533 goto cifs_setattr_exit;
2535 if ((attrs->ia_valid & ATTR_SIZE) &&
2536 attrs->ia_size != i_size_read(inode))
2537 truncate_setsize(inode, attrs->ia_size);
2539 setattr_copy(inode, attrs);
2540 mark_inode_dirty(inode);
2549 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2551 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
2552 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2553 int rc, retries = 0;
2556 if (pTcon->unix_ext)
2557 rc = cifs_setattr_unix(direntry, attrs);
2559 rc = cifs_setattr_nounix(direntry, attrs);
2561 } while (is_retryable_error(rc) && retries < 2);
2563 /* BB: add cifs_setattr_legacy for really old servers */
2568 void cifs_delete_inode(struct inode *inode)
2570 cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2571 /* may have to add back in if and when safe distributed caching of
2572 directories added e.g. via FindNotify */