4 * Copyright (C) International Business Machines Corp., 2002,2010
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/stat.h>
23 #include <linux/slab.h>
24 #include <linux/pagemap.h>
25 #include <linux/freezer.h>
26 #include <asm/div64.h>
30 #include "cifsproto.h"
31 #include "cifs_debug.h"
32 #include "cifs_fs_sb.h"
36 static void cifs_set_ops(struct inode *inode)
38 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
40 switch (inode->i_mode & S_IFMT) {
42 inode->i_op = &cifs_file_inode_ops;
43 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
44 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
45 inode->i_fop = &cifs_file_direct_nobrl_ops;
47 inode->i_fop = &cifs_file_direct_ops;
48 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
49 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
50 inode->i_fop = &cifs_file_strict_nobrl_ops;
52 inode->i_fop = &cifs_file_strict_ops;
53 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
54 inode->i_fop = &cifs_file_nobrl_ops;
55 else { /* not direct, send byte range locks */
56 inode->i_fop = &cifs_file_ops;
59 /* check if server can support readpages */
60 if (cifs_sb_master_tcon(cifs_sb)->ses->server->maxBuf <
61 PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
62 inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
64 inode->i_data.a_ops = &cifs_addr_ops;
67 #ifdef CONFIG_CIFS_DFS_UPCALL
68 if (IS_AUTOMOUNT(inode)) {
69 inode->i_op = &cifs_dfs_referral_inode_operations;
71 #else /* NO DFS support, treat as a directory */
74 inode->i_op = &cifs_dir_inode_ops;
75 inode->i_fop = &cifs_dir_ops;
79 inode->i_op = &cifs_symlink_inode_ops;
82 init_special_inode(inode, inode->i_mode, inode->i_rdev);
87 /* check inode attributes against fattr. If they don't match, tag the
88 * inode for cache invalidation
91 cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
93 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
95 cifs_dbg(FYI, "%s: revalidating inode %llu\n",
96 __func__, cifs_i->uniqueid);
98 if (inode->i_state & I_NEW) {
99 cifs_dbg(FYI, "%s: inode %llu is new\n",
100 __func__, cifs_i->uniqueid);
104 /* don't bother with revalidation if we have an oplock */
105 if (CIFS_CACHE_READ(cifs_i)) {
106 cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
107 __func__, cifs_i->uniqueid);
111 /* revalidate if mtime or size have changed */
112 if (timespec_equal(&inode->i_mtime, &fattr->cf_mtime) &&
113 cifs_i->server_eof == fattr->cf_eof) {
114 cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
115 __func__, cifs_i->uniqueid);
119 cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
120 __func__, cifs_i->uniqueid);
121 set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags);
125 * copy nlink to the inode, unless it wasn't provided. Provide
126 * sane values if we don't have an existing one and none was provided
129 cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
132 * if we're in a situation where we can't trust what we
133 * got from the server (readdir, some non-unix cases)
134 * fake reasonable values
136 if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
137 /* only provide fake values on a new inode */
138 if (inode->i_state & I_NEW) {
139 if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
147 /* we trust the server, so update it */
148 set_nlink(inode, fattr->cf_nlink);
151 /* populate an inode with info from a cifs_fattr struct */
153 cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
155 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
156 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
158 cifs_revalidate_cache(inode, fattr);
160 spin_lock(&inode->i_lock);
161 inode->i_atime = fattr->cf_atime;
162 inode->i_mtime = fattr->cf_mtime;
163 inode->i_ctime = fattr->cf_ctime;
164 inode->i_rdev = fattr->cf_rdev;
165 cifs_nlink_fattr_to_inode(inode, fattr);
166 inode->i_uid = fattr->cf_uid;
167 inode->i_gid = fattr->cf_gid;
169 /* if dynperm is set, don't clobber existing mode */
170 if (inode->i_state & I_NEW ||
171 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
172 inode->i_mode = fattr->cf_mode;
174 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
176 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
179 cifs_i->time = jiffies;
181 if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING)
182 set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
184 clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
186 cifs_i->server_eof = fattr->cf_eof;
188 * Can't safely change the file size here if the client is writing to
189 * it due to potential races.
191 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
192 i_size_write(inode, fattr->cf_eof);
195 * i_blocks is not related to (i_size / i_blksize),
196 * but instead 512 byte (2**9) size is required for
197 * calculating num blocks.
199 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
201 spin_unlock(&inode->i_lock);
203 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
204 inode->i_flags |= S_AUTOMOUNT;
205 if (inode->i_state & I_NEW)
210 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
212 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
214 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
217 fattr->cf_uniqueid = iunique(sb, ROOT_I);
220 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
222 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
223 struct cifs_sb_info *cifs_sb)
225 memset(fattr, 0, sizeof(*fattr));
226 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
227 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
228 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
230 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
231 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
232 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
233 fattr->cf_mode = le64_to_cpu(info->Permissions);
236 * Since we set the inode type below we need to mask off
237 * to avoid strange results if bits set above.
239 fattr->cf_mode &= ~S_IFMT;
240 switch (le32_to_cpu(info->Type)) {
242 fattr->cf_mode |= S_IFREG;
243 fattr->cf_dtype = DT_REG;
246 fattr->cf_mode |= S_IFLNK;
247 fattr->cf_dtype = DT_LNK;
250 fattr->cf_mode |= S_IFDIR;
251 fattr->cf_dtype = DT_DIR;
254 fattr->cf_mode |= S_IFCHR;
255 fattr->cf_dtype = DT_CHR;
256 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
257 le64_to_cpu(info->DevMinor) & MINORMASK);
260 fattr->cf_mode |= S_IFBLK;
261 fattr->cf_dtype = DT_BLK;
262 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
263 le64_to_cpu(info->DevMinor) & MINORMASK);
266 fattr->cf_mode |= S_IFIFO;
267 fattr->cf_dtype = DT_FIFO;
270 fattr->cf_mode |= S_IFSOCK;
271 fattr->cf_dtype = DT_SOCK;
274 /* safest to call it a file if we do not know */
275 fattr->cf_mode |= S_IFREG;
276 fattr->cf_dtype = DT_REG;
277 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
281 fattr->cf_uid = cifs_sb->mnt_uid;
282 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
283 u64 id = le64_to_cpu(info->Uid);
284 if (id < ((uid_t)-1)) {
285 kuid_t uid = make_kuid(&init_user_ns, id);
291 fattr->cf_gid = cifs_sb->mnt_gid;
292 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
293 u64 id = le64_to_cpu(info->Gid);
294 if (id < ((gid_t)-1)) {
295 kgid_t gid = make_kgid(&init_user_ns, id);
301 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
305 * Fill a cifs_fattr struct with fake inode info.
307 * Needed to setup cifs_fattr data for the directory which is the
308 * junction to the new submount (ie to setup the fake directory
309 * which represents a DFS referral).
312 cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
314 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
316 cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
318 memset(fattr, 0, sizeof(*fattr));
319 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
320 fattr->cf_uid = cifs_sb->mnt_uid;
321 fattr->cf_gid = cifs_sb->mnt_gid;
322 fattr->cf_atime = CURRENT_TIME;
323 fattr->cf_ctime = CURRENT_TIME;
324 fattr->cf_mtime = CURRENT_TIME;
326 fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
330 cifs_get_file_info_unix(struct file *filp)
334 FILE_UNIX_BASIC_INFO find_data;
335 struct cifs_fattr fattr;
336 struct inode *inode = file_inode(filp);
337 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
338 struct cifsFileInfo *cfile = filp->private_data;
339 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
342 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
344 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
345 } else if (rc == -EREMOTE) {
346 cifs_create_dfs_fattr(&fattr, inode->i_sb);
350 cifs_fattr_to_inode(inode, &fattr);
355 int cifs_get_inode_info_unix(struct inode **pinode,
356 const unsigned char *full_path,
357 struct super_block *sb, unsigned int xid)
360 FILE_UNIX_BASIC_INFO find_data;
361 struct cifs_fattr fattr;
362 struct cifs_tcon *tcon;
363 struct tcon_link *tlink;
364 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
366 cifs_dbg(FYI, "Getting info on %s\n", full_path);
368 tlink = cifs_sb_tlink(cifs_sb);
370 return PTR_ERR(tlink);
371 tcon = tlink_tcon(tlink);
373 /* could have done a find first instead but this returns more info */
374 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
375 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
376 CIFS_MOUNT_MAP_SPECIAL_CHR);
377 cifs_put_tlink(tlink);
380 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
381 } else if (rc == -EREMOTE) {
382 cifs_create_dfs_fattr(&fattr, sb);
388 /* check for Minshall+French symlinks */
389 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
390 int tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
393 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
396 if (*pinode == NULL) {
398 cifs_fill_uniqueid(sb, &fattr);
399 *pinode = cifs_iget(sb, &fattr);
403 /* we already have inode, update it */
404 cifs_fattr_to_inode(*pinode, &fattr);
411 cifs_sfu_type(struct cifs_fattr *fattr, const char *path,
412 struct cifs_sb_info *cifs_sb, unsigned int xid)
416 struct tcon_link *tlink;
417 struct cifs_tcon *tcon;
419 struct cifs_open_parms oparms;
420 struct cifs_io_parms io_parms;
422 unsigned int bytes_read;
424 int buf_type = CIFS_NO_BUFFER;
428 fattr->cf_mode &= ~S_IFMT;
430 if (fattr->cf_eof == 0) {
431 fattr->cf_mode |= S_IFIFO;
432 fattr->cf_dtype = DT_FIFO;
434 } else if (fattr->cf_eof < 8) {
435 fattr->cf_mode |= S_IFREG;
436 fattr->cf_dtype = DT_REG;
437 return -EINVAL; /* EOPNOTSUPP? */
440 tlink = cifs_sb_tlink(cifs_sb);
442 return PTR_ERR(tlink);
443 tcon = tlink_tcon(tlink);
446 oparms.cifs_sb = cifs_sb;
447 oparms.desired_access = GENERIC_READ;
448 oparms.create_options = CREATE_NOT_DIR;
449 oparms.disposition = FILE_OPEN;
452 oparms.reconnect = false;
454 rc = CIFS_open(xid, &oparms, &oplock, NULL);
456 cifs_put_tlink(tlink);
461 io_parms.netfid = fid.netfid;
462 io_parms.pid = current->tgid;
463 io_parms.tcon = tcon;
465 io_parms.length = 24;
467 rc = CIFSSMBRead(xid, &io_parms, &bytes_read, &pbuf, &buf_type);
468 if ((rc == 0) && (bytes_read >= 8)) {
469 if (memcmp("IntxBLK", pbuf, 8) == 0) {
470 cifs_dbg(FYI, "Block device\n");
471 fattr->cf_mode |= S_IFBLK;
472 fattr->cf_dtype = DT_BLK;
473 if (bytes_read == 24) {
474 /* we have enough to decode dev num */
475 __u64 mjr; /* major */
476 __u64 mnr; /* minor */
477 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
478 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
479 fattr->cf_rdev = MKDEV(mjr, mnr);
481 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
482 cifs_dbg(FYI, "Char device\n");
483 fattr->cf_mode |= S_IFCHR;
484 fattr->cf_dtype = DT_CHR;
485 if (bytes_read == 24) {
486 /* we have enough to decode dev num */
487 __u64 mjr; /* major */
488 __u64 mnr; /* minor */
489 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
490 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
491 fattr->cf_rdev = MKDEV(mjr, mnr);
493 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
494 cifs_dbg(FYI, "Symlink\n");
495 fattr->cf_mode |= S_IFLNK;
496 fattr->cf_dtype = DT_LNK;
498 fattr->cf_mode |= S_IFREG; /* file? */
499 fattr->cf_dtype = DT_REG;
503 fattr->cf_mode |= S_IFREG; /* then it is a file */
504 fattr->cf_dtype = DT_REG;
505 rc = -EOPNOTSUPP; /* or some unknown SFU type */
507 CIFSSMBClose(xid, tcon, fid.netfid);
508 cifs_put_tlink(tlink);
512 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
515 * Fetch mode bits as provided by SFU.
517 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
519 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
520 struct cifs_sb_info *cifs_sb, unsigned int xid)
522 #ifdef CONFIG_CIFS_XATTR
526 struct tcon_link *tlink;
527 struct cifs_tcon *tcon;
529 tlink = cifs_sb_tlink(cifs_sb);
531 return PTR_ERR(tlink);
532 tcon = tlink_tcon(tlink);
534 if (tcon->ses->server->ops->query_all_EAs == NULL) {
535 cifs_put_tlink(tlink);
539 rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
540 "SETFILEBITS", ea_value, 4 /* size of buf */,
542 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
543 cifs_put_tlink(tlink);
547 mode = le32_to_cpu(*((__le32 *)ea_value));
548 fattr->cf_mode &= ~SFBITS_MASK;
549 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
550 mode, fattr->cf_mode);
551 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
552 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
561 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
563 cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
564 struct cifs_sb_info *cifs_sb, bool adjust_tz,
567 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
569 memset(fattr, 0, sizeof(*fattr));
570 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
571 if (info->DeletePending)
572 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
574 if (info->LastAccessTime)
575 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
577 fattr->cf_atime = CURRENT_TIME;
579 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
580 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
583 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
584 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
587 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
588 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
589 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
591 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
594 fattr->cf_mode = S_IFLNK;
595 fattr->cf_dtype = DT_LNK;
596 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
597 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
598 fattr->cf_dtype = DT_DIR;
600 * Server can return wrong NumberOfLinks value for directories
601 * when Unix extensions are disabled - fake it.
604 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
606 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
607 fattr->cf_dtype = DT_REG;
609 /* clear write bits if ATTR_READONLY is set */
610 if (fattr->cf_cifsattrs & ATTR_READONLY)
611 fattr->cf_mode &= ~(S_IWUGO);
614 * Don't accept zero nlink from non-unix servers unless
615 * delete is pending. Instead mark it as unknown.
617 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
618 !info->DeletePending) {
619 cifs_dbg(1, "bogus file nlink value %u\n",
621 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
625 fattr->cf_uid = cifs_sb->mnt_uid;
626 fattr->cf_gid = cifs_sb->mnt_gid;
630 cifs_get_file_info(struct file *filp)
634 FILE_ALL_INFO find_data;
635 struct cifs_fattr fattr;
636 struct inode *inode = file_inode(filp);
637 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
638 struct cifsFileInfo *cfile = filp->private_data;
639 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
640 struct TCP_Server_Info *server = tcon->ses->server;
642 if (!server->ops->query_file_info)
646 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
649 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false,
653 cifs_create_dfs_fattr(&fattr, inode->i_sb);
659 * FIXME: legacy server -- fall back to path-based call?
660 * for now, just skip revalidating and mark inode for
664 CIFS_I(inode)->time = 0;
670 * don't bother with SFU junk here -- just mark inode as needing
673 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
674 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
675 cifs_fattr_to_inode(inode, &fattr);
682 cifs_get_inode_info(struct inode **inode, const char *full_path,
683 FILE_ALL_INFO *data, struct super_block *sb, int xid,
684 const struct cifs_fid *fid)
686 bool validinum = false;
688 int rc = 0, tmprc = ENOSYS;
689 struct cifs_tcon *tcon;
690 struct TCP_Server_Info *server;
691 struct tcon_link *tlink;
692 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
694 bool adjust_tz = false;
695 struct cifs_fattr fattr;
696 struct cifs_search_info *srchinf = NULL;
697 bool symlink = false;
699 tlink = cifs_sb_tlink(cifs_sb);
701 return PTR_ERR(tlink);
702 tcon = tlink_tcon(tlink);
703 server = tcon->ses->server;
705 cifs_dbg(FYI, "Getting info on %s\n", full_path);
707 if ((data == NULL) && (*inode != NULL)) {
708 if (CIFS_CACHE_READ(CIFS_I(*inode))) {
709 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
714 /* if inode info is not passed, get it from server */
716 if (!server->ops->query_path_info) {
720 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
725 data = (FILE_ALL_INFO *)buf;
726 rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path,
727 data, &adjust_tz, &symlink);
731 cifs_all_info_to_fattr(&fattr, data, cifs_sb, adjust_tz,
733 } else if (rc == -EREMOTE) {
734 cifs_create_dfs_fattr(&fattr, sb);
736 } else if (rc == -EACCES && backup_cred(cifs_sb)) {
737 srchinf = kzalloc(sizeof(struct cifs_search_info),
739 if (srchinf == NULL) {
744 srchinf->endOfSearch = false;
745 srchinf->info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
747 srchflgs = CIFS_SEARCH_CLOSE_ALWAYS |
748 CIFS_SEARCH_CLOSE_AT_END |
749 CIFS_SEARCH_BACKUP_SEARCH;
751 rc = CIFSFindFirst(xid, tcon, full_path,
752 cifs_sb, NULL, srchflgs, srchinf, false);
755 (FILE_ALL_INFO *)srchinf->srch_entries_start;
757 cifs_dir_info_to_fattr(&fattr,
758 (FILE_DIRECTORY_INFO *)data, cifs_sb);
759 fattr.cf_uniqueid = le64_to_cpu(
760 ((SEARCH_ID_FULL_DIR_INFO *)data)->UniqueId);
763 cifs_buf_release(srchinf->ntwrk_buf_start);
770 * If an inode wasn't passed in, then get the inode number
772 * Is an i_ino of zero legal? Can we use that to check if the server
773 * supports returning inode numbers? Are there other sanity checks we
774 * can use to ensure that the server is really filling in that field?
776 if (*inode == NULL) {
777 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
778 if (validinum == false) {
779 if (server->ops->get_srv_inum)
780 tmprc = server->ops->get_srv_inum(xid,
781 tcon, cifs_sb, full_path,
782 &fattr.cf_uniqueid, data);
784 cifs_dbg(FYI, "GetSrvInodeNum rc %d\n",
786 fattr.cf_uniqueid = iunique(sb, ROOT_I);
787 cifs_autodisable_serverino(cifs_sb);
791 fattr.cf_uniqueid = iunique(sb, ROOT_I);
793 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
795 /* query for SFU type info if supported and needed */
796 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
797 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
798 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
800 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
803 #ifdef CONFIG_CIFS_ACL
804 /* fill in 0777 bits from ACL */
805 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
806 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, full_path, fid);
808 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
813 #endif /* CONFIG_CIFS_ACL */
815 /* fill in remaining high mode bits e.g. SUID, VTX */
816 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
817 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
819 /* check for Minshall+French symlinks */
820 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
821 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
824 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
828 *inode = cifs_iget(sb, &fattr);
832 cifs_fattr_to_inode(*inode, &fattr);
837 cifs_put_tlink(tlink);
841 static const struct inode_operations cifs_ipc_inode_ops = {
842 .lookup = cifs_lookup,
846 cifs_find_inode(struct inode *inode, void *opaque)
848 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
850 /* don't match inode with different uniqueid */
851 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
854 /* use createtime like an i_generation field */
855 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
858 /* don't match inode of different type */
859 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
862 /* if it's not a directory or has no dentries, then flag it */
863 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
864 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
870 cifs_init_inode(struct inode *inode, void *opaque)
872 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
874 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
875 CIFS_I(inode)->createtime = fattr->cf_createtime;
880 * walk dentry list for an inode and report whether it has aliases that
881 * are hashed. We use this to determine if a directory inode can actually
885 inode_has_hashed_dentries(struct inode *inode)
887 struct dentry *dentry;
889 spin_lock(&inode->i_lock);
890 hlist_for_each_entry(dentry, &inode->i_dentry, d_alias) {
891 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
892 spin_unlock(&inode->i_lock);
896 spin_unlock(&inode->i_lock);
900 /* Given fattrs, get a corresponding inode */
902 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
908 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
910 /* hash down to 32-bits on 32-bit arch */
911 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
913 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
915 /* was there a potentially problematic inode collision? */
916 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
917 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
919 if (inode_has_hashed_dentries(inode)) {
920 cifs_autodisable_serverino(CIFS_SB(sb));
922 fattr->cf_uniqueid = iunique(sb, ROOT_I);
923 goto retry_iget5_locked;
927 cifs_fattr_to_inode(inode, fattr);
928 if (sb->s_flags & MS_NOATIME)
929 inode->i_flags |= S_NOATIME | S_NOCMTIME;
930 if (inode->i_state & I_NEW) {
932 if (S_ISREG(inode->i_mode))
933 inode->i_data.backing_dev_info = sb->s_bdi;
934 #ifdef CONFIG_CIFS_FSCACHE
935 /* initialize per-inode cache cookie pointer */
936 CIFS_I(inode)->fscache = NULL;
938 unlock_new_inode(inode);
945 /* gets root inode */
946 struct inode *cifs_root_iget(struct super_block *sb)
949 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
950 struct inode *inode = NULL;
952 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
956 rc = cifs_get_inode_info_unix(&inode, "", sb, xid);
958 rc = cifs_get_inode_info(&inode, "", NULL, sb, xid, NULL);
965 #ifdef CONFIG_CIFS_FSCACHE
966 /* populate tcon->resource_id */
967 tcon->resource_id = CIFS_I(inode)->uniqueid;
970 if (rc && tcon->ipc) {
971 cifs_dbg(FYI, "ipc connection - fake read inode\n");
972 spin_lock(&inode->i_lock);
973 inode->i_mode |= S_IFDIR;
975 inode->i_op = &cifs_ipc_inode_ops;
976 inode->i_fop = &simple_dir_operations;
977 inode->i_uid = cifs_sb->mnt_uid;
978 inode->i_gid = cifs_sb->mnt_gid;
979 spin_unlock(&inode->i_lock);
986 /* can not call macro free_xid here since in a void func
987 * TODO: This is no longer true
994 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
995 char *full_path, __u32 dosattr)
997 bool set_time = false;
998 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
999 struct TCP_Server_Info *server;
1000 FILE_BASIC_INFO info_buf;
1005 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1006 if (!server->ops->set_file_info)
1009 if (attrs->ia_valid & ATTR_ATIME) {
1011 info_buf.LastAccessTime =
1012 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1014 info_buf.LastAccessTime = 0;
1016 if (attrs->ia_valid & ATTR_MTIME) {
1018 info_buf.LastWriteTime =
1019 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1021 info_buf.LastWriteTime = 0;
1024 * Samba throws this field away, but windows may actually use it.
1025 * Do not set ctime unless other time stamps are changed explicitly
1026 * (i.e. by utimes()) since we would then have a mix of client and
1029 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1030 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1031 info_buf.ChangeTime =
1032 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1034 info_buf.ChangeTime = 0;
1036 info_buf.CreationTime = 0; /* don't change */
1037 info_buf.Attributes = cpu_to_le32(dosattr);
1039 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1043 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1044 * and rename it to a random name that hopefully won't conflict with
1048 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1049 const unsigned int xid)
1053 struct cifs_fid fid;
1054 struct cifs_open_parms oparms;
1055 struct inode *inode = dentry->d_inode;
1056 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1057 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1058 struct tcon_link *tlink;
1059 struct cifs_tcon *tcon;
1060 __u32 dosattr, origattr;
1061 FILE_BASIC_INFO *info_buf = NULL;
1063 tlink = cifs_sb_tlink(cifs_sb);
1065 return PTR_ERR(tlink);
1066 tcon = tlink_tcon(tlink);
1069 * We cannot rename the file if the server doesn't support
1070 * CAP_INFOLEVEL_PASSTHRU
1072 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1078 oparms.cifs_sb = cifs_sb;
1079 oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1080 oparms.create_options = CREATE_NOT_DIR;
1081 oparms.disposition = FILE_OPEN;
1082 oparms.path = full_path;
1084 oparms.reconnect = false;
1086 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1090 origattr = cifsInode->cifsAttrs;
1092 origattr |= ATTR_NORMAL;
1094 dosattr = origattr & ~ATTR_READONLY;
1096 dosattr |= ATTR_NORMAL;
1097 dosattr |= ATTR_HIDDEN;
1099 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1100 if (dosattr != origattr) {
1101 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1102 if (info_buf == NULL) {
1106 info_buf->Attributes = cpu_to_le32(dosattr);
1107 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1109 /* although we would like to mark the file hidden
1110 if that fails we will still try to rename it */
1112 cifsInode->cifsAttrs = dosattr;
1114 dosattr = origattr; /* since not able to change them */
1117 /* rename the file */
1118 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1120 cifs_sb->mnt_cifs_flags &
1121 CIFS_MOUNT_MAP_SPECIAL_CHR);
1127 /* try to set DELETE_ON_CLOSE */
1128 if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1129 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1132 * some samba versions return -ENOENT when we try to set the
1133 * file disposition here. Likely a samba bug, but work around
1134 * it for now. This means that some cifsXXX files may hang
1135 * around after they shouldn't.
1137 * BB: remove this hack after more servers have the fix
1145 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1149 CIFSSMBClose(xid, tcon, fid.netfid);
1152 cifs_put_tlink(tlink);
1156 * reset everything back to the original state. Don't bother
1157 * dealing with errors here since we can't do anything about
1161 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1162 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1163 CIFS_MOUNT_MAP_SPECIAL_CHR);
1165 if (dosattr != origattr) {
1166 info_buf->Attributes = cpu_to_le32(origattr);
1167 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1169 cifsInode->cifsAttrs = origattr;
1175 /* copied from fs/nfs/dir.c with small changes */
1177 cifs_drop_nlink(struct inode *inode)
1179 spin_lock(&inode->i_lock);
1180 if (inode->i_nlink > 0)
1182 spin_unlock(&inode->i_lock);
1186 * If dentry->d_inode is null (usually meaning the cached dentry
1187 * is a negative dentry) then we would attempt a standard SMB delete, but
1188 * if that fails we can not attempt the fall back mechanisms on EACCESS
1189 * but will return the EACCESS to the caller. Note that the VFS does not call
1190 * unlink on negative dentries currently.
1192 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1196 char *full_path = NULL;
1197 struct inode *inode = dentry->d_inode;
1198 struct cifsInodeInfo *cifs_inode;
1199 struct super_block *sb = dir->i_sb;
1200 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1201 struct tcon_link *tlink;
1202 struct cifs_tcon *tcon;
1203 struct TCP_Server_Info *server;
1204 struct iattr *attrs = NULL;
1205 __u32 dosattr = 0, origattr = 0;
1207 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1209 tlink = cifs_sb_tlink(cifs_sb);
1211 return PTR_ERR(tlink);
1212 tcon = tlink_tcon(tlink);
1213 server = tcon->ses->server;
1217 /* Unlink can be called from rename so we can not take the
1218 * sb->s_vfs_rename_mutex here */
1219 full_path = build_path_from_dentry(dentry);
1220 if (full_path == NULL) {
1225 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1226 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1227 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1228 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1229 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1230 cifs_dbg(FYI, "posix del rc %d\n", rc);
1231 if ((rc == 0) || (rc == -ENOENT))
1232 goto psx_del_no_retry;
1236 if (!server->ops->unlink) {
1238 goto psx_del_no_retry;
1241 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1246 cifs_drop_nlink(inode);
1247 } else if (rc == -ENOENT) {
1249 } else if (rc == -EBUSY) {
1250 if (server->ops->rename_pending_delete) {
1251 rc = server->ops->rename_pending_delete(full_path,
1254 cifs_drop_nlink(inode);
1256 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1257 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1258 if (attrs == NULL) {
1263 /* try to reset dos attributes */
1264 cifs_inode = CIFS_I(inode);
1265 origattr = cifs_inode->cifsAttrs;
1267 origattr |= ATTR_NORMAL;
1268 dosattr = origattr & ~ATTR_READONLY;
1270 dosattr |= ATTR_NORMAL;
1271 dosattr |= ATTR_HIDDEN;
1273 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1277 goto retry_std_delete;
1280 /* undo the setattr if we errored out and it's needed */
1281 if (rc != 0 && dosattr != 0)
1282 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1286 cifs_inode = CIFS_I(inode);
1287 cifs_inode->time = 0; /* will force revalidate to get info
1289 inode->i_ctime = current_fs_time(sb);
1291 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1292 cifs_inode = CIFS_I(dir);
1293 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1298 cifs_put_tlink(tlink);
1303 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1304 const char *full_path, struct cifs_sb_info *cifs_sb,
1305 struct cifs_tcon *tcon, const unsigned int xid)
1308 struct inode *inode = NULL;
1311 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1314 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1321 * setting nlink not necessary except in cases where we failed to get it
1322 * from the server or was set bogus. Also, since this is a brand new
1323 * inode, no need to grab the i_lock before setting the i_nlink.
1325 if (inode->i_nlink < 2)
1326 set_nlink(inode, 2);
1327 mode &= ~current_umask();
1328 /* must turn on setgid bit if parent dir has it */
1329 if (parent->i_mode & S_ISGID)
1332 if (tcon->unix_ext) {
1333 struct cifs_unix_set_info_args args = {
1335 .ctime = NO_CHANGE_64,
1336 .atime = NO_CHANGE_64,
1337 .mtime = NO_CHANGE_64,
1340 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1341 args.uid = current_fsuid();
1342 if (parent->i_mode & S_ISGID)
1343 args.gid = parent->i_gid;
1345 args.gid = current_fsgid();
1347 args.uid = INVALID_UID; /* no change */
1348 args.gid = INVALID_GID; /* no change */
1350 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1352 cifs_sb->mnt_cifs_flags &
1353 CIFS_MOUNT_MAP_SPECIAL_CHR);
1355 struct TCP_Server_Info *server = tcon->ses->server;
1356 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1357 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1358 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1360 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1361 inode->i_mode = (mode | S_IFDIR);
1363 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1364 inode->i_uid = current_fsuid();
1365 if (inode->i_mode & S_ISGID)
1366 inode->i_gid = parent->i_gid;
1368 inode->i_gid = current_fsgid();
1371 d_instantiate(dentry, inode);
1376 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1377 const char *full_path, struct cifs_sb_info *cifs_sb,
1378 struct cifs_tcon *tcon, const unsigned int xid)
1382 FILE_UNIX_BASIC_INFO *info = NULL;
1383 struct inode *newinode = NULL;
1384 struct cifs_fattr fattr;
1386 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1389 goto posix_mkdir_out;
1392 mode &= ~current_umask();
1393 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1394 NULL /* netfid */, info, &oplock, full_path,
1395 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1396 CIFS_MOUNT_MAP_SPECIAL_CHR);
1397 if (rc == -EOPNOTSUPP)
1398 goto posix_mkdir_out;
1400 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1402 goto posix_mkdir_out;
1405 if (info->Type == cpu_to_le32(-1))
1406 /* no return info, go query for it */
1407 goto posix_mkdir_get_info;
1409 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1410 * need to set uid/gid.
1413 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1414 cifs_fill_uniqueid(inode->i_sb, &fattr);
1415 newinode = cifs_iget(inode->i_sb, &fattr);
1417 goto posix_mkdir_get_info;
1419 d_instantiate(dentry, newinode);
1421 #ifdef CONFIG_CIFS_DEBUG2
1422 cifs_dbg(FYI, "instantiated dentry %p %s to inode %p\n",
1423 dentry, dentry->d_name.name, newinode);
1425 if (newinode->i_nlink != 2)
1426 cifs_dbg(FYI, "unexpected number of links %d\n",
1433 posix_mkdir_get_info:
1434 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1436 goto posix_mkdir_out;
1439 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1443 struct cifs_sb_info *cifs_sb;
1444 struct tcon_link *tlink;
1445 struct cifs_tcon *tcon;
1446 struct TCP_Server_Info *server;
1449 cifs_dbg(FYI, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1452 cifs_sb = CIFS_SB(inode->i_sb);
1453 tlink = cifs_sb_tlink(cifs_sb);
1455 return PTR_ERR(tlink);
1456 tcon = tlink_tcon(tlink);
1460 full_path = build_path_from_dentry(direntry);
1461 if (full_path == NULL) {
1466 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1467 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1468 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1470 if (rc != -EOPNOTSUPP)
1474 server = tcon->ses->server;
1476 if (!server->ops->mkdir) {
1481 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1482 rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
1484 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1489 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1493 * Force revalidate to get parent dir info when needed since cached
1494 * attributes are invalid now.
1496 CIFS_I(inode)->time = 0;
1499 cifs_put_tlink(tlink);
1503 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1507 struct cifs_sb_info *cifs_sb;
1508 struct tcon_link *tlink;
1509 struct cifs_tcon *tcon;
1510 struct TCP_Server_Info *server;
1511 char *full_path = NULL;
1512 struct cifsInodeInfo *cifsInode;
1514 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1518 full_path = build_path_from_dentry(direntry);
1519 if (full_path == NULL) {
1524 cifs_sb = CIFS_SB(inode->i_sb);
1525 tlink = cifs_sb_tlink(cifs_sb);
1526 if (IS_ERR(tlink)) {
1527 rc = PTR_ERR(tlink);
1530 tcon = tlink_tcon(tlink);
1531 server = tcon->ses->server;
1533 if (!server->ops->rmdir) {
1535 cifs_put_tlink(tlink);
1539 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1540 cifs_put_tlink(tlink);
1543 spin_lock(&direntry->d_inode->i_lock);
1544 i_size_write(direntry->d_inode, 0);
1545 clear_nlink(direntry->d_inode);
1546 spin_unlock(&direntry->d_inode->i_lock);
1549 cifsInode = CIFS_I(direntry->d_inode);
1550 /* force revalidate to go get info when needed */
1551 cifsInode->time = 0;
1553 cifsInode = CIFS_I(inode);
1555 * Force revalidate to get parent dir info when needed since cached
1556 * attributes are invalid now.
1558 cifsInode->time = 0;
1560 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1561 current_fs_time(inode->i_sb);
1570 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1571 const char *from_path, struct dentry *to_dentry,
1572 const char *to_path)
1574 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1575 struct tcon_link *tlink;
1576 struct cifs_tcon *tcon;
1577 struct TCP_Server_Info *server;
1578 struct cifs_fid fid;
1579 struct cifs_open_parms oparms;
1582 tlink = cifs_sb_tlink(cifs_sb);
1584 return PTR_ERR(tlink);
1585 tcon = tlink_tcon(tlink);
1586 server = tcon->ses->server;
1588 if (!server->ops->rename)
1591 /* try path-based rename first */
1592 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1595 * Don't bother with rename by filehandle unless file is busy and
1596 * source. Note that cross directory moves do not work with
1597 * rename by filehandle to various Windows servers.
1599 if (rc == 0 || rc != -EBUSY)
1600 goto do_rename_exit;
1602 /* open-file renames don't work across directories */
1603 if (to_dentry->d_parent != from_dentry->d_parent)
1604 goto do_rename_exit;
1607 oparms.cifs_sb = cifs_sb;
1608 /* open the file to be renamed -- we need DELETE perms */
1609 oparms.desired_access = DELETE;
1610 oparms.create_options = CREATE_NOT_DIR;
1611 oparms.disposition = FILE_OPEN;
1612 oparms.path = from_path;
1614 oparms.reconnect = false;
1616 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1618 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
1619 (const char *) to_dentry->d_name.name,
1620 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1621 CIFS_MOUNT_MAP_SPECIAL_CHR);
1622 CIFSSMBClose(xid, tcon, fid.netfid);
1625 cifs_put_tlink(tlink);
1630 cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
1631 struct inode *target_dir, struct dentry *target_dentry,
1634 char *from_name = NULL;
1635 char *to_name = NULL;
1636 struct cifs_sb_info *cifs_sb;
1637 struct tcon_link *tlink;
1638 struct cifs_tcon *tcon;
1639 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1640 FILE_UNIX_BASIC_INFO *info_buf_target;
1644 if (flags & ~RENAME_NOREPLACE)
1647 cifs_sb = CIFS_SB(source_dir->i_sb);
1648 tlink = cifs_sb_tlink(cifs_sb);
1650 return PTR_ERR(tlink);
1651 tcon = tlink_tcon(tlink);
1656 * we already have the rename sem so we do not need to
1657 * grab it again here to protect the path integrity
1659 from_name = build_path_from_dentry(source_dentry);
1660 if (from_name == NULL) {
1662 goto cifs_rename_exit;
1665 to_name = build_path_from_dentry(target_dentry);
1666 if (to_name == NULL) {
1668 goto cifs_rename_exit;
1671 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1675 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1677 if (flags & RENAME_NOREPLACE)
1678 goto cifs_rename_exit;
1680 if (rc == -EEXIST && tcon->unix_ext) {
1682 * Are src and dst hardlinks of same inode? We can only tell
1683 * with unix extensions enabled.
1686 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1688 if (info_buf_source == NULL) {
1690 goto cifs_rename_exit;
1693 info_buf_target = info_buf_source + 1;
1694 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1697 cifs_sb->mnt_cifs_flags &
1698 CIFS_MOUNT_MAP_SPECIAL_CHR);
1702 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1705 cifs_sb->mnt_cifs_flags &
1706 CIFS_MOUNT_MAP_SPECIAL_CHR);
1708 if (tmprc == 0 && (info_buf_source->UniqueId ==
1709 info_buf_target->UniqueId)) {
1710 /* same file, POSIX says that this is a noop */
1712 goto cifs_rename_exit;
1716 * else ... BB we could add the same check for Windows by
1717 * checking the UniqueId via FILE_INTERNAL_INFO
1721 /* Try unlinking the target dentry if it's not negative */
1722 if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
1723 if (d_is_dir(target_dentry))
1724 tmprc = cifs_rmdir(target_dir, target_dentry);
1726 tmprc = cifs_unlink(target_dir, target_dentry);
1728 goto cifs_rename_exit;
1729 rc = cifs_do_rename(xid, source_dentry, from_name,
1730 target_dentry, to_name);
1733 /* force revalidate to go get info when needed */
1734 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
1736 source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
1737 target_dir->i_mtime = current_fs_time(source_dir->i_sb);
1740 kfree(info_buf_source);
1744 cifs_put_tlink(tlink);
1749 cifs_inode_needs_reval(struct inode *inode)
1751 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1752 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1754 if (CIFS_CACHE_READ(cifs_i))
1757 if (!lookupCacheEnabled)
1760 if (cifs_i->time == 0)
1763 if (!cifs_sb->actimeo)
1766 if (!time_in_range(jiffies, cifs_i->time,
1767 cifs_i->time + cifs_sb->actimeo))
1770 /* hardlinked files w/ noserverino get "special" treatment */
1771 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1772 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1779 * Zap the cache. Called when invalid_mapping flag is set.
1782 cifs_invalidate_mapping(struct inode *inode)
1786 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1787 rc = invalidate_inode_pages2(inode->i_mapping);
1789 cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1793 cifs_fscache_reset_inode_cookie(inode);
1798 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
1799 * @word: long word containing the bit lock
1802 cifs_wait_bit_killable(struct wait_bit_key *key)
1804 if (fatal_signal_pending(current))
1805 return -ERESTARTSYS;
1806 freezable_schedule_unsafe();
1811 cifs_revalidate_mapping(struct inode *inode)
1814 unsigned long *flags = &CIFS_I(inode)->flags;
1816 rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
1821 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
1822 rc = cifs_invalidate_mapping(inode);
1824 set_bit(CIFS_INO_INVALID_MAPPING, flags);
1827 clear_bit_unlock(CIFS_INO_LOCK, flags);
1828 smp_mb__after_atomic();
1829 wake_up_bit(flags, CIFS_INO_LOCK);
1835 cifs_zap_mapping(struct inode *inode)
1837 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
1838 return cifs_revalidate_mapping(inode);
1841 int cifs_revalidate_file_attr(struct file *filp)
1844 struct inode *inode = file_inode(filp);
1845 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1847 if (!cifs_inode_needs_reval(inode))
1850 if (tlink_tcon(cfile->tlink)->unix_ext)
1851 rc = cifs_get_file_info_unix(filp);
1853 rc = cifs_get_file_info(filp);
1858 int cifs_revalidate_dentry_attr(struct dentry *dentry)
1862 struct inode *inode = dentry->d_inode;
1863 struct super_block *sb = dentry->d_sb;
1864 char *full_path = NULL;
1869 if (!cifs_inode_needs_reval(inode))
1874 /* can not safely grab the rename sem here if rename calls revalidate
1875 since that would deadlock */
1876 full_path = build_path_from_dentry(dentry);
1877 if (full_path == NULL) {
1882 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1883 full_path, inode, inode->i_count.counter,
1884 dentry, dentry->d_time, jiffies);
1886 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1887 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1889 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1898 int cifs_revalidate_file(struct file *filp)
1901 struct inode *inode = file_inode(filp);
1903 rc = cifs_revalidate_file_attr(filp);
1907 return cifs_revalidate_mapping(inode);
1910 /* revalidate a dentry's inode attributes */
1911 int cifs_revalidate_dentry(struct dentry *dentry)
1914 struct inode *inode = dentry->d_inode;
1916 rc = cifs_revalidate_dentry_attr(dentry);
1920 return cifs_revalidate_mapping(inode);
1923 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1926 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1927 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1928 struct inode *inode = dentry->d_inode;
1932 * We need to be sure that all dirty pages are written and the server
1933 * has actual ctime, mtime and file length.
1935 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
1936 inode->i_mapping->nrpages != 0) {
1937 rc = filemap_fdatawait(inode->i_mapping);
1939 mapping_set_error(inode->i_mapping, rc);
1944 rc = cifs_revalidate_dentry_attr(dentry);
1948 generic_fillattr(inode, stat);
1949 stat->blksize = CIFS_MAX_MSGSIZE;
1950 stat->ino = CIFS_I(inode)->uniqueid;
1953 * If on a multiuser mount without unix extensions or cifsacl being
1954 * enabled, and the admin hasn't overridden them, set the ownership
1955 * to the fsuid/fsgid of the current process.
1957 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
1958 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1960 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1961 stat->uid = current_fsuid();
1962 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1963 stat->gid = current_fsgid();
1968 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1970 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1971 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1975 page = grab_cache_page(mapping, index);
1979 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1981 page_cache_release(page);
1985 static void cifs_setsize(struct inode *inode, loff_t offset)
1987 spin_lock(&inode->i_lock);
1988 i_size_write(inode, offset);
1989 spin_unlock(&inode->i_lock);
1991 truncate_pagecache(inode, offset);
1995 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1996 unsigned int xid, char *full_path)
1999 struct cifsFileInfo *open_file;
2000 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2001 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2002 struct tcon_link *tlink = NULL;
2003 struct cifs_tcon *tcon = NULL;
2004 struct TCP_Server_Info *server;
2005 struct cifs_io_parms io_parms;
2008 * To avoid spurious oplock breaks from server, in the case of
2009 * inodes that we already have open, avoid doing path based
2010 * setting of file size if we can do it by handle.
2011 * This keeps our caching token (oplock) and avoids timeouts
2012 * when the local oplock break takes longer to flush
2013 * writebehind data than the SMB timeout for the SetPathInfo
2014 * request would allow
2016 open_file = find_writable_file(cifsInode, true);
2018 tcon = tlink_tcon(open_file->tlink);
2019 server = tcon->ses->server;
2020 if (server->ops->set_file_size)
2021 rc = server->ops->set_file_size(xid, tcon, open_file,
2022 attrs->ia_size, false);
2025 cifsFileInfo_put(open_file);
2026 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2027 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
2028 unsigned int bytes_written;
2030 io_parms.netfid = open_file->fid.netfid;
2031 io_parms.pid = open_file->pid;
2032 io_parms.tcon = tcon;
2033 io_parms.offset = 0;
2034 io_parms.length = attrs->ia_size;
2035 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written,
2037 cifs_dbg(FYI, "Wrt seteof rc %d\n", rc);
2046 tlink = cifs_sb_tlink(cifs_sb);
2048 return PTR_ERR(tlink);
2049 tcon = tlink_tcon(tlink);
2050 server = tcon->ses->server;
2054 * Set file size by pathname rather than by handle either because no
2055 * valid, writeable file handle for it was found or because there was
2056 * an error setting it by handle.
2058 if (server->ops->set_path_size)
2059 rc = server->ops->set_path_size(xid, tcon, full_path,
2060 attrs->ia_size, cifs_sb, false);
2063 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2064 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
2068 rc = SMBLegacyOpen(xid, tcon, full_path, FILE_OPEN,
2069 GENERIC_WRITE, CREATE_NOT_DIR, &netfid,
2070 &oplock, NULL, cifs_sb->local_nls,
2071 cifs_sb->mnt_cifs_flags &
2072 CIFS_MOUNT_MAP_SPECIAL_CHR);
2074 unsigned int bytes_written;
2076 io_parms.netfid = netfid;
2077 io_parms.pid = current->tgid;
2078 io_parms.tcon = tcon;
2079 io_parms.offset = 0;
2080 io_parms.length = attrs->ia_size;
2081 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written, NULL,
2083 cifs_dbg(FYI, "wrt seteof rc %d\n", rc);
2084 CIFSSMBClose(xid, tcon, netfid);
2088 cifs_put_tlink(tlink);
2092 cifsInode->server_eof = attrs->ia_size;
2093 cifs_setsize(inode, attrs->ia_size);
2094 cifs_truncate_page(inode->i_mapping, inode->i_size);
2101 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2105 char *full_path = NULL;
2106 struct inode *inode = direntry->d_inode;
2107 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2108 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2109 struct tcon_link *tlink;
2110 struct cifs_tcon *pTcon;
2111 struct cifs_unix_set_info_args *args = NULL;
2112 struct cifsFileInfo *open_file;
2114 cifs_dbg(FYI, "setattr_unix on file %s attrs->ia_valid=0x%x\n",
2115 direntry->d_name.name, attrs->ia_valid);
2119 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2120 attrs->ia_valid |= ATTR_FORCE;
2122 rc = inode_change_ok(inode, attrs);
2126 full_path = build_path_from_dentry(direntry);
2127 if (full_path == NULL) {
2133 * Attempt to flush data before changing attributes. We need to do
2134 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2135 * ownership or mode then we may also need to do this. Here, we take
2136 * the safe way out and just do the flush on all setattr requests. If
2137 * the flush returns error, store it to report later and continue.
2139 * BB: This should be smarter. Why bother flushing pages that
2140 * will be truncated anyway? Also, should we error out here if
2141 * the flush returns error?
2143 rc = filemap_write_and_wait(inode->i_mapping);
2144 mapping_set_error(inode->i_mapping, rc);
2147 if (attrs->ia_valid & ATTR_SIZE) {
2148 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2153 /* skip mode change if it's just for clearing setuid/setgid */
2154 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2155 attrs->ia_valid &= ~ATTR_MODE;
2157 args = kmalloc(sizeof(*args), GFP_KERNEL);
2163 /* set up the struct */
2164 if (attrs->ia_valid & ATTR_MODE)
2165 args->mode = attrs->ia_mode;
2167 args->mode = NO_CHANGE_64;
2169 if (attrs->ia_valid & ATTR_UID)
2170 args->uid = attrs->ia_uid;
2172 args->uid = INVALID_UID; /* no change */
2174 if (attrs->ia_valid & ATTR_GID)
2175 args->gid = attrs->ia_gid;
2177 args->gid = INVALID_GID; /* no change */
2179 if (attrs->ia_valid & ATTR_ATIME)
2180 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2182 args->atime = NO_CHANGE_64;
2184 if (attrs->ia_valid & ATTR_MTIME)
2185 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2187 args->mtime = NO_CHANGE_64;
2189 if (attrs->ia_valid & ATTR_CTIME)
2190 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2192 args->ctime = NO_CHANGE_64;
2195 open_file = find_writable_file(cifsInode, true);
2197 u16 nfid = open_file->fid.netfid;
2198 u32 npid = open_file->pid;
2199 pTcon = tlink_tcon(open_file->tlink);
2200 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2201 cifsFileInfo_put(open_file);
2203 tlink = cifs_sb_tlink(cifs_sb);
2204 if (IS_ERR(tlink)) {
2205 rc = PTR_ERR(tlink);
2208 pTcon = tlink_tcon(tlink);
2209 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2211 cifs_sb->mnt_cifs_flags &
2212 CIFS_MOUNT_MAP_SPECIAL_CHR);
2213 cifs_put_tlink(tlink);
2219 if ((attrs->ia_valid & ATTR_SIZE) &&
2220 attrs->ia_size != i_size_read(inode))
2221 truncate_setsize(inode, attrs->ia_size);
2223 setattr_copy(inode, attrs);
2224 mark_inode_dirty(inode);
2226 /* force revalidate when any of these times are set since some
2227 of the fs types (eg ext3, fat) do not have fine enough
2228 time granularity to match protocol, and we do not have a
2229 a way (yet) to query the server fs's time granularity (and
2230 whether it rounds times down).
2232 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2233 cifsInode->time = 0;
2242 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2245 kuid_t uid = INVALID_UID;
2246 kgid_t gid = INVALID_GID;
2247 struct inode *inode = direntry->d_inode;
2248 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2249 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2250 char *full_path = NULL;
2253 __u64 mode = NO_CHANGE_64;
2257 cifs_dbg(FYI, "setattr on file %s attrs->iavalid 0x%x\n",
2258 direntry->d_name.name, attrs->ia_valid);
2260 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2261 attrs->ia_valid |= ATTR_FORCE;
2263 rc = inode_change_ok(inode, attrs);
2269 full_path = build_path_from_dentry(direntry);
2270 if (full_path == NULL) {
2277 * Attempt to flush data before changing attributes. We need to do
2278 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2279 * ownership or mode then we may also need to do this. Here, we take
2280 * the safe way out and just do the flush on all setattr requests. If
2281 * the flush returns error, store it to report later and continue.
2283 * BB: This should be smarter. Why bother flushing pages that
2284 * will be truncated anyway? Also, should we error out here if
2285 * the flush returns error?
2287 rc = filemap_write_and_wait(inode->i_mapping);
2288 mapping_set_error(inode->i_mapping, rc);
2291 if (attrs->ia_valid & ATTR_SIZE) {
2292 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2294 goto cifs_setattr_exit;
2297 if (attrs->ia_valid & ATTR_UID)
2298 uid = attrs->ia_uid;
2300 if (attrs->ia_valid & ATTR_GID)
2301 gid = attrs->ia_gid;
2303 #ifdef CONFIG_CIFS_ACL
2304 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2305 if (uid_valid(uid) || gid_valid(gid)) {
2306 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2309 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2311 goto cifs_setattr_exit;
2315 #endif /* CONFIG_CIFS_ACL */
2316 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2317 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2319 /* skip mode change if it's just for clearing setuid/setgid */
2320 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2321 attrs->ia_valid &= ~ATTR_MODE;
2323 if (attrs->ia_valid & ATTR_MODE) {
2324 mode = attrs->ia_mode;
2326 #ifdef CONFIG_CIFS_ACL
2327 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2328 rc = id_mode_to_cifs_acl(inode, full_path, mode,
2329 INVALID_UID, INVALID_GID);
2331 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2333 goto cifs_setattr_exit;
2336 #endif /* CONFIG_CIFS_ACL */
2337 if (((mode & S_IWUGO) == 0) &&
2338 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2340 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2342 /* fix up mode if we're not using dynperm */
2343 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2344 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2345 } else if ((mode & S_IWUGO) &&
2346 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2348 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2349 /* Attributes of 0 are ignored */
2351 dosattr |= ATTR_NORMAL;
2353 /* reset local inode permissions to normal */
2354 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2355 attrs->ia_mode &= ~(S_IALLUGO);
2356 if (S_ISDIR(inode->i_mode))
2358 cifs_sb->mnt_dir_mode;
2361 cifs_sb->mnt_file_mode;
2363 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2364 /* ignore mode change - ATTR_READONLY hasn't changed */
2365 attrs->ia_valid &= ~ATTR_MODE;
2369 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2370 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2371 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2372 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2374 /* Even if error on time set, no sense failing the call if
2375 the server would set the time to a reasonable value anyway,
2376 and this check ensures that we are not being called from
2377 sys_utimes in which case we ought to fail the call back to
2378 the user when the server rejects the call */
2379 if ((rc) && (attrs->ia_valid &
2380 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2384 /* do not need local check to inode_check_ok since the server does
2387 goto cifs_setattr_exit;
2389 if ((attrs->ia_valid & ATTR_SIZE) &&
2390 attrs->ia_size != i_size_read(inode))
2391 truncate_setsize(inode, attrs->ia_size);
2393 setattr_copy(inode, attrs);
2394 mark_inode_dirty(inode);
2403 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2405 struct inode *inode = direntry->d_inode;
2406 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2407 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2409 if (pTcon->unix_ext)
2410 return cifs_setattr_unix(direntry, attrs);
2412 return cifs_setattr_nounix(direntry, attrs);
2414 /* BB: add cifs_setattr_legacy for really old servers */
2418 void cifs_delete_inode(struct inode *inode)
2420 cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2421 /* may have to add back in if and when safe distributed caching of
2422 directories added e.g. via FindNotify */