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 cFYI(1, "%s: revalidating inode %llu", __func__, cifs_i->uniqueid);
96 if (inode->i_state & I_NEW) {
97 cFYI(1, "%s: inode %llu is new", __func__, cifs_i->uniqueid);
101 /* don't bother with revalidation if we have an oplock */
102 if (cifs_i->clientCanCacheRead) {
103 cFYI(1, "%s: inode %llu is oplocked", __func__,
108 /* revalidate if mtime or size have changed */
109 if (timespec_equal(&inode->i_mtime, &fattr->cf_mtime) &&
110 cifs_i->server_eof == fattr->cf_eof) {
111 cFYI(1, "%s: inode %llu is unchanged", __func__,
116 cFYI(1, "%s: invalidating inode %llu mapping", __func__,
118 cifs_i->invalid_mapping = true;
121 /* populate an inode with info from a cifs_fattr struct */
123 cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
125 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
126 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
127 unsigned long oldtime = cifs_i->time;
129 cifs_revalidate_cache(inode, fattr);
131 inode->i_atime = fattr->cf_atime;
132 inode->i_mtime = fattr->cf_mtime;
133 inode->i_ctime = fattr->cf_ctime;
134 inode->i_rdev = fattr->cf_rdev;
135 set_nlink(inode, fattr->cf_nlink);
136 inode->i_uid = fattr->cf_uid;
137 inode->i_gid = fattr->cf_gid;
139 /* if dynperm is set, don't clobber existing mode */
140 if (inode->i_state & I_NEW ||
141 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
142 inode->i_mode = fattr->cf_mode;
144 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
146 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
149 cifs_i->time = jiffies;
151 cFYI(1, "inode 0x%p old_time=%ld new_time=%ld", inode,
152 oldtime, cifs_i->time);
154 cifs_i->delete_pending = fattr->cf_flags & CIFS_FATTR_DELETE_PENDING;
156 cifs_i->server_eof = fattr->cf_eof;
158 * Can't safely change the file size here if the client is writing to
159 * it due to potential races.
161 spin_lock(&inode->i_lock);
162 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
163 i_size_write(inode, fattr->cf_eof);
166 * i_blocks is not related to (i_size / i_blksize),
167 * but instead 512 byte (2**9) size is required for
168 * calculating num blocks.
170 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
172 spin_unlock(&inode->i_lock);
174 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
175 inode->i_flags |= S_AUTOMOUNT;
176 if (inode->i_state & I_NEW)
181 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
183 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
185 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
188 fattr->cf_uniqueid = iunique(sb, ROOT_I);
191 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
193 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
194 struct cifs_sb_info *cifs_sb)
196 memset(fattr, 0, sizeof(*fattr));
197 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
198 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
199 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
201 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
202 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
203 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
204 fattr->cf_mode = le64_to_cpu(info->Permissions);
207 * Since we set the inode type below we need to mask off
208 * to avoid strange results if bits set above.
210 fattr->cf_mode &= ~S_IFMT;
211 switch (le32_to_cpu(info->Type)) {
213 fattr->cf_mode |= S_IFREG;
214 fattr->cf_dtype = DT_REG;
217 fattr->cf_mode |= S_IFLNK;
218 fattr->cf_dtype = DT_LNK;
221 fattr->cf_mode |= S_IFDIR;
222 fattr->cf_dtype = DT_DIR;
225 fattr->cf_mode |= S_IFCHR;
226 fattr->cf_dtype = DT_CHR;
227 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
228 le64_to_cpu(info->DevMinor) & MINORMASK);
231 fattr->cf_mode |= S_IFBLK;
232 fattr->cf_dtype = DT_BLK;
233 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
234 le64_to_cpu(info->DevMinor) & MINORMASK);
237 fattr->cf_mode |= S_IFIFO;
238 fattr->cf_dtype = DT_FIFO;
241 fattr->cf_mode |= S_IFSOCK;
242 fattr->cf_dtype = DT_SOCK;
245 /* safest to call it a file if we do not know */
246 fattr->cf_mode |= S_IFREG;
247 fattr->cf_dtype = DT_REG;
248 cFYI(1, "unknown type %d", le32_to_cpu(info->Type));
252 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
253 fattr->cf_uid = cifs_sb->mnt_uid;
255 fattr->cf_uid = le64_to_cpu(info->Uid);
257 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
258 fattr->cf_gid = cifs_sb->mnt_gid;
260 fattr->cf_gid = le64_to_cpu(info->Gid);
262 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
266 * Fill a cifs_fattr struct with fake inode info.
268 * Needed to setup cifs_fattr data for the directory which is the
269 * junction to the new submount (ie to setup the fake directory
270 * which represents a DFS referral).
273 cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
275 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
277 cFYI(1, "creating fake fattr for DFS referral");
279 memset(fattr, 0, sizeof(*fattr));
280 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
281 fattr->cf_uid = cifs_sb->mnt_uid;
282 fattr->cf_gid = cifs_sb->mnt_gid;
283 fattr->cf_atime = CURRENT_TIME;
284 fattr->cf_ctime = CURRENT_TIME;
285 fattr->cf_mtime = CURRENT_TIME;
287 fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
290 int cifs_get_file_info_unix(struct file *filp)
294 FILE_UNIX_BASIC_INFO find_data;
295 struct cifs_fattr fattr;
296 struct inode *inode = filp->f_path.dentry->d_inode;
297 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
298 struct cifsFileInfo *cfile = filp->private_data;
299 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
302 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->netfid, &find_data);
304 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
305 } else if (rc == -EREMOTE) {
306 cifs_create_dfs_fattr(&fattr, inode->i_sb);
310 cifs_fattr_to_inode(inode, &fattr);
315 int cifs_get_inode_info_unix(struct inode **pinode,
316 const unsigned char *full_path,
317 struct super_block *sb, int xid)
320 FILE_UNIX_BASIC_INFO find_data;
321 struct cifs_fattr fattr;
322 struct cifs_tcon *tcon;
323 struct tcon_link *tlink;
324 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
326 cFYI(1, "Getting info on %s", full_path);
328 tlink = cifs_sb_tlink(cifs_sb);
330 return PTR_ERR(tlink);
331 tcon = tlink_tcon(tlink);
333 /* could have done a find first instead but this returns more info */
334 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
335 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
336 CIFS_MOUNT_MAP_SPECIAL_CHR);
337 cifs_put_tlink(tlink);
340 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
341 } else if (rc == -EREMOTE) {
342 cifs_create_dfs_fattr(&fattr, sb);
348 /* check for Minshall+French symlinks */
349 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
350 int tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
352 cFYI(1, "CIFSCheckMFSymlink: %d", tmprc);
355 if (*pinode == NULL) {
357 cifs_fill_uniqueid(sb, &fattr);
358 *pinode = cifs_iget(sb, &fattr);
362 /* we already have inode, update it */
363 cifs_fattr_to_inode(*pinode, &fattr);
370 cifs_sfu_type(struct cifs_fattr *fattr, const unsigned char *path,
371 struct cifs_sb_info *cifs_sb, int xid)
376 struct tcon_link *tlink;
377 struct cifs_tcon *tcon;
378 struct cifs_io_parms io_parms;
380 unsigned int bytes_read;
385 fattr->cf_mode &= ~S_IFMT;
387 if (fattr->cf_eof == 0) {
388 fattr->cf_mode |= S_IFIFO;
389 fattr->cf_dtype = DT_FIFO;
391 } else if (fattr->cf_eof < 8) {
392 fattr->cf_mode |= S_IFREG;
393 fattr->cf_dtype = DT_REG;
394 return -EINVAL; /* EOPNOTSUPP? */
397 tlink = cifs_sb_tlink(cifs_sb);
399 return PTR_ERR(tlink);
400 tcon = tlink_tcon(tlink);
402 rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, GENERIC_READ,
403 CREATE_NOT_DIR, &netfid, &oplock, NULL,
405 cifs_sb->mnt_cifs_flags &
406 CIFS_MOUNT_MAP_SPECIAL_CHR);
408 int buf_type = CIFS_NO_BUFFER;
410 io_parms.netfid = netfid;
411 io_parms.pid = current->tgid;
412 io_parms.tcon = tcon;
414 io_parms.length = 24;
415 rc = CIFSSMBRead(xid, &io_parms, &bytes_read, &pbuf,
417 if ((rc == 0) && (bytes_read >= 8)) {
418 if (memcmp("IntxBLK", pbuf, 8) == 0) {
419 cFYI(1, "Block device");
420 fattr->cf_mode |= S_IFBLK;
421 fattr->cf_dtype = DT_BLK;
422 if (bytes_read == 24) {
423 /* we have enough to decode dev num */
424 __u64 mjr; /* major */
425 __u64 mnr; /* minor */
426 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
427 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
428 fattr->cf_rdev = MKDEV(mjr, mnr);
430 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
431 cFYI(1, "Char device");
432 fattr->cf_mode |= S_IFCHR;
433 fattr->cf_dtype = DT_CHR;
434 if (bytes_read == 24) {
435 /* we have enough to decode dev num */
436 __u64 mjr; /* major */
437 __u64 mnr; /* minor */
438 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
439 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
440 fattr->cf_rdev = MKDEV(mjr, mnr);
442 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
444 fattr->cf_mode |= S_IFLNK;
445 fattr->cf_dtype = DT_LNK;
447 fattr->cf_mode |= S_IFREG; /* file? */
448 fattr->cf_dtype = DT_REG;
452 fattr->cf_mode |= S_IFREG; /* then it is a file */
453 fattr->cf_dtype = DT_REG;
454 rc = -EOPNOTSUPP; /* or some unknown SFU type */
456 CIFSSMBClose(xid, tcon, netfid);
458 cifs_put_tlink(tlink);
462 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
465 * Fetch mode bits as provided by SFU.
467 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
469 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
470 struct cifs_sb_info *cifs_sb, int xid)
472 #ifdef CONFIG_CIFS_XATTR
476 struct tcon_link *tlink;
477 struct cifs_tcon *tcon;
479 tlink = cifs_sb_tlink(cifs_sb);
481 return PTR_ERR(tlink);
482 tcon = tlink_tcon(tlink);
484 rc = CIFSSMBQAllEAs(xid, tcon, path, "SETFILEBITS",
485 ea_value, 4 /* size of buf */, cifs_sb->local_nls,
486 cifs_sb->mnt_cifs_flags &
487 CIFS_MOUNT_MAP_SPECIAL_CHR);
488 cifs_put_tlink(tlink);
492 mode = le32_to_cpu(*((__le32 *)ea_value));
493 fattr->cf_mode &= ~SFBITS_MASK;
494 cFYI(1, "special bits 0%o org mode 0%o", mode,
496 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
497 cFYI(1, "special mode bits 0%o", mode);
506 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
508 cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
509 struct cifs_sb_info *cifs_sb, bool adjust_tz)
511 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
513 memset(fattr, 0, sizeof(*fattr));
514 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
515 if (info->DeletePending)
516 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
518 if (info->LastAccessTime)
519 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
521 fattr->cf_atime = CURRENT_TIME;
523 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
524 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
527 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
528 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
531 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
532 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
533 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
535 if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
536 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
537 fattr->cf_dtype = DT_DIR;
539 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
540 fattr->cf_dtype = DT_REG;
542 /* clear write bits if ATTR_READONLY is set */
543 if (fattr->cf_cifsattrs & ATTR_READONLY)
544 fattr->cf_mode &= ~(S_IWUGO);
547 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
549 fattr->cf_uid = cifs_sb->mnt_uid;
550 fattr->cf_gid = cifs_sb->mnt_gid;
553 int cifs_get_file_info(struct file *filp)
557 FILE_ALL_INFO find_data;
558 struct cifs_fattr fattr;
559 struct inode *inode = filp->f_path.dentry->d_inode;
560 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
561 struct cifsFileInfo *cfile = filp->private_data;
562 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
565 rc = CIFSSMBQFileInfo(xid, tcon, cfile->netfid, &find_data);
568 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false);
571 cifs_create_dfs_fattr(&fattr, inode->i_sb);
577 * FIXME: legacy server -- fall back to path-based call?
578 * for now, just skip revalidating and mark inode for
582 CIFS_I(inode)->time = 0;
588 * don't bother with SFU junk here -- just mark inode as needing
591 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
592 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
593 cifs_fattr_to_inode(inode, &fattr);
599 int cifs_get_inode_info(struct inode **pinode,
600 const unsigned char *full_path, FILE_ALL_INFO *pfindData,
601 struct super_block *sb, int xid, const __u16 *pfid)
604 struct cifs_tcon *pTcon;
605 struct tcon_link *tlink;
606 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
608 bool adjustTZ = false;
609 struct cifs_fattr fattr;
611 tlink = cifs_sb_tlink(cifs_sb);
613 return PTR_ERR(tlink);
614 pTcon = tlink_tcon(tlink);
616 cFYI(1, "Getting info on %s", full_path);
618 if ((pfindData == NULL) && (*pinode != NULL)) {
619 if (CIFS_I(*pinode)->clientCanCacheRead) {
620 cFYI(1, "No need to revalidate cached inode sizes");
625 /* if file info not passed in then get it from server */
626 if (pfindData == NULL) {
627 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
632 pfindData = (FILE_ALL_INFO *)buf;
634 /* could do find first instead but this returns more info */
635 rc = CIFSSMBQPathInfo(xid, pTcon, full_path, pfindData,
637 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
638 CIFS_MOUNT_MAP_SPECIAL_CHR);
639 /* BB optimize code so we do not make the above call
640 when server claims no NT SMB support and the above call
641 failed at least once - set flag in tcon or mount */
642 if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
643 rc = SMBQueryInformation(xid, pTcon, full_path,
644 pfindData, cifs_sb->local_nls,
645 cifs_sb->mnt_cifs_flags &
646 CIFS_MOUNT_MAP_SPECIAL_CHR);
652 cifs_all_info_to_fattr(&fattr, (FILE_ALL_INFO *) pfindData,
654 } else if (rc == -EREMOTE) {
655 cifs_create_dfs_fattr(&fattr, sb);
662 * If an inode wasn't passed in, then get the inode number
664 * Is an i_ino of zero legal? Can we use that to check if the server
665 * supports returning inode numbers? Are there other sanity checks we
666 * can use to ensure that the server is really filling in that field?
668 * We can not use the IndexNumber field by default from Windows or
669 * Samba (in ALL_INFO buf) but we can request it explicitly. The SNIA
670 * CIFS spec claims that this value is unique within the scope of a
671 * share, and the windows docs hint that it's actually unique
674 * There may be higher info levels that work but are there Windows
675 * server or network appliances for which IndexNumber field is not
678 if (*pinode == NULL) {
679 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
682 rc1 = CIFSGetSrvInodeNumber(xid, pTcon,
683 full_path, &fattr.cf_uniqueid,
685 cifs_sb->mnt_cifs_flags &
686 CIFS_MOUNT_MAP_SPECIAL_CHR);
687 if (rc1 || !fattr.cf_uniqueid) {
688 cFYI(1, "GetSrvInodeNum rc %d", rc1);
689 fattr.cf_uniqueid = iunique(sb, ROOT_I);
690 cifs_autodisable_serverino(cifs_sb);
693 fattr.cf_uniqueid = iunique(sb, ROOT_I);
696 fattr.cf_uniqueid = CIFS_I(*pinode)->uniqueid;
699 /* query for SFU type info if supported and needed */
700 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
701 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
702 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
704 cFYI(1, "cifs_sfu_type failed: %d", tmprc);
707 #ifdef CONFIG_CIFS_ACL
708 /* fill in 0777 bits from ACL */
709 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
710 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *pinode, full_path,
713 cFYI(1, "%s: Getting ACL failed with error: %d",
718 #endif /* CONFIG_CIFS_ACL */
720 /* fill in remaining high mode bits e.g. SUID, VTX */
721 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
722 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
724 /* check for Minshall+French symlinks */
725 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
726 tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
728 cFYI(1, "CIFSCheckMFSymlink: %d", tmprc);
732 *pinode = cifs_iget(sb, &fattr);
736 cifs_fattr_to_inode(*pinode, &fattr);
741 cifs_put_tlink(tlink);
745 static const struct inode_operations cifs_ipc_inode_ops = {
746 .lookup = cifs_lookup,
749 char *cifs_build_path_to_root(struct smb_vol *vol, struct cifs_sb_info *cifs_sb,
750 struct cifs_tcon *tcon)
752 int pplen = vol->prepath ? strlen(vol->prepath) : 0;
754 char *full_path = NULL;
756 /* if no prefix path, simply set path to the root of share to "" */
758 full_path = kmalloc(1, GFP_KERNEL);
764 if (tcon->Flags & SMB_SHARE_IS_IN_DFS)
765 dfsplen = strnlen(tcon->treeName, MAX_TREE_SIZE + 1);
769 full_path = kmalloc(dfsplen + pplen + 1, GFP_KERNEL);
770 if (full_path == NULL)
774 strncpy(full_path, tcon->treeName, dfsplen);
775 strncpy(full_path + dfsplen, vol->prepath, pplen);
776 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
777 full_path[dfsplen + pplen] = 0; /* add trailing null */
782 cifs_find_inode(struct inode *inode, void *opaque)
784 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
786 /* don't match inode with different uniqueid */
787 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
790 /* use createtime like an i_generation field */
791 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
794 /* don't match inode of different type */
795 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
798 /* if it's not a directory or has no dentries, then flag it */
799 if (S_ISDIR(inode->i_mode) && !list_empty(&inode->i_dentry))
800 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
806 cifs_init_inode(struct inode *inode, void *opaque)
808 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
810 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
811 CIFS_I(inode)->createtime = fattr->cf_createtime;
816 * walk dentry list for an inode and report whether it has aliases that
817 * are hashed. We use this to determine if a directory inode can actually
821 inode_has_hashed_dentries(struct inode *inode)
823 struct dentry *dentry;
825 spin_lock(&inode->i_lock);
826 list_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
827 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
828 spin_unlock(&inode->i_lock);
832 spin_unlock(&inode->i_lock);
836 /* Given fattrs, get a corresponding inode */
838 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
844 cFYI(1, "looking for uniqueid=%llu", fattr->cf_uniqueid);
846 /* hash down to 32-bits on 32-bit arch */
847 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
849 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
851 /* was there a potentially problematic inode collision? */
852 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
853 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
855 if (inode_has_hashed_dentries(inode)) {
856 cifs_autodisable_serverino(CIFS_SB(sb));
858 fattr->cf_uniqueid = iunique(sb, ROOT_I);
859 goto retry_iget5_locked;
863 cifs_fattr_to_inode(inode, fattr);
864 if (sb->s_flags & MS_NOATIME)
865 inode->i_flags |= S_NOATIME | S_NOCMTIME;
866 if (inode->i_state & I_NEW) {
868 if (S_ISREG(inode->i_mode))
869 inode->i_data.backing_dev_info = sb->s_bdi;
870 #ifdef CONFIG_CIFS_FSCACHE
871 /* initialize per-inode cache cookie pointer */
872 CIFS_I(inode)->fscache = NULL;
874 unlock_new_inode(inode);
881 /* gets root inode */
882 struct inode *cifs_root_iget(struct super_block *sb)
885 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
886 struct inode *inode = NULL;
888 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
892 rc = cifs_get_inode_info_unix(&inode, "", sb, xid);
894 rc = cifs_get_inode_info(&inode, "", NULL, sb, xid, NULL);
901 #ifdef CONFIG_CIFS_FSCACHE
902 /* populate tcon->resource_id */
903 tcon->resource_id = CIFS_I(inode)->uniqueid;
906 if (rc && tcon->ipc) {
907 cFYI(1, "ipc connection - fake read inode");
908 inode->i_mode |= S_IFDIR;
910 inode->i_op = &cifs_ipc_inode_ops;
911 inode->i_fop = &simple_dir_operations;
912 inode->i_uid = cifs_sb->mnt_uid;
913 inode->i_gid = cifs_sb->mnt_gid;
920 /* can not call macro FreeXid here since in a void func
921 * TODO: This is no longer true
928 cifs_set_file_info(struct inode *inode, struct iattr *attrs, int xid,
929 char *full_path, __u32 dosattr)
935 bool set_time = false;
936 struct cifsFileInfo *open_file;
937 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
938 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
939 struct tcon_link *tlink = NULL;
940 struct cifs_tcon *pTcon;
941 FILE_BASIC_INFO info_buf;
946 if (attrs->ia_valid & ATTR_ATIME) {
948 info_buf.LastAccessTime =
949 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
951 info_buf.LastAccessTime = 0;
953 if (attrs->ia_valid & ATTR_MTIME) {
955 info_buf.LastWriteTime =
956 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
958 info_buf.LastWriteTime = 0;
961 * Samba throws this field away, but windows may actually use it.
962 * Do not set ctime unless other time stamps are changed explicitly
963 * (i.e. by utimes()) since we would then have a mix of client and
966 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
967 cFYI(1, "CIFS - CTIME changed");
968 info_buf.ChangeTime =
969 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
971 info_buf.ChangeTime = 0;
973 info_buf.CreationTime = 0; /* don't change */
974 info_buf.Attributes = cpu_to_le32(dosattr);
977 * If the file is already open for write, just use that fileid
979 open_file = find_writable_file(cifsInode, true);
981 netfid = open_file->netfid;
982 netpid = open_file->pid;
983 pTcon = tlink_tcon(open_file->tlink);
984 goto set_via_filehandle;
987 tlink = cifs_sb_tlink(cifs_sb);
993 pTcon = tlink_tcon(tlink);
996 * NT4 apparently returns success on this call, but it doesn't
999 if (!(pTcon->ses->flags & CIFS_SES_NT4)) {
1000 rc = CIFSSMBSetPathInfo(xid, pTcon, full_path,
1001 &info_buf, cifs_sb->local_nls,
1002 cifs_sb->mnt_cifs_flags &
1003 CIFS_MOUNT_MAP_SPECIAL_CHR);
1005 cifsInode->cifsAttrs = dosattr;
1007 } else if (rc != -EOPNOTSUPP && rc != -EINVAL)
1011 cFYI(1, "calling SetFileInfo since SetPathInfo for "
1012 "times not supported by this server");
1013 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
1014 SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
1015 CREATE_NOT_DIR, &netfid, &oplock,
1016 NULL, cifs_sb->local_nls,
1017 cifs_sb->mnt_cifs_flags &
1018 CIFS_MOUNT_MAP_SPECIAL_CHR);
1026 netpid = current->tgid;
1029 rc = CIFSSMBSetFileInfo(xid, pTcon, &info_buf, netfid, netpid);
1031 cifsInode->cifsAttrs = dosattr;
1033 if (open_file == NULL)
1034 CIFSSMBClose(xid, pTcon, netfid);
1036 cifsFileInfo_put(open_file);
1039 cifs_put_tlink(tlink);
1044 * open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1045 * and rename it to a random name that hopefully won't conflict with
1049 cifs_rename_pending_delete(char *full_path, struct dentry *dentry, int xid)
1054 struct inode *inode = dentry->d_inode;
1055 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1056 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1057 struct tcon_link *tlink;
1058 struct cifs_tcon *tcon;
1059 __u32 dosattr, origattr;
1060 FILE_BASIC_INFO *info_buf = NULL;
1062 tlink = cifs_sb_tlink(cifs_sb);
1064 return PTR_ERR(tlink);
1065 tcon = tlink_tcon(tlink);
1067 rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
1068 DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
1069 &netfid, &oplock, NULL, cifs_sb->local_nls,
1070 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1074 origattr = cifsInode->cifsAttrs;
1076 origattr |= ATTR_NORMAL;
1078 dosattr = origattr & ~ATTR_READONLY;
1080 dosattr |= ATTR_NORMAL;
1081 dosattr |= ATTR_HIDDEN;
1083 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1084 if (dosattr != origattr) {
1085 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1086 if (info_buf == NULL) {
1090 info_buf->Attributes = cpu_to_le32(dosattr);
1091 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1093 /* although we would like to mark the file hidden
1094 if that fails we will still try to rename it */
1096 cifsInode->cifsAttrs = dosattr;
1098 dosattr = origattr; /* since not able to change them */
1101 /* rename the file */
1102 rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
1103 cifs_sb->mnt_cifs_flags &
1104 CIFS_MOUNT_MAP_SPECIAL_CHR);
1110 /* try to set DELETE_ON_CLOSE */
1111 if (!cifsInode->delete_pending) {
1112 rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
1115 * some samba versions return -ENOENT when we try to set the
1116 * file disposition here. Likely a samba bug, but work around
1117 * it for now. This means that some cifsXXX files may hang
1118 * around after they shouldn't.
1120 * BB: remove this hack after more servers have the fix
1128 cifsInode->delete_pending = true;
1132 CIFSSMBClose(xid, tcon, netfid);
1135 cifs_put_tlink(tlink);
1139 * reset everything back to the original state. Don't bother
1140 * dealing with errors here since we can't do anything about
1144 CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
1145 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1146 CIFS_MOUNT_MAP_SPECIAL_CHR);
1148 if (dosattr != origattr) {
1149 info_buf->Attributes = cpu_to_le32(origattr);
1150 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1152 cifsInode->cifsAttrs = origattr;
1160 * If dentry->d_inode is null (usually meaning the cached dentry
1161 * is a negative dentry) then we would attempt a standard SMB delete, but
1162 * if that fails we can not attempt the fall back mechanisms on EACCESS
1163 * but will return the EACCESS to the caller. Note that the VFS does not call
1164 * unlink on negative dentries currently.
1166 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1170 char *full_path = NULL;
1171 struct inode *inode = dentry->d_inode;
1172 struct cifsInodeInfo *cifs_inode;
1173 struct super_block *sb = dir->i_sb;
1174 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1175 struct tcon_link *tlink;
1176 struct cifs_tcon *tcon;
1177 struct iattr *attrs = NULL;
1178 __u32 dosattr = 0, origattr = 0;
1180 cFYI(1, "cifs_unlink, dir=0x%p, dentry=0x%p", dir, dentry);
1182 tlink = cifs_sb_tlink(cifs_sb);
1184 return PTR_ERR(tlink);
1185 tcon = tlink_tcon(tlink);
1189 /* Unlink can be called from rename so we can not take the
1190 * sb->s_vfs_rename_mutex here */
1191 full_path = build_path_from_dentry(dentry);
1192 if (full_path == NULL) {
1197 if ((tcon->ses->capabilities & CAP_UNIX) &&
1198 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1199 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1200 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1201 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1202 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1203 cFYI(1, "posix del rc %d", rc);
1204 if ((rc == 0) || (rc == -ENOENT))
1205 goto psx_del_no_retry;
1209 rc = CIFSSMBDelFile(xid, tcon, full_path, cifs_sb->local_nls,
1210 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1216 } else if (rc == -ENOENT) {
1218 } else if (rc == -ETXTBSY) {
1219 rc = cifs_rename_pending_delete(full_path, dentry, xid);
1222 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1223 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1224 if (attrs == NULL) {
1229 /* try to reset dos attributes */
1230 cifs_inode = CIFS_I(inode);
1231 origattr = cifs_inode->cifsAttrs;
1233 origattr |= ATTR_NORMAL;
1234 dosattr = origattr & ~ATTR_READONLY;
1236 dosattr |= ATTR_NORMAL;
1237 dosattr |= ATTR_HIDDEN;
1239 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1243 goto retry_std_delete;
1246 /* undo the setattr if we errored out and it's needed */
1247 if (rc != 0 && dosattr != 0)
1248 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1252 cifs_inode = CIFS_I(inode);
1253 cifs_inode->time = 0; /* will force revalidate to get info
1255 inode->i_ctime = current_fs_time(sb);
1257 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1258 cifs_inode = CIFS_I(dir);
1259 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1264 cifs_put_tlink(tlink);
1268 int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
1272 struct cifs_sb_info *cifs_sb;
1273 struct tcon_link *tlink;
1274 struct cifs_tcon *pTcon;
1275 char *full_path = NULL;
1276 struct inode *newinode = NULL;
1277 struct cifs_fattr fattr;
1279 cFYI(1, "In cifs_mkdir, mode = 0x%x inode = 0x%p", mode, inode);
1281 cifs_sb = CIFS_SB(inode->i_sb);
1282 tlink = cifs_sb_tlink(cifs_sb);
1284 return PTR_ERR(tlink);
1285 pTcon = tlink_tcon(tlink);
1289 full_path = build_path_from_dentry(direntry);
1290 if (full_path == NULL) {
1295 if ((pTcon->ses->capabilities & CAP_UNIX) &&
1296 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1297 le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
1299 FILE_UNIX_BASIC_INFO *pInfo =
1300 kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1301 if (pInfo == NULL) {
1306 mode &= ~current_umask();
1307 rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
1308 mode, NULL /* netfid */, pInfo, &oplock,
1309 full_path, cifs_sb->local_nls,
1310 cifs_sb->mnt_cifs_flags &
1311 CIFS_MOUNT_MAP_SPECIAL_CHR);
1312 if (rc == -EOPNOTSUPP) {
1314 goto mkdir_retry_old;
1316 cFYI(1, "posix mkdir returned 0x%x", rc);
1319 if (pInfo->Type == cpu_to_le32(-1)) {
1320 /* no return info, go query for it */
1322 goto mkdir_get_info;
1324 /*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
1328 cifs_unix_basic_to_fattr(&fattr, pInfo, cifs_sb);
1329 cifs_fill_uniqueid(inode->i_sb, &fattr);
1330 newinode = cifs_iget(inode->i_sb, &fattr);
1333 goto mkdir_get_info;
1336 d_instantiate(direntry, newinode);
1338 #ifdef CONFIG_CIFS_DEBUG2
1339 cFYI(1, "instantiated dentry %p %s to inode %p",
1340 direntry, direntry->d_name.name, newinode);
1342 if (newinode->i_nlink != 2)
1343 cFYI(1, "unexpected number of links %d",
1351 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1352 rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
1353 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1355 cFYI(1, "cifs_mkdir returned 0x%x", rc);
1360 if (pTcon->unix_ext)
1361 rc = cifs_get_inode_info_unix(&newinode, full_path,
1364 rc = cifs_get_inode_info(&newinode, full_path, NULL,
1365 inode->i_sb, xid, NULL);
1367 d_instantiate(direntry, newinode);
1368 /* setting nlink not necessary except in cases where we
1369 * failed to get it from the server or was set bogus */
1370 if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
1371 set_nlink(direntry->d_inode, 2);
1373 mode &= ~current_umask();
1374 /* must turn on setgid bit if parent dir has it */
1375 if (inode->i_mode & S_ISGID)
1378 if (pTcon->unix_ext) {
1379 struct cifs_unix_set_info_args args = {
1381 .ctime = NO_CHANGE_64,
1382 .atime = NO_CHANGE_64,
1383 .mtime = NO_CHANGE_64,
1386 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1387 args.uid = (__u64)current_fsuid();
1388 if (inode->i_mode & S_ISGID)
1389 args.gid = (__u64)inode->i_gid;
1391 args.gid = (__u64)current_fsgid();
1393 args.uid = NO_CHANGE_64;
1394 args.gid = NO_CHANGE_64;
1396 CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
1398 cifs_sb->mnt_cifs_flags &
1399 CIFS_MOUNT_MAP_SPECIAL_CHR);
1401 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1402 (mode & S_IWUGO) == 0) {
1403 FILE_BASIC_INFO pInfo;
1404 struct cifsInodeInfo *cifsInode;
1407 memset(&pInfo, 0, sizeof(pInfo));
1408 cifsInode = CIFS_I(newinode);
1409 dosattrs = cifsInode->cifsAttrs|ATTR_READONLY;
1410 pInfo.Attributes = cpu_to_le32(dosattrs);
1411 tmprc = CIFSSMBSetPathInfo(xid, pTcon,
1414 cifs_sb->mnt_cifs_flags &
1415 CIFS_MOUNT_MAP_SPECIAL_CHR);
1417 cifsInode->cifsAttrs = dosattrs;
1419 if (direntry->d_inode) {
1420 if (cifs_sb->mnt_cifs_flags &
1422 direntry->d_inode->i_mode =
1425 if (cifs_sb->mnt_cifs_flags &
1426 CIFS_MOUNT_SET_UID) {
1427 direntry->d_inode->i_uid =
1429 if (inode->i_mode & S_ISGID)
1430 direntry->d_inode->i_gid =
1433 direntry->d_inode->i_gid =
1442 cifs_put_tlink(tlink);
1446 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1450 struct cifs_sb_info *cifs_sb;
1451 struct tcon_link *tlink;
1452 struct cifs_tcon *pTcon;
1453 char *full_path = NULL;
1454 struct cifsInodeInfo *cifsInode;
1456 cFYI(1, "cifs_rmdir, inode = 0x%p", inode);
1460 full_path = build_path_from_dentry(direntry);
1461 if (full_path == NULL) {
1466 cifs_sb = CIFS_SB(inode->i_sb);
1467 tlink = cifs_sb_tlink(cifs_sb);
1468 if (IS_ERR(tlink)) {
1469 rc = PTR_ERR(tlink);
1472 pTcon = tlink_tcon(tlink);
1474 rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
1475 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1476 cifs_put_tlink(tlink);
1480 spin_lock(&direntry->d_inode->i_lock);
1481 i_size_write(direntry->d_inode, 0);
1482 clear_nlink(direntry->d_inode);
1483 spin_unlock(&direntry->d_inode->i_lock);
1486 cifsInode = CIFS_I(direntry->d_inode);
1487 cifsInode->time = 0; /* force revalidate to go get info when
1490 cifsInode = CIFS_I(inode);
1491 cifsInode->time = 0; /* force revalidate to get parent dir info
1492 since cached search results now invalid */
1494 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1495 current_fs_time(inode->i_sb);
1504 cifs_do_rename(int xid, struct dentry *from_dentry, const char *fromPath,
1505 struct dentry *to_dentry, const char *toPath)
1507 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1508 struct tcon_link *tlink;
1509 struct cifs_tcon *pTcon;
1513 tlink = cifs_sb_tlink(cifs_sb);
1515 return PTR_ERR(tlink);
1516 pTcon = tlink_tcon(tlink);
1518 /* try path-based rename first */
1519 rc = CIFSSMBRename(xid, pTcon, fromPath, toPath, cifs_sb->local_nls,
1520 cifs_sb->mnt_cifs_flags &
1521 CIFS_MOUNT_MAP_SPECIAL_CHR);
1524 * don't bother with rename by filehandle unless file is busy and
1525 * source Note that cross directory moves do not work with
1526 * rename by filehandle to various Windows servers.
1528 if (rc == 0 || rc != -ETXTBSY)
1529 goto do_rename_exit;
1531 /* open-file renames don't work across directories */
1532 if (to_dentry->d_parent != from_dentry->d_parent)
1533 goto do_rename_exit;
1535 /* open the file to be renamed -- we need DELETE perms */
1536 rc = CIFSSMBOpen(xid, pTcon, fromPath, FILE_OPEN, DELETE,
1537 CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1538 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1539 CIFS_MOUNT_MAP_SPECIAL_CHR);
1542 rc = CIFSSMBRenameOpenFile(xid, pTcon, srcfid,
1543 (const char *) to_dentry->d_name.name,
1544 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1545 CIFS_MOUNT_MAP_SPECIAL_CHR);
1547 CIFSSMBClose(xid, pTcon, srcfid);
1550 cifs_put_tlink(tlink);
1554 int cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1555 struct inode *target_dir, struct dentry *target_dentry)
1557 char *fromName = NULL;
1558 char *toName = NULL;
1559 struct cifs_sb_info *cifs_sb;
1560 struct tcon_link *tlink;
1561 struct cifs_tcon *tcon;
1562 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1563 FILE_UNIX_BASIC_INFO *info_buf_target;
1566 cifs_sb = CIFS_SB(source_dir->i_sb);
1567 tlink = cifs_sb_tlink(cifs_sb);
1569 return PTR_ERR(tlink);
1570 tcon = tlink_tcon(tlink);
1575 * we already have the rename sem so we do not need to
1576 * grab it again here to protect the path integrity
1578 fromName = build_path_from_dentry(source_dentry);
1579 if (fromName == NULL) {
1581 goto cifs_rename_exit;
1584 toName = build_path_from_dentry(target_dentry);
1585 if (toName == NULL) {
1587 goto cifs_rename_exit;
1590 rc = cifs_do_rename(xid, source_dentry, fromName,
1591 target_dentry, toName);
1593 if (rc == -EEXIST && tcon->unix_ext) {
1595 * Are src and dst hardlinks of same inode? We can
1596 * only tell with unix extensions enabled
1599 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1601 if (info_buf_source == NULL) {
1603 goto cifs_rename_exit;
1606 info_buf_target = info_buf_source + 1;
1607 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, fromName,
1610 cifs_sb->mnt_cifs_flags &
1611 CIFS_MOUNT_MAP_SPECIAL_CHR);
1615 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, toName,
1618 cifs_sb->mnt_cifs_flags &
1619 CIFS_MOUNT_MAP_SPECIAL_CHR);
1621 if (tmprc == 0 && (info_buf_source->UniqueId ==
1622 info_buf_target->UniqueId)) {
1623 /* same file, POSIX says that this is a noop */
1625 goto cifs_rename_exit;
1627 } /* else ... BB we could add the same check for Windows by
1628 checking the UniqueId via FILE_INTERNAL_INFO */
1631 /* Try unlinking the target dentry if it's not negative */
1632 if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
1633 tmprc = cifs_unlink(target_dir, target_dentry);
1635 goto cifs_rename_exit;
1637 rc = cifs_do_rename(xid, source_dentry, fromName,
1638 target_dentry, toName);
1641 /* force revalidate to go get info when needed */
1642 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
1644 source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
1645 target_dir->i_mtime = current_fs_time(source_dir->i_sb);
1648 kfree(info_buf_source);
1652 cifs_put_tlink(tlink);
1657 cifs_inode_needs_reval(struct inode *inode)
1659 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1660 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1662 if (cifs_i->clientCanCacheRead)
1665 if (!lookupCacheEnabled)
1668 if (cifs_i->time == 0)
1671 if (!time_in_range(jiffies, cifs_i->time,
1672 cifs_i->time + cifs_sb->actimeo))
1675 /* hardlinked files w/ noserverino get "special" treatment */
1676 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1677 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1684 * Zap the cache. Called when invalid_mapping flag is set.
1687 cifs_invalidate_mapping(struct inode *inode)
1690 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1692 cifs_i->invalid_mapping = false;
1694 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1695 rc = invalidate_inode_pages2(inode->i_mapping);
1697 cERROR(1, "%s: could not invalidate inode %p", __func__,
1699 cifs_i->invalid_mapping = true;
1703 cifs_fscache_reset_inode_cookie(inode);
1707 int cifs_revalidate_file_attr(struct file *filp)
1710 struct inode *inode = filp->f_path.dentry->d_inode;
1711 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1713 if (!cifs_inode_needs_reval(inode))
1716 if (tlink_tcon(cfile->tlink)->unix_ext)
1717 rc = cifs_get_file_info_unix(filp);
1719 rc = cifs_get_file_info(filp);
1724 int cifs_revalidate_dentry_attr(struct dentry *dentry)
1728 struct inode *inode = dentry->d_inode;
1729 struct super_block *sb = dentry->d_sb;
1730 char *full_path = NULL;
1735 if (!cifs_inode_needs_reval(inode))
1740 /* can not safely grab the rename sem here if rename calls revalidate
1741 since that would deadlock */
1742 full_path = build_path_from_dentry(dentry);
1743 if (full_path == NULL) {
1748 cFYI(1, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time "
1749 "%ld jiffies %ld", full_path, inode, inode->i_count.counter,
1750 dentry, dentry->d_time, jiffies);
1752 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1753 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1755 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1764 int cifs_revalidate_file(struct file *filp)
1767 struct inode *inode = filp->f_path.dentry->d_inode;
1769 rc = cifs_revalidate_file_attr(filp);
1773 if (CIFS_I(inode)->invalid_mapping)
1774 rc = cifs_invalidate_mapping(inode);
1778 /* revalidate a dentry's inode attributes */
1779 int cifs_revalidate_dentry(struct dentry *dentry)
1782 struct inode *inode = dentry->d_inode;
1784 rc = cifs_revalidate_dentry_attr(dentry);
1788 if (CIFS_I(inode)->invalid_mapping)
1789 rc = cifs_invalidate_mapping(inode);
1793 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1796 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1797 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1798 struct inode *inode = dentry->d_inode;
1802 * We need to be sure that all dirty pages are written and the server
1803 * has actual ctime, mtime and file length.
1805 if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping &&
1806 inode->i_mapping->nrpages != 0) {
1807 rc = filemap_fdatawait(inode->i_mapping);
1809 mapping_set_error(inode->i_mapping, rc);
1814 rc = cifs_revalidate_dentry_attr(dentry);
1818 generic_fillattr(inode, stat);
1819 stat->blksize = CIFS_MAX_MSGSIZE;
1820 stat->ino = CIFS_I(inode)->uniqueid;
1823 * If on a multiuser mount without unix extensions, and the admin hasn't
1824 * overridden them, set the ownership to the fsuid/fsgid of the current
1827 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
1829 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1830 stat->uid = current_fsuid();
1831 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1832 stat->gid = current_fsgid();
1837 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1839 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1840 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1844 page = grab_cache_page(mapping, index);
1848 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1850 page_cache_release(page);
1854 static void cifs_setsize(struct inode *inode, loff_t offset)
1858 spin_lock(&inode->i_lock);
1859 oldsize = inode->i_size;
1860 i_size_write(inode, offset);
1861 spin_unlock(&inode->i_lock);
1863 truncate_pagecache(inode, oldsize, offset);
1867 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1868 int xid, char *full_path)
1871 struct cifsFileInfo *open_file;
1872 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1873 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1874 struct tcon_link *tlink = NULL;
1875 struct cifs_tcon *pTcon = NULL;
1878 * To avoid spurious oplock breaks from server, in the case of
1879 * inodes that we already have open, avoid doing path based
1880 * setting of file size if we can do it by handle.
1881 * This keeps our caching token (oplock) and avoids timeouts
1882 * when the local oplock break takes longer to flush
1883 * writebehind data than the SMB timeout for the SetPathInfo
1884 * request would allow
1886 open_file = find_writable_file(cifsInode, true);
1888 __u16 nfid = open_file->netfid;
1889 __u32 npid = open_file->pid;
1890 pTcon = tlink_tcon(open_file->tlink);
1891 rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size, nfid,
1893 cifsFileInfo_put(open_file);
1894 cFYI(1, "SetFSize for attrs rc = %d", rc);
1899 if (pTcon == NULL) {
1900 tlink = cifs_sb_tlink(cifs_sb);
1902 return PTR_ERR(tlink);
1903 pTcon = tlink_tcon(tlink);
1906 /* Set file size by pathname rather than by handle
1907 either because no valid, writeable file handle for
1908 it was found or because there was an error setting
1910 rc = CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size,
1911 false, cifs_sb->local_nls,
1912 cifs_sb->mnt_cifs_flags &
1913 CIFS_MOUNT_MAP_SPECIAL_CHR);
1914 cFYI(1, "SetEOF by path (setattrs) rc = %d", rc);
1917 cifs_put_tlink(tlink);
1921 cifsInode->server_eof = attrs->ia_size;
1922 cifs_setsize(inode, attrs->ia_size);
1923 cifs_truncate_page(inode->i_mapping, inode->i_size);
1930 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1934 char *full_path = NULL;
1935 struct inode *inode = direntry->d_inode;
1936 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1937 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1938 struct tcon_link *tlink;
1939 struct cifs_tcon *pTcon;
1940 struct cifs_unix_set_info_args *args = NULL;
1941 struct cifsFileInfo *open_file;
1943 cFYI(1, "setattr_unix on file %s attrs->ia_valid=0x%x",
1944 direntry->d_name.name, attrs->ia_valid);
1948 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
1949 attrs->ia_valid |= ATTR_FORCE;
1951 rc = setattr_prepare(direntry, attrs);
1955 full_path = build_path_from_dentry(direntry);
1956 if (full_path == NULL) {
1962 * Attempt to flush data before changing attributes. We need to do
1963 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1964 * ownership or mode then we may also need to do this. Here, we take
1965 * the safe way out and just do the flush on all setattr requests. If
1966 * the flush returns error, store it to report later and continue.
1968 * BB: This should be smarter. Why bother flushing pages that
1969 * will be truncated anyway? Also, should we error out here if
1970 * the flush returns error?
1972 rc = filemap_write_and_wait(inode->i_mapping);
1973 mapping_set_error(inode->i_mapping, rc);
1976 if (attrs->ia_valid & ATTR_SIZE) {
1977 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1982 /* skip mode change if it's just for clearing setuid/setgid */
1983 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1984 attrs->ia_valid &= ~ATTR_MODE;
1986 args = kmalloc(sizeof(*args), GFP_KERNEL);
1992 /* set up the struct */
1993 if (attrs->ia_valid & ATTR_MODE)
1994 args->mode = attrs->ia_mode;
1996 args->mode = NO_CHANGE_64;
1998 if (attrs->ia_valid & ATTR_UID)
1999 args->uid = attrs->ia_uid;
2001 args->uid = NO_CHANGE_64;
2003 if (attrs->ia_valid & ATTR_GID)
2004 args->gid = attrs->ia_gid;
2006 args->gid = NO_CHANGE_64;
2008 if (attrs->ia_valid & ATTR_ATIME)
2009 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2011 args->atime = NO_CHANGE_64;
2013 if (attrs->ia_valid & ATTR_MTIME)
2014 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2016 args->mtime = NO_CHANGE_64;
2018 if (attrs->ia_valid & ATTR_CTIME)
2019 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2021 args->ctime = NO_CHANGE_64;
2024 open_file = find_writable_file(cifsInode, true);
2026 u16 nfid = open_file->netfid;
2027 u32 npid = open_file->pid;
2028 pTcon = tlink_tcon(open_file->tlink);
2029 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2030 cifsFileInfo_put(open_file);
2032 tlink = cifs_sb_tlink(cifs_sb);
2033 if (IS_ERR(tlink)) {
2034 rc = PTR_ERR(tlink);
2037 pTcon = tlink_tcon(tlink);
2038 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2040 cifs_sb->mnt_cifs_flags &
2041 CIFS_MOUNT_MAP_SPECIAL_CHR);
2042 cifs_put_tlink(tlink);
2048 if ((attrs->ia_valid & ATTR_SIZE) &&
2049 attrs->ia_size != i_size_read(inode))
2050 truncate_setsize(inode, attrs->ia_size);
2052 setattr_copy(inode, attrs);
2053 mark_inode_dirty(inode);
2055 /* force revalidate when any of these times are set since some
2056 of the fs types (eg ext3, fat) do not have fine enough
2057 time granularity to match protocol, and we do not have a
2058 a way (yet) to query the server fs's time granularity (and
2059 whether it rounds times down).
2061 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2062 cifsInode->time = 0;
2071 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2074 uid_t uid = NO_CHANGE_32;
2075 gid_t gid = NO_CHANGE_32;
2076 struct inode *inode = direntry->d_inode;
2077 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2078 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2079 char *full_path = NULL;
2082 __u64 mode = NO_CHANGE_64;
2086 cFYI(1, "setattr on file %s attrs->iavalid 0x%x",
2087 direntry->d_name.name, attrs->ia_valid);
2089 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2090 attrs->ia_valid |= ATTR_FORCE;
2092 rc = setattr_prepare(direntry, attrs);
2098 full_path = build_path_from_dentry(direntry);
2099 if (full_path == NULL) {
2106 * Attempt to flush data before changing attributes. We need to do
2107 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2108 * ownership or mode then we may also need to do this. Here, we take
2109 * the safe way out and just do the flush on all setattr requests. If
2110 * the flush returns error, store it to report later and continue.
2112 * BB: This should be smarter. Why bother flushing pages that
2113 * will be truncated anyway? Also, should we error out here if
2114 * the flush returns error?
2116 rc = filemap_write_and_wait(inode->i_mapping);
2117 mapping_set_error(inode->i_mapping, rc);
2120 if (attrs->ia_valid & ATTR_SIZE) {
2121 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2123 goto cifs_setattr_exit;
2126 if (attrs->ia_valid & ATTR_UID)
2127 uid = attrs->ia_uid;
2129 if (attrs->ia_valid & ATTR_GID)
2130 gid = attrs->ia_gid;
2132 #ifdef CONFIG_CIFS_ACL
2133 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2134 if (uid != NO_CHANGE_32 || gid != NO_CHANGE_32) {
2135 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2138 cFYI(1, "%s: Setting id failed with error: %d",
2140 goto cifs_setattr_exit;
2144 #endif /* CONFIG_CIFS_ACL */
2145 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2146 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2148 /* skip mode change if it's just for clearing setuid/setgid */
2149 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2150 attrs->ia_valid &= ~ATTR_MODE;
2152 if (attrs->ia_valid & ATTR_MODE) {
2153 mode = attrs->ia_mode;
2155 #ifdef CONFIG_CIFS_ACL
2156 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2157 rc = id_mode_to_cifs_acl(inode, full_path, mode,
2158 NO_CHANGE_32, NO_CHANGE_32);
2160 cFYI(1, "%s: Setting ACL failed with error: %d",
2162 goto cifs_setattr_exit;
2165 #endif /* CONFIG_CIFS_ACL */
2166 if (((mode & S_IWUGO) == 0) &&
2167 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2169 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2171 /* fix up mode if we're not using dynperm */
2172 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2173 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2174 } else if ((mode & S_IWUGO) &&
2175 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2177 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2178 /* Attributes of 0 are ignored */
2180 dosattr |= ATTR_NORMAL;
2182 /* reset local inode permissions to normal */
2183 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2184 attrs->ia_mode &= ~(S_IALLUGO);
2185 if (S_ISDIR(inode->i_mode))
2187 cifs_sb->mnt_dir_mode;
2190 cifs_sb->mnt_file_mode;
2192 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2193 /* ignore mode change - ATTR_READONLY hasn't changed */
2194 attrs->ia_valid &= ~ATTR_MODE;
2198 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2199 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2200 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2201 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2203 /* Even if error on time set, no sense failing the call if
2204 the server would set the time to a reasonable value anyway,
2205 and this check ensures that we are not being called from
2206 sys_utimes in which case we ought to fail the call back to
2207 the user when the server rejects the call */
2208 if ((rc) && (attrs->ia_valid &
2209 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2213 /* do not need local check to inode_check_ok since the server does
2216 goto cifs_setattr_exit;
2218 if ((attrs->ia_valid & ATTR_SIZE) &&
2219 attrs->ia_size != i_size_read(inode))
2220 truncate_setsize(inode, attrs->ia_size);
2222 setattr_copy(inode, attrs);
2223 mark_inode_dirty(inode);
2232 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2234 struct inode *inode = direntry->d_inode;
2235 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2236 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2238 if (pTcon->unix_ext)
2239 return cifs_setattr_unix(direntry, attrs);
2241 return cifs_setattr_nounix(direntry, attrs);
2243 /* BB: add cifs_setattr_legacy for really old servers */
2247 void cifs_delete_inode(struct inode *inode)
2249 cFYI(1, "In cifs_delete_inode, inode = 0x%p", inode);
2250 /* may have to add back in if and when safe distributed caching of
2251 directories added e.g. via FindNotify */