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 inode->i_nlink = 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;
180 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
182 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
184 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
187 fattr->cf_uniqueid = iunique(sb, ROOT_I);
190 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
192 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
193 struct cifs_sb_info *cifs_sb)
195 memset(fattr, 0, sizeof(*fattr));
196 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
197 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
198 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
200 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
201 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
202 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
203 fattr->cf_mode = le64_to_cpu(info->Permissions);
206 * Since we set the inode type below we need to mask off
207 * to avoid strange results if bits set above.
209 fattr->cf_mode &= ~S_IFMT;
210 switch (le32_to_cpu(info->Type)) {
212 fattr->cf_mode |= S_IFREG;
213 fattr->cf_dtype = DT_REG;
216 fattr->cf_mode |= S_IFLNK;
217 fattr->cf_dtype = DT_LNK;
220 fattr->cf_mode |= S_IFDIR;
221 fattr->cf_dtype = DT_DIR;
224 fattr->cf_mode |= S_IFCHR;
225 fattr->cf_dtype = DT_CHR;
226 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
227 le64_to_cpu(info->DevMinor) & MINORMASK);
230 fattr->cf_mode |= S_IFBLK;
231 fattr->cf_dtype = DT_BLK;
232 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
233 le64_to_cpu(info->DevMinor) & MINORMASK);
236 fattr->cf_mode |= S_IFIFO;
237 fattr->cf_dtype = DT_FIFO;
240 fattr->cf_mode |= S_IFSOCK;
241 fattr->cf_dtype = DT_SOCK;
244 /* safest to call it a file if we do not know */
245 fattr->cf_mode |= S_IFREG;
246 fattr->cf_dtype = DT_REG;
247 cFYI(1, "unknown type %d", le32_to_cpu(info->Type));
251 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
252 fattr->cf_uid = cifs_sb->mnt_uid;
254 fattr->cf_uid = le64_to_cpu(info->Uid);
256 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
257 fattr->cf_gid = cifs_sb->mnt_gid;
259 fattr->cf_gid = le64_to_cpu(info->Gid);
261 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
265 * Fill a cifs_fattr struct with fake inode info.
267 * Needed to setup cifs_fattr data for the directory which is the
268 * junction to the new submount (ie to setup the fake directory
269 * which represents a DFS referral).
272 cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
274 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
276 cFYI(1, "creating fake fattr for DFS referral");
278 memset(fattr, 0, sizeof(*fattr));
279 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
280 fattr->cf_uid = cifs_sb->mnt_uid;
281 fattr->cf_gid = cifs_sb->mnt_gid;
282 fattr->cf_atime = CURRENT_TIME;
283 fattr->cf_ctime = CURRENT_TIME;
284 fattr->cf_mtime = CURRENT_TIME;
286 fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
289 int cifs_get_file_info_unix(struct file *filp)
293 FILE_UNIX_BASIC_INFO find_data;
294 struct cifs_fattr fattr;
295 struct inode *inode = filp->f_path.dentry->d_inode;
296 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
297 struct cifsFileInfo *cfile = filp->private_data;
298 struct cifsTconInfo *tcon = tlink_tcon(cfile->tlink);
301 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->netfid, &find_data);
303 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
304 } else if (rc == -EREMOTE) {
305 cifs_create_dfs_fattr(&fattr, inode->i_sb);
309 cifs_fattr_to_inode(inode, &fattr);
314 int cifs_get_inode_info_unix(struct inode **pinode,
315 const unsigned char *full_path,
316 struct super_block *sb, int xid)
319 FILE_UNIX_BASIC_INFO find_data;
320 struct cifs_fattr fattr;
321 struct cifsTconInfo *tcon;
322 struct tcon_link *tlink;
323 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
325 cFYI(1, "Getting info on %s", full_path);
327 tlink = cifs_sb_tlink(cifs_sb);
329 return PTR_ERR(tlink);
330 tcon = tlink_tcon(tlink);
332 /* could have done a find first instead but this returns more info */
333 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
334 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
335 CIFS_MOUNT_MAP_SPECIAL_CHR);
336 cifs_put_tlink(tlink);
339 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
340 } else if (rc == -EREMOTE) {
341 cifs_create_dfs_fattr(&fattr, sb);
347 /* check for Minshall+French symlinks */
348 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
349 int tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
351 cFYI(1, "CIFSCheckMFSymlink: %d", tmprc);
354 if (*pinode == NULL) {
356 cifs_fill_uniqueid(sb, &fattr);
357 *pinode = cifs_iget(sb, &fattr);
361 /* we already have inode, update it */
362 cifs_fattr_to_inode(*pinode, &fattr);
369 cifs_sfu_type(struct cifs_fattr *fattr, const unsigned char *path,
370 struct cifs_sb_info *cifs_sb, int xid)
375 struct tcon_link *tlink;
376 struct cifsTconInfo *tcon;
378 unsigned int bytes_read;
383 fattr->cf_mode &= ~S_IFMT;
385 if (fattr->cf_eof == 0) {
386 fattr->cf_mode |= S_IFIFO;
387 fattr->cf_dtype = DT_FIFO;
389 } else if (fattr->cf_eof < 8) {
390 fattr->cf_mode |= S_IFREG;
391 fattr->cf_dtype = DT_REG;
392 return -EINVAL; /* EOPNOTSUPP? */
395 tlink = cifs_sb_tlink(cifs_sb);
397 return PTR_ERR(tlink);
398 tcon = tlink_tcon(tlink);
400 rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, GENERIC_READ,
401 CREATE_NOT_DIR, &netfid, &oplock, NULL,
403 cifs_sb->mnt_cifs_flags &
404 CIFS_MOUNT_MAP_SPECIAL_CHR);
406 int buf_type = CIFS_NO_BUFFER;
408 rc = CIFSSMBRead(xid, tcon, netfid,
409 24 /* length */, 0 /* offset */,
410 &bytes_read, &pbuf, &buf_type);
411 if ((rc == 0) && (bytes_read >= 8)) {
412 if (memcmp("IntxBLK", pbuf, 8) == 0) {
413 cFYI(1, "Block device");
414 fattr->cf_mode |= S_IFBLK;
415 fattr->cf_dtype = DT_BLK;
416 if (bytes_read == 24) {
417 /* we have enough to decode dev num */
418 __u64 mjr; /* major */
419 __u64 mnr; /* minor */
420 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
421 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
422 fattr->cf_rdev = MKDEV(mjr, mnr);
424 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
425 cFYI(1, "Char device");
426 fattr->cf_mode |= S_IFCHR;
427 fattr->cf_dtype = DT_CHR;
428 if (bytes_read == 24) {
429 /* we have enough to decode dev num */
430 __u64 mjr; /* major */
431 __u64 mnr; /* minor */
432 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
433 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
434 fattr->cf_rdev = MKDEV(mjr, mnr);
436 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
438 fattr->cf_mode |= S_IFLNK;
439 fattr->cf_dtype = DT_LNK;
441 fattr->cf_mode |= S_IFREG; /* file? */
442 fattr->cf_dtype = DT_REG;
446 fattr->cf_mode |= S_IFREG; /* then it is a file */
447 fattr->cf_dtype = DT_REG;
448 rc = -EOPNOTSUPP; /* or some unknown SFU type */
450 CIFSSMBClose(xid, tcon, netfid);
452 cifs_put_tlink(tlink);
456 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
459 * Fetch mode bits as provided by SFU.
461 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
463 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
464 struct cifs_sb_info *cifs_sb, int xid)
466 #ifdef CONFIG_CIFS_XATTR
470 struct tcon_link *tlink;
471 struct cifsTconInfo *tcon;
473 tlink = cifs_sb_tlink(cifs_sb);
475 return PTR_ERR(tlink);
476 tcon = tlink_tcon(tlink);
478 rc = CIFSSMBQAllEAs(xid, tcon, path, "SETFILEBITS",
479 ea_value, 4 /* size of buf */, cifs_sb->local_nls,
480 cifs_sb->mnt_cifs_flags &
481 CIFS_MOUNT_MAP_SPECIAL_CHR);
482 cifs_put_tlink(tlink);
486 mode = le32_to_cpu(*((__le32 *)ea_value));
487 fattr->cf_mode &= ~SFBITS_MASK;
488 cFYI(1, "special bits 0%o org mode 0%o", mode,
490 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
491 cFYI(1, "special mode bits 0%o", mode);
500 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
502 cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
503 struct cifs_sb_info *cifs_sb, bool adjust_tz)
505 struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
507 memset(fattr, 0, sizeof(*fattr));
508 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
509 if (info->DeletePending)
510 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
512 if (info->LastAccessTime)
513 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
515 fattr->cf_atime = CURRENT_TIME;
517 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
518 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
521 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
522 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
525 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
526 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
527 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
529 if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
530 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
531 fattr->cf_dtype = DT_DIR;
533 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
534 fattr->cf_dtype = DT_REG;
536 /* clear write bits if ATTR_READONLY is set */
537 if (fattr->cf_cifsattrs & ATTR_READONLY)
538 fattr->cf_mode &= ~(S_IWUGO);
541 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
543 fattr->cf_uid = cifs_sb->mnt_uid;
544 fattr->cf_gid = cifs_sb->mnt_gid;
547 int cifs_get_file_info(struct file *filp)
551 FILE_ALL_INFO find_data;
552 struct cifs_fattr fattr;
553 struct inode *inode = filp->f_path.dentry->d_inode;
554 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
555 struct cifsFileInfo *cfile = filp->private_data;
556 struct cifsTconInfo *tcon = tlink_tcon(cfile->tlink);
559 rc = CIFSSMBQFileInfo(xid, tcon, cfile->netfid, &find_data);
560 if (rc == -EOPNOTSUPP || rc == -EINVAL) {
562 * FIXME: legacy server -- fall back to path-based call?
563 * for now, just skip revalidating and mark inode for
567 CIFS_I(inode)->time = 0;
569 } else if (rc == -EREMOTE) {
570 cifs_create_dfs_fattr(&fattr, inode->i_sb);
576 * don't bother with SFU junk here -- just mark inode as needing
579 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false);
580 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
581 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
582 cifs_fattr_to_inode(inode, &fattr);
588 int cifs_get_inode_info(struct inode **pinode,
589 const unsigned char *full_path, FILE_ALL_INFO *pfindData,
590 struct super_block *sb, int xid, const __u16 *pfid)
593 struct cifsTconInfo *pTcon;
594 struct tcon_link *tlink;
595 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
597 bool adjustTZ = false;
598 struct cifs_fattr fattr;
600 tlink = cifs_sb_tlink(cifs_sb);
602 return PTR_ERR(tlink);
603 pTcon = tlink_tcon(tlink);
605 cFYI(1, "Getting info on %s", full_path);
607 if ((pfindData == NULL) && (*pinode != NULL)) {
608 if (CIFS_I(*pinode)->clientCanCacheRead) {
609 cFYI(1, "No need to revalidate cached inode sizes");
614 /* if file info not passed in then get it from server */
615 if (pfindData == NULL) {
616 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
621 pfindData = (FILE_ALL_INFO *)buf;
623 /* could do find first instead but this returns more info */
624 rc = CIFSSMBQPathInfo(xid, pTcon, full_path, pfindData,
626 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
627 CIFS_MOUNT_MAP_SPECIAL_CHR);
628 /* BB optimize code so we do not make the above call
629 when server claims no NT SMB support and the above call
630 failed at least once - set flag in tcon or mount */
631 if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
632 rc = SMBQueryInformation(xid, pTcon, full_path,
633 pfindData, cifs_sb->local_nls,
634 cifs_sb->mnt_cifs_flags &
635 CIFS_MOUNT_MAP_SPECIAL_CHR);
641 cifs_all_info_to_fattr(&fattr, (FILE_ALL_INFO *) pfindData,
643 } else if (rc == -EREMOTE) {
644 cifs_create_dfs_fattr(&fattr, sb);
651 * If an inode wasn't passed in, then get the inode number
653 * Is an i_ino of zero legal? Can we use that to check if the server
654 * supports returning inode numbers? Are there other sanity checks we
655 * can use to ensure that the server is really filling in that field?
657 * We can not use the IndexNumber field by default from Windows or
658 * Samba (in ALL_INFO buf) but we can request it explicitly. The SNIA
659 * CIFS spec claims that this value is unique within the scope of a
660 * share, and the windows docs hint that it's actually unique
663 * There may be higher info levels that work but are there Windows
664 * server or network appliances for which IndexNumber field is not
667 if (*pinode == NULL) {
668 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
671 rc1 = CIFSGetSrvInodeNumber(xid, pTcon,
672 full_path, &fattr.cf_uniqueid,
674 cifs_sb->mnt_cifs_flags &
675 CIFS_MOUNT_MAP_SPECIAL_CHR);
676 if (rc1 || !fattr.cf_uniqueid) {
677 cFYI(1, "GetSrvInodeNum rc %d", rc1);
678 fattr.cf_uniqueid = iunique(sb, ROOT_I);
679 cifs_autodisable_serverino(cifs_sb);
682 fattr.cf_uniqueid = iunique(sb, ROOT_I);
685 fattr.cf_uniqueid = CIFS_I(*pinode)->uniqueid;
688 /* query for SFU type info if supported and needed */
689 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
690 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
691 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
693 cFYI(1, "cifs_sfu_type failed: %d", tmprc);
696 #ifdef CONFIG_CIFS_ACL
697 /* fill in 0777 bits from ACL */
698 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
699 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *pinode, full_path,
702 cFYI(1, "%s: Getting ACL failed with error: %d",
707 #endif /* CONFIG_CIFS_ACL */
709 /* fill in remaining high mode bits e.g. SUID, VTX */
710 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
711 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
713 /* check for Minshall+French symlinks */
714 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
715 tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
717 cFYI(1, "CIFSCheckMFSymlink: %d", tmprc);
721 *pinode = cifs_iget(sb, &fattr);
725 cifs_fattr_to_inode(*pinode, &fattr);
730 cifs_put_tlink(tlink);
734 static const struct inode_operations cifs_ipc_inode_ops = {
735 .lookup = cifs_lookup,
738 char *cifs_build_path_to_root(struct cifs_sb_info *cifs_sb,
739 struct cifsTconInfo *tcon)
741 int pplen = cifs_sb->prepathlen;
743 char *full_path = NULL;
745 /* if no prefix path, simply set path to the root of share to "" */
747 full_path = kmalloc(1, GFP_KERNEL);
753 if (tcon->Flags & SMB_SHARE_IS_IN_DFS)
754 dfsplen = strnlen(tcon->treeName, MAX_TREE_SIZE + 1);
758 full_path = kmalloc(dfsplen + pplen + 1, GFP_KERNEL);
759 if (full_path == NULL)
763 strncpy(full_path, tcon->treeName, dfsplen);
764 /* switch slash direction in prepath depending on whether
765 * windows or posix style path names
767 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
769 for (i = 0; i < dfsplen; i++) {
770 if (full_path[i] == '\\')
775 strncpy(full_path + dfsplen, cifs_sb->prepath, pplen);
776 full_path[dfsplen + pplen] = 0; /* add trailing null */
781 cifs_find_inode(struct inode *inode, void *opaque)
783 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
785 /* don't match inode with different uniqueid */
786 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
789 /* use createtime like an i_generation field */
790 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
793 /* don't match inode of different type */
794 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
797 /* if it's not a directory or has no dentries, then flag it */
798 if (S_ISDIR(inode->i_mode) && !list_empty(&inode->i_dentry))
799 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
805 cifs_init_inode(struct inode *inode, void *opaque)
807 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
809 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
810 CIFS_I(inode)->createtime = fattr->cf_createtime;
815 * walk dentry list for an inode and report whether it has aliases that
816 * are hashed. We use this to determine if a directory inode can actually
820 inode_has_hashed_dentries(struct inode *inode)
822 struct dentry *dentry;
824 spin_lock(&inode->i_lock);
825 list_for_each_entry(dentry, &inode->i_dentry, d_alias) {
826 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
827 spin_unlock(&inode->i_lock);
831 spin_unlock(&inode->i_lock);
835 /* Given fattrs, get a corresponding inode */
837 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
843 cFYI(1, "looking for uniqueid=%llu", fattr->cf_uniqueid);
845 /* hash down to 32-bits on 32-bit arch */
846 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
848 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
850 /* was there a potentially problematic inode collision? */
851 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
852 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
854 if (inode_has_hashed_dentries(inode)) {
855 cifs_autodisable_serverino(CIFS_SB(sb));
857 fattr->cf_uniqueid = iunique(sb, ROOT_I);
858 goto retry_iget5_locked;
862 cifs_fattr_to_inode(inode, fattr);
863 if (sb->s_flags & MS_NOATIME)
864 inode->i_flags |= S_NOATIME | S_NOCMTIME;
865 if (inode->i_state & I_NEW) {
867 if (S_ISREG(inode->i_mode))
868 inode->i_data.backing_dev_info = sb->s_bdi;
869 #ifdef CONFIG_CIFS_FSCACHE
870 /* initialize per-inode cache cookie pointer */
871 CIFS_I(inode)->fscache = NULL;
873 unlock_new_inode(inode);
880 /* gets root inode */
881 struct inode *cifs_root_iget(struct super_block *sb, unsigned long ino)
884 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
885 struct inode *inode = NULL;
888 struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
890 full_path = cifs_build_path_to_root(cifs_sb, tcon);
891 if (full_path == NULL)
892 return ERR_PTR(-ENOMEM);
896 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
898 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
906 #ifdef CONFIG_CIFS_FSCACHE
907 /* populate tcon->resource_id */
908 tcon->resource_id = CIFS_I(inode)->uniqueid;
911 if (rc && tcon->ipc) {
912 cFYI(1, "ipc connection - fake read inode");
913 inode->i_mode |= S_IFDIR;
915 inode->i_op = &cifs_ipc_inode_ops;
916 inode->i_fop = &simple_dir_operations;
917 inode->i_uid = cifs_sb->mnt_uid;
918 inode->i_gid = cifs_sb->mnt_gid;
926 /* can not call macro FreeXid here since in a void func
927 * TODO: This is no longer true
934 cifs_set_file_info(struct inode *inode, struct iattr *attrs, int xid,
935 char *full_path, __u32 dosattr)
941 bool set_time = false;
942 struct cifsFileInfo *open_file;
943 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
944 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
945 struct tcon_link *tlink = NULL;
946 struct cifsTconInfo *pTcon;
947 FILE_BASIC_INFO info_buf;
952 if (attrs->ia_valid & ATTR_ATIME) {
954 info_buf.LastAccessTime =
955 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
957 info_buf.LastAccessTime = 0;
959 if (attrs->ia_valid & ATTR_MTIME) {
961 info_buf.LastWriteTime =
962 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
964 info_buf.LastWriteTime = 0;
967 * Samba throws this field away, but windows may actually use it.
968 * Do not set ctime unless other time stamps are changed explicitly
969 * (i.e. by utimes()) since we would then have a mix of client and
972 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
973 cFYI(1, "CIFS - CTIME changed");
974 info_buf.ChangeTime =
975 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
977 info_buf.ChangeTime = 0;
979 info_buf.CreationTime = 0; /* don't change */
980 info_buf.Attributes = cpu_to_le32(dosattr);
983 * If the file is already open for write, just use that fileid
985 open_file = find_writable_file(cifsInode, true);
987 netfid = open_file->netfid;
988 netpid = open_file->pid;
989 pTcon = tlink_tcon(open_file->tlink);
990 goto set_via_filehandle;
993 tlink = cifs_sb_tlink(cifs_sb);
999 pTcon = tlink_tcon(tlink);
1002 * NT4 apparently returns success on this call, but it doesn't
1005 if (!(pTcon->ses->flags & CIFS_SES_NT4)) {
1006 rc = CIFSSMBSetPathInfo(xid, pTcon, full_path,
1007 &info_buf, cifs_sb->local_nls,
1008 cifs_sb->mnt_cifs_flags &
1009 CIFS_MOUNT_MAP_SPECIAL_CHR);
1011 cifsInode->cifsAttrs = dosattr;
1013 } else if (rc != -EOPNOTSUPP && rc != -EINVAL)
1017 cFYI(1, "calling SetFileInfo since SetPathInfo for "
1018 "times not supported by this server");
1019 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
1020 SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
1021 CREATE_NOT_DIR, &netfid, &oplock,
1022 NULL, cifs_sb->local_nls,
1023 cifs_sb->mnt_cifs_flags &
1024 CIFS_MOUNT_MAP_SPECIAL_CHR);
1032 netpid = current->tgid;
1035 rc = CIFSSMBSetFileInfo(xid, pTcon, &info_buf, netfid, netpid);
1037 cifsInode->cifsAttrs = dosattr;
1039 if (open_file == NULL)
1040 CIFSSMBClose(xid, pTcon, netfid);
1042 cifsFileInfo_put(open_file);
1045 cifs_put_tlink(tlink);
1050 * open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1051 * and rename it to a random name that hopefully won't conflict with
1055 cifs_rename_pending_delete(char *full_path, struct dentry *dentry, int xid)
1060 struct inode *inode = dentry->d_inode;
1061 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1062 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1063 struct tcon_link *tlink;
1064 struct cifsTconInfo *tcon;
1065 __u32 dosattr, origattr;
1066 FILE_BASIC_INFO *info_buf = NULL;
1068 tlink = cifs_sb_tlink(cifs_sb);
1070 return PTR_ERR(tlink);
1071 tcon = tlink_tcon(tlink);
1073 rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
1074 DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
1075 &netfid, &oplock, NULL, cifs_sb->local_nls,
1076 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1080 origattr = cifsInode->cifsAttrs;
1082 origattr |= ATTR_NORMAL;
1084 dosattr = origattr & ~ATTR_READONLY;
1086 dosattr |= ATTR_NORMAL;
1087 dosattr |= ATTR_HIDDEN;
1089 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1090 if (dosattr != origattr) {
1091 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1092 if (info_buf == NULL) {
1096 info_buf->Attributes = cpu_to_le32(dosattr);
1097 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1099 /* although we would like to mark the file hidden
1100 if that fails we will still try to rename it */
1102 cifsInode->cifsAttrs = dosattr;
1104 dosattr = origattr; /* since not able to change them */
1107 /* rename the file */
1108 rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
1109 cifs_sb->mnt_cifs_flags &
1110 CIFS_MOUNT_MAP_SPECIAL_CHR);
1116 /* try to set DELETE_ON_CLOSE */
1117 if (!cifsInode->delete_pending) {
1118 rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
1121 * some samba versions return -ENOENT when we try to set the
1122 * file disposition here. Likely a samba bug, but work around
1123 * it for now. This means that some cifsXXX files may hang
1124 * around after they shouldn't.
1126 * BB: remove this hack after more servers have the fix
1134 cifsInode->delete_pending = true;
1138 CIFSSMBClose(xid, tcon, netfid);
1141 cifs_put_tlink(tlink);
1145 * reset everything back to the original state. Don't bother
1146 * dealing with errors here since we can't do anything about
1150 CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
1151 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1152 CIFS_MOUNT_MAP_SPECIAL_CHR);
1154 if (dosattr != origattr) {
1155 info_buf->Attributes = cpu_to_le32(origattr);
1156 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1158 cifsInode->cifsAttrs = origattr;
1166 * If dentry->d_inode is null (usually meaning the cached dentry
1167 * is a negative dentry) then we would attempt a standard SMB delete, but
1168 * if that fails we can not attempt the fall back mechanisms on EACCESS
1169 * but will return the EACCESS to the caller. Note that the VFS does not call
1170 * unlink on negative dentries currently.
1172 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1176 char *full_path = NULL;
1177 struct inode *inode = dentry->d_inode;
1178 struct cifsInodeInfo *cifs_inode;
1179 struct super_block *sb = dir->i_sb;
1180 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1181 struct tcon_link *tlink;
1182 struct cifsTconInfo *tcon;
1183 struct iattr *attrs = NULL;
1184 __u32 dosattr = 0, origattr = 0;
1186 cFYI(1, "cifs_unlink, dir=0x%p, dentry=0x%p", dir, dentry);
1188 tlink = cifs_sb_tlink(cifs_sb);
1190 return PTR_ERR(tlink);
1191 tcon = tlink_tcon(tlink);
1195 /* Unlink can be called from rename so we can not take the
1196 * sb->s_vfs_rename_mutex here */
1197 full_path = build_path_from_dentry(dentry);
1198 if (full_path == NULL) {
1203 if ((tcon->ses->capabilities & CAP_UNIX) &&
1204 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1205 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1206 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1207 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1208 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1209 cFYI(1, "posix del rc %d", rc);
1210 if ((rc == 0) || (rc == -ENOENT))
1211 goto psx_del_no_retry;
1215 rc = CIFSSMBDelFile(xid, tcon, full_path, cifs_sb->local_nls,
1216 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1222 } else if (rc == -ENOENT) {
1224 } else if (rc == -ETXTBSY) {
1225 rc = cifs_rename_pending_delete(full_path, dentry, xid);
1228 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1229 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1230 if (attrs == NULL) {
1235 /* try to reset dos attributes */
1236 cifs_inode = CIFS_I(inode);
1237 origattr = cifs_inode->cifsAttrs;
1239 origattr |= ATTR_NORMAL;
1240 dosattr = origattr & ~ATTR_READONLY;
1242 dosattr |= ATTR_NORMAL;
1243 dosattr |= ATTR_HIDDEN;
1245 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1249 goto retry_std_delete;
1252 /* undo the setattr if we errored out and it's needed */
1253 if (rc != 0 && dosattr != 0)
1254 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1258 cifs_inode = CIFS_I(inode);
1259 cifs_inode->time = 0; /* will force revalidate to get info
1261 inode->i_ctime = current_fs_time(sb);
1263 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1264 cifs_inode = CIFS_I(dir);
1265 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1270 cifs_put_tlink(tlink);
1274 int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
1278 struct cifs_sb_info *cifs_sb;
1279 struct tcon_link *tlink;
1280 struct cifsTconInfo *pTcon;
1281 char *full_path = NULL;
1282 struct inode *newinode = NULL;
1283 struct cifs_fattr fattr;
1285 cFYI(1, "In cifs_mkdir, mode = 0x%x inode = 0x%p", mode, inode);
1287 cifs_sb = CIFS_SB(inode->i_sb);
1288 tlink = cifs_sb_tlink(cifs_sb);
1290 return PTR_ERR(tlink);
1291 pTcon = tlink_tcon(tlink);
1295 full_path = build_path_from_dentry(direntry);
1296 if (full_path == NULL) {
1301 if ((pTcon->ses->capabilities & CAP_UNIX) &&
1302 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1303 le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
1305 FILE_UNIX_BASIC_INFO *pInfo =
1306 kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1307 if (pInfo == NULL) {
1312 mode &= ~current_umask();
1313 rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
1314 mode, NULL /* netfid */, pInfo, &oplock,
1315 full_path, cifs_sb->local_nls,
1316 cifs_sb->mnt_cifs_flags &
1317 CIFS_MOUNT_MAP_SPECIAL_CHR);
1318 if (rc == -EOPNOTSUPP) {
1320 goto mkdir_retry_old;
1322 cFYI(1, "posix mkdir returned 0x%x", rc);
1325 if (pInfo->Type == cpu_to_le32(-1)) {
1326 /* no return info, go query for it */
1328 goto mkdir_get_info;
1330 /*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
1334 cifs_unix_basic_to_fattr(&fattr, pInfo, cifs_sb);
1335 cifs_fill_uniqueid(inode->i_sb, &fattr);
1336 newinode = cifs_iget(inode->i_sb, &fattr);
1339 goto mkdir_get_info;
1342 d_instantiate(direntry, newinode);
1344 #ifdef CONFIG_CIFS_DEBUG2
1345 cFYI(1, "instantiated dentry %p %s to inode %p",
1346 direntry, direntry->d_name.name, newinode);
1348 if (newinode->i_nlink != 2)
1349 cFYI(1, "unexpected number of links %d",
1357 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1358 rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
1359 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1361 cFYI(1, "cifs_mkdir returned 0x%x", rc);
1366 if (pTcon->unix_ext)
1367 rc = cifs_get_inode_info_unix(&newinode, full_path,
1370 rc = cifs_get_inode_info(&newinode, full_path, NULL,
1371 inode->i_sb, xid, NULL);
1373 d_instantiate(direntry, newinode);
1374 /* setting nlink not necessary except in cases where we
1375 * failed to get it from the server or was set bogus */
1376 if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
1377 direntry->d_inode->i_nlink = 2;
1379 mode &= ~current_umask();
1380 /* must turn on setgid bit if parent dir has it */
1381 if (inode->i_mode & S_ISGID)
1384 if (pTcon->unix_ext) {
1385 struct cifs_unix_set_info_args args = {
1387 .ctime = NO_CHANGE_64,
1388 .atime = NO_CHANGE_64,
1389 .mtime = NO_CHANGE_64,
1392 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1393 args.uid = (__u64)current_fsuid();
1394 if (inode->i_mode & S_ISGID)
1395 args.gid = (__u64)inode->i_gid;
1397 args.gid = (__u64)current_fsgid();
1399 args.uid = NO_CHANGE_64;
1400 args.gid = NO_CHANGE_64;
1402 CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
1404 cifs_sb->mnt_cifs_flags &
1405 CIFS_MOUNT_MAP_SPECIAL_CHR);
1407 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1408 (mode & S_IWUGO) == 0) {
1409 FILE_BASIC_INFO pInfo;
1410 struct cifsInodeInfo *cifsInode;
1413 memset(&pInfo, 0, sizeof(pInfo));
1414 cifsInode = CIFS_I(newinode);
1415 dosattrs = cifsInode->cifsAttrs|ATTR_READONLY;
1416 pInfo.Attributes = cpu_to_le32(dosattrs);
1417 tmprc = CIFSSMBSetPathInfo(xid, pTcon,
1420 cifs_sb->mnt_cifs_flags &
1421 CIFS_MOUNT_MAP_SPECIAL_CHR);
1423 cifsInode->cifsAttrs = dosattrs;
1425 if (direntry->d_inode) {
1426 if (cifs_sb->mnt_cifs_flags &
1428 direntry->d_inode->i_mode =
1431 if (cifs_sb->mnt_cifs_flags &
1432 CIFS_MOUNT_SET_UID) {
1433 direntry->d_inode->i_uid =
1435 if (inode->i_mode & S_ISGID)
1436 direntry->d_inode->i_gid =
1439 direntry->d_inode->i_gid =
1448 cifs_put_tlink(tlink);
1452 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1456 struct cifs_sb_info *cifs_sb;
1457 struct tcon_link *tlink;
1458 struct cifsTconInfo *pTcon;
1459 char *full_path = NULL;
1460 struct cifsInodeInfo *cifsInode;
1462 cFYI(1, "cifs_rmdir, inode = 0x%p", inode);
1464 dentry_unhash(direntry);
1468 full_path = build_path_from_dentry(direntry);
1469 if (full_path == NULL) {
1474 cifs_sb = CIFS_SB(inode->i_sb);
1475 tlink = cifs_sb_tlink(cifs_sb);
1476 if (IS_ERR(tlink)) {
1477 rc = PTR_ERR(tlink);
1480 pTcon = tlink_tcon(tlink);
1482 rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
1483 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1484 cifs_put_tlink(tlink);
1488 spin_lock(&direntry->d_inode->i_lock);
1489 i_size_write(direntry->d_inode, 0);
1490 clear_nlink(direntry->d_inode);
1491 spin_unlock(&direntry->d_inode->i_lock);
1494 cifsInode = CIFS_I(direntry->d_inode);
1495 cifsInode->time = 0; /* force revalidate to go get info when
1498 cifsInode = CIFS_I(inode);
1499 cifsInode->time = 0; /* force revalidate to get parent dir info
1500 since cached search results now invalid */
1502 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1503 current_fs_time(inode->i_sb);
1512 cifs_do_rename(int xid, struct dentry *from_dentry, const char *fromPath,
1513 struct dentry *to_dentry, const char *toPath)
1515 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1516 struct tcon_link *tlink;
1517 struct cifsTconInfo *pTcon;
1521 tlink = cifs_sb_tlink(cifs_sb);
1523 return PTR_ERR(tlink);
1524 pTcon = tlink_tcon(tlink);
1526 /* try path-based rename first */
1527 rc = CIFSSMBRename(xid, pTcon, fromPath, toPath, cifs_sb->local_nls,
1528 cifs_sb->mnt_cifs_flags &
1529 CIFS_MOUNT_MAP_SPECIAL_CHR);
1532 * don't bother with rename by filehandle unless file is busy and
1533 * source Note that cross directory moves do not work with
1534 * rename by filehandle to various Windows servers.
1536 if (rc == 0 || rc != -ETXTBSY)
1537 goto do_rename_exit;
1539 /* open-file renames don't work across directories */
1540 if (to_dentry->d_parent != from_dentry->d_parent)
1541 goto do_rename_exit;
1543 /* open the file to be renamed -- we need DELETE perms */
1544 rc = CIFSSMBOpen(xid, pTcon, fromPath, FILE_OPEN, DELETE,
1545 CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1546 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1547 CIFS_MOUNT_MAP_SPECIAL_CHR);
1550 rc = CIFSSMBRenameOpenFile(xid, pTcon, srcfid,
1551 (const char *) to_dentry->d_name.name,
1552 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1553 CIFS_MOUNT_MAP_SPECIAL_CHR);
1555 CIFSSMBClose(xid, pTcon, srcfid);
1558 cifs_put_tlink(tlink);
1562 int cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1563 struct inode *target_dir, struct dentry *target_dentry)
1565 char *fromName = NULL;
1566 char *toName = NULL;
1567 struct cifs_sb_info *cifs_sb;
1568 struct tcon_link *tlink;
1569 struct cifsTconInfo *tcon;
1570 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1571 FILE_UNIX_BASIC_INFO *info_buf_target;
1574 if (target_dentry->d_inode && S_ISDIR(target_dentry->d_inode->i_mode))
1575 dentry_unhash(target_dentry);
1577 cifs_sb = CIFS_SB(source_dir->i_sb);
1578 tlink = cifs_sb_tlink(cifs_sb);
1580 return PTR_ERR(tlink);
1581 tcon = tlink_tcon(tlink);
1586 * we already have the rename sem so we do not need to
1587 * grab it again here to protect the path integrity
1589 fromName = build_path_from_dentry(source_dentry);
1590 if (fromName == NULL) {
1592 goto cifs_rename_exit;
1595 toName = build_path_from_dentry(target_dentry);
1596 if (toName == NULL) {
1598 goto cifs_rename_exit;
1601 rc = cifs_do_rename(xid, source_dentry, fromName,
1602 target_dentry, toName);
1604 if (rc == -EEXIST && tcon->unix_ext) {
1606 * Are src and dst hardlinks of same inode? We can
1607 * only tell with unix extensions enabled
1610 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1612 if (info_buf_source == NULL) {
1614 goto cifs_rename_exit;
1617 info_buf_target = info_buf_source + 1;
1618 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, fromName,
1621 cifs_sb->mnt_cifs_flags &
1622 CIFS_MOUNT_MAP_SPECIAL_CHR);
1626 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, toName,
1629 cifs_sb->mnt_cifs_flags &
1630 CIFS_MOUNT_MAP_SPECIAL_CHR);
1632 if (tmprc == 0 && (info_buf_source->UniqueId ==
1633 info_buf_target->UniqueId)) {
1634 /* same file, POSIX says that this is a noop */
1636 goto cifs_rename_exit;
1638 } /* else ... BB we could add the same check for Windows by
1639 checking the UniqueId via FILE_INTERNAL_INFO */
1642 /* Try unlinking the target dentry if it's not negative */
1643 if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
1644 tmprc = cifs_unlink(target_dir, target_dentry);
1646 goto cifs_rename_exit;
1648 rc = cifs_do_rename(xid, source_dentry, fromName,
1649 target_dentry, toName);
1653 kfree(info_buf_source);
1657 cifs_put_tlink(tlink);
1662 cifs_inode_needs_reval(struct inode *inode)
1664 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1665 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1667 if (cifs_i->clientCanCacheRead)
1670 if (!lookupCacheEnabled)
1673 if (cifs_i->time == 0)
1676 if (!time_in_range(jiffies, cifs_i->time,
1677 cifs_i->time + cifs_sb->actimeo))
1680 /* hardlinked files w/ noserverino get "special" treatment */
1681 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1682 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1689 * Zap the cache. Called when invalid_mapping flag is set.
1692 cifs_invalidate_mapping(struct inode *inode)
1695 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1697 cifs_i->invalid_mapping = false;
1699 /* write back any cached data */
1700 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1701 rc = filemap_write_and_wait(inode->i_mapping);
1702 mapping_set_error(inode->i_mapping, rc);
1704 invalidate_remote_inode(inode);
1705 cifs_fscache_reset_inode_cookie(inode);
1708 int cifs_revalidate_file(struct file *filp)
1711 struct inode *inode = filp->f_path.dentry->d_inode;
1712 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1714 if (!cifs_inode_needs_reval(inode))
1717 if (tlink_tcon(cfile->tlink)->unix_ext)
1718 rc = cifs_get_file_info_unix(filp);
1720 rc = cifs_get_file_info(filp);
1723 if (CIFS_I(inode)->invalid_mapping)
1724 cifs_invalidate_mapping(inode);
1729 /* revalidate a dentry's inode attributes */
1730 int cifs_revalidate_dentry(struct dentry *dentry)
1734 char *full_path = NULL;
1735 struct inode *inode = dentry->d_inode;
1736 struct super_block *sb = dentry->d_sb;
1743 if (!cifs_inode_needs_reval(inode))
1746 /* can not safely grab the rename sem here if rename calls revalidate
1747 since that would deadlock */
1748 full_path = build_path_from_dentry(dentry);
1749 if (full_path == NULL) {
1754 cFYI(1, "Revalidate: %s inode 0x%p count %d dentry: 0x%p d_time %ld "
1755 "jiffies %ld", full_path, inode, inode->i_count.counter,
1756 dentry, dentry->d_time, jiffies);
1758 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1759 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1761 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1765 if (CIFS_I(inode)->invalid_mapping)
1766 cifs_invalidate_mapping(inode);
1773 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1776 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1777 struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
1778 int err = cifs_revalidate_dentry(dentry);
1781 generic_fillattr(dentry->d_inode, stat);
1782 stat->blksize = CIFS_MAX_MSGSIZE;
1783 stat->ino = CIFS_I(dentry->d_inode)->uniqueid;
1786 * If on a multiuser mount without unix extensions, and the
1787 * admin hasn't overridden them, set the ownership to the
1788 * fsuid/fsgid of the current process.
1790 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
1792 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1793 stat->uid = current_fsuid();
1794 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1795 stat->gid = current_fsgid();
1801 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1803 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1804 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1808 page = grab_cache_page(mapping, index);
1812 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1814 page_cache_release(page);
1818 static void cifs_setsize(struct inode *inode, loff_t offset)
1822 spin_lock(&inode->i_lock);
1823 oldsize = inode->i_size;
1824 i_size_write(inode, offset);
1825 spin_unlock(&inode->i_lock);
1827 truncate_pagecache(inode, oldsize, offset);
1831 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1832 int xid, char *full_path)
1835 struct cifsFileInfo *open_file;
1836 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1837 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1838 struct tcon_link *tlink = NULL;
1839 struct cifsTconInfo *pTcon = NULL;
1842 * To avoid spurious oplock breaks from server, in the case of
1843 * inodes that we already have open, avoid doing path based
1844 * setting of file size if we can do it by handle.
1845 * This keeps our caching token (oplock) and avoids timeouts
1846 * when the local oplock break takes longer to flush
1847 * writebehind data than the SMB timeout for the SetPathInfo
1848 * request would allow
1850 open_file = find_writable_file(cifsInode, true);
1852 __u16 nfid = open_file->netfid;
1853 __u32 npid = open_file->pid;
1854 pTcon = tlink_tcon(open_file->tlink);
1855 rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size, nfid,
1857 cifsFileInfo_put(open_file);
1858 cFYI(1, "SetFSize for attrs rc = %d", rc);
1859 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1860 unsigned int bytes_written;
1861 rc = CIFSSMBWrite(xid, pTcon, nfid, 0, attrs->ia_size,
1862 &bytes_written, NULL, NULL, 1);
1863 cFYI(1, "Wrt seteof rc %d", rc);
1869 if (pTcon == NULL) {
1870 tlink = cifs_sb_tlink(cifs_sb);
1872 return PTR_ERR(tlink);
1873 pTcon = tlink_tcon(tlink);
1876 /* Set file size by pathname rather than by handle
1877 either because no valid, writeable file handle for
1878 it was found or because there was an error setting
1880 rc = CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size,
1881 false, cifs_sb->local_nls,
1882 cifs_sb->mnt_cifs_flags &
1883 CIFS_MOUNT_MAP_SPECIAL_CHR);
1884 cFYI(1, "SetEOF by path (setattrs) rc = %d", rc);
1885 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1889 rc = SMBLegacyOpen(xid, pTcon, full_path,
1890 FILE_OPEN, GENERIC_WRITE,
1891 CREATE_NOT_DIR, &netfid, &oplock, NULL,
1893 cifs_sb->mnt_cifs_flags &
1894 CIFS_MOUNT_MAP_SPECIAL_CHR);
1896 unsigned int bytes_written;
1897 rc = CIFSSMBWrite(xid, pTcon, netfid, 0,
1899 &bytes_written, NULL,
1901 cFYI(1, "wrt seteof rc %d", rc);
1902 CIFSSMBClose(xid, pTcon, netfid);
1906 cifs_put_tlink(tlink);
1910 cifsInode->server_eof = attrs->ia_size;
1911 cifs_setsize(inode, attrs->ia_size);
1912 cifs_truncate_page(inode->i_mapping, inode->i_size);
1919 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1923 char *full_path = NULL;
1924 struct inode *inode = direntry->d_inode;
1925 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1926 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1927 struct tcon_link *tlink;
1928 struct cifsTconInfo *pTcon;
1929 struct cifs_unix_set_info_args *args = NULL;
1930 struct cifsFileInfo *open_file;
1932 cFYI(1, "setattr_unix on file %s attrs->ia_valid=0x%x",
1933 direntry->d_name.name, attrs->ia_valid);
1937 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
1938 attrs->ia_valid |= ATTR_FORCE;
1940 rc = inode_change_ok(inode, attrs);
1944 full_path = build_path_from_dentry(direntry);
1945 if (full_path == NULL) {
1951 * Attempt to flush data before changing attributes. We need to do
1952 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1953 * ownership or mode then we may also need to do this. Here, we take
1954 * the safe way out and just do the flush on all setattr requests. If
1955 * the flush returns error, store it to report later and continue.
1957 * BB: This should be smarter. Why bother flushing pages that
1958 * will be truncated anyway? Also, should we error out here if
1959 * the flush returns error?
1961 rc = filemap_write_and_wait(inode->i_mapping);
1962 mapping_set_error(inode->i_mapping, rc);
1965 if (attrs->ia_valid & ATTR_SIZE) {
1966 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1971 /* skip mode change if it's just for clearing setuid/setgid */
1972 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1973 attrs->ia_valid &= ~ATTR_MODE;
1975 args = kmalloc(sizeof(*args), GFP_KERNEL);
1981 /* set up the struct */
1982 if (attrs->ia_valid & ATTR_MODE)
1983 args->mode = attrs->ia_mode;
1985 args->mode = NO_CHANGE_64;
1987 if (attrs->ia_valid & ATTR_UID)
1988 args->uid = attrs->ia_uid;
1990 args->uid = NO_CHANGE_64;
1992 if (attrs->ia_valid & ATTR_GID)
1993 args->gid = attrs->ia_gid;
1995 args->gid = NO_CHANGE_64;
1997 if (attrs->ia_valid & ATTR_ATIME)
1998 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2000 args->atime = NO_CHANGE_64;
2002 if (attrs->ia_valid & ATTR_MTIME)
2003 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2005 args->mtime = NO_CHANGE_64;
2007 if (attrs->ia_valid & ATTR_CTIME)
2008 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2010 args->ctime = NO_CHANGE_64;
2013 open_file = find_writable_file(cifsInode, true);
2015 u16 nfid = open_file->netfid;
2016 u32 npid = open_file->pid;
2017 pTcon = tlink_tcon(open_file->tlink);
2018 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2019 cifsFileInfo_put(open_file);
2021 tlink = cifs_sb_tlink(cifs_sb);
2022 if (IS_ERR(tlink)) {
2023 rc = PTR_ERR(tlink);
2026 pTcon = tlink_tcon(tlink);
2027 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2029 cifs_sb->mnt_cifs_flags &
2030 CIFS_MOUNT_MAP_SPECIAL_CHR);
2031 cifs_put_tlink(tlink);
2037 if ((attrs->ia_valid & ATTR_SIZE) &&
2038 attrs->ia_size != i_size_read(inode))
2039 truncate_setsize(inode, attrs->ia_size);
2041 setattr_copy(inode, attrs);
2042 mark_inode_dirty(inode);
2044 /* force revalidate when any of these times are set since some
2045 of the fs types (eg ext3, fat) do not have fine enough
2046 time granularity to match protocol, and we do not have a
2047 a way (yet) to query the server fs's time granularity (and
2048 whether it rounds times down).
2050 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2051 cifsInode->time = 0;
2060 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2063 struct inode *inode = direntry->d_inode;
2064 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2065 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2066 char *full_path = NULL;
2069 __u64 mode = NO_CHANGE_64;
2073 cFYI(1, "setattr on file %s attrs->iavalid 0x%x",
2074 direntry->d_name.name, attrs->ia_valid);
2076 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2077 attrs->ia_valid |= ATTR_FORCE;
2079 rc = inode_change_ok(inode, attrs);
2085 full_path = build_path_from_dentry(direntry);
2086 if (full_path == NULL) {
2093 * Attempt to flush data before changing attributes. We need to do
2094 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2095 * ownership or mode then we may also need to do this. Here, we take
2096 * the safe way out and just do the flush on all setattr requests. If
2097 * the flush returns error, store it to report later and continue.
2099 * BB: This should be smarter. Why bother flushing pages that
2100 * will be truncated anyway? Also, should we error out here if
2101 * the flush returns error?
2103 rc = filemap_write_and_wait(inode->i_mapping);
2104 mapping_set_error(inode->i_mapping, rc);
2107 if (attrs->ia_valid & ATTR_SIZE) {
2108 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2110 goto cifs_setattr_exit;
2114 * Without unix extensions we can't send ownership changes to the
2115 * server, so silently ignore them. This is consistent with how
2116 * local DOS/Windows filesystems behave (VFAT, NTFS, etc). With
2117 * CIFSACL support + proper Windows to Unix idmapping, we may be
2118 * able to support this in the future.
2120 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2121 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2123 /* skip mode change if it's just for clearing setuid/setgid */
2124 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2125 attrs->ia_valid &= ~ATTR_MODE;
2127 if (attrs->ia_valid & ATTR_MODE) {
2128 cFYI(1, "Mode changed to 0%o", attrs->ia_mode);
2129 mode = attrs->ia_mode;
2132 if (attrs->ia_valid & ATTR_MODE) {
2134 #ifdef CONFIG_CIFS_ACL
2135 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2136 rc = mode_to_cifs_acl(inode, full_path, mode);
2138 cFYI(1, "%s: Setting ACL failed with error: %d",
2140 goto cifs_setattr_exit;
2143 #endif /* CONFIG_CIFS_ACL */
2144 if (((mode & S_IWUGO) == 0) &&
2145 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2147 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2149 /* fix up mode if we're not using dynperm */
2150 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2151 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2152 } else if ((mode & S_IWUGO) &&
2153 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2155 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2156 /* Attributes of 0 are ignored */
2158 dosattr |= ATTR_NORMAL;
2160 /* reset local inode permissions to normal */
2161 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2162 attrs->ia_mode &= ~(S_IALLUGO);
2163 if (S_ISDIR(inode->i_mode))
2165 cifs_sb->mnt_dir_mode;
2168 cifs_sb->mnt_file_mode;
2170 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2171 /* ignore mode change - ATTR_READONLY hasn't changed */
2172 attrs->ia_valid &= ~ATTR_MODE;
2176 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2177 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2178 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2179 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2181 /* Even if error on time set, no sense failing the call if
2182 the server would set the time to a reasonable value anyway,
2183 and this check ensures that we are not being called from
2184 sys_utimes in which case we ought to fail the call back to
2185 the user when the server rejects the call */
2186 if ((rc) && (attrs->ia_valid &
2187 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2191 /* do not need local check to inode_check_ok since the server does
2194 goto cifs_setattr_exit;
2196 if ((attrs->ia_valid & ATTR_SIZE) &&
2197 attrs->ia_size != i_size_read(inode))
2198 truncate_setsize(inode, attrs->ia_size);
2200 setattr_copy(inode, attrs);
2201 mark_inode_dirty(inode);
2210 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2212 struct inode *inode = direntry->d_inode;
2213 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2214 struct cifsTconInfo *pTcon = cifs_sb_master_tcon(cifs_sb);
2216 if (pTcon->unix_ext)
2217 return cifs_setattr_unix(direntry, attrs);
2219 return cifs_setattr_nounix(direntry, attrs);
2221 /* BB: add cifs_setattr_legacy for really old servers */
2225 void cifs_delete_inode(struct inode *inode)
2227 cFYI(1, "In cifs_delete_inode, inode = 0x%p", inode);
2228 /* may have to add back in if and when safe distributed caching of
2229 directories added e.g. via FindNotify */