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 <asm/div64.h>
29 #include "cifsproto.h"
30 #include "cifs_debug.h"
31 #include "cifs_fs_sb.h"
35 static void cifs_set_ops(struct inode *inode)
37 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
39 switch (inode->i_mode & S_IFMT) {
41 inode->i_op = &cifs_file_inode_ops;
42 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
43 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
44 inode->i_fop = &cifs_file_direct_nobrl_ops;
46 inode->i_fop = &cifs_file_direct_ops;
47 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
48 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
49 inode->i_fop = &cifs_file_strict_nobrl_ops;
51 inode->i_fop = &cifs_file_strict_ops;
52 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
53 inode->i_fop = &cifs_file_nobrl_ops;
54 else { /* not direct, send byte range locks */
55 inode->i_fop = &cifs_file_ops;
58 /* check if server can support readpages */
59 if (cifs_sb_master_tcon(cifs_sb)->ses->server->maxBuf <
60 PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
61 inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
63 inode->i_data.a_ops = &cifs_addr_ops;
66 #ifdef CONFIG_CIFS_DFS_UPCALL
67 if (IS_AUTOMOUNT(inode)) {
68 inode->i_op = &cifs_dfs_referral_inode_operations;
70 #else /* NO DFS support, treat as a directory */
73 inode->i_op = &cifs_dir_inode_ops;
74 inode->i_fop = &cifs_dir_ops;
78 inode->i_op = &cifs_symlink_inode_ops;
81 init_special_inode(inode, inode->i_mode, inode->i_rdev);
86 /* check inode attributes against fattr. If they don't match, tag the
87 * inode for cache invalidation
90 cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
92 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
94 cifs_dbg(FYI, "%s: revalidating inode %llu\n",
95 __func__, cifs_i->uniqueid);
97 if (inode->i_state & I_NEW) {
98 cifs_dbg(FYI, "%s: inode %llu is new\n",
99 __func__, cifs_i->uniqueid);
103 /* don't bother with revalidation if we have an oplock */
104 if (CIFS_CACHE_READ(cifs_i)) {
105 cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
106 __func__, cifs_i->uniqueid);
110 /* revalidate if mtime or size have changed */
111 if (timespec_equal(&inode->i_mtime, &fattr->cf_mtime) &&
112 cifs_i->server_eof == fattr->cf_eof) {
113 cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
114 __func__, cifs_i->uniqueid);
118 cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
119 __func__, cifs_i->uniqueid);
120 cifs_i->invalid_mapping = true;
124 * copy nlink to the inode, unless it wasn't provided. Provide
125 * sane values if we don't have an existing one and none was provided
128 cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
131 * if we're in a situation where we can't trust what we
132 * got from the server (readdir, some non-unix cases)
133 * fake reasonable values
135 if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
136 /* only provide fake values on a new inode */
137 if (inode->i_state & I_NEW) {
138 if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
146 /* we trust the server, so update it */
147 set_nlink(inode, fattr->cf_nlink);
150 /* populate an inode with info from a cifs_fattr struct */
152 cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
154 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
155 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
157 cifs_revalidate_cache(inode, fattr);
159 spin_lock(&inode->i_lock);
160 inode->i_atime = fattr->cf_atime;
161 inode->i_mtime = fattr->cf_mtime;
162 inode->i_ctime = fattr->cf_ctime;
163 inode->i_rdev = fattr->cf_rdev;
164 cifs_nlink_fattr_to_inode(inode, fattr);
165 inode->i_uid = fattr->cf_uid;
166 inode->i_gid = fattr->cf_gid;
168 /* if dynperm is set, don't clobber existing mode */
169 if (inode->i_state & I_NEW ||
170 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
171 inode->i_mode = fattr->cf_mode;
173 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
175 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
178 cifs_i->time = jiffies;
180 cifs_i->delete_pending = fattr->cf_flags & CIFS_FATTR_DELETE_PENDING;
182 cifs_i->server_eof = fattr->cf_eof;
184 * Can't safely change the file size here if the client is writing to
185 * it due to potential races.
187 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
188 i_size_write(inode, fattr->cf_eof);
191 * i_blocks is not related to (i_size / i_blksize),
192 * but instead 512 byte (2**9) size is required for
193 * calculating num blocks.
195 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
197 spin_unlock(&inode->i_lock);
199 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
200 inode->i_flags |= S_AUTOMOUNT;
201 if (inode->i_state & I_NEW)
206 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
208 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
210 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
213 fattr->cf_uniqueid = iunique(sb, ROOT_I);
216 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
218 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
219 struct cifs_sb_info *cifs_sb)
221 memset(fattr, 0, sizeof(*fattr));
222 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
223 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
224 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
226 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
227 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
228 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
229 fattr->cf_mode = le64_to_cpu(info->Permissions);
232 * Since we set the inode type below we need to mask off
233 * to avoid strange results if bits set above.
235 fattr->cf_mode &= ~S_IFMT;
236 switch (le32_to_cpu(info->Type)) {
238 fattr->cf_mode |= S_IFREG;
239 fattr->cf_dtype = DT_REG;
242 fattr->cf_mode |= S_IFLNK;
243 fattr->cf_dtype = DT_LNK;
246 fattr->cf_mode |= S_IFDIR;
247 fattr->cf_dtype = DT_DIR;
250 fattr->cf_mode |= S_IFCHR;
251 fattr->cf_dtype = DT_CHR;
252 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
253 le64_to_cpu(info->DevMinor) & MINORMASK);
256 fattr->cf_mode |= S_IFBLK;
257 fattr->cf_dtype = DT_BLK;
258 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
259 le64_to_cpu(info->DevMinor) & MINORMASK);
262 fattr->cf_mode |= S_IFIFO;
263 fattr->cf_dtype = DT_FIFO;
266 fattr->cf_mode |= S_IFSOCK;
267 fattr->cf_dtype = DT_SOCK;
270 /* safest to call it a file if we do not know */
271 fattr->cf_mode |= S_IFREG;
272 fattr->cf_dtype = DT_REG;
273 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
277 fattr->cf_uid = cifs_sb->mnt_uid;
278 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
279 u64 id = le64_to_cpu(info->Uid);
280 if (id < ((uid_t)-1)) {
281 kuid_t uid = make_kuid(&init_user_ns, id);
287 fattr->cf_gid = cifs_sb->mnt_gid;
288 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
289 u64 id = le64_to_cpu(info->Gid);
290 if (id < ((gid_t)-1)) {
291 kgid_t gid = make_kgid(&init_user_ns, id);
297 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
301 * Fill a cifs_fattr struct with fake inode info.
303 * Needed to setup cifs_fattr data for the directory which is the
304 * junction to the new submount (ie to setup the fake directory
305 * which represents a DFS referral).
308 cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
310 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
312 cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
314 memset(fattr, 0, sizeof(*fattr));
315 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
316 fattr->cf_uid = cifs_sb->mnt_uid;
317 fattr->cf_gid = cifs_sb->mnt_gid;
318 fattr->cf_atime = CURRENT_TIME;
319 fattr->cf_ctime = CURRENT_TIME;
320 fattr->cf_mtime = CURRENT_TIME;
322 fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
326 cifs_get_file_info_unix(struct file *filp)
330 FILE_UNIX_BASIC_INFO find_data;
331 struct cifs_fattr fattr;
332 struct inode *inode = file_inode(filp);
333 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
334 struct cifsFileInfo *cfile = filp->private_data;
335 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
338 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
340 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
341 } else if (rc == -EREMOTE) {
342 cifs_create_dfs_fattr(&fattr, inode->i_sb);
346 cifs_fattr_to_inode(inode, &fattr);
351 int cifs_get_inode_info_unix(struct inode **pinode,
352 const unsigned char *full_path,
353 struct super_block *sb, unsigned int xid)
356 FILE_UNIX_BASIC_INFO find_data;
357 struct cifs_fattr fattr;
358 struct cifs_tcon *tcon;
359 struct tcon_link *tlink;
360 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
362 cifs_dbg(FYI, "Getting info on %s\n", full_path);
364 tlink = cifs_sb_tlink(cifs_sb);
366 return PTR_ERR(tlink);
367 tcon = tlink_tcon(tlink);
369 /* could have done a find first instead but this returns more info */
370 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
371 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
372 CIFS_MOUNT_MAP_SPECIAL_CHR);
373 cifs_put_tlink(tlink);
376 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
377 } else if (rc == -EREMOTE) {
378 cifs_create_dfs_fattr(&fattr, sb);
384 /* check for Minshall+French symlinks */
385 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
386 int tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
388 cifs_dbg(FYI, "CIFSCheckMFSymlink: %d\n", tmprc);
391 if (*pinode == NULL) {
393 cifs_fill_uniqueid(sb, &fattr);
394 *pinode = cifs_iget(sb, &fattr);
398 /* we already have inode, update it */
399 cifs_fattr_to_inode(*pinode, &fattr);
406 cifs_sfu_type(struct cifs_fattr *fattr, const unsigned char *path,
407 struct cifs_sb_info *cifs_sb, unsigned int xid)
412 struct tcon_link *tlink;
413 struct cifs_tcon *tcon;
414 struct cifs_io_parms io_parms;
416 unsigned int bytes_read;
421 fattr->cf_mode &= ~S_IFMT;
423 if (fattr->cf_eof == 0) {
424 fattr->cf_mode |= S_IFIFO;
425 fattr->cf_dtype = DT_FIFO;
427 } else if (fattr->cf_eof < 8) {
428 fattr->cf_mode |= S_IFREG;
429 fattr->cf_dtype = DT_REG;
430 return -EINVAL; /* EOPNOTSUPP? */
433 tlink = cifs_sb_tlink(cifs_sb);
435 return PTR_ERR(tlink);
436 tcon = tlink_tcon(tlink);
438 rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, GENERIC_READ,
439 CREATE_NOT_DIR, &netfid, &oplock, NULL,
441 cifs_sb->mnt_cifs_flags &
442 CIFS_MOUNT_MAP_SPECIAL_CHR);
444 int buf_type = CIFS_NO_BUFFER;
446 io_parms.netfid = netfid;
447 io_parms.pid = current->tgid;
448 io_parms.tcon = tcon;
450 io_parms.length = 24;
451 rc = CIFSSMBRead(xid, &io_parms, &bytes_read, &pbuf,
453 if ((rc == 0) && (bytes_read >= 8)) {
454 if (memcmp("IntxBLK", pbuf, 8) == 0) {
455 cifs_dbg(FYI, "Block device\n");
456 fattr->cf_mode |= S_IFBLK;
457 fattr->cf_dtype = DT_BLK;
458 if (bytes_read == 24) {
459 /* we have enough to decode dev num */
460 __u64 mjr; /* major */
461 __u64 mnr; /* minor */
462 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
463 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
464 fattr->cf_rdev = MKDEV(mjr, mnr);
466 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
467 cifs_dbg(FYI, "Char device\n");
468 fattr->cf_mode |= S_IFCHR;
469 fattr->cf_dtype = DT_CHR;
470 if (bytes_read == 24) {
471 /* we have enough to decode dev num */
472 __u64 mjr; /* major */
473 __u64 mnr; /* minor */
474 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
475 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
476 fattr->cf_rdev = MKDEV(mjr, mnr);
478 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
479 cifs_dbg(FYI, "Symlink\n");
480 fattr->cf_mode |= S_IFLNK;
481 fattr->cf_dtype = DT_LNK;
483 fattr->cf_mode |= S_IFREG; /* file? */
484 fattr->cf_dtype = DT_REG;
488 fattr->cf_mode |= S_IFREG; /* then it is a file */
489 fattr->cf_dtype = DT_REG;
490 rc = -EOPNOTSUPP; /* or some unknown SFU type */
492 CIFSSMBClose(xid, tcon, netfid);
494 cifs_put_tlink(tlink);
498 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
501 * Fetch mode bits as provided by SFU.
503 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
505 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
506 struct cifs_sb_info *cifs_sb, unsigned int xid)
508 #ifdef CONFIG_CIFS_XATTR
512 struct tcon_link *tlink;
513 struct cifs_tcon *tcon;
515 tlink = cifs_sb_tlink(cifs_sb);
517 return PTR_ERR(tlink);
518 tcon = tlink_tcon(tlink);
520 rc = CIFSSMBQAllEAs(xid, tcon, path, "SETFILEBITS",
521 ea_value, 4 /* size of buf */, cifs_sb->local_nls,
522 cifs_sb->mnt_cifs_flags &
523 CIFS_MOUNT_MAP_SPECIAL_CHR);
524 cifs_put_tlink(tlink);
528 mode = le32_to_cpu(*((__le32 *)ea_value));
529 fattr->cf_mode &= ~SFBITS_MASK;
530 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
531 mode, fattr->cf_mode);
532 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
533 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
542 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
544 cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
545 struct cifs_sb_info *cifs_sb, bool adjust_tz)
547 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
549 memset(fattr, 0, sizeof(*fattr));
550 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
551 if (info->DeletePending)
552 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
554 if (info->LastAccessTime)
555 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
557 fattr->cf_atime = CURRENT_TIME;
559 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
560 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
563 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
564 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
567 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
568 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
569 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
571 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
572 if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
573 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
574 fattr->cf_dtype = DT_DIR;
576 * Server can return wrong NumberOfLinks value for directories
577 * when Unix extensions are disabled - fake it.
580 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
581 } else if (fattr->cf_cifsattrs & ATTR_REPARSE) {
582 fattr->cf_mode = S_IFLNK;
583 fattr->cf_dtype = DT_LNK;
584 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
586 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
587 fattr->cf_dtype = DT_REG;
589 /* clear write bits if ATTR_READONLY is set */
590 if (fattr->cf_cifsattrs & ATTR_READONLY)
591 fattr->cf_mode &= ~(S_IWUGO);
594 * Don't accept zero nlink from non-unix servers unless
595 * delete is pending. Instead mark it as unknown.
597 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
598 !info->DeletePending) {
599 cifs_dbg(1, "bogus file nlink value %u\n",
601 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
605 fattr->cf_uid = cifs_sb->mnt_uid;
606 fattr->cf_gid = cifs_sb->mnt_gid;
610 cifs_get_file_info(struct file *filp)
614 FILE_ALL_INFO find_data;
615 struct cifs_fattr fattr;
616 struct inode *inode = file_inode(filp);
617 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
618 struct cifsFileInfo *cfile = filp->private_data;
619 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
620 struct TCP_Server_Info *server = tcon->ses->server;
622 if (!server->ops->query_file_info)
626 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
629 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false);
632 cifs_create_dfs_fattr(&fattr, inode->i_sb);
638 * FIXME: legacy server -- fall back to path-based call?
639 * for now, just skip revalidating and mark inode for
643 CIFS_I(inode)->time = 0;
649 * don't bother with SFU junk here -- just mark inode as needing
652 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
653 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
654 cifs_fattr_to_inode(inode, &fattr);
661 cifs_get_inode_info(struct inode **inode, const char *full_path,
662 FILE_ALL_INFO *data, struct super_block *sb, int xid,
665 bool validinum = false;
667 int rc = 0, tmprc = ENOSYS;
668 struct cifs_tcon *tcon;
669 struct TCP_Server_Info *server;
670 struct tcon_link *tlink;
671 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
673 bool adjust_tz = false;
674 struct cifs_fattr fattr;
675 struct cifs_search_info *srchinf = NULL;
677 tlink = cifs_sb_tlink(cifs_sb);
679 return PTR_ERR(tlink);
680 tcon = tlink_tcon(tlink);
681 server = tcon->ses->server;
683 cifs_dbg(FYI, "Getting info on %s\n", full_path);
685 if ((data == NULL) && (*inode != NULL)) {
686 if (CIFS_CACHE_READ(CIFS_I(*inode))) {
687 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
692 /* if inode info is not passed, get it from server */
694 if (!server->ops->query_path_info) {
698 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
703 data = (FILE_ALL_INFO *)buf;
704 rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path,
709 cifs_all_info_to_fattr(&fattr, (FILE_ALL_INFO *)data, cifs_sb,
711 } else if (rc == -EREMOTE) {
712 cifs_create_dfs_fattr(&fattr, sb);
714 } else if (rc == -EACCES && backup_cred(cifs_sb)) {
715 srchinf = kzalloc(sizeof(struct cifs_search_info),
717 if (srchinf == NULL) {
722 srchinf->endOfSearch = false;
723 srchinf->info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
725 srchflgs = CIFS_SEARCH_CLOSE_ALWAYS |
726 CIFS_SEARCH_CLOSE_AT_END |
727 CIFS_SEARCH_BACKUP_SEARCH;
729 rc = CIFSFindFirst(xid, tcon, full_path,
730 cifs_sb, NULL, srchflgs, srchinf, false);
733 (FILE_ALL_INFO *)srchinf->srch_entries_start;
735 cifs_dir_info_to_fattr(&fattr,
736 (FILE_DIRECTORY_INFO *)data, cifs_sb);
737 fattr.cf_uniqueid = le64_to_cpu(
738 ((SEARCH_ID_FULL_DIR_INFO *)data)->UniqueId);
741 cifs_buf_release(srchinf->ntwrk_buf_start);
748 * If an inode wasn't passed in, then get the inode number
750 * Is an i_ino of zero legal? Can we use that to check if the server
751 * supports returning inode numbers? Are there other sanity checks we
752 * can use to ensure that the server is really filling in that field?
754 if (*inode == NULL) {
755 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
756 if (validinum == false) {
757 if (server->ops->get_srv_inum)
758 tmprc = server->ops->get_srv_inum(xid,
759 tcon, cifs_sb, full_path,
760 &fattr.cf_uniqueid, data);
762 cifs_dbg(FYI, "GetSrvInodeNum rc %d\n",
764 fattr.cf_uniqueid = iunique(sb, ROOT_I);
765 cifs_autodisable_serverino(cifs_sb);
769 fattr.cf_uniqueid = iunique(sb, ROOT_I);
771 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
773 /* query for SFU type info if supported and needed */
774 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
775 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
776 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
778 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
781 #ifdef CONFIG_CIFS_ACL
782 /* fill in 0777 bits from ACL */
783 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
784 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, full_path, fid);
786 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
791 #endif /* CONFIG_CIFS_ACL */
793 /* fill in remaining high mode bits e.g. SUID, VTX */
794 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
795 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
797 /* check for Minshall+French symlinks */
798 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
799 tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
801 cifs_dbg(FYI, "CIFSCheckMFSymlink: %d\n", tmprc);
805 *inode = cifs_iget(sb, &fattr);
809 cifs_fattr_to_inode(*inode, &fattr);
814 cifs_put_tlink(tlink);
818 static const struct inode_operations cifs_ipc_inode_ops = {
819 .lookup = cifs_lookup,
823 cifs_find_inode(struct inode *inode, void *opaque)
825 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
827 /* don't match inode with different uniqueid */
828 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
831 /* use createtime like an i_generation field */
832 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
835 /* don't match inode of different type */
836 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
839 /* if it's not a directory or has no dentries, then flag it */
840 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
841 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
847 cifs_init_inode(struct inode *inode, void *opaque)
849 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
851 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
852 CIFS_I(inode)->createtime = fattr->cf_createtime;
857 * walk dentry list for an inode and report whether it has aliases that
858 * are hashed. We use this to determine if a directory inode can actually
862 inode_has_hashed_dentries(struct inode *inode)
864 struct dentry *dentry;
866 spin_lock(&inode->i_lock);
867 hlist_for_each_entry(dentry, &inode->i_dentry, d_alias) {
868 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
869 spin_unlock(&inode->i_lock);
873 spin_unlock(&inode->i_lock);
877 /* Given fattrs, get a corresponding inode */
879 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
885 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
887 /* hash down to 32-bits on 32-bit arch */
888 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
890 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
892 /* was there a potentially problematic inode collision? */
893 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
894 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
896 if (inode_has_hashed_dentries(inode)) {
897 cifs_autodisable_serverino(CIFS_SB(sb));
899 fattr->cf_uniqueid = iunique(sb, ROOT_I);
900 goto retry_iget5_locked;
904 cifs_fattr_to_inode(inode, fattr);
905 if (sb->s_flags & MS_NOATIME)
906 inode->i_flags |= S_NOATIME | S_NOCMTIME;
907 if (inode->i_state & I_NEW) {
909 if (S_ISREG(inode->i_mode))
910 inode->i_data.backing_dev_info = sb->s_bdi;
911 #ifdef CONFIG_CIFS_FSCACHE
912 /* initialize per-inode cache cookie pointer */
913 CIFS_I(inode)->fscache = NULL;
915 unlock_new_inode(inode);
922 /* gets root inode */
923 struct inode *cifs_root_iget(struct super_block *sb)
926 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
927 struct inode *inode = NULL;
929 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
933 rc = cifs_get_inode_info_unix(&inode, "", sb, xid);
935 rc = cifs_get_inode_info(&inode, "", NULL, sb, xid, NULL);
942 #ifdef CONFIG_CIFS_FSCACHE
943 /* populate tcon->resource_id */
944 tcon->resource_id = CIFS_I(inode)->uniqueid;
947 if (rc && tcon->ipc) {
948 cifs_dbg(FYI, "ipc connection - fake read inode\n");
949 spin_lock(&inode->i_lock);
950 inode->i_mode |= S_IFDIR;
952 inode->i_op = &cifs_ipc_inode_ops;
953 inode->i_fop = &simple_dir_operations;
954 inode->i_uid = cifs_sb->mnt_uid;
955 inode->i_gid = cifs_sb->mnt_gid;
956 spin_unlock(&inode->i_lock);
963 /* can not call macro free_xid here since in a void func
964 * TODO: This is no longer true
971 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
972 char *full_path, __u32 dosattr)
974 bool set_time = false;
975 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
976 struct TCP_Server_Info *server;
977 FILE_BASIC_INFO info_buf;
982 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
983 if (!server->ops->set_file_info)
986 if (attrs->ia_valid & ATTR_ATIME) {
988 info_buf.LastAccessTime =
989 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
991 info_buf.LastAccessTime = 0;
993 if (attrs->ia_valid & ATTR_MTIME) {
995 info_buf.LastWriteTime =
996 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
998 info_buf.LastWriteTime = 0;
1001 * Samba throws this field away, but windows may actually use it.
1002 * Do not set ctime unless other time stamps are changed explicitly
1003 * (i.e. by utimes()) since we would then have a mix of client and
1006 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1007 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1008 info_buf.ChangeTime =
1009 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1011 info_buf.ChangeTime = 0;
1013 info_buf.CreationTime = 0; /* don't change */
1014 info_buf.Attributes = cpu_to_le32(dosattr);
1016 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1020 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1021 * and rename it to a random name that hopefully won't conflict with
1025 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1026 const unsigned int xid)
1031 struct inode *inode = dentry->d_inode;
1032 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1033 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1034 struct tcon_link *tlink;
1035 struct cifs_tcon *tcon;
1036 __u32 dosattr, origattr;
1037 FILE_BASIC_INFO *info_buf = NULL;
1039 tlink = cifs_sb_tlink(cifs_sb);
1041 return PTR_ERR(tlink);
1042 tcon = tlink_tcon(tlink);
1045 * We cannot rename the file if the server doesn't support
1046 * CAP_INFOLEVEL_PASSTHRU
1048 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1053 rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
1054 DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
1055 &netfid, &oplock, NULL, cifs_sb->local_nls,
1056 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1060 origattr = cifsInode->cifsAttrs;
1062 origattr |= ATTR_NORMAL;
1064 dosattr = origattr & ~ATTR_READONLY;
1066 dosattr |= ATTR_NORMAL;
1067 dosattr |= ATTR_HIDDEN;
1069 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1070 if (dosattr != origattr) {
1071 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1072 if (info_buf == NULL) {
1076 info_buf->Attributes = cpu_to_le32(dosattr);
1077 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1079 /* although we would like to mark the file hidden
1080 if that fails we will still try to rename it */
1082 cifsInode->cifsAttrs = dosattr;
1084 dosattr = origattr; /* since not able to change them */
1087 /* rename the file */
1088 rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
1089 cifs_sb->mnt_cifs_flags &
1090 CIFS_MOUNT_MAP_SPECIAL_CHR);
1096 /* try to set DELETE_ON_CLOSE */
1097 if (!cifsInode->delete_pending) {
1098 rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
1101 * some samba versions return -ENOENT when we try to set the
1102 * file disposition here. Likely a samba bug, but work around
1103 * it for now. This means that some cifsXXX files may hang
1104 * around after they shouldn't.
1106 * BB: remove this hack after more servers have the fix
1114 cifsInode->delete_pending = true;
1118 CIFSSMBClose(xid, tcon, netfid);
1121 cifs_put_tlink(tlink);
1125 * reset everything back to the original state. Don't bother
1126 * dealing with errors here since we can't do anything about
1130 CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
1131 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1132 CIFS_MOUNT_MAP_SPECIAL_CHR);
1134 if (dosattr != origattr) {
1135 info_buf->Attributes = cpu_to_le32(origattr);
1136 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1138 cifsInode->cifsAttrs = origattr;
1144 /* copied from fs/nfs/dir.c with small changes */
1146 cifs_drop_nlink(struct inode *inode)
1148 spin_lock(&inode->i_lock);
1149 if (inode->i_nlink > 0)
1151 spin_unlock(&inode->i_lock);
1155 * If dentry->d_inode is null (usually meaning the cached dentry
1156 * is a negative dentry) then we would attempt a standard SMB delete, but
1157 * if that fails we can not attempt the fall back mechanisms on EACCESS
1158 * but will return the EACCESS to the caller. Note that the VFS does not call
1159 * unlink on negative dentries currently.
1161 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1165 char *full_path = NULL;
1166 struct inode *inode = dentry->d_inode;
1167 struct cifsInodeInfo *cifs_inode;
1168 struct super_block *sb = dir->i_sb;
1169 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1170 struct tcon_link *tlink;
1171 struct cifs_tcon *tcon;
1172 struct TCP_Server_Info *server;
1173 struct iattr *attrs = NULL;
1174 __u32 dosattr = 0, origattr = 0;
1176 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1178 tlink = cifs_sb_tlink(cifs_sb);
1180 return PTR_ERR(tlink);
1181 tcon = tlink_tcon(tlink);
1182 server = tcon->ses->server;
1186 /* Unlink can be called from rename so we can not take the
1187 * sb->s_vfs_rename_mutex here */
1188 full_path = build_path_from_dentry(dentry);
1189 if (full_path == NULL) {
1194 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1195 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1196 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1197 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1198 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1199 cifs_dbg(FYI, "posix del rc %d\n", rc);
1200 if ((rc == 0) || (rc == -ENOENT))
1201 goto psx_del_no_retry;
1205 if (!server->ops->unlink) {
1207 goto psx_del_no_retry;
1210 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1215 cifs_drop_nlink(inode);
1216 } else if (rc == -ENOENT) {
1218 } else if (rc == -EBUSY) {
1219 if (server->ops->rename_pending_delete) {
1220 rc = server->ops->rename_pending_delete(full_path,
1223 cifs_drop_nlink(inode);
1225 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1226 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1227 if (attrs == NULL) {
1232 /* try to reset dos attributes */
1233 cifs_inode = CIFS_I(inode);
1234 origattr = cifs_inode->cifsAttrs;
1236 origattr |= ATTR_NORMAL;
1237 dosattr = origattr & ~ATTR_READONLY;
1239 dosattr |= ATTR_NORMAL;
1240 dosattr |= ATTR_HIDDEN;
1242 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1246 goto retry_std_delete;
1249 /* undo the setattr if we errored out and it's needed */
1250 if (rc != 0 && dosattr != 0)
1251 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1255 cifs_inode = CIFS_I(inode);
1256 cifs_inode->time = 0; /* will force revalidate to get info
1258 inode->i_ctime = current_fs_time(sb);
1260 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1261 cifs_inode = CIFS_I(dir);
1262 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1267 cifs_put_tlink(tlink);
1272 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1273 const char *full_path, struct cifs_sb_info *cifs_sb,
1274 struct cifs_tcon *tcon, const unsigned int xid)
1277 struct inode *inode = NULL;
1280 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1283 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1290 * setting nlink not necessary except in cases where we failed to get it
1291 * from the server or was set bogus. Also, since this is a brand new
1292 * inode, no need to grab the i_lock before setting the i_nlink.
1294 if (inode->i_nlink < 2)
1295 set_nlink(inode, 2);
1296 mode &= ~current_umask();
1297 /* must turn on setgid bit if parent dir has it */
1298 if (parent->i_mode & S_ISGID)
1301 if (tcon->unix_ext) {
1302 struct cifs_unix_set_info_args args = {
1304 .ctime = NO_CHANGE_64,
1305 .atime = NO_CHANGE_64,
1306 .mtime = NO_CHANGE_64,
1309 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1310 args.uid = current_fsuid();
1311 if (parent->i_mode & S_ISGID)
1312 args.gid = parent->i_gid;
1314 args.gid = current_fsgid();
1316 args.uid = INVALID_UID; /* no change */
1317 args.gid = INVALID_GID; /* no change */
1319 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1321 cifs_sb->mnt_cifs_flags &
1322 CIFS_MOUNT_MAP_SPECIAL_CHR);
1324 struct TCP_Server_Info *server = tcon->ses->server;
1325 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1326 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1327 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1329 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1330 inode->i_mode = (mode | S_IFDIR);
1332 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1333 inode->i_uid = current_fsuid();
1334 if (inode->i_mode & S_ISGID)
1335 inode->i_gid = parent->i_gid;
1337 inode->i_gid = current_fsgid();
1340 d_instantiate(dentry, inode);
1345 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1346 const char *full_path, struct cifs_sb_info *cifs_sb,
1347 struct cifs_tcon *tcon, const unsigned int xid)
1351 FILE_UNIX_BASIC_INFO *info = NULL;
1352 struct inode *newinode = NULL;
1353 struct cifs_fattr fattr;
1355 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1358 goto posix_mkdir_out;
1361 mode &= ~current_umask();
1362 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1363 NULL /* netfid */, info, &oplock, full_path,
1364 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1365 CIFS_MOUNT_MAP_SPECIAL_CHR);
1366 if (rc == -EOPNOTSUPP)
1367 goto posix_mkdir_out;
1369 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1371 goto posix_mkdir_out;
1374 if (info->Type == cpu_to_le32(-1))
1375 /* no return info, go query for it */
1376 goto posix_mkdir_get_info;
1378 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1379 * need to set uid/gid.
1382 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1383 cifs_fill_uniqueid(inode->i_sb, &fattr);
1384 newinode = cifs_iget(inode->i_sb, &fattr);
1386 goto posix_mkdir_get_info;
1388 d_instantiate(dentry, newinode);
1390 #ifdef CONFIG_CIFS_DEBUG2
1391 cifs_dbg(FYI, "instantiated dentry %p %s to inode %p\n",
1392 dentry, dentry->d_name.name, newinode);
1394 if (newinode->i_nlink != 2)
1395 cifs_dbg(FYI, "unexpected number of links %d\n",
1402 posix_mkdir_get_info:
1403 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1405 goto posix_mkdir_out;
1408 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1412 struct cifs_sb_info *cifs_sb;
1413 struct tcon_link *tlink;
1414 struct cifs_tcon *tcon;
1415 struct TCP_Server_Info *server;
1418 cifs_dbg(FYI, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1421 cifs_sb = CIFS_SB(inode->i_sb);
1422 tlink = cifs_sb_tlink(cifs_sb);
1424 return PTR_ERR(tlink);
1425 tcon = tlink_tcon(tlink);
1429 full_path = build_path_from_dentry(direntry);
1430 if (full_path == NULL) {
1435 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1436 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1437 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1439 if (rc != -EOPNOTSUPP)
1443 server = tcon->ses->server;
1445 if (!server->ops->mkdir) {
1450 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1451 rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
1453 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1458 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1462 * Force revalidate to get parent dir info when needed since cached
1463 * attributes are invalid now.
1465 CIFS_I(inode)->time = 0;
1468 cifs_put_tlink(tlink);
1472 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1476 struct cifs_sb_info *cifs_sb;
1477 struct tcon_link *tlink;
1478 struct cifs_tcon *tcon;
1479 struct TCP_Server_Info *server;
1480 char *full_path = NULL;
1481 struct cifsInodeInfo *cifsInode;
1483 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1487 full_path = build_path_from_dentry(direntry);
1488 if (full_path == NULL) {
1493 cifs_sb = CIFS_SB(inode->i_sb);
1494 tlink = cifs_sb_tlink(cifs_sb);
1495 if (IS_ERR(tlink)) {
1496 rc = PTR_ERR(tlink);
1499 tcon = tlink_tcon(tlink);
1500 server = tcon->ses->server;
1502 if (!server->ops->rmdir) {
1504 cifs_put_tlink(tlink);
1508 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1509 cifs_put_tlink(tlink);
1512 spin_lock(&direntry->d_inode->i_lock);
1513 i_size_write(direntry->d_inode, 0);
1514 clear_nlink(direntry->d_inode);
1515 spin_unlock(&direntry->d_inode->i_lock);
1518 cifsInode = CIFS_I(direntry->d_inode);
1519 /* force revalidate to go get info when needed */
1520 cifsInode->time = 0;
1522 cifsInode = CIFS_I(inode);
1524 * Force revalidate to get parent dir info when needed since cached
1525 * attributes are invalid now.
1527 cifsInode->time = 0;
1529 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1530 current_fs_time(inode->i_sb);
1539 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1540 const char *from_path, struct dentry *to_dentry,
1541 const char *to_path)
1543 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1544 struct tcon_link *tlink;
1545 struct cifs_tcon *tcon;
1546 struct TCP_Server_Info *server;
1550 tlink = cifs_sb_tlink(cifs_sb);
1552 return PTR_ERR(tlink);
1553 tcon = tlink_tcon(tlink);
1554 server = tcon->ses->server;
1556 if (!server->ops->rename)
1559 /* try path-based rename first */
1560 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1563 * Don't bother with rename by filehandle unless file is busy and
1564 * source. Note that cross directory moves do not work with
1565 * rename by filehandle to various Windows servers.
1567 if (rc == 0 || rc != -EBUSY)
1568 goto do_rename_exit;
1570 /* open-file renames don't work across directories */
1571 if (to_dentry->d_parent != from_dentry->d_parent)
1572 goto do_rename_exit;
1574 /* open the file to be renamed -- we need DELETE perms */
1575 rc = CIFSSMBOpen(xid, tcon, from_path, FILE_OPEN, DELETE,
1576 CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1577 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1578 CIFS_MOUNT_MAP_SPECIAL_CHR);
1580 rc = CIFSSMBRenameOpenFile(xid, tcon, srcfid,
1581 (const char *) to_dentry->d_name.name,
1582 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1583 CIFS_MOUNT_MAP_SPECIAL_CHR);
1584 CIFSSMBClose(xid, tcon, srcfid);
1587 cifs_put_tlink(tlink);
1592 cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1593 struct inode *target_dir, struct dentry *target_dentry)
1595 char *from_name = NULL;
1596 char *to_name = NULL;
1597 struct cifs_sb_info *cifs_sb;
1598 struct tcon_link *tlink;
1599 struct cifs_tcon *tcon;
1600 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1601 FILE_UNIX_BASIC_INFO *info_buf_target;
1605 cifs_sb = CIFS_SB(source_dir->i_sb);
1606 tlink = cifs_sb_tlink(cifs_sb);
1608 return PTR_ERR(tlink);
1609 tcon = tlink_tcon(tlink);
1614 * we already have the rename sem so we do not need to
1615 * grab it again here to protect the path integrity
1617 from_name = build_path_from_dentry(source_dentry);
1618 if (from_name == NULL) {
1620 goto cifs_rename_exit;
1623 to_name = build_path_from_dentry(target_dentry);
1624 if (to_name == NULL) {
1626 goto cifs_rename_exit;
1629 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1632 if (rc == -EEXIST && tcon->unix_ext) {
1634 * Are src and dst hardlinks of same inode? We can only tell
1635 * with unix extensions enabled.
1638 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1640 if (info_buf_source == NULL) {
1642 goto cifs_rename_exit;
1645 info_buf_target = info_buf_source + 1;
1646 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1649 cifs_sb->mnt_cifs_flags &
1650 CIFS_MOUNT_MAP_SPECIAL_CHR);
1654 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1657 cifs_sb->mnt_cifs_flags &
1658 CIFS_MOUNT_MAP_SPECIAL_CHR);
1660 if (tmprc == 0 && (info_buf_source->UniqueId ==
1661 info_buf_target->UniqueId)) {
1662 /* same file, POSIX says that this is a noop */
1664 goto cifs_rename_exit;
1668 * else ... BB we could add the same check for Windows by
1669 * checking the UniqueId via FILE_INTERNAL_INFO
1673 /* Try unlinking the target dentry if it's not negative */
1674 if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
1675 tmprc = cifs_unlink(target_dir, target_dentry);
1677 goto cifs_rename_exit;
1678 rc = cifs_do_rename(xid, source_dentry, from_name,
1679 target_dentry, to_name);
1683 kfree(info_buf_source);
1687 cifs_put_tlink(tlink);
1692 cifs_inode_needs_reval(struct inode *inode)
1694 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1695 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1697 if (CIFS_CACHE_READ(cifs_i))
1700 if (!lookupCacheEnabled)
1703 if (cifs_i->time == 0)
1706 if (!time_in_range(jiffies, cifs_i->time,
1707 cifs_i->time + cifs_sb->actimeo))
1710 /* hardlinked files w/ noserverino get "special" treatment */
1711 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1712 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1719 * Zap the cache. Called when invalid_mapping flag is set.
1722 cifs_invalidate_mapping(struct inode *inode)
1725 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1727 cifs_i->invalid_mapping = false;
1729 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1730 rc = invalidate_inode_pages2(inode->i_mapping);
1732 cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1734 cifs_i->invalid_mapping = true;
1738 cifs_fscache_reset_inode_cookie(inode);
1742 int cifs_revalidate_file_attr(struct file *filp)
1745 struct inode *inode = file_inode(filp);
1746 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1748 if (!cifs_inode_needs_reval(inode))
1751 if (tlink_tcon(cfile->tlink)->unix_ext)
1752 rc = cifs_get_file_info_unix(filp);
1754 rc = cifs_get_file_info(filp);
1759 int cifs_revalidate_dentry_attr(struct dentry *dentry)
1763 struct inode *inode = dentry->d_inode;
1764 struct super_block *sb = dentry->d_sb;
1765 char *full_path = NULL;
1770 if (!cifs_inode_needs_reval(inode))
1775 /* can not safely grab the rename sem here if rename calls revalidate
1776 since that would deadlock */
1777 full_path = build_path_from_dentry(dentry);
1778 if (full_path == NULL) {
1783 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1784 full_path, inode, inode->i_count.counter,
1785 dentry, dentry->d_time, jiffies);
1787 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1788 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1790 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1799 int cifs_revalidate_file(struct file *filp)
1802 struct inode *inode = file_inode(filp);
1804 rc = cifs_revalidate_file_attr(filp);
1808 if (CIFS_I(inode)->invalid_mapping)
1809 rc = cifs_invalidate_mapping(inode);
1813 /* revalidate a dentry's inode attributes */
1814 int cifs_revalidate_dentry(struct dentry *dentry)
1817 struct inode *inode = dentry->d_inode;
1819 rc = cifs_revalidate_dentry_attr(dentry);
1823 if (CIFS_I(inode)->invalid_mapping)
1824 rc = cifs_invalidate_mapping(inode);
1828 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1831 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1832 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1833 struct inode *inode = dentry->d_inode;
1837 * We need to be sure that all dirty pages are written and the server
1838 * has actual ctime, mtime and file length.
1840 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
1841 inode->i_mapping->nrpages != 0) {
1842 rc = filemap_fdatawait(inode->i_mapping);
1844 mapping_set_error(inode->i_mapping, rc);
1849 rc = cifs_revalidate_dentry_attr(dentry);
1853 generic_fillattr(inode, stat);
1854 stat->blksize = CIFS_MAX_MSGSIZE;
1855 stat->ino = CIFS_I(inode)->uniqueid;
1858 * If on a multiuser mount without unix extensions or cifsacl being
1859 * enabled, and the admin hasn't overridden them, set the ownership
1860 * to the fsuid/fsgid of the current process.
1862 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
1863 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1865 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1866 stat->uid = current_fsuid();
1867 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1868 stat->gid = current_fsgid();
1873 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1875 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1876 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1880 page = grab_cache_page(mapping, index);
1884 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1886 page_cache_release(page);
1890 static void cifs_setsize(struct inode *inode, loff_t offset)
1892 spin_lock(&inode->i_lock);
1893 i_size_write(inode, offset);
1894 spin_unlock(&inode->i_lock);
1896 truncate_pagecache(inode, offset);
1900 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1901 unsigned int xid, char *full_path)
1904 struct cifsFileInfo *open_file;
1905 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1906 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1907 struct tcon_link *tlink = NULL;
1908 struct cifs_tcon *tcon = NULL;
1909 struct TCP_Server_Info *server;
1910 struct cifs_io_parms io_parms;
1913 * To avoid spurious oplock breaks from server, in the case of
1914 * inodes that we already have open, avoid doing path based
1915 * setting of file size if we can do it by handle.
1916 * This keeps our caching token (oplock) and avoids timeouts
1917 * when the local oplock break takes longer to flush
1918 * writebehind data than the SMB timeout for the SetPathInfo
1919 * request would allow
1921 open_file = find_writable_file(cifsInode, true);
1923 tcon = tlink_tcon(open_file->tlink);
1924 server = tcon->ses->server;
1925 if (server->ops->set_file_size)
1926 rc = server->ops->set_file_size(xid, tcon, open_file,
1927 attrs->ia_size, false);
1930 cifsFileInfo_put(open_file);
1931 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
1932 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1933 unsigned int bytes_written;
1935 io_parms.netfid = open_file->fid.netfid;
1936 io_parms.pid = open_file->pid;
1937 io_parms.tcon = tcon;
1938 io_parms.offset = 0;
1939 io_parms.length = attrs->ia_size;
1940 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written,
1942 cifs_dbg(FYI, "Wrt seteof rc %d\n", rc);
1951 tlink = cifs_sb_tlink(cifs_sb);
1953 return PTR_ERR(tlink);
1954 tcon = tlink_tcon(tlink);
1955 server = tcon->ses->server;
1959 * Set file size by pathname rather than by handle either because no
1960 * valid, writeable file handle for it was found or because there was
1961 * an error setting it by handle.
1963 if (server->ops->set_path_size)
1964 rc = server->ops->set_path_size(xid, tcon, full_path,
1965 attrs->ia_size, cifs_sb, false);
1968 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
1969 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1973 rc = SMBLegacyOpen(xid, tcon, full_path, FILE_OPEN,
1974 GENERIC_WRITE, CREATE_NOT_DIR, &netfid,
1975 &oplock, NULL, cifs_sb->local_nls,
1976 cifs_sb->mnt_cifs_flags &
1977 CIFS_MOUNT_MAP_SPECIAL_CHR);
1979 unsigned int bytes_written;
1981 io_parms.netfid = netfid;
1982 io_parms.pid = current->tgid;
1983 io_parms.tcon = tcon;
1984 io_parms.offset = 0;
1985 io_parms.length = attrs->ia_size;
1986 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written, NULL,
1988 cifs_dbg(FYI, "wrt seteof rc %d\n", rc);
1989 CIFSSMBClose(xid, tcon, netfid);
1993 cifs_put_tlink(tlink);
1997 cifsInode->server_eof = attrs->ia_size;
1998 cifs_setsize(inode, attrs->ia_size);
1999 cifs_truncate_page(inode->i_mapping, inode->i_size);
2006 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2010 char *full_path = NULL;
2011 struct inode *inode = direntry->d_inode;
2012 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2013 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2014 struct tcon_link *tlink;
2015 struct cifs_tcon *pTcon;
2016 struct cifs_unix_set_info_args *args = NULL;
2017 struct cifsFileInfo *open_file;
2019 cifs_dbg(FYI, "setattr_unix on file %s attrs->ia_valid=0x%x\n",
2020 direntry->d_name.name, attrs->ia_valid);
2024 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2025 attrs->ia_valid |= ATTR_FORCE;
2027 rc = inode_change_ok(inode, attrs);
2031 full_path = build_path_from_dentry(direntry);
2032 if (full_path == NULL) {
2038 * Attempt to flush data before changing attributes. We need to do
2039 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2040 * ownership or mode then we may also need to do this. Here, we take
2041 * the safe way out and just do the flush on all setattr requests. If
2042 * the flush returns error, store it to report later and continue.
2044 * BB: This should be smarter. Why bother flushing pages that
2045 * will be truncated anyway? Also, should we error out here if
2046 * the flush returns error?
2048 rc = filemap_write_and_wait(inode->i_mapping);
2049 mapping_set_error(inode->i_mapping, rc);
2052 if (attrs->ia_valid & ATTR_SIZE) {
2053 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2058 /* skip mode change if it's just for clearing setuid/setgid */
2059 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2060 attrs->ia_valid &= ~ATTR_MODE;
2062 args = kmalloc(sizeof(*args), GFP_KERNEL);
2068 /* set up the struct */
2069 if (attrs->ia_valid & ATTR_MODE)
2070 args->mode = attrs->ia_mode;
2072 args->mode = NO_CHANGE_64;
2074 if (attrs->ia_valid & ATTR_UID)
2075 args->uid = attrs->ia_uid;
2077 args->uid = INVALID_UID; /* no change */
2079 if (attrs->ia_valid & ATTR_GID)
2080 args->gid = attrs->ia_gid;
2082 args->gid = INVALID_GID; /* no change */
2084 if (attrs->ia_valid & ATTR_ATIME)
2085 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2087 args->atime = NO_CHANGE_64;
2089 if (attrs->ia_valid & ATTR_MTIME)
2090 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2092 args->mtime = NO_CHANGE_64;
2094 if (attrs->ia_valid & ATTR_CTIME)
2095 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2097 args->ctime = NO_CHANGE_64;
2100 open_file = find_writable_file(cifsInode, true);
2102 u16 nfid = open_file->fid.netfid;
2103 u32 npid = open_file->pid;
2104 pTcon = tlink_tcon(open_file->tlink);
2105 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2106 cifsFileInfo_put(open_file);
2108 tlink = cifs_sb_tlink(cifs_sb);
2109 if (IS_ERR(tlink)) {
2110 rc = PTR_ERR(tlink);
2113 pTcon = tlink_tcon(tlink);
2114 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2116 cifs_sb->mnt_cifs_flags &
2117 CIFS_MOUNT_MAP_SPECIAL_CHR);
2118 cifs_put_tlink(tlink);
2124 if ((attrs->ia_valid & ATTR_SIZE) &&
2125 attrs->ia_size != i_size_read(inode))
2126 truncate_setsize(inode, attrs->ia_size);
2128 setattr_copy(inode, attrs);
2129 mark_inode_dirty(inode);
2131 /* force revalidate when any of these times are set since some
2132 of the fs types (eg ext3, fat) do not have fine enough
2133 time granularity to match protocol, and we do not have a
2134 a way (yet) to query the server fs's time granularity (and
2135 whether it rounds times down).
2137 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2138 cifsInode->time = 0;
2147 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2150 kuid_t uid = INVALID_UID;
2151 kgid_t gid = INVALID_GID;
2152 struct inode *inode = direntry->d_inode;
2153 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2154 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2155 char *full_path = NULL;
2158 __u64 mode = NO_CHANGE_64;
2162 cifs_dbg(FYI, "setattr on file %s attrs->iavalid 0x%x\n",
2163 direntry->d_name.name, attrs->ia_valid);
2165 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2166 attrs->ia_valid |= ATTR_FORCE;
2168 rc = inode_change_ok(inode, attrs);
2174 full_path = build_path_from_dentry(direntry);
2175 if (full_path == NULL) {
2182 * Attempt to flush data before changing attributes. We need to do
2183 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2184 * ownership or mode then we may also need to do this. Here, we take
2185 * the safe way out and just do the flush on all setattr requests. If
2186 * the flush returns error, store it to report later and continue.
2188 * BB: This should be smarter. Why bother flushing pages that
2189 * will be truncated anyway? Also, should we error out here if
2190 * the flush returns error?
2192 rc = filemap_write_and_wait(inode->i_mapping);
2193 mapping_set_error(inode->i_mapping, rc);
2196 if (attrs->ia_valid & ATTR_SIZE) {
2197 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2199 goto cifs_setattr_exit;
2202 if (attrs->ia_valid & ATTR_UID)
2203 uid = attrs->ia_uid;
2205 if (attrs->ia_valid & ATTR_GID)
2206 gid = attrs->ia_gid;
2208 #ifdef CONFIG_CIFS_ACL
2209 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2210 if (uid_valid(uid) || gid_valid(gid)) {
2211 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2214 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2216 goto cifs_setattr_exit;
2220 #endif /* CONFIG_CIFS_ACL */
2221 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2222 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2224 /* skip mode change if it's just for clearing setuid/setgid */
2225 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2226 attrs->ia_valid &= ~ATTR_MODE;
2228 if (attrs->ia_valid & ATTR_MODE) {
2229 mode = attrs->ia_mode;
2231 #ifdef CONFIG_CIFS_ACL
2232 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2233 rc = id_mode_to_cifs_acl(inode, full_path, mode,
2234 INVALID_UID, INVALID_GID);
2236 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2238 goto cifs_setattr_exit;
2241 #endif /* CONFIG_CIFS_ACL */
2242 if (((mode & S_IWUGO) == 0) &&
2243 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2245 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2247 /* fix up mode if we're not using dynperm */
2248 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2249 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2250 } else if ((mode & S_IWUGO) &&
2251 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2253 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2254 /* Attributes of 0 are ignored */
2256 dosattr |= ATTR_NORMAL;
2258 /* reset local inode permissions to normal */
2259 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2260 attrs->ia_mode &= ~(S_IALLUGO);
2261 if (S_ISDIR(inode->i_mode))
2263 cifs_sb->mnt_dir_mode;
2266 cifs_sb->mnt_file_mode;
2268 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2269 /* ignore mode change - ATTR_READONLY hasn't changed */
2270 attrs->ia_valid &= ~ATTR_MODE;
2274 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2275 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2276 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2277 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2279 /* Even if error on time set, no sense failing the call if
2280 the server would set the time to a reasonable value anyway,
2281 and this check ensures that we are not being called from
2282 sys_utimes in which case we ought to fail the call back to
2283 the user when the server rejects the call */
2284 if ((rc) && (attrs->ia_valid &
2285 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2289 /* do not need local check to inode_check_ok since the server does
2292 goto cifs_setattr_exit;
2294 if ((attrs->ia_valid & ATTR_SIZE) &&
2295 attrs->ia_size != i_size_read(inode))
2296 truncate_setsize(inode, attrs->ia_size);
2298 setattr_copy(inode, attrs);
2299 mark_inode_dirty(inode);
2308 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2310 struct inode *inode = direntry->d_inode;
2311 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2312 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2314 if (pTcon->unix_ext)
2315 return cifs_setattr_unix(direntry, attrs);
2317 return cifs_setattr_nounix(direntry, attrs);
2319 /* BB: add cifs_setattr_legacy for really old servers */
2323 void cifs_delete_inode(struct inode *inode)
2325 cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2326 /* may have to add back in if and when safe distributed caching of
2327 directories added e.g. via FindNotify */