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, const bool is_dfs_referral)
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_NO_BRL)
48 inode->i_fop = &cifs_file_nobrl_ops;
49 else { /* not direct, send byte range locks */
50 inode->i_fop = &cifs_file_ops;
54 /* check if server can support readpages */
55 if (cifs_sb_master_tcon(cifs_sb)->ses->server->maxBuf <
56 PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
57 inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
59 inode->i_data.a_ops = &cifs_addr_ops;
62 #ifdef CONFIG_CIFS_DFS_UPCALL
63 if (is_dfs_referral) {
64 inode->i_op = &cifs_dfs_referral_inode_operations;
66 #else /* NO DFS support, treat as a directory */
69 inode->i_op = &cifs_dir_inode_ops;
70 inode->i_fop = &cifs_dir_ops;
74 inode->i_op = &cifs_symlink_inode_ops;
77 init_special_inode(inode, inode->i_mode, inode->i_rdev);
82 /* check inode attributes against fattr. If they don't match, tag the
83 * inode for cache invalidation
86 cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
88 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
90 cFYI(1, "%s: revalidating inode %llu", __func__, cifs_i->uniqueid);
92 if (inode->i_state & I_NEW) {
93 cFYI(1, "%s: inode %llu is new", __func__, cifs_i->uniqueid);
97 /* don't bother with revalidation if we have an oplock */
98 if (cifs_i->clientCanCacheRead) {
99 cFYI(1, "%s: inode %llu is oplocked", __func__,
104 /* revalidate if mtime or size have changed */
105 if (timespec_equal(&inode->i_mtime, &fattr->cf_mtime) &&
106 cifs_i->server_eof == fattr->cf_eof) {
107 cFYI(1, "%s: inode %llu is unchanged", __func__,
112 cFYI(1, "%s: invalidating inode %llu mapping", __func__,
114 cifs_i->invalid_mapping = true;
117 /* populate an inode with info from a cifs_fattr struct */
119 cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
121 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
122 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
123 unsigned long oldtime = cifs_i->time;
125 cifs_revalidate_cache(inode, fattr);
127 inode->i_atime = fattr->cf_atime;
128 inode->i_mtime = fattr->cf_mtime;
129 inode->i_ctime = fattr->cf_ctime;
130 inode->i_rdev = fattr->cf_rdev;
131 inode->i_nlink = fattr->cf_nlink;
132 inode->i_uid = fattr->cf_uid;
133 inode->i_gid = fattr->cf_gid;
135 /* if dynperm is set, don't clobber existing mode */
136 if (inode->i_state & I_NEW ||
137 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
138 inode->i_mode = fattr->cf_mode;
140 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
142 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
145 cifs_i->time = jiffies;
147 cFYI(1, "inode 0x%p old_time=%ld new_time=%ld", inode,
148 oldtime, cifs_i->time);
150 cifs_i->delete_pending = fattr->cf_flags & CIFS_FATTR_DELETE_PENDING;
152 cifs_i->server_eof = fattr->cf_eof;
154 * Can't safely change the file size here if the client is writing to
155 * it due to potential races.
157 spin_lock(&inode->i_lock);
158 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
159 i_size_write(inode, fattr->cf_eof);
162 * i_blocks is not related to (i_size / i_blksize),
163 * but instead 512 byte (2**9) size is required for
164 * calculating num blocks.
166 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
168 spin_unlock(&inode->i_lock);
170 cifs_set_ops(inode, fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL);
174 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
176 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
178 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
181 fattr->cf_uniqueid = iunique(sb, ROOT_I);
184 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
186 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
187 struct cifs_sb_info *cifs_sb)
189 memset(fattr, 0, sizeof(*fattr));
190 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
191 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
192 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
194 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
195 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
196 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
197 fattr->cf_mode = le64_to_cpu(info->Permissions);
200 * Since we set the inode type below we need to mask off
201 * to avoid strange results if bits set above.
203 fattr->cf_mode &= ~S_IFMT;
204 switch (le32_to_cpu(info->Type)) {
206 fattr->cf_mode |= S_IFREG;
207 fattr->cf_dtype = DT_REG;
210 fattr->cf_mode |= S_IFLNK;
211 fattr->cf_dtype = DT_LNK;
214 fattr->cf_mode |= S_IFDIR;
215 fattr->cf_dtype = DT_DIR;
218 fattr->cf_mode |= S_IFCHR;
219 fattr->cf_dtype = DT_CHR;
220 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
221 le64_to_cpu(info->DevMinor) & MINORMASK);
224 fattr->cf_mode |= S_IFBLK;
225 fattr->cf_dtype = DT_BLK;
226 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
227 le64_to_cpu(info->DevMinor) & MINORMASK);
230 fattr->cf_mode |= S_IFIFO;
231 fattr->cf_dtype = DT_FIFO;
234 fattr->cf_mode |= S_IFSOCK;
235 fattr->cf_dtype = DT_SOCK;
238 /* safest to call it a file if we do not know */
239 fattr->cf_mode |= S_IFREG;
240 fattr->cf_dtype = DT_REG;
241 cFYI(1, "unknown type %d", le32_to_cpu(info->Type));
245 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
246 fattr->cf_uid = cifs_sb->mnt_uid;
248 fattr->cf_uid = le64_to_cpu(info->Uid);
250 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
251 fattr->cf_gid = cifs_sb->mnt_gid;
253 fattr->cf_gid = le64_to_cpu(info->Gid);
255 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
259 * Fill a cifs_fattr struct with fake inode info.
261 * Needed to setup cifs_fattr data for the directory which is the
262 * junction to the new submount (ie to setup the fake directory
263 * which represents a DFS referral).
266 cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
268 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
270 cFYI(1, "creating fake fattr for DFS referral");
272 memset(fattr, 0, sizeof(*fattr));
273 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
274 fattr->cf_uid = cifs_sb->mnt_uid;
275 fattr->cf_gid = cifs_sb->mnt_gid;
276 fattr->cf_atime = CURRENT_TIME;
277 fattr->cf_ctime = CURRENT_TIME;
278 fattr->cf_mtime = CURRENT_TIME;
280 fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
283 int cifs_get_file_info_unix(struct file *filp)
287 FILE_UNIX_BASIC_INFO find_data;
288 struct cifs_fattr fattr;
289 struct inode *inode = filp->f_path.dentry->d_inode;
290 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
291 struct cifsFileInfo *cfile = filp->private_data;
292 struct cifsTconInfo *tcon = tlink_tcon(cfile->tlink);
295 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->netfid, &find_data);
297 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
298 } else if (rc == -EREMOTE) {
299 cifs_create_dfs_fattr(&fattr, inode->i_sb);
303 cifs_fattr_to_inode(inode, &fattr);
308 int cifs_get_inode_info_unix(struct inode **pinode,
309 const unsigned char *full_path,
310 struct super_block *sb, int xid)
313 FILE_UNIX_BASIC_INFO find_data;
314 struct cifs_fattr fattr;
315 struct cifsTconInfo *tcon;
316 struct tcon_link *tlink;
317 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
319 cFYI(1, "Getting info on %s", full_path);
321 tlink = cifs_sb_tlink(cifs_sb);
323 return PTR_ERR(tlink);
324 tcon = tlink_tcon(tlink);
326 /* could have done a find first instead but this returns more info */
327 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
328 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
329 CIFS_MOUNT_MAP_SPECIAL_CHR);
330 cifs_put_tlink(tlink);
333 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
334 } else if (rc == -EREMOTE) {
335 cifs_create_dfs_fattr(&fattr, sb);
341 /* check for Minshall+French symlinks */
342 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
343 int tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
345 cFYI(1, "CIFSCheckMFSymlink: %d", tmprc);
348 if (*pinode == NULL) {
350 cifs_fill_uniqueid(sb, &fattr);
351 *pinode = cifs_iget(sb, &fattr);
355 /* we already have inode, update it */
356 cifs_fattr_to_inode(*pinode, &fattr);
363 cifs_sfu_type(struct cifs_fattr *fattr, const unsigned char *path,
364 struct cifs_sb_info *cifs_sb, int xid)
369 struct tcon_link *tlink;
370 struct cifsTconInfo *tcon;
372 unsigned int bytes_read;
377 fattr->cf_mode &= ~S_IFMT;
379 if (fattr->cf_eof == 0) {
380 fattr->cf_mode |= S_IFIFO;
381 fattr->cf_dtype = DT_FIFO;
383 } else if (fattr->cf_eof < 8) {
384 fattr->cf_mode |= S_IFREG;
385 fattr->cf_dtype = DT_REG;
386 return -EINVAL; /* EOPNOTSUPP? */
389 tlink = cifs_sb_tlink(cifs_sb);
391 return PTR_ERR(tlink);
392 tcon = tlink_tcon(tlink);
394 rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, GENERIC_READ,
395 CREATE_NOT_DIR, &netfid, &oplock, NULL,
397 cifs_sb->mnt_cifs_flags &
398 CIFS_MOUNT_MAP_SPECIAL_CHR);
400 int buf_type = CIFS_NO_BUFFER;
402 rc = CIFSSMBRead(xid, tcon, netfid,
403 24 /* length */, 0 /* offset */,
404 &bytes_read, &pbuf, &buf_type);
405 if ((rc == 0) && (bytes_read >= 8)) {
406 if (memcmp("IntxBLK", pbuf, 8) == 0) {
407 cFYI(1, "Block device");
408 fattr->cf_mode |= S_IFBLK;
409 fattr->cf_dtype = DT_BLK;
410 if (bytes_read == 24) {
411 /* we have enough to decode dev num */
412 __u64 mjr; /* major */
413 __u64 mnr; /* minor */
414 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
415 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
416 fattr->cf_rdev = MKDEV(mjr, mnr);
418 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
419 cFYI(1, "Char device");
420 fattr->cf_mode |= S_IFCHR;
421 fattr->cf_dtype = DT_CHR;
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("IntxLNK", pbuf, 7) == 0) {
432 fattr->cf_mode |= S_IFLNK;
433 fattr->cf_dtype = DT_LNK;
435 fattr->cf_mode |= S_IFREG; /* file? */
436 fattr->cf_dtype = DT_REG;
440 fattr->cf_mode |= S_IFREG; /* then it is a file */
441 fattr->cf_dtype = DT_REG;
442 rc = -EOPNOTSUPP; /* or some unknown SFU type */
444 CIFSSMBClose(xid, tcon, netfid);
446 cifs_put_tlink(tlink);
450 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
453 * Fetch mode bits as provided by SFU.
455 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
457 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
458 struct cifs_sb_info *cifs_sb, int xid)
460 #ifdef CONFIG_CIFS_XATTR
464 struct tcon_link *tlink;
465 struct cifsTconInfo *tcon;
467 tlink = cifs_sb_tlink(cifs_sb);
469 return PTR_ERR(tlink);
470 tcon = tlink_tcon(tlink);
472 rc = CIFSSMBQAllEAs(xid, tcon, path, "SETFILEBITS",
473 ea_value, 4 /* size of buf */, cifs_sb->local_nls,
474 cifs_sb->mnt_cifs_flags &
475 CIFS_MOUNT_MAP_SPECIAL_CHR);
476 cifs_put_tlink(tlink);
480 mode = le32_to_cpu(*((__le32 *)ea_value));
481 fattr->cf_mode &= ~SFBITS_MASK;
482 cFYI(1, "special bits 0%o org mode 0%o", mode,
484 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
485 cFYI(1, "special mode bits 0%o", mode);
494 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
496 cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
497 struct cifs_sb_info *cifs_sb, bool adjust_tz)
499 struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
501 memset(fattr, 0, sizeof(*fattr));
502 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
503 if (info->DeletePending)
504 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
506 if (info->LastAccessTime)
507 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
509 fattr->cf_atime = CURRENT_TIME;
511 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
512 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
515 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
516 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
519 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
520 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
522 if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
523 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
524 fattr->cf_dtype = DT_DIR;
526 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
527 fattr->cf_dtype = DT_REG;
529 /* clear write bits if ATTR_READONLY is set */
530 if (fattr->cf_cifsattrs & ATTR_READONLY)
531 fattr->cf_mode &= ~(S_IWUGO);
534 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
536 fattr->cf_uid = cifs_sb->mnt_uid;
537 fattr->cf_gid = cifs_sb->mnt_gid;
540 int cifs_get_file_info(struct file *filp)
544 FILE_ALL_INFO find_data;
545 struct cifs_fattr fattr;
546 struct inode *inode = filp->f_path.dentry->d_inode;
547 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
548 struct cifsFileInfo *cfile = filp->private_data;
549 struct cifsTconInfo *tcon = tlink_tcon(cfile->tlink);
552 rc = CIFSSMBQFileInfo(xid, tcon, cfile->netfid, &find_data);
553 if (rc == -EOPNOTSUPP || rc == -EINVAL) {
555 * FIXME: legacy server -- fall back to path-based call?
556 * for now, just skip revalidating and mark inode for
560 CIFS_I(inode)->time = 0;
562 } else if (rc == -EREMOTE) {
563 cifs_create_dfs_fattr(&fattr, inode->i_sb);
569 * don't bother with SFU junk here -- just mark inode as needing
572 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false);
573 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
574 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
575 cifs_fattr_to_inode(inode, &fattr);
581 int cifs_get_inode_info(struct inode **pinode,
582 const unsigned char *full_path, FILE_ALL_INFO *pfindData,
583 struct super_block *sb, int xid, const __u16 *pfid)
586 struct cifsTconInfo *pTcon;
587 struct tcon_link *tlink;
588 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
590 bool adjustTZ = false;
591 struct cifs_fattr fattr;
593 tlink = cifs_sb_tlink(cifs_sb);
595 return PTR_ERR(tlink);
596 pTcon = tlink_tcon(tlink);
598 cFYI(1, "Getting info on %s", full_path);
600 if ((pfindData == NULL) && (*pinode != NULL)) {
601 if (CIFS_I(*pinode)->clientCanCacheRead) {
602 cFYI(1, "No need to revalidate cached inode sizes");
607 /* if file info not passed in then get it from server */
608 if (pfindData == NULL) {
609 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
614 pfindData = (FILE_ALL_INFO *)buf;
616 /* could do find first instead but this returns more info */
617 rc = CIFSSMBQPathInfo(xid, pTcon, full_path, pfindData,
619 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
620 CIFS_MOUNT_MAP_SPECIAL_CHR);
621 /* BB optimize code so we do not make the above call
622 when server claims no NT SMB support and the above call
623 failed at least once - set flag in tcon or mount */
624 if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
625 rc = SMBQueryInformation(xid, pTcon, full_path,
626 pfindData, cifs_sb->local_nls,
627 cifs_sb->mnt_cifs_flags &
628 CIFS_MOUNT_MAP_SPECIAL_CHR);
634 cifs_all_info_to_fattr(&fattr, (FILE_ALL_INFO *) pfindData,
636 } else if (rc == -EREMOTE) {
637 cifs_create_dfs_fattr(&fattr, sb);
644 * If an inode wasn't passed in, then get the inode number
646 * Is an i_ino of zero legal? Can we use that to check if the server
647 * supports returning inode numbers? Are there other sanity checks we
648 * can use to ensure that the server is really filling in that field?
650 * We can not use the IndexNumber field by default from Windows or
651 * Samba (in ALL_INFO buf) but we can request it explicitly. The SNIA
652 * CIFS spec claims that this value is unique within the scope of a
653 * share, and the windows docs hint that it's actually unique
656 * There may be higher info levels that work but are there Windows
657 * server or network appliances for which IndexNumber field is not
660 if (*pinode == NULL) {
661 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
664 rc1 = CIFSGetSrvInodeNumber(xid, pTcon,
665 full_path, &fattr.cf_uniqueid,
667 cifs_sb->mnt_cifs_flags &
668 CIFS_MOUNT_MAP_SPECIAL_CHR);
669 if (rc1 || !fattr.cf_uniqueid) {
670 cFYI(1, "GetSrvInodeNum rc %d", rc1);
671 fattr.cf_uniqueid = iunique(sb, ROOT_I);
672 cifs_autodisable_serverino(cifs_sb);
675 fattr.cf_uniqueid = iunique(sb, ROOT_I);
678 fattr.cf_uniqueid = CIFS_I(*pinode)->uniqueid;
681 /* query for SFU type info if supported and needed */
682 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
683 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
684 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
686 cFYI(1, "cifs_sfu_type failed: %d", tmprc);
689 #ifdef CONFIG_CIFS_ACL
690 /* fill in 0777 bits from ACL */
691 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
692 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *pinode, full_path,
695 cFYI(1, "%s: Getting ACL failed with error: %d",
700 #endif /* CONFIG_CIFS_ACL */
702 /* fill in remaining high mode bits e.g. SUID, VTX */
703 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
704 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
706 /* check for Minshall+French symlinks */
707 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
708 tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
710 cFYI(1, "CIFSCheckMFSymlink: %d", tmprc);
714 *pinode = cifs_iget(sb, &fattr);
718 cifs_fattr_to_inode(*pinode, &fattr);
723 cifs_put_tlink(tlink);
727 static const struct inode_operations cifs_ipc_inode_ops = {
728 .lookup = cifs_lookup,
731 char *cifs_build_path_to_root(struct cifs_sb_info *cifs_sb,
732 struct cifsTconInfo *tcon)
734 int pplen = cifs_sb->prepathlen;
736 char *full_path = NULL;
738 /* if no prefix path, simply set path to the root of share to "" */
740 full_path = kmalloc(1, GFP_KERNEL);
746 if (tcon->Flags & SMB_SHARE_IS_IN_DFS)
747 dfsplen = strnlen(tcon->treeName, MAX_TREE_SIZE + 1);
751 full_path = kmalloc(dfsplen + pplen + 1, GFP_KERNEL);
752 if (full_path == NULL)
756 strncpy(full_path, tcon->treeName, dfsplen);
757 /* switch slash direction in prepath depending on whether
758 * windows or posix style path names
760 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
762 for (i = 0; i < dfsplen; i++) {
763 if (full_path[i] == '\\')
768 strncpy(full_path + dfsplen, cifs_sb->prepath, pplen);
769 full_path[dfsplen + pplen] = 0; /* add trailing null */
774 cifs_find_inode(struct inode *inode, void *opaque)
776 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
778 /* don't match inode with different uniqueid */
779 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
782 /* don't match inode of different type */
783 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
786 /* if it's not a directory or has no dentries, then flag it */
787 if (S_ISDIR(inode->i_mode) && !list_empty(&inode->i_dentry))
788 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
794 cifs_init_inode(struct inode *inode, void *opaque)
796 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
798 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
803 * walk dentry list for an inode and report whether it has aliases that
804 * are hashed. We use this to determine if a directory inode can actually
808 inode_has_hashed_dentries(struct inode *inode)
810 struct dentry *dentry;
812 spin_lock(&dcache_lock);
813 list_for_each_entry(dentry, &inode->i_dentry, d_alias) {
814 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
815 spin_unlock(&dcache_lock);
819 spin_unlock(&dcache_lock);
823 /* Given fattrs, get a corresponding inode */
825 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
831 cFYI(1, "looking for uniqueid=%llu", fattr->cf_uniqueid);
833 /* hash down to 32-bits on 32-bit arch */
834 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
836 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
838 /* was there a potentially problematic inode collision? */
839 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
840 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
842 if (inode_has_hashed_dentries(inode)) {
843 cifs_autodisable_serverino(CIFS_SB(sb));
845 fattr->cf_uniqueid = iunique(sb, ROOT_I);
846 goto retry_iget5_locked;
850 cifs_fattr_to_inode(inode, fattr);
851 if (sb->s_flags & MS_NOATIME)
852 inode->i_flags |= S_NOATIME | S_NOCMTIME;
853 if (inode->i_state & I_NEW) {
855 if (S_ISREG(inode->i_mode))
856 inode->i_data.backing_dev_info = sb->s_bdi;
857 #ifdef CONFIG_CIFS_FSCACHE
858 /* initialize per-inode cache cookie pointer */
859 CIFS_I(inode)->fscache = NULL;
861 unlock_new_inode(inode);
868 /* gets root inode */
869 struct inode *cifs_root_iget(struct super_block *sb, unsigned long ino)
872 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
873 struct inode *inode = NULL;
876 struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
878 full_path = cifs_build_path_to_root(cifs_sb, tcon);
879 if (full_path == NULL)
880 return ERR_PTR(-ENOMEM);
884 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
886 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
894 #ifdef CONFIG_CIFS_FSCACHE
895 /* populate tcon->resource_id */
896 tcon->resource_id = CIFS_I(inode)->uniqueid;
899 if (rc && tcon->ipc) {
900 cFYI(1, "ipc connection - fake read inode");
901 inode->i_mode |= S_IFDIR;
903 inode->i_op = &cifs_ipc_inode_ops;
904 inode->i_fop = &simple_dir_operations;
905 inode->i_uid = cifs_sb->mnt_uid;
906 inode->i_gid = cifs_sb->mnt_gid;
914 /* can not call macro FreeXid here since in a void func
915 * TODO: This is no longer true
922 cifs_set_file_info(struct inode *inode, struct iattr *attrs, int xid,
923 char *full_path, __u32 dosattr)
929 bool set_time = false;
930 struct cifsFileInfo *open_file;
931 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
932 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
933 struct tcon_link *tlink = NULL;
934 struct cifsTconInfo *pTcon;
935 FILE_BASIC_INFO info_buf;
940 if (attrs->ia_valid & ATTR_ATIME) {
942 info_buf.LastAccessTime =
943 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
945 info_buf.LastAccessTime = 0;
947 if (attrs->ia_valid & ATTR_MTIME) {
949 info_buf.LastWriteTime =
950 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
952 info_buf.LastWriteTime = 0;
955 * Samba throws this field away, but windows may actually use it.
956 * Do not set ctime unless other time stamps are changed explicitly
957 * (i.e. by utimes()) since we would then have a mix of client and
960 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
961 cFYI(1, "CIFS - CTIME changed");
962 info_buf.ChangeTime =
963 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
965 info_buf.ChangeTime = 0;
967 info_buf.CreationTime = 0; /* don't change */
968 info_buf.Attributes = cpu_to_le32(dosattr);
971 * If the file is already open for write, just use that fileid
973 open_file = find_writable_file(cifsInode, true);
975 netfid = open_file->netfid;
976 netpid = open_file->pid;
977 pTcon = tlink_tcon(open_file->tlink);
978 goto set_via_filehandle;
981 tlink = cifs_sb_tlink(cifs_sb);
987 pTcon = tlink_tcon(tlink);
990 * NT4 apparently returns success on this call, but it doesn't
993 if (!(pTcon->ses->flags & CIFS_SES_NT4)) {
994 rc = CIFSSMBSetPathInfo(xid, pTcon, full_path,
995 &info_buf, cifs_sb->local_nls,
996 cifs_sb->mnt_cifs_flags &
997 CIFS_MOUNT_MAP_SPECIAL_CHR);
999 cifsInode->cifsAttrs = dosattr;
1001 } else if (rc != -EOPNOTSUPP && rc != -EINVAL)
1005 cFYI(1, "calling SetFileInfo since SetPathInfo for "
1006 "times not supported by this server");
1007 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
1008 SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
1009 CREATE_NOT_DIR, &netfid, &oplock,
1010 NULL, cifs_sb->local_nls,
1011 cifs_sb->mnt_cifs_flags &
1012 CIFS_MOUNT_MAP_SPECIAL_CHR);
1020 netpid = current->tgid;
1023 rc = CIFSSMBSetFileInfo(xid, pTcon, &info_buf, netfid, netpid);
1025 cifsInode->cifsAttrs = dosattr;
1027 if (open_file == NULL)
1028 CIFSSMBClose(xid, pTcon, netfid);
1030 cifsFileInfo_put(open_file);
1033 cifs_put_tlink(tlink);
1038 * open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1039 * and rename it to a random name that hopefully won't conflict with
1043 cifs_rename_pending_delete(char *full_path, struct dentry *dentry, int xid)
1048 struct inode *inode = dentry->d_inode;
1049 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1050 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1051 struct tcon_link *tlink;
1052 struct cifsTconInfo *tcon;
1053 __u32 dosattr, origattr;
1054 FILE_BASIC_INFO *info_buf = NULL;
1056 tlink = cifs_sb_tlink(cifs_sb);
1058 return PTR_ERR(tlink);
1059 tcon = tlink_tcon(tlink);
1061 rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
1062 DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
1063 &netfid, &oplock, NULL, cifs_sb->local_nls,
1064 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1068 origattr = cifsInode->cifsAttrs;
1070 origattr |= ATTR_NORMAL;
1072 dosattr = origattr & ~ATTR_READONLY;
1074 dosattr |= ATTR_NORMAL;
1075 dosattr |= ATTR_HIDDEN;
1077 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1078 if (dosattr != origattr) {
1079 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1080 if (info_buf == NULL) {
1084 info_buf->Attributes = cpu_to_le32(dosattr);
1085 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1087 /* although we would like to mark the file hidden
1088 if that fails we will still try to rename it */
1090 cifsInode->cifsAttrs = dosattr;
1092 dosattr = origattr; /* since not able to change them */
1095 /* rename the file */
1096 rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
1097 cifs_sb->mnt_cifs_flags &
1098 CIFS_MOUNT_MAP_SPECIAL_CHR);
1104 /* try to set DELETE_ON_CLOSE */
1105 if (!cifsInode->delete_pending) {
1106 rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
1109 * some samba versions return -ENOENT when we try to set the
1110 * file disposition here. Likely a samba bug, but work around
1111 * it for now. This means that some cifsXXX files may hang
1112 * around after they shouldn't.
1114 * BB: remove this hack after more servers have the fix
1122 cifsInode->delete_pending = true;
1126 CIFSSMBClose(xid, tcon, netfid);
1129 cifs_put_tlink(tlink);
1133 * reset everything back to the original state. Don't bother
1134 * dealing with errors here since we can't do anything about
1138 CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
1139 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1140 CIFS_MOUNT_MAP_SPECIAL_CHR);
1142 if (dosattr != origattr) {
1143 info_buf->Attributes = cpu_to_le32(origattr);
1144 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1146 cifsInode->cifsAttrs = origattr;
1154 * If dentry->d_inode is null (usually meaning the cached dentry
1155 * is a negative dentry) then we would attempt a standard SMB delete, but
1156 * if that fails we can not attempt the fall back mechanisms on EACCESS
1157 * but will return the EACCESS to the caller. Note that the VFS does not call
1158 * unlink on negative dentries currently.
1160 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1164 char *full_path = NULL;
1165 struct inode *inode = dentry->d_inode;
1166 struct cifsInodeInfo *cifs_inode;
1167 struct super_block *sb = dir->i_sb;
1168 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1169 struct tcon_link *tlink;
1170 struct cifsTconInfo *tcon;
1171 struct iattr *attrs = NULL;
1172 __u32 dosattr = 0, origattr = 0;
1174 cFYI(1, "cifs_unlink, dir=0x%p, dentry=0x%p", dir, dentry);
1176 tlink = cifs_sb_tlink(cifs_sb);
1178 return PTR_ERR(tlink);
1179 tcon = tlink_tcon(tlink);
1183 /* Unlink can be called from rename so we can not take the
1184 * sb->s_vfs_rename_mutex here */
1185 full_path = build_path_from_dentry(dentry);
1186 if (full_path == NULL) {
1191 if ((tcon->ses->capabilities & CAP_UNIX) &&
1192 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1193 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1194 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1195 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1196 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1197 cFYI(1, "posix del rc %d", rc);
1198 if ((rc == 0) || (rc == -ENOENT))
1199 goto psx_del_no_retry;
1203 rc = CIFSSMBDelFile(xid, tcon, full_path, cifs_sb->local_nls,
1204 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1210 } else if (rc == -ENOENT) {
1212 } else if (rc == -ETXTBSY) {
1213 rc = cifs_rename_pending_delete(full_path, dentry, xid);
1216 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1217 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1218 if (attrs == NULL) {
1223 /* try to reset dos attributes */
1224 cifs_inode = CIFS_I(inode);
1225 origattr = cifs_inode->cifsAttrs;
1227 origattr |= ATTR_NORMAL;
1228 dosattr = origattr & ~ATTR_READONLY;
1230 dosattr |= ATTR_NORMAL;
1231 dosattr |= ATTR_HIDDEN;
1233 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1237 goto retry_std_delete;
1240 /* undo the setattr if we errored out and it's needed */
1241 if (rc != 0 && dosattr != 0)
1242 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1246 cifs_inode = CIFS_I(inode);
1247 cifs_inode->time = 0; /* will force revalidate to get info
1249 inode->i_ctime = current_fs_time(sb);
1251 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1252 cifs_inode = CIFS_I(dir);
1253 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1258 cifs_put_tlink(tlink);
1262 int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
1266 struct cifs_sb_info *cifs_sb;
1267 struct tcon_link *tlink;
1268 struct cifsTconInfo *pTcon;
1269 char *full_path = NULL;
1270 struct inode *newinode = NULL;
1271 struct cifs_fattr fattr;
1273 cFYI(1, "In cifs_mkdir, mode = 0x%x inode = 0x%p", mode, inode);
1275 cifs_sb = CIFS_SB(inode->i_sb);
1276 tlink = cifs_sb_tlink(cifs_sb);
1278 return PTR_ERR(tlink);
1279 pTcon = tlink_tcon(tlink);
1283 full_path = build_path_from_dentry(direntry);
1284 if (full_path == NULL) {
1289 if ((pTcon->ses->capabilities & CAP_UNIX) &&
1290 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1291 le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
1293 FILE_UNIX_BASIC_INFO *pInfo =
1294 kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1295 if (pInfo == NULL) {
1300 mode &= ~current_umask();
1301 rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
1302 mode, NULL /* netfid */, pInfo, &oplock,
1303 full_path, cifs_sb->local_nls,
1304 cifs_sb->mnt_cifs_flags &
1305 CIFS_MOUNT_MAP_SPECIAL_CHR);
1306 if (rc == -EOPNOTSUPP) {
1308 goto mkdir_retry_old;
1310 cFYI(1, "posix mkdir returned 0x%x", rc);
1313 if (pInfo->Type == cpu_to_le32(-1)) {
1314 /* no return info, go query for it */
1316 goto mkdir_get_info;
1318 /*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
1322 direntry->d_op = &cifs_ci_dentry_ops;
1324 direntry->d_op = &cifs_dentry_ops;
1326 cifs_unix_basic_to_fattr(&fattr, pInfo, cifs_sb);
1327 cifs_fill_uniqueid(inode->i_sb, &fattr);
1328 newinode = cifs_iget(inode->i_sb, &fattr);
1331 goto mkdir_get_info;
1334 d_instantiate(direntry, newinode);
1336 #ifdef CONFIG_CIFS_DEBUG2
1337 cFYI(1, "instantiated dentry %p %s to inode %p",
1338 direntry, direntry->d_name.name, newinode);
1340 if (newinode->i_nlink != 2)
1341 cFYI(1, "unexpected number of links %d",
1349 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1350 rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
1351 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1353 cFYI(1, "cifs_mkdir returned 0x%x", rc);
1358 if (pTcon->unix_ext)
1359 rc = cifs_get_inode_info_unix(&newinode, full_path,
1362 rc = cifs_get_inode_info(&newinode, full_path, NULL,
1363 inode->i_sb, xid, NULL);
1366 direntry->d_op = &cifs_ci_dentry_ops;
1368 direntry->d_op = &cifs_dentry_ops;
1369 d_instantiate(direntry, newinode);
1370 /* setting nlink not necessary except in cases where we
1371 * failed to get it from the server or was set bogus */
1372 if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
1373 direntry->d_inode->i_nlink = 2;
1375 mode &= ~current_umask();
1376 /* must turn on setgid bit if parent dir has it */
1377 if (inode->i_mode & S_ISGID)
1380 if (pTcon->unix_ext) {
1381 struct cifs_unix_set_info_args args = {
1383 .ctime = NO_CHANGE_64,
1384 .atime = NO_CHANGE_64,
1385 .mtime = NO_CHANGE_64,
1388 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1389 args.uid = (__u64)current_fsuid();
1390 if (inode->i_mode & S_ISGID)
1391 args.gid = (__u64)inode->i_gid;
1393 args.gid = (__u64)current_fsgid();
1395 args.uid = NO_CHANGE_64;
1396 args.gid = NO_CHANGE_64;
1398 CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
1400 cifs_sb->mnt_cifs_flags &
1401 CIFS_MOUNT_MAP_SPECIAL_CHR);
1403 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1404 (mode & S_IWUGO) == 0) {
1405 FILE_BASIC_INFO pInfo;
1406 struct cifsInodeInfo *cifsInode;
1409 memset(&pInfo, 0, sizeof(pInfo));
1410 cifsInode = CIFS_I(newinode);
1411 dosattrs = cifsInode->cifsAttrs|ATTR_READONLY;
1412 pInfo.Attributes = cpu_to_le32(dosattrs);
1413 tmprc = CIFSSMBSetPathInfo(xid, pTcon,
1416 cifs_sb->mnt_cifs_flags &
1417 CIFS_MOUNT_MAP_SPECIAL_CHR);
1419 cifsInode->cifsAttrs = dosattrs;
1421 if (direntry->d_inode) {
1422 if (cifs_sb->mnt_cifs_flags &
1424 direntry->d_inode->i_mode =
1427 if (cifs_sb->mnt_cifs_flags &
1428 CIFS_MOUNT_SET_UID) {
1429 direntry->d_inode->i_uid =
1431 if (inode->i_mode & S_ISGID)
1432 direntry->d_inode->i_gid =
1435 direntry->d_inode->i_gid =
1444 cifs_put_tlink(tlink);
1448 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1452 struct cifs_sb_info *cifs_sb;
1453 struct tcon_link *tlink;
1454 struct cifsTconInfo *pTcon;
1455 char *full_path = NULL;
1456 struct cifsInodeInfo *cifsInode;
1458 cFYI(1, "cifs_rmdir, inode = 0x%p", inode);
1462 full_path = build_path_from_dentry(direntry);
1463 if (full_path == NULL) {
1468 cifs_sb = CIFS_SB(inode->i_sb);
1469 tlink = cifs_sb_tlink(cifs_sb);
1470 if (IS_ERR(tlink)) {
1471 rc = PTR_ERR(tlink);
1474 pTcon = tlink_tcon(tlink);
1476 rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
1477 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1478 cifs_put_tlink(tlink);
1482 spin_lock(&direntry->d_inode->i_lock);
1483 i_size_write(direntry->d_inode, 0);
1484 clear_nlink(direntry->d_inode);
1485 spin_unlock(&direntry->d_inode->i_lock);
1488 cifsInode = CIFS_I(direntry->d_inode);
1489 cifsInode->time = 0; /* force revalidate to go get info when
1492 cifsInode = CIFS_I(inode);
1493 cifsInode->time = 0; /* force revalidate to get parent dir info
1494 since cached search results now invalid */
1496 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1497 current_fs_time(inode->i_sb);
1506 cifs_do_rename(int xid, struct dentry *from_dentry, const char *fromPath,
1507 struct dentry *to_dentry, const char *toPath)
1509 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1510 struct tcon_link *tlink;
1511 struct cifsTconInfo *pTcon;
1515 tlink = cifs_sb_tlink(cifs_sb);
1517 return PTR_ERR(tlink);
1518 pTcon = tlink_tcon(tlink);
1520 /* try path-based rename first */
1521 rc = CIFSSMBRename(xid, pTcon, fromPath, toPath, cifs_sb->local_nls,
1522 cifs_sb->mnt_cifs_flags &
1523 CIFS_MOUNT_MAP_SPECIAL_CHR);
1526 * don't bother with rename by filehandle unless file is busy and
1527 * source Note that cross directory moves do not work with
1528 * rename by filehandle to various Windows servers.
1530 if (rc == 0 || rc != -ETXTBSY)
1531 goto do_rename_exit;
1533 /* open-file renames don't work across directories */
1534 if (to_dentry->d_parent != from_dentry->d_parent)
1535 goto do_rename_exit;
1537 /* open the file to be renamed -- we need DELETE perms */
1538 rc = CIFSSMBOpen(xid, pTcon, fromPath, FILE_OPEN, DELETE,
1539 CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1540 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1541 CIFS_MOUNT_MAP_SPECIAL_CHR);
1544 rc = CIFSSMBRenameOpenFile(xid, pTcon, srcfid,
1545 (const char *) to_dentry->d_name.name,
1546 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1547 CIFS_MOUNT_MAP_SPECIAL_CHR);
1549 CIFSSMBClose(xid, pTcon, srcfid);
1552 cifs_put_tlink(tlink);
1556 int cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1557 struct inode *target_dir, struct dentry *target_dentry)
1559 char *fromName = NULL;
1560 char *toName = NULL;
1561 struct cifs_sb_info *cifs_sb;
1562 struct tcon_link *tlink;
1563 struct cifsTconInfo *tcon;
1564 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1565 FILE_UNIX_BASIC_INFO *info_buf_target;
1568 cifs_sb = CIFS_SB(source_dir->i_sb);
1569 tlink = cifs_sb_tlink(cifs_sb);
1571 return PTR_ERR(tlink);
1572 tcon = tlink_tcon(tlink);
1577 * we already have the rename sem so we do not need to
1578 * grab it again here to protect the path integrity
1580 fromName = build_path_from_dentry(source_dentry);
1581 if (fromName == NULL) {
1583 goto cifs_rename_exit;
1586 toName = build_path_from_dentry(target_dentry);
1587 if (toName == NULL) {
1589 goto cifs_rename_exit;
1592 rc = cifs_do_rename(xid, source_dentry, fromName,
1593 target_dentry, toName);
1595 if (rc == -EEXIST && tcon->unix_ext) {
1597 * Are src and dst hardlinks of same inode? We can
1598 * only tell with unix extensions enabled
1601 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1603 if (info_buf_source == NULL) {
1605 goto cifs_rename_exit;
1608 info_buf_target = info_buf_source + 1;
1609 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, fromName,
1612 cifs_sb->mnt_cifs_flags &
1613 CIFS_MOUNT_MAP_SPECIAL_CHR);
1617 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, toName,
1620 cifs_sb->mnt_cifs_flags &
1621 CIFS_MOUNT_MAP_SPECIAL_CHR);
1623 if (tmprc == 0 && (info_buf_source->UniqueId ==
1624 info_buf_target->UniqueId)) {
1625 /* same file, POSIX says that this is a noop */
1627 goto cifs_rename_exit;
1629 } /* else ... BB we could add the same check for Windows by
1630 checking the UniqueId via FILE_INTERNAL_INFO */
1633 /* Try unlinking the target dentry if it's not negative */
1634 if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
1635 tmprc = cifs_unlink(target_dir, target_dentry);
1637 goto cifs_rename_exit;
1639 rc = cifs_do_rename(xid, source_dentry, fromName,
1640 target_dentry, toName);
1644 kfree(info_buf_source);
1648 cifs_put_tlink(tlink);
1653 cifs_inode_needs_reval(struct inode *inode)
1655 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1656 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1658 if (cifs_i->clientCanCacheRead)
1661 if (!lookupCacheEnabled)
1664 if (cifs_i->time == 0)
1667 if (!time_in_range(jiffies, cifs_i->time,
1668 cifs_i->time + cifs_sb->actimeo))
1671 /* hardlinked files w/ noserverino get "special" treatment */
1672 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1673 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1680 * Zap the cache. Called when invalid_mapping flag is set.
1683 cifs_invalidate_mapping(struct inode *inode)
1686 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1688 cifs_i->invalid_mapping = false;
1690 /* write back any cached data */
1691 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1692 rc = filemap_write_and_wait(inode->i_mapping);
1693 mapping_set_error(inode->i_mapping, rc);
1695 invalidate_remote_inode(inode);
1696 cifs_fscache_reset_inode_cookie(inode);
1699 int cifs_revalidate_file(struct file *filp)
1702 struct inode *inode = filp->f_path.dentry->d_inode;
1703 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1705 if (!cifs_inode_needs_reval(inode))
1708 if (tlink_tcon(cfile->tlink)->unix_ext)
1709 rc = cifs_get_file_info_unix(filp);
1711 rc = cifs_get_file_info(filp);
1714 if (CIFS_I(inode)->invalid_mapping)
1715 cifs_invalidate_mapping(inode);
1720 /* revalidate a dentry's inode attributes */
1721 int cifs_revalidate_dentry(struct dentry *dentry)
1725 char *full_path = NULL;
1726 struct inode *inode = dentry->d_inode;
1727 struct super_block *sb = dentry->d_sb;
1734 if (!cifs_inode_needs_reval(inode))
1737 /* can not safely grab the rename sem here if rename calls revalidate
1738 since that would deadlock */
1739 full_path = build_path_from_dentry(dentry);
1740 if (full_path == NULL) {
1745 cFYI(1, "Revalidate: %s inode 0x%p count %d dentry: 0x%p d_time %ld "
1746 "jiffies %ld", full_path, inode, inode->i_count.counter,
1747 dentry, dentry->d_time, jiffies);
1749 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1750 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1752 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1756 if (CIFS_I(inode)->invalid_mapping)
1757 cifs_invalidate_mapping(inode);
1764 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1767 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1768 struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
1769 int err = cifs_revalidate_dentry(dentry);
1772 generic_fillattr(dentry->d_inode, stat);
1773 stat->blksize = CIFS_MAX_MSGSIZE;
1774 stat->ino = CIFS_I(dentry->d_inode)->uniqueid;
1777 * If on a multiuser mount without unix extensions, and the
1778 * admin hasn't overridden them, set the ownership to the
1779 * fsuid/fsgid of the current process.
1781 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
1783 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1784 stat->uid = current_fsuid();
1785 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1786 stat->gid = current_fsgid();
1792 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1794 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1795 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1799 page = grab_cache_page(mapping, index);
1803 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1805 page_cache_release(page);
1809 static void cifs_setsize(struct inode *inode, loff_t offset)
1813 spin_lock(&inode->i_lock);
1814 oldsize = inode->i_size;
1815 i_size_write(inode, offset);
1816 spin_unlock(&inode->i_lock);
1818 truncate_pagecache(inode, oldsize, offset);
1822 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1823 int xid, char *full_path)
1826 struct cifsFileInfo *open_file;
1827 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1828 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1829 struct tcon_link *tlink = NULL;
1830 struct cifsTconInfo *pTcon = NULL;
1833 * To avoid spurious oplock breaks from server, in the case of
1834 * inodes that we already have open, avoid doing path based
1835 * setting of file size if we can do it by handle.
1836 * This keeps our caching token (oplock) and avoids timeouts
1837 * when the local oplock break takes longer to flush
1838 * writebehind data than the SMB timeout for the SetPathInfo
1839 * request would allow
1841 open_file = find_writable_file(cifsInode, true);
1843 __u16 nfid = open_file->netfid;
1844 __u32 npid = open_file->pid;
1845 pTcon = tlink_tcon(open_file->tlink);
1846 rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size, nfid,
1848 cifsFileInfo_put(open_file);
1849 cFYI(1, "SetFSize for attrs rc = %d", rc);
1850 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1851 unsigned int bytes_written;
1852 rc = CIFSSMBWrite(xid, pTcon, nfid, 0, attrs->ia_size,
1853 &bytes_written, NULL, NULL, 1);
1854 cFYI(1, "Wrt seteof rc %d", rc);
1860 if (pTcon == NULL) {
1861 tlink = cifs_sb_tlink(cifs_sb);
1863 return PTR_ERR(tlink);
1864 pTcon = tlink_tcon(tlink);
1867 /* Set file size by pathname rather than by handle
1868 either because no valid, writeable file handle for
1869 it was found or because there was an error setting
1871 rc = CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size,
1872 false, cifs_sb->local_nls,
1873 cifs_sb->mnt_cifs_flags &
1874 CIFS_MOUNT_MAP_SPECIAL_CHR);
1875 cFYI(1, "SetEOF by path (setattrs) rc = %d", rc);
1876 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1880 rc = SMBLegacyOpen(xid, pTcon, full_path,
1881 FILE_OPEN, GENERIC_WRITE,
1882 CREATE_NOT_DIR, &netfid, &oplock, NULL,
1884 cifs_sb->mnt_cifs_flags &
1885 CIFS_MOUNT_MAP_SPECIAL_CHR);
1887 unsigned int bytes_written;
1888 rc = CIFSSMBWrite(xid, pTcon, netfid, 0,
1890 &bytes_written, NULL,
1892 cFYI(1, "wrt seteof rc %d", rc);
1893 CIFSSMBClose(xid, pTcon, netfid);
1897 cifs_put_tlink(tlink);
1901 cifsInode->server_eof = attrs->ia_size;
1902 cifs_setsize(inode, attrs->ia_size);
1903 cifs_truncate_page(inode->i_mapping, inode->i_size);
1910 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1914 char *full_path = NULL;
1915 struct inode *inode = direntry->d_inode;
1916 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1917 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1918 struct tcon_link *tlink;
1919 struct cifsTconInfo *pTcon;
1920 struct cifs_unix_set_info_args *args = NULL;
1921 struct cifsFileInfo *open_file;
1923 cFYI(1, "setattr_unix on file %s attrs->ia_valid=0x%x",
1924 direntry->d_name.name, attrs->ia_valid);
1928 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
1929 attrs->ia_valid |= ATTR_FORCE;
1931 rc = inode_change_ok(inode, attrs);
1935 full_path = build_path_from_dentry(direntry);
1936 if (full_path == NULL) {
1942 * Attempt to flush data before changing attributes. We need to do
1943 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1944 * ownership or mode then we may also need to do this. Here, we take
1945 * the safe way out and just do the flush on all setattr requests. If
1946 * the flush returns error, store it to report later and continue.
1948 * BB: This should be smarter. Why bother flushing pages that
1949 * will be truncated anyway? Also, should we error out here if
1950 * the flush returns error?
1952 rc = filemap_write_and_wait(inode->i_mapping);
1953 mapping_set_error(inode->i_mapping, rc);
1956 if (attrs->ia_valid & ATTR_SIZE) {
1957 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1962 /* skip mode change if it's just for clearing setuid/setgid */
1963 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1964 attrs->ia_valid &= ~ATTR_MODE;
1966 args = kmalloc(sizeof(*args), GFP_KERNEL);
1972 /* set up the struct */
1973 if (attrs->ia_valid & ATTR_MODE)
1974 args->mode = attrs->ia_mode;
1976 args->mode = NO_CHANGE_64;
1978 if (attrs->ia_valid & ATTR_UID)
1979 args->uid = attrs->ia_uid;
1981 args->uid = NO_CHANGE_64;
1983 if (attrs->ia_valid & ATTR_GID)
1984 args->gid = attrs->ia_gid;
1986 args->gid = NO_CHANGE_64;
1988 if (attrs->ia_valid & ATTR_ATIME)
1989 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
1991 args->atime = NO_CHANGE_64;
1993 if (attrs->ia_valid & ATTR_MTIME)
1994 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
1996 args->mtime = NO_CHANGE_64;
1998 if (attrs->ia_valid & ATTR_CTIME)
1999 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2001 args->ctime = NO_CHANGE_64;
2004 open_file = find_writable_file(cifsInode, true);
2006 u16 nfid = open_file->netfid;
2007 u32 npid = open_file->pid;
2008 pTcon = tlink_tcon(open_file->tlink);
2009 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2010 cifsFileInfo_put(open_file);
2012 tlink = cifs_sb_tlink(cifs_sb);
2013 if (IS_ERR(tlink)) {
2014 rc = PTR_ERR(tlink);
2017 pTcon = tlink_tcon(tlink);
2018 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2020 cifs_sb->mnt_cifs_flags &
2021 CIFS_MOUNT_MAP_SPECIAL_CHR);
2022 cifs_put_tlink(tlink);
2028 if ((attrs->ia_valid & ATTR_SIZE) &&
2029 attrs->ia_size != i_size_read(inode))
2030 truncate_setsize(inode, attrs->ia_size);
2032 setattr_copy(inode, attrs);
2033 mark_inode_dirty(inode);
2035 /* force revalidate when any of these times are set since some
2036 of the fs types (eg ext3, fat) do not have fine enough
2037 time granularity to match protocol, and we do not have a
2038 a way (yet) to query the server fs's time granularity (and
2039 whether it rounds times down).
2041 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2042 cifsInode->time = 0;
2051 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2054 struct inode *inode = direntry->d_inode;
2055 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2056 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2057 char *full_path = NULL;
2060 __u64 mode = NO_CHANGE_64;
2064 cFYI(1, "setattr on file %s attrs->iavalid 0x%x",
2065 direntry->d_name.name, attrs->ia_valid);
2067 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2068 attrs->ia_valid |= ATTR_FORCE;
2070 rc = inode_change_ok(inode, attrs);
2076 full_path = build_path_from_dentry(direntry);
2077 if (full_path == NULL) {
2084 * Attempt to flush data before changing attributes. We need to do
2085 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2086 * ownership or mode then we may also need to do this. Here, we take
2087 * the safe way out and just do the flush on all setattr requests. If
2088 * the flush returns error, store it to report later and continue.
2090 * BB: This should be smarter. Why bother flushing pages that
2091 * will be truncated anyway? Also, should we error out here if
2092 * the flush returns error?
2094 rc = filemap_write_and_wait(inode->i_mapping);
2095 mapping_set_error(inode->i_mapping, rc);
2098 if (attrs->ia_valid & ATTR_SIZE) {
2099 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2101 goto cifs_setattr_exit;
2105 * Without unix extensions we can't send ownership changes to the
2106 * server, so silently ignore them. This is consistent with how
2107 * local DOS/Windows filesystems behave (VFAT, NTFS, etc). With
2108 * CIFSACL support + proper Windows to Unix idmapping, we may be
2109 * able to support this in the future.
2111 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2112 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2114 /* skip mode change if it's just for clearing setuid/setgid */
2115 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2116 attrs->ia_valid &= ~ATTR_MODE;
2118 if (attrs->ia_valid & ATTR_MODE) {
2119 cFYI(1, "Mode changed to 0%o", attrs->ia_mode);
2120 mode = attrs->ia_mode;
2123 if (attrs->ia_valid & ATTR_MODE) {
2125 #ifdef CONFIG_CIFS_ACL
2126 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2127 rc = mode_to_cifs_acl(inode, full_path, mode);
2129 cFYI(1, "%s: Setting ACL failed with error: %d",
2131 goto cifs_setattr_exit;
2134 #endif /* CONFIG_CIFS_ACL */
2135 if (((mode & S_IWUGO) == 0) &&
2136 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2138 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2140 /* fix up mode if we're not using dynperm */
2141 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2142 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2143 } else if ((mode & S_IWUGO) &&
2144 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2146 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2147 /* Attributes of 0 are ignored */
2149 dosattr |= ATTR_NORMAL;
2151 /* reset local inode permissions to normal */
2152 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2153 attrs->ia_mode &= ~(S_IALLUGO);
2154 if (S_ISDIR(inode->i_mode))
2156 cifs_sb->mnt_dir_mode;
2159 cifs_sb->mnt_file_mode;
2161 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2162 /* ignore mode change - ATTR_READONLY hasn't changed */
2163 attrs->ia_valid &= ~ATTR_MODE;
2167 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2168 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2169 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2170 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2172 /* Even if error on time set, no sense failing the call if
2173 the server would set the time to a reasonable value anyway,
2174 and this check ensures that we are not being called from
2175 sys_utimes in which case we ought to fail the call back to
2176 the user when the server rejects the call */
2177 if ((rc) && (attrs->ia_valid &
2178 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2182 /* do not need local check to inode_check_ok since the server does
2185 goto cifs_setattr_exit;
2187 if ((attrs->ia_valid & ATTR_SIZE) &&
2188 attrs->ia_size != i_size_read(inode))
2189 truncate_setsize(inode, attrs->ia_size);
2191 setattr_copy(inode, attrs);
2192 mark_inode_dirty(inode);
2201 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2203 struct inode *inode = direntry->d_inode;
2204 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2205 struct cifsTconInfo *pTcon = cifs_sb_master_tcon(cifs_sb);
2207 if (pTcon->unix_ext)
2208 return cifs_setattr_unix(direntry, attrs);
2210 return cifs_setattr_nounix(direntry, attrs);
2212 /* BB: add cifs_setattr_legacy for really old servers */
2216 void cifs_delete_inode(struct inode *inode)
2218 cFYI(1, "In cifs_delete_inode, inode = 0x%p", inode);
2219 /* may have to add back in if and when safe distributed caching of
2220 directories added e.g. via FindNotify */