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 = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
389 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
392 if (*pinode == NULL) {
394 cifs_fill_uniqueid(sb, &fattr);
395 *pinode = cifs_iget(sb, &fattr);
399 /* we already have inode, update it */
400 cifs_fattr_to_inode(*pinode, &fattr);
407 cifs_sfu_type(struct cifs_fattr *fattr, const char *path,
408 struct cifs_sb_info *cifs_sb, unsigned int xid)
412 struct tcon_link *tlink;
413 struct cifs_tcon *tcon;
415 struct cifs_open_parms oparms;
416 struct cifs_io_parms io_parms;
418 unsigned int bytes_read;
420 int buf_type = CIFS_NO_BUFFER;
424 fattr->cf_mode &= ~S_IFMT;
426 if (fattr->cf_eof == 0) {
427 fattr->cf_mode |= S_IFIFO;
428 fattr->cf_dtype = DT_FIFO;
430 } else if (fattr->cf_eof < 8) {
431 fattr->cf_mode |= S_IFREG;
432 fattr->cf_dtype = DT_REG;
433 return -EINVAL; /* EOPNOTSUPP? */
436 tlink = cifs_sb_tlink(cifs_sb);
438 return PTR_ERR(tlink);
439 tcon = tlink_tcon(tlink);
442 oparms.cifs_sb = cifs_sb;
443 oparms.desired_access = GENERIC_READ;
444 oparms.create_options = CREATE_NOT_DIR;
445 oparms.disposition = FILE_OPEN;
448 oparms.reconnect = false;
450 rc = CIFS_open(xid, &oparms, &oplock, NULL);
452 cifs_put_tlink(tlink);
457 io_parms.netfid = fid.netfid;
458 io_parms.pid = current->tgid;
459 io_parms.tcon = tcon;
461 io_parms.length = 24;
463 rc = CIFSSMBRead(xid, &io_parms, &bytes_read, &pbuf, &buf_type);
464 if ((rc == 0) && (bytes_read >= 8)) {
465 if (memcmp("IntxBLK", pbuf, 8) == 0) {
466 cifs_dbg(FYI, "Block device\n");
467 fattr->cf_mode |= S_IFBLK;
468 fattr->cf_dtype = DT_BLK;
469 if (bytes_read == 24) {
470 /* we have enough to decode dev num */
471 __u64 mjr; /* major */
472 __u64 mnr; /* minor */
473 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
474 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
475 fattr->cf_rdev = MKDEV(mjr, mnr);
477 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
478 cifs_dbg(FYI, "Char device\n");
479 fattr->cf_mode |= S_IFCHR;
480 fattr->cf_dtype = DT_CHR;
481 if (bytes_read == 24) {
482 /* we have enough to decode dev num */
483 __u64 mjr; /* major */
484 __u64 mnr; /* minor */
485 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
486 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
487 fattr->cf_rdev = MKDEV(mjr, mnr);
489 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
490 cifs_dbg(FYI, "Symlink\n");
491 fattr->cf_mode |= S_IFLNK;
492 fattr->cf_dtype = DT_LNK;
494 fattr->cf_mode |= S_IFREG; /* file? */
495 fattr->cf_dtype = DT_REG;
499 fattr->cf_mode |= S_IFREG; /* then it is a file */
500 fattr->cf_dtype = DT_REG;
501 rc = -EOPNOTSUPP; /* or some unknown SFU type */
503 CIFSSMBClose(xid, tcon, fid.netfid);
504 cifs_put_tlink(tlink);
508 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
511 * Fetch mode bits as provided by SFU.
513 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
515 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
516 struct cifs_sb_info *cifs_sb, unsigned int xid)
518 #ifdef CONFIG_CIFS_XATTR
522 struct tcon_link *tlink;
523 struct cifs_tcon *tcon;
525 tlink = cifs_sb_tlink(cifs_sb);
527 return PTR_ERR(tlink);
528 tcon = tlink_tcon(tlink);
530 if (tcon->ses->server->ops->query_all_EAs == NULL) {
531 cifs_put_tlink(tlink);
535 rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
536 "SETFILEBITS", ea_value, 4 /* size of buf */,
538 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
539 cifs_put_tlink(tlink);
543 mode = le32_to_cpu(*((__le32 *)ea_value));
544 fattr->cf_mode &= ~SFBITS_MASK;
545 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
546 mode, fattr->cf_mode);
547 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
548 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
557 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
559 cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
560 struct cifs_sb_info *cifs_sb, bool adjust_tz,
563 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
565 memset(fattr, 0, sizeof(*fattr));
566 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
567 if (info->DeletePending)
568 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
570 if (info->LastAccessTime)
571 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
573 fattr->cf_atime = CURRENT_TIME;
575 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
576 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
579 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
580 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
583 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
584 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
585 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
587 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
590 fattr->cf_mode = S_IFLNK;
591 fattr->cf_dtype = DT_LNK;
592 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
593 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
594 fattr->cf_dtype = DT_DIR;
596 * Server can return wrong NumberOfLinks value for directories
597 * when Unix extensions are disabled - fake it.
600 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
602 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
603 fattr->cf_dtype = DT_REG;
605 /* clear write bits if ATTR_READONLY is set */
606 if (fattr->cf_cifsattrs & ATTR_READONLY)
607 fattr->cf_mode &= ~(S_IWUGO);
610 * Don't accept zero nlink from non-unix servers unless
611 * delete is pending. Instead mark it as unknown.
613 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
614 !info->DeletePending) {
615 cifs_dbg(1, "bogus file nlink value %u\n",
617 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
621 fattr->cf_uid = cifs_sb->mnt_uid;
622 fattr->cf_gid = cifs_sb->mnt_gid;
626 cifs_get_file_info(struct file *filp)
630 FILE_ALL_INFO find_data;
631 struct cifs_fattr fattr;
632 struct inode *inode = file_inode(filp);
633 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
634 struct cifsFileInfo *cfile = filp->private_data;
635 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
636 struct TCP_Server_Info *server = tcon->ses->server;
638 if (!server->ops->query_file_info)
642 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
645 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false,
649 cifs_create_dfs_fattr(&fattr, inode->i_sb);
655 * FIXME: legacy server -- fall back to path-based call?
656 * for now, just skip revalidating and mark inode for
660 CIFS_I(inode)->time = 0;
666 * don't bother with SFU junk here -- just mark inode as needing
669 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
670 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
671 cifs_fattr_to_inode(inode, &fattr);
678 cifs_get_inode_info(struct inode **inode, const char *full_path,
679 FILE_ALL_INFO *data, struct super_block *sb, int xid,
680 const struct cifs_fid *fid)
682 bool validinum = false;
684 int rc = 0, tmprc = ENOSYS;
685 struct cifs_tcon *tcon;
686 struct TCP_Server_Info *server;
687 struct tcon_link *tlink;
688 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
690 bool adjust_tz = false;
691 struct cifs_fattr fattr;
692 struct cifs_search_info *srchinf = NULL;
693 bool symlink = false;
695 tlink = cifs_sb_tlink(cifs_sb);
697 return PTR_ERR(tlink);
698 tcon = tlink_tcon(tlink);
699 server = tcon->ses->server;
701 cifs_dbg(FYI, "Getting info on %s\n", full_path);
703 if ((data == NULL) && (*inode != NULL)) {
704 if (CIFS_CACHE_READ(CIFS_I(*inode))) {
705 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
710 /* if inode info is not passed, get it from server */
712 if (!server->ops->query_path_info) {
716 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
721 data = (FILE_ALL_INFO *)buf;
722 rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path,
723 data, &adjust_tz, &symlink);
727 cifs_all_info_to_fattr(&fattr, data, cifs_sb, adjust_tz,
729 } else if (rc == -EREMOTE) {
730 cifs_create_dfs_fattr(&fattr, sb);
732 } else if (rc == -EACCES && backup_cred(cifs_sb)) {
733 srchinf = kzalloc(sizeof(struct cifs_search_info),
735 if (srchinf == NULL) {
740 srchinf->endOfSearch = false;
741 srchinf->info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
743 srchflgs = CIFS_SEARCH_CLOSE_ALWAYS |
744 CIFS_SEARCH_CLOSE_AT_END |
745 CIFS_SEARCH_BACKUP_SEARCH;
747 rc = CIFSFindFirst(xid, tcon, full_path,
748 cifs_sb, NULL, srchflgs, srchinf, false);
751 (FILE_ALL_INFO *)srchinf->srch_entries_start;
753 cifs_dir_info_to_fattr(&fattr,
754 (FILE_DIRECTORY_INFO *)data, cifs_sb);
755 fattr.cf_uniqueid = le64_to_cpu(
756 ((SEARCH_ID_FULL_DIR_INFO *)data)->UniqueId);
759 cifs_buf_release(srchinf->ntwrk_buf_start);
766 * If an inode wasn't passed in, then get the inode number
768 * Is an i_ino of zero legal? Can we use that to check if the server
769 * supports returning inode numbers? Are there other sanity checks we
770 * can use to ensure that the server is really filling in that field?
772 if (*inode == NULL) {
773 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
774 if (validinum == false) {
775 if (server->ops->get_srv_inum)
776 tmprc = server->ops->get_srv_inum(xid,
777 tcon, cifs_sb, full_path,
778 &fattr.cf_uniqueid, data);
780 cifs_dbg(FYI, "GetSrvInodeNum rc %d\n",
782 fattr.cf_uniqueid = iunique(sb, ROOT_I);
783 cifs_autodisable_serverino(cifs_sb);
787 fattr.cf_uniqueid = iunique(sb, ROOT_I);
789 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
791 /* query for SFU type info if supported and needed */
792 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
793 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
794 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
796 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
799 #ifdef CONFIG_CIFS_ACL
800 /* fill in 0777 bits from ACL */
801 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
802 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, full_path, fid);
804 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
809 #endif /* CONFIG_CIFS_ACL */
811 /* fill in remaining high mode bits e.g. SUID, VTX */
812 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
813 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
815 /* check for Minshall+French symlinks */
816 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
817 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
820 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
824 *inode = cifs_iget(sb, &fattr);
828 cifs_fattr_to_inode(*inode, &fattr);
833 cifs_put_tlink(tlink);
837 static const struct inode_operations cifs_ipc_inode_ops = {
838 .lookup = cifs_lookup,
842 cifs_find_inode(struct inode *inode, void *opaque)
844 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
846 /* don't match inode with different uniqueid */
847 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
850 /* use createtime like an i_generation field */
851 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
854 /* don't match inode of different type */
855 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
858 /* if it's not a directory or has no dentries, then flag it */
859 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
860 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
866 cifs_init_inode(struct inode *inode, void *opaque)
868 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
870 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
871 CIFS_I(inode)->createtime = fattr->cf_createtime;
876 * walk dentry list for an inode and report whether it has aliases that
877 * are hashed. We use this to determine if a directory inode can actually
881 inode_has_hashed_dentries(struct inode *inode)
883 struct dentry *dentry;
885 spin_lock(&inode->i_lock);
886 hlist_for_each_entry(dentry, &inode->i_dentry, d_alias) {
887 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
888 spin_unlock(&inode->i_lock);
892 spin_unlock(&inode->i_lock);
896 /* Given fattrs, get a corresponding inode */
898 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
904 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
906 /* hash down to 32-bits on 32-bit arch */
907 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
909 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
911 /* was there a potentially problematic inode collision? */
912 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
913 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
915 if (inode_has_hashed_dentries(inode)) {
916 cifs_autodisable_serverino(CIFS_SB(sb));
918 fattr->cf_uniqueid = iunique(sb, ROOT_I);
919 goto retry_iget5_locked;
923 cifs_fattr_to_inode(inode, fattr);
924 if (sb->s_flags & MS_NOATIME)
925 inode->i_flags |= S_NOATIME | S_NOCMTIME;
926 if (inode->i_state & I_NEW) {
928 if (S_ISREG(inode->i_mode))
929 inode->i_data.backing_dev_info = sb->s_bdi;
930 #ifdef CONFIG_CIFS_FSCACHE
931 /* initialize per-inode cache cookie pointer */
932 CIFS_I(inode)->fscache = NULL;
934 unlock_new_inode(inode);
941 /* gets root inode */
942 struct inode *cifs_root_iget(struct super_block *sb)
945 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
946 struct inode *inode = NULL;
948 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
952 rc = cifs_get_inode_info_unix(&inode, "", sb, xid);
954 rc = cifs_get_inode_info(&inode, "", NULL, sb, xid, NULL);
961 #ifdef CONFIG_CIFS_FSCACHE
962 /* populate tcon->resource_id */
963 tcon->resource_id = CIFS_I(inode)->uniqueid;
966 if (rc && tcon->ipc) {
967 cifs_dbg(FYI, "ipc connection - fake read inode\n");
968 spin_lock(&inode->i_lock);
969 inode->i_mode |= S_IFDIR;
971 inode->i_op = &cifs_ipc_inode_ops;
972 inode->i_fop = &simple_dir_operations;
973 inode->i_uid = cifs_sb->mnt_uid;
974 inode->i_gid = cifs_sb->mnt_gid;
975 spin_unlock(&inode->i_lock);
982 /* can not call macro free_xid here since in a void func
983 * TODO: This is no longer true
990 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
991 char *full_path, __u32 dosattr)
993 bool set_time = false;
994 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
995 struct TCP_Server_Info *server;
996 FILE_BASIC_INFO info_buf;
1001 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1002 if (!server->ops->set_file_info)
1005 if (attrs->ia_valid & ATTR_ATIME) {
1007 info_buf.LastAccessTime =
1008 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1010 info_buf.LastAccessTime = 0;
1012 if (attrs->ia_valid & ATTR_MTIME) {
1014 info_buf.LastWriteTime =
1015 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1017 info_buf.LastWriteTime = 0;
1020 * Samba throws this field away, but windows may actually use it.
1021 * Do not set ctime unless other time stamps are changed explicitly
1022 * (i.e. by utimes()) since we would then have a mix of client and
1025 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1026 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1027 info_buf.ChangeTime =
1028 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1030 info_buf.ChangeTime = 0;
1032 info_buf.CreationTime = 0; /* don't change */
1033 info_buf.Attributes = cpu_to_le32(dosattr);
1035 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1039 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1040 * and rename it to a random name that hopefully won't conflict with
1044 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1045 const unsigned int xid)
1049 struct cifs_fid fid;
1050 struct cifs_open_parms oparms;
1051 struct inode *inode = dentry->d_inode;
1052 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1053 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1054 struct tcon_link *tlink;
1055 struct cifs_tcon *tcon;
1056 __u32 dosattr, origattr;
1057 FILE_BASIC_INFO *info_buf = NULL;
1059 tlink = cifs_sb_tlink(cifs_sb);
1061 return PTR_ERR(tlink);
1062 tcon = tlink_tcon(tlink);
1065 * We cannot rename the file if the server doesn't support
1066 * CAP_INFOLEVEL_PASSTHRU
1068 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1074 oparms.cifs_sb = cifs_sb;
1075 oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1076 oparms.create_options = CREATE_NOT_DIR;
1077 oparms.disposition = FILE_OPEN;
1078 oparms.path = full_path;
1080 oparms.reconnect = false;
1082 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1086 origattr = cifsInode->cifsAttrs;
1088 origattr |= ATTR_NORMAL;
1090 dosattr = origattr & ~ATTR_READONLY;
1092 dosattr |= ATTR_NORMAL;
1093 dosattr |= ATTR_HIDDEN;
1095 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1096 if (dosattr != origattr) {
1097 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1098 if (info_buf == NULL) {
1102 info_buf->Attributes = cpu_to_le32(dosattr);
1103 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1105 /* although we would like to mark the file hidden
1106 if that fails we will still try to rename it */
1108 cifsInode->cifsAttrs = dosattr;
1110 dosattr = origattr; /* since not able to change them */
1113 /* rename the file */
1114 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1116 cifs_sb->mnt_cifs_flags &
1117 CIFS_MOUNT_MAP_SPECIAL_CHR);
1123 /* try to set DELETE_ON_CLOSE */
1124 if (!cifsInode->delete_pending) {
1125 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1128 * some samba versions return -ENOENT when we try to set the
1129 * file disposition here. Likely a samba bug, but work around
1130 * it for now. This means that some cifsXXX files may hang
1131 * around after they shouldn't.
1133 * BB: remove this hack after more servers have the fix
1141 cifsInode->delete_pending = true;
1145 CIFSSMBClose(xid, tcon, fid.netfid);
1148 cifs_put_tlink(tlink);
1152 * reset everything back to the original state. Don't bother
1153 * dealing with errors here since we can't do anything about
1157 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1158 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1159 CIFS_MOUNT_MAP_SPECIAL_CHR);
1161 if (dosattr != origattr) {
1162 info_buf->Attributes = cpu_to_le32(origattr);
1163 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1165 cifsInode->cifsAttrs = origattr;
1171 /* copied from fs/nfs/dir.c with small changes */
1173 cifs_drop_nlink(struct inode *inode)
1175 spin_lock(&inode->i_lock);
1176 if (inode->i_nlink > 0)
1178 spin_unlock(&inode->i_lock);
1182 * If dentry->d_inode is null (usually meaning the cached dentry
1183 * is a negative dentry) then we would attempt a standard SMB delete, but
1184 * if that fails we can not attempt the fall back mechanisms on EACCESS
1185 * but will return the EACCESS to the caller. Note that the VFS does not call
1186 * unlink on negative dentries currently.
1188 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1192 char *full_path = NULL;
1193 struct inode *inode = dentry->d_inode;
1194 struct cifsInodeInfo *cifs_inode;
1195 struct super_block *sb = dir->i_sb;
1196 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1197 struct tcon_link *tlink;
1198 struct cifs_tcon *tcon;
1199 struct TCP_Server_Info *server;
1200 struct iattr *attrs = NULL;
1201 __u32 dosattr = 0, origattr = 0;
1203 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1205 tlink = cifs_sb_tlink(cifs_sb);
1207 return PTR_ERR(tlink);
1208 tcon = tlink_tcon(tlink);
1209 server = tcon->ses->server;
1213 /* Unlink can be called from rename so we can not take the
1214 * sb->s_vfs_rename_mutex here */
1215 full_path = build_path_from_dentry(dentry);
1216 if (full_path == NULL) {
1221 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1222 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1223 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1224 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1225 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1226 cifs_dbg(FYI, "posix del rc %d\n", rc);
1227 if ((rc == 0) || (rc == -ENOENT))
1228 goto psx_del_no_retry;
1232 if (!server->ops->unlink) {
1234 goto psx_del_no_retry;
1237 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1242 cifs_drop_nlink(inode);
1243 } else if (rc == -ENOENT) {
1245 } else if (rc == -EBUSY) {
1246 if (server->ops->rename_pending_delete) {
1247 rc = server->ops->rename_pending_delete(full_path,
1250 cifs_drop_nlink(inode);
1252 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1253 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1254 if (attrs == NULL) {
1259 /* try to reset dos attributes */
1260 cifs_inode = CIFS_I(inode);
1261 origattr = cifs_inode->cifsAttrs;
1263 origattr |= ATTR_NORMAL;
1264 dosattr = origattr & ~ATTR_READONLY;
1266 dosattr |= ATTR_NORMAL;
1267 dosattr |= ATTR_HIDDEN;
1269 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1273 goto retry_std_delete;
1276 /* undo the setattr if we errored out and it's needed */
1277 if (rc != 0 && dosattr != 0)
1278 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1282 cifs_inode = CIFS_I(inode);
1283 cifs_inode->time = 0; /* will force revalidate to get info
1285 inode->i_ctime = current_fs_time(sb);
1287 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1288 cifs_inode = CIFS_I(dir);
1289 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1294 cifs_put_tlink(tlink);
1299 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1300 const char *full_path, struct cifs_sb_info *cifs_sb,
1301 struct cifs_tcon *tcon, const unsigned int xid)
1304 struct inode *inode = NULL;
1307 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1310 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1317 * setting nlink not necessary except in cases where we failed to get it
1318 * from the server or was set bogus. Also, since this is a brand new
1319 * inode, no need to grab the i_lock before setting the i_nlink.
1321 if (inode->i_nlink < 2)
1322 set_nlink(inode, 2);
1323 mode &= ~current_umask();
1324 /* must turn on setgid bit if parent dir has it */
1325 if (parent->i_mode & S_ISGID)
1328 if (tcon->unix_ext) {
1329 struct cifs_unix_set_info_args args = {
1331 .ctime = NO_CHANGE_64,
1332 .atime = NO_CHANGE_64,
1333 .mtime = NO_CHANGE_64,
1336 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1337 args.uid = current_fsuid();
1338 if (parent->i_mode & S_ISGID)
1339 args.gid = parent->i_gid;
1341 args.gid = current_fsgid();
1343 args.uid = INVALID_UID; /* no change */
1344 args.gid = INVALID_GID; /* no change */
1346 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1348 cifs_sb->mnt_cifs_flags &
1349 CIFS_MOUNT_MAP_SPECIAL_CHR);
1351 struct TCP_Server_Info *server = tcon->ses->server;
1352 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1353 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1354 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1356 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1357 inode->i_mode = (mode | S_IFDIR);
1359 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1360 inode->i_uid = current_fsuid();
1361 if (inode->i_mode & S_ISGID)
1362 inode->i_gid = parent->i_gid;
1364 inode->i_gid = current_fsgid();
1367 d_instantiate(dentry, inode);
1372 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1373 const char *full_path, struct cifs_sb_info *cifs_sb,
1374 struct cifs_tcon *tcon, const unsigned int xid)
1378 FILE_UNIX_BASIC_INFO *info = NULL;
1379 struct inode *newinode = NULL;
1380 struct cifs_fattr fattr;
1382 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1385 goto posix_mkdir_out;
1388 mode &= ~current_umask();
1389 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1390 NULL /* netfid */, info, &oplock, full_path,
1391 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1392 CIFS_MOUNT_MAP_SPECIAL_CHR);
1393 if (rc == -EOPNOTSUPP)
1394 goto posix_mkdir_out;
1396 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1398 goto posix_mkdir_out;
1401 if (info->Type == cpu_to_le32(-1))
1402 /* no return info, go query for it */
1403 goto posix_mkdir_get_info;
1405 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1406 * need to set uid/gid.
1409 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1410 cifs_fill_uniqueid(inode->i_sb, &fattr);
1411 newinode = cifs_iget(inode->i_sb, &fattr);
1413 goto posix_mkdir_get_info;
1415 d_instantiate(dentry, newinode);
1417 #ifdef CONFIG_CIFS_DEBUG2
1418 cifs_dbg(FYI, "instantiated dentry %p %s to inode %p\n",
1419 dentry, dentry->d_name.name, newinode);
1421 if (newinode->i_nlink != 2)
1422 cifs_dbg(FYI, "unexpected number of links %d\n",
1429 posix_mkdir_get_info:
1430 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1432 goto posix_mkdir_out;
1435 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1439 struct cifs_sb_info *cifs_sb;
1440 struct tcon_link *tlink;
1441 struct cifs_tcon *tcon;
1442 struct TCP_Server_Info *server;
1445 cifs_dbg(FYI, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1448 cifs_sb = CIFS_SB(inode->i_sb);
1449 tlink = cifs_sb_tlink(cifs_sb);
1451 return PTR_ERR(tlink);
1452 tcon = tlink_tcon(tlink);
1456 full_path = build_path_from_dentry(direntry);
1457 if (full_path == NULL) {
1462 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1463 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1464 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1466 if (rc != -EOPNOTSUPP)
1470 server = tcon->ses->server;
1472 if (!server->ops->mkdir) {
1477 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1478 rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
1480 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1485 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1489 * Force revalidate to get parent dir info when needed since cached
1490 * attributes are invalid now.
1492 CIFS_I(inode)->time = 0;
1495 cifs_put_tlink(tlink);
1499 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1503 struct cifs_sb_info *cifs_sb;
1504 struct tcon_link *tlink;
1505 struct cifs_tcon *tcon;
1506 struct TCP_Server_Info *server;
1507 char *full_path = NULL;
1508 struct cifsInodeInfo *cifsInode;
1510 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1514 full_path = build_path_from_dentry(direntry);
1515 if (full_path == NULL) {
1520 cifs_sb = CIFS_SB(inode->i_sb);
1521 tlink = cifs_sb_tlink(cifs_sb);
1522 if (IS_ERR(tlink)) {
1523 rc = PTR_ERR(tlink);
1526 tcon = tlink_tcon(tlink);
1527 server = tcon->ses->server;
1529 if (!server->ops->rmdir) {
1531 cifs_put_tlink(tlink);
1535 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1536 cifs_put_tlink(tlink);
1539 spin_lock(&direntry->d_inode->i_lock);
1540 i_size_write(direntry->d_inode, 0);
1541 clear_nlink(direntry->d_inode);
1542 spin_unlock(&direntry->d_inode->i_lock);
1545 cifsInode = CIFS_I(direntry->d_inode);
1546 /* force revalidate to go get info when needed */
1547 cifsInode->time = 0;
1549 cifsInode = CIFS_I(inode);
1551 * Force revalidate to get parent dir info when needed since cached
1552 * attributes are invalid now.
1554 cifsInode->time = 0;
1556 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1557 current_fs_time(inode->i_sb);
1566 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1567 const char *from_path, struct dentry *to_dentry,
1568 const char *to_path)
1570 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1571 struct tcon_link *tlink;
1572 struct cifs_tcon *tcon;
1573 struct TCP_Server_Info *server;
1574 struct cifs_fid fid;
1575 struct cifs_open_parms oparms;
1578 tlink = cifs_sb_tlink(cifs_sb);
1580 return PTR_ERR(tlink);
1581 tcon = tlink_tcon(tlink);
1582 server = tcon->ses->server;
1584 if (!server->ops->rename)
1587 /* try path-based rename first */
1588 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1591 * Don't bother with rename by filehandle unless file is busy and
1592 * source. Note that cross directory moves do not work with
1593 * rename by filehandle to various Windows servers.
1595 if (rc == 0 || rc != -EBUSY)
1596 goto do_rename_exit;
1598 /* open-file renames don't work across directories */
1599 if (to_dentry->d_parent != from_dentry->d_parent)
1600 goto do_rename_exit;
1603 oparms.cifs_sb = cifs_sb;
1604 /* open the file to be renamed -- we need DELETE perms */
1605 oparms.desired_access = DELETE;
1606 oparms.create_options = CREATE_NOT_DIR;
1607 oparms.disposition = FILE_OPEN;
1608 oparms.path = from_path;
1610 oparms.reconnect = false;
1612 rc = CIFS_open(xid, &oparms, &oplock, NULL);
1614 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
1615 (const char *) to_dentry->d_name.name,
1616 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1617 CIFS_MOUNT_MAP_SPECIAL_CHR);
1618 CIFSSMBClose(xid, tcon, fid.netfid);
1621 cifs_put_tlink(tlink);
1626 cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1627 struct inode *target_dir, struct dentry *target_dentry)
1629 char *from_name = NULL;
1630 char *to_name = NULL;
1631 struct cifs_sb_info *cifs_sb;
1632 struct tcon_link *tlink;
1633 struct cifs_tcon *tcon;
1634 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1635 FILE_UNIX_BASIC_INFO *info_buf_target;
1639 cifs_sb = CIFS_SB(source_dir->i_sb);
1640 tlink = cifs_sb_tlink(cifs_sb);
1642 return PTR_ERR(tlink);
1643 tcon = tlink_tcon(tlink);
1648 * we already have the rename sem so we do not need to
1649 * grab it again here to protect the path integrity
1651 from_name = build_path_from_dentry(source_dentry);
1652 if (from_name == NULL) {
1654 goto cifs_rename_exit;
1657 to_name = build_path_from_dentry(target_dentry);
1658 if (to_name == NULL) {
1660 goto cifs_rename_exit;
1663 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1666 if (rc == -EEXIST && tcon->unix_ext) {
1668 * Are src and dst hardlinks of same inode? We can only tell
1669 * with unix extensions enabled.
1672 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1674 if (info_buf_source == NULL) {
1676 goto cifs_rename_exit;
1679 info_buf_target = info_buf_source + 1;
1680 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1683 cifs_sb->mnt_cifs_flags &
1684 CIFS_MOUNT_MAP_SPECIAL_CHR);
1688 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1691 cifs_sb->mnt_cifs_flags &
1692 CIFS_MOUNT_MAP_SPECIAL_CHR);
1694 if (tmprc == 0 && (info_buf_source->UniqueId ==
1695 info_buf_target->UniqueId)) {
1696 /* same file, POSIX says that this is a noop */
1698 goto cifs_rename_exit;
1702 * else ... BB we could add the same check for Windows by
1703 * checking the UniqueId via FILE_INTERNAL_INFO
1707 /* Try unlinking the target dentry if it's not negative */
1708 if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
1709 tmprc = cifs_unlink(target_dir, target_dentry);
1711 goto cifs_rename_exit;
1712 rc = cifs_do_rename(xid, source_dentry, from_name,
1713 target_dentry, to_name);
1717 kfree(info_buf_source);
1721 cifs_put_tlink(tlink);
1726 cifs_inode_needs_reval(struct inode *inode)
1728 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1729 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1731 if (CIFS_CACHE_READ(cifs_i))
1734 if (!lookupCacheEnabled)
1737 if (cifs_i->time == 0)
1740 if (!time_in_range(jiffies, cifs_i->time,
1741 cifs_i->time + cifs_sb->actimeo))
1744 /* hardlinked files w/ noserverino get "special" treatment */
1745 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1746 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1753 * Zap the cache. Called when invalid_mapping flag is set.
1756 cifs_invalidate_mapping(struct inode *inode)
1759 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1761 cifs_i->invalid_mapping = false;
1763 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1764 rc = invalidate_inode_pages2(inode->i_mapping);
1766 cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1768 cifs_i->invalid_mapping = true;
1772 cifs_fscache_reset_inode_cookie(inode);
1776 int cifs_revalidate_file_attr(struct file *filp)
1779 struct inode *inode = file_inode(filp);
1780 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1782 if (!cifs_inode_needs_reval(inode))
1785 if (tlink_tcon(cfile->tlink)->unix_ext)
1786 rc = cifs_get_file_info_unix(filp);
1788 rc = cifs_get_file_info(filp);
1793 int cifs_revalidate_dentry_attr(struct dentry *dentry)
1797 struct inode *inode = dentry->d_inode;
1798 struct super_block *sb = dentry->d_sb;
1799 char *full_path = NULL;
1804 if (!cifs_inode_needs_reval(inode))
1809 /* can not safely grab the rename sem here if rename calls revalidate
1810 since that would deadlock */
1811 full_path = build_path_from_dentry(dentry);
1812 if (full_path == NULL) {
1817 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1818 full_path, inode, inode->i_count.counter,
1819 dentry, dentry->d_time, jiffies);
1821 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1822 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1824 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1833 int cifs_revalidate_file(struct file *filp)
1836 struct inode *inode = file_inode(filp);
1838 rc = cifs_revalidate_file_attr(filp);
1842 if (CIFS_I(inode)->invalid_mapping)
1843 rc = cifs_invalidate_mapping(inode);
1847 /* revalidate a dentry's inode attributes */
1848 int cifs_revalidate_dentry(struct dentry *dentry)
1851 struct inode *inode = dentry->d_inode;
1853 rc = cifs_revalidate_dentry_attr(dentry);
1857 if (CIFS_I(inode)->invalid_mapping)
1858 rc = cifs_invalidate_mapping(inode);
1862 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1865 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1866 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1867 struct inode *inode = dentry->d_inode;
1871 * We need to be sure that all dirty pages are written and the server
1872 * has actual ctime, mtime and file length.
1874 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
1875 inode->i_mapping->nrpages != 0) {
1876 rc = filemap_fdatawait(inode->i_mapping);
1878 mapping_set_error(inode->i_mapping, rc);
1883 rc = cifs_revalidate_dentry_attr(dentry);
1887 generic_fillattr(inode, stat);
1888 stat->blksize = CIFS_MAX_MSGSIZE;
1889 stat->ino = CIFS_I(inode)->uniqueid;
1892 * If on a multiuser mount without unix extensions or cifsacl being
1893 * enabled, and the admin hasn't overridden them, set the ownership
1894 * to the fsuid/fsgid of the current process.
1896 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
1897 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1899 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1900 stat->uid = current_fsuid();
1901 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1902 stat->gid = current_fsgid();
1907 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1909 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1910 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1914 page = grab_cache_page(mapping, index);
1918 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1920 page_cache_release(page);
1924 static void cifs_setsize(struct inode *inode, loff_t offset)
1926 spin_lock(&inode->i_lock);
1927 i_size_write(inode, offset);
1928 spin_unlock(&inode->i_lock);
1930 truncate_pagecache(inode, offset);
1934 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1935 unsigned int xid, char *full_path)
1938 struct cifsFileInfo *open_file;
1939 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1940 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1941 struct tcon_link *tlink = NULL;
1942 struct cifs_tcon *tcon = NULL;
1943 struct TCP_Server_Info *server;
1944 struct cifs_io_parms io_parms;
1947 * To avoid spurious oplock breaks from server, in the case of
1948 * inodes that we already have open, avoid doing path based
1949 * setting of file size if we can do it by handle.
1950 * This keeps our caching token (oplock) and avoids timeouts
1951 * when the local oplock break takes longer to flush
1952 * writebehind data than the SMB timeout for the SetPathInfo
1953 * request would allow
1955 open_file = find_writable_file(cifsInode, true);
1957 tcon = tlink_tcon(open_file->tlink);
1958 server = tcon->ses->server;
1959 if (server->ops->set_file_size)
1960 rc = server->ops->set_file_size(xid, tcon, open_file,
1961 attrs->ia_size, false);
1964 cifsFileInfo_put(open_file);
1965 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
1966 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1967 unsigned int bytes_written;
1969 io_parms.netfid = open_file->fid.netfid;
1970 io_parms.pid = open_file->pid;
1971 io_parms.tcon = tcon;
1972 io_parms.offset = 0;
1973 io_parms.length = attrs->ia_size;
1974 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written,
1976 cifs_dbg(FYI, "Wrt seteof rc %d\n", rc);
1985 tlink = cifs_sb_tlink(cifs_sb);
1987 return PTR_ERR(tlink);
1988 tcon = tlink_tcon(tlink);
1989 server = tcon->ses->server;
1993 * Set file size by pathname rather than by handle either because no
1994 * valid, writeable file handle for it was found or because there was
1995 * an error setting it by handle.
1997 if (server->ops->set_path_size)
1998 rc = server->ops->set_path_size(xid, tcon, full_path,
1999 attrs->ia_size, cifs_sb, false);
2002 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2003 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
2007 rc = SMBLegacyOpen(xid, tcon, full_path, FILE_OPEN,
2008 GENERIC_WRITE, CREATE_NOT_DIR, &netfid,
2009 &oplock, NULL, cifs_sb->local_nls,
2010 cifs_sb->mnt_cifs_flags &
2011 CIFS_MOUNT_MAP_SPECIAL_CHR);
2013 unsigned int bytes_written;
2015 io_parms.netfid = netfid;
2016 io_parms.pid = current->tgid;
2017 io_parms.tcon = tcon;
2018 io_parms.offset = 0;
2019 io_parms.length = attrs->ia_size;
2020 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written, NULL,
2022 cifs_dbg(FYI, "wrt seteof rc %d\n", rc);
2023 CIFSSMBClose(xid, tcon, netfid);
2027 cifs_put_tlink(tlink);
2031 cifsInode->server_eof = attrs->ia_size;
2032 cifs_setsize(inode, attrs->ia_size);
2033 cifs_truncate_page(inode->i_mapping, inode->i_size);
2040 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2044 char *full_path = NULL;
2045 struct inode *inode = direntry->d_inode;
2046 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2047 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2048 struct tcon_link *tlink;
2049 struct cifs_tcon *pTcon;
2050 struct cifs_unix_set_info_args *args = NULL;
2051 struct cifsFileInfo *open_file;
2053 cifs_dbg(FYI, "setattr_unix on file %s attrs->ia_valid=0x%x\n",
2054 direntry->d_name.name, attrs->ia_valid);
2058 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2059 attrs->ia_valid |= ATTR_FORCE;
2061 rc = inode_change_ok(inode, attrs);
2065 full_path = build_path_from_dentry(direntry);
2066 if (full_path == NULL) {
2072 * Attempt to flush data before changing attributes. We need to do
2073 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2074 * ownership or mode then we may also need to do this. Here, we take
2075 * the safe way out and just do the flush on all setattr requests. If
2076 * the flush returns error, store it to report later and continue.
2078 * BB: This should be smarter. Why bother flushing pages that
2079 * will be truncated anyway? Also, should we error out here if
2080 * the flush returns error?
2082 rc = filemap_write_and_wait(inode->i_mapping);
2083 mapping_set_error(inode->i_mapping, rc);
2086 if (attrs->ia_valid & ATTR_SIZE) {
2087 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2092 /* skip mode change if it's just for clearing setuid/setgid */
2093 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2094 attrs->ia_valid &= ~ATTR_MODE;
2096 args = kmalloc(sizeof(*args), GFP_KERNEL);
2102 /* set up the struct */
2103 if (attrs->ia_valid & ATTR_MODE)
2104 args->mode = attrs->ia_mode;
2106 args->mode = NO_CHANGE_64;
2108 if (attrs->ia_valid & ATTR_UID)
2109 args->uid = attrs->ia_uid;
2111 args->uid = INVALID_UID; /* no change */
2113 if (attrs->ia_valid & ATTR_GID)
2114 args->gid = attrs->ia_gid;
2116 args->gid = INVALID_GID; /* no change */
2118 if (attrs->ia_valid & ATTR_ATIME)
2119 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2121 args->atime = NO_CHANGE_64;
2123 if (attrs->ia_valid & ATTR_MTIME)
2124 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2126 args->mtime = NO_CHANGE_64;
2128 if (attrs->ia_valid & ATTR_CTIME)
2129 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2131 args->ctime = NO_CHANGE_64;
2134 open_file = find_writable_file(cifsInode, true);
2136 u16 nfid = open_file->fid.netfid;
2137 u32 npid = open_file->pid;
2138 pTcon = tlink_tcon(open_file->tlink);
2139 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2140 cifsFileInfo_put(open_file);
2142 tlink = cifs_sb_tlink(cifs_sb);
2143 if (IS_ERR(tlink)) {
2144 rc = PTR_ERR(tlink);
2147 pTcon = tlink_tcon(tlink);
2148 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2150 cifs_sb->mnt_cifs_flags &
2151 CIFS_MOUNT_MAP_SPECIAL_CHR);
2152 cifs_put_tlink(tlink);
2158 if ((attrs->ia_valid & ATTR_SIZE) &&
2159 attrs->ia_size != i_size_read(inode))
2160 truncate_setsize(inode, attrs->ia_size);
2162 setattr_copy(inode, attrs);
2163 mark_inode_dirty(inode);
2165 /* force revalidate when any of these times are set since some
2166 of the fs types (eg ext3, fat) do not have fine enough
2167 time granularity to match protocol, and we do not have a
2168 a way (yet) to query the server fs's time granularity (and
2169 whether it rounds times down).
2171 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2172 cifsInode->time = 0;
2181 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2184 kuid_t uid = INVALID_UID;
2185 kgid_t gid = INVALID_GID;
2186 struct inode *inode = direntry->d_inode;
2187 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2188 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2189 char *full_path = NULL;
2192 __u64 mode = NO_CHANGE_64;
2196 cifs_dbg(FYI, "setattr on file %s attrs->iavalid 0x%x\n",
2197 direntry->d_name.name, attrs->ia_valid);
2199 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2200 attrs->ia_valid |= ATTR_FORCE;
2202 rc = inode_change_ok(inode, attrs);
2208 full_path = build_path_from_dentry(direntry);
2209 if (full_path == NULL) {
2216 * Attempt to flush data before changing attributes. We need to do
2217 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2218 * ownership or mode then we may also need to do this. Here, we take
2219 * the safe way out and just do the flush on all setattr requests. If
2220 * the flush returns error, store it to report later and continue.
2222 * BB: This should be smarter. Why bother flushing pages that
2223 * will be truncated anyway? Also, should we error out here if
2224 * the flush returns error?
2226 rc = filemap_write_and_wait(inode->i_mapping);
2227 mapping_set_error(inode->i_mapping, rc);
2230 if (attrs->ia_valid & ATTR_SIZE) {
2231 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2233 goto cifs_setattr_exit;
2236 if (attrs->ia_valid & ATTR_UID)
2237 uid = attrs->ia_uid;
2239 if (attrs->ia_valid & ATTR_GID)
2240 gid = attrs->ia_gid;
2242 #ifdef CONFIG_CIFS_ACL
2243 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2244 if (uid_valid(uid) || gid_valid(gid)) {
2245 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2248 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2250 goto cifs_setattr_exit;
2254 #endif /* CONFIG_CIFS_ACL */
2255 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2256 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2258 /* skip mode change if it's just for clearing setuid/setgid */
2259 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2260 attrs->ia_valid &= ~ATTR_MODE;
2262 if (attrs->ia_valid & ATTR_MODE) {
2263 mode = attrs->ia_mode;
2265 #ifdef CONFIG_CIFS_ACL
2266 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2267 rc = id_mode_to_cifs_acl(inode, full_path, mode,
2268 INVALID_UID, INVALID_GID);
2270 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2272 goto cifs_setattr_exit;
2275 #endif /* CONFIG_CIFS_ACL */
2276 if (((mode & S_IWUGO) == 0) &&
2277 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2279 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2281 /* fix up mode if we're not using dynperm */
2282 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2283 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2284 } else if ((mode & S_IWUGO) &&
2285 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2287 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2288 /* Attributes of 0 are ignored */
2290 dosattr |= ATTR_NORMAL;
2292 /* reset local inode permissions to normal */
2293 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2294 attrs->ia_mode &= ~(S_IALLUGO);
2295 if (S_ISDIR(inode->i_mode))
2297 cifs_sb->mnt_dir_mode;
2300 cifs_sb->mnt_file_mode;
2302 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2303 /* ignore mode change - ATTR_READONLY hasn't changed */
2304 attrs->ia_valid &= ~ATTR_MODE;
2308 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2309 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2310 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2311 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2313 /* Even if error on time set, no sense failing the call if
2314 the server would set the time to a reasonable value anyway,
2315 and this check ensures that we are not being called from
2316 sys_utimes in which case we ought to fail the call back to
2317 the user when the server rejects the call */
2318 if ((rc) && (attrs->ia_valid &
2319 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2323 /* do not need local check to inode_check_ok since the server does
2326 goto cifs_setattr_exit;
2328 if ((attrs->ia_valid & ATTR_SIZE) &&
2329 attrs->ia_size != i_size_read(inode))
2330 truncate_setsize(inode, attrs->ia_size);
2332 setattr_copy(inode, attrs);
2333 mark_inode_dirty(inode);
2342 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2344 struct inode *inode = direntry->d_inode;
2345 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2346 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2348 if (pTcon->unix_ext)
2349 return cifs_setattr_unix(direntry, attrs);
2351 return cifs_setattr_nounix(direntry, attrs);
2353 /* BB: add cifs_setattr_legacy for really old servers */
2357 void cifs_delete_inode(struct inode *inode)
2359 cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2360 /* may have to add back in if and when safe distributed caching of
2361 directories added e.g. via FindNotify */