4 * Copyright (C) International Business Machines Corp., 2002,2010
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/stat.h>
23 #include <linux/slab.h>
24 #include <linux/pagemap.h>
25 #include <asm/div64.h>
29 #include "cifsproto.h"
30 #include "cifs_debug.h"
31 #include "cifs_fs_sb.h"
35 static void cifs_set_ops(struct inode *inode)
37 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
39 switch (inode->i_mode & S_IFMT) {
41 inode->i_op = &cifs_file_inode_ops;
42 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
43 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
44 inode->i_fop = &cifs_file_direct_nobrl_ops;
46 inode->i_fop = &cifs_file_direct_ops;
47 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
48 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
49 inode->i_fop = &cifs_file_strict_nobrl_ops;
51 inode->i_fop = &cifs_file_strict_ops;
52 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
53 inode->i_fop = &cifs_file_nobrl_ops;
54 else { /* not direct, send byte range locks */
55 inode->i_fop = &cifs_file_ops;
58 /* check if server can support readpages */
59 if (cifs_sb_master_tcon(cifs_sb)->ses->server->maxBuf <
60 PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
61 inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
63 inode->i_data.a_ops = &cifs_addr_ops;
66 #ifdef CONFIG_CIFS_DFS_UPCALL
67 if (IS_AUTOMOUNT(inode)) {
68 inode->i_op = &cifs_dfs_referral_inode_operations;
70 #else /* NO DFS support, treat as a directory */
73 inode->i_op = &cifs_dir_inode_ops;
74 inode->i_fop = &cifs_dir_ops;
78 inode->i_op = &cifs_symlink_inode_ops;
81 init_special_inode(inode, inode->i_mode, inode->i_rdev);
86 /* check inode attributes against fattr. If they don't match, tag the
87 * inode for cache invalidation
90 cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
92 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
94 cFYI(1, "%s: revalidating inode %llu", __func__, cifs_i->uniqueid);
96 if (inode->i_state & I_NEW) {
97 cFYI(1, "%s: inode %llu is new", __func__, cifs_i->uniqueid);
101 /* don't bother with revalidation if we have an oplock */
102 if (cifs_i->clientCanCacheRead) {
103 cFYI(1, "%s: inode %llu is oplocked", __func__,
108 /* revalidate if mtime or size have changed */
109 if (timespec_equal(&inode->i_mtime, &fattr->cf_mtime) &&
110 cifs_i->server_eof == fattr->cf_eof) {
111 cFYI(1, "%s: inode %llu is unchanged", __func__,
116 cFYI(1, "%s: invalidating inode %llu mapping", __func__,
118 cifs_i->invalid_mapping = true;
121 /* populate an inode with info from a cifs_fattr struct */
123 cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
125 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
126 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
127 unsigned long oldtime = cifs_i->time;
129 cifs_revalidate_cache(inode, fattr);
131 inode->i_atime = fattr->cf_atime;
132 inode->i_mtime = fattr->cf_mtime;
133 inode->i_ctime = fattr->cf_ctime;
134 inode->i_rdev = fattr->cf_rdev;
135 set_nlink(inode, fattr->cf_nlink);
136 inode->i_uid = fattr->cf_uid;
137 inode->i_gid = fattr->cf_gid;
139 /* if dynperm is set, don't clobber existing mode */
140 if (inode->i_state & I_NEW ||
141 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
142 inode->i_mode = fattr->cf_mode;
144 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
146 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
149 cifs_i->time = jiffies;
151 cFYI(1, "inode 0x%p old_time=%ld new_time=%ld", inode,
152 oldtime, cifs_i->time);
154 cifs_i->delete_pending = fattr->cf_flags & CIFS_FATTR_DELETE_PENDING;
156 cifs_i->server_eof = fattr->cf_eof;
158 * Can't safely change the file size here if the client is writing to
159 * it due to potential races.
161 spin_lock(&inode->i_lock);
162 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
163 i_size_write(inode, fattr->cf_eof);
166 * i_blocks is not related to (i_size / i_blksize),
167 * but instead 512 byte (2**9) size is required for
168 * calculating num blocks.
170 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
172 spin_unlock(&inode->i_lock);
174 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
175 inode->i_flags |= S_AUTOMOUNT;
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 cifs_tcon *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, unsigned int xid)
319 FILE_UNIX_BASIC_INFO find_data;
320 struct cifs_fattr fattr;
321 struct cifs_tcon *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, unsigned int xid)
375 struct tcon_link *tlink;
376 struct cifs_tcon *tcon;
377 struct cifs_io_parms io_parms;
379 unsigned int bytes_read;
384 fattr->cf_mode &= ~S_IFMT;
386 if (fattr->cf_eof == 0) {
387 fattr->cf_mode |= S_IFIFO;
388 fattr->cf_dtype = DT_FIFO;
390 } else if (fattr->cf_eof < 8) {
391 fattr->cf_mode |= S_IFREG;
392 fattr->cf_dtype = DT_REG;
393 return -EINVAL; /* EOPNOTSUPP? */
396 tlink = cifs_sb_tlink(cifs_sb);
398 return PTR_ERR(tlink);
399 tcon = tlink_tcon(tlink);
401 rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, GENERIC_READ,
402 CREATE_NOT_DIR, &netfid, &oplock, NULL,
404 cifs_sb->mnt_cifs_flags &
405 CIFS_MOUNT_MAP_SPECIAL_CHR);
407 int buf_type = CIFS_NO_BUFFER;
409 io_parms.netfid = netfid;
410 io_parms.pid = current->tgid;
411 io_parms.tcon = tcon;
413 io_parms.length = 24;
414 rc = CIFSSMBRead(xid, &io_parms, &bytes_read, &pbuf,
416 if ((rc == 0) && (bytes_read >= 8)) {
417 if (memcmp("IntxBLK", pbuf, 8) == 0) {
418 cFYI(1, "Block device");
419 fattr->cf_mode |= S_IFBLK;
420 fattr->cf_dtype = DT_BLK;
421 if (bytes_read == 24) {
422 /* we have enough to decode dev num */
423 __u64 mjr; /* major */
424 __u64 mnr; /* minor */
425 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
426 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
427 fattr->cf_rdev = MKDEV(mjr, mnr);
429 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
430 cFYI(1, "Char device");
431 fattr->cf_mode |= S_IFCHR;
432 fattr->cf_dtype = DT_CHR;
433 if (bytes_read == 24) {
434 /* we have enough to decode dev num */
435 __u64 mjr; /* major */
436 __u64 mnr; /* minor */
437 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
438 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
439 fattr->cf_rdev = MKDEV(mjr, mnr);
441 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
443 fattr->cf_mode |= S_IFLNK;
444 fattr->cf_dtype = DT_LNK;
446 fattr->cf_mode |= S_IFREG; /* file? */
447 fattr->cf_dtype = DT_REG;
451 fattr->cf_mode |= S_IFREG; /* then it is a file */
452 fattr->cf_dtype = DT_REG;
453 rc = -EOPNOTSUPP; /* or some unknown SFU type */
455 CIFSSMBClose(xid, tcon, netfid);
457 cifs_put_tlink(tlink);
461 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
464 * Fetch mode bits as provided by SFU.
466 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
468 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
469 struct cifs_sb_info *cifs_sb, unsigned int xid)
471 #ifdef CONFIG_CIFS_XATTR
475 struct tcon_link *tlink;
476 struct cifs_tcon *tcon;
478 tlink = cifs_sb_tlink(cifs_sb);
480 return PTR_ERR(tlink);
481 tcon = tlink_tcon(tlink);
483 rc = CIFSSMBQAllEAs(xid, tcon, path, "SETFILEBITS",
484 ea_value, 4 /* size of buf */, cifs_sb->local_nls,
485 cifs_sb->mnt_cifs_flags &
486 CIFS_MOUNT_MAP_SPECIAL_CHR);
487 cifs_put_tlink(tlink);
491 mode = le32_to_cpu(*((__le32 *)ea_value));
492 fattr->cf_mode &= ~SFBITS_MASK;
493 cFYI(1, "special bits 0%o org mode 0%o", mode,
495 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
496 cFYI(1, "special mode bits 0%o", mode);
505 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
507 cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
508 struct cifs_sb_info *cifs_sb, bool adjust_tz)
510 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
512 memset(fattr, 0, sizeof(*fattr));
513 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
514 if (info->DeletePending)
515 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
517 if (info->LastAccessTime)
518 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
520 fattr->cf_atime = CURRENT_TIME;
522 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
523 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
526 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
527 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
530 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
531 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
532 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
534 if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
535 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
536 fattr->cf_dtype = DT_DIR;
538 * Server can return wrong NumberOfLinks value for directories
539 * when Unix extensions are disabled - fake it.
543 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
544 fattr->cf_dtype = DT_REG;
546 /* clear write bits if ATTR_READONLY is set */
547 if (fattr->cf_cifsattrs & ATTR_READONLY)
548 fattr->cf_mode &= ~(S_IWUGO);
550 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
553 fattr->cf_uid = cifs_sb->mnt_uid;
554 fattr->cf_gid = cifs_sb->mnt_gid;
557 int cifs_get_file_info(struct file *filp)
561 FILE_ALL_INFO find_data;
562 struct cifs_fattr fattr;
563 struct inode *inode = filp->f_path.dentry->d_inode;
564 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
565 struct cifsFileInfo *cfile = filp->private_data;
566 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
569 rc = CIFSSMBQFileInfo(xid, tcon, cfile->netfid, &find_data);
572 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false);
575 cifs_create_dfs_fattr(&fattr, inode->i_sb);
581 * FIXME: legacy server -- fall back to path-based call?
582 * for now, just skip revalidating and mark inode for
586 CIFS_I(inode)->time = 0;
592 * don't bother with SFU junk here -- just mark inode as needing
595 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
596 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
597 cifs_fattr_to_inode(inode, &fattr);
604 cifs_get_inode_info(struct inode **inode, const char *full_path,
605 FILE_ALL_INFO *data, struct super_block *sb, int xid,
609 struct cifs_tcon *tcon;
610 struct TCP_Server_Info *server;
611 struct tcon_link *tlink;
612 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
614 bool adjust_tz = false;
615 struct cifs_fattr fattr;
617 tlink = cifs_sb_tlink(cifs_sb);
619 return PTR_ERR(tlink);
620 tcon = tlink_tcon(tlink);
621 server = tcon->ses->server;
623 cFYI(1, "Getting info on %s", full_path);
625 if ((data == NULL) && (*inode != NULL)) {
626 if (CIFS_I(*inode)->clientCanCacheRead) {
627 cFYI(1, "No need to revalidate cached inode sizes");
632 /* if inode info is not passed, get it from server */
634 if (!server->ops->query_path_info) {
638 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
643 data = (FILE_ALL_INFO *)buf;
644 rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path,
649 cifs_all_info_to_fattr(&fattr, (FILE_ALL_INFO *)data, cifs_sb,
651 } else if (rc == -EREMOTE) {
652 cifs_create_dfs_fattr(&fattr, sb);
659 * If an inode wasn't passed in, then get the inode number
661 * Is an i_ino of zero legal? Can we use that to check if the server
662 * supports returning inode numbers? Are there other sanity checks we
663 * can use to ensure that the server is really filling in that field?
665 if (*inode == NULL) {
666 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
667 if (server->ops->get_srv_inum)
668 tmprc = server->ops->get_srv_inum(xid, tcon,
669 cifs_sb, full_path, &fattr.cf_uniqueid,
673 if (tmprc || !fattr.cf_uniqueid) {
674 cFYI(1, "GetSrvInodeNum rc %d", tmprc);
675 fattr.cf_uniqueid = iunique(sb, ROOT_I);
676 cifs_autodisable_serverino(cifs_sb);
679 fattr.cf_uniqueid = iunique(sb, ROOT_I);
682 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
685 /* query for SFU type info if supported and needed */
686 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
687 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
688 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
690 cFYI(1, "cifs_sfu_type failed: %d", tmprc);
693 #ifdef CONFIG_CIFS_ACL
694 /* fill in 0777 bits from ACL */
695 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
696 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, full_path, fid);
698 cFYI(1, "%s: Getting ACL failed with error: %d",
703 #endif /* CONFIG_CIFS_ACL */
705 /* fill in remaining high mode bits e.g. SUID, VTX */
706 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
707 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
709 /* check for Minshall+French symlinks */
710 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
711 tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
713 cFYI(1, "CIFSCheckMFSymlink: %d", tmprc);
717 *inode = cifs_iget(sb, &fattr);
721 cifs_fattr_to_inode(*inode, &fattr);
726 cifs_put_tlink(tlink);
730 static const struct inode_operations cifs_ipc_inode_ops = {
731 .lookup = cifs_lookup,
735 cifs_find_inode(struct inode *inode, void *opaque)
737 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
739 /* don't match inode with different uniqueid */
740 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
743 /* use createtime like an i_generation field */
744 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
747 /* don't match inode of different type */
748 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
751 /* if it's not a directory or has no dentries, then flag it */
752 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
753 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
759 cifs_init_inode(struct inode *inode, void *opaque)
761 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
763 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
764 CIFS_I(inode)->createtime = fattr->cf_createtime;
769 * walk dentry list for an inode and report whether it has aliases that
770 * are hashed. We use this to determine if a directory inode can actually
774 inode_has_hashed_dentries(struct inode *inode)
776 struct dentry *dentry;
777 struct hlist_node *p;
779 spin_lock(&inode->i_lock);
780 hlist_for_each_entry(dentry, p, &inode->i_dentry, d_alias) {
781 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
782 spin_unlock(&inode->i_lock);
786 spin_unlock(&inode->i_lock);
790 /* Given fattrs, get a corresponding inode */
792 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
798 cFYI(1, "looking for uniqueid=%llu", fattr->cf_uniqueid);
800 /* hash down to 32-bits on 32-bit arch */
801 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
803 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
805 /* was there a potentially problematic inode collision? */
806 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
807 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
809 if (inode_has_hashed_dentries(inode)) {
810 cifs_autodisable_serverino(CIFS_SB(sb));
812 fattr->cf_uniqueid = iunique(sb, ROOT_I);
813 goto retry_iget5_locked;
817 cifs_fattr_to_inode(inode, fattr);
818 if (sb->s_flags & MS_NOATIME)
819 inode->i_flags |= S_NOATIME | S_NOCMTIME;
820 if (inode->i_state & I_NEW) {
822 if (S_ISREG(inode->i_mode))
823 inode->i_data.backing_dev_info = sb->s_bdi;
824 #ifdef CONFIG_CIFS_FSCACHE
825 /* initialize per-inode cache cookie pointer */
826 CIFS_I(inode)->fscache = NULL;
828 unlock_new_inode(inode);
835 /* gets root inode */
836 struct inode *cifs_root_iget(struct super_block *sb)
839 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
840 struct inode *inode = NULL;
842 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
846 rc = cifs_get_inode_info_unix(&inode, "", sb, xid);
848 rc = cifs_get_inode_info(&inode, "", NULL, sb, xid, NULL);
855 #ifdef CONFIG_CIFS_FSCACHE
856 /* populate tcon->resource_id */
857 tcon->resource_id = CIFS_I(inode)->uniqueid;
860 if (rc && tcon->ipc) {
861 cFYI(1, "ipc connection - fake read inode");
862 inode->i_mode |= S_IFDIR;
864 inode->i_op = &cifs_ipc_inode_ops;
865 inode->i_fop = &simple_dir_operations;
866 inode->i_uid = cifs_sb->mnt_uid;
867 inode->i_gid = cifs_sb->mnt_gid;
874 /* can not call macro free_xid here since in a void func
875 * TODO: This is no longer true
882 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
883 char *full_path, __u32 dosattr)
889 bool set_time = false;
890 struct cifsFileInfo *open_file;
891 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
892 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
893 struct tcon_link *tlink = NULL;
894 struct cifs_tcon *pTcon;
895 FILE_BASIC_INFO info_buf;
900 if (attrs->ia_valid & ATTR_ATIME) {
902 info_buf.LastAccessTime =
903 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
905 info_buf.LastAccessTime = 0;
907 if (attrs->ia_valid & ATTR_MTIME) {
909 info_buf.LastWriteTime =
910 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
912 info_buf.LastWriteTime = 0;
915 * Samba throws this field away, but windows may actually use it.
916 * Do not set ctime unless other time stamps are changed explicitly
917 * (i.e. by utimes()) since we would then have a mix of client and
920 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
921 cFYI(1, "CIFS - CTIME changed");
922 info_buf.ChangeTime =
923 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
925 info_buf.ChangeTime = 0;
927 info_buf.CreationTime = 0; /* don't change */
928 info_buf.Attributes = cpu_to_le32(dosattr);
931 * If the file is already open for write, just use that fileid
933 open_file = find_writable_file(cifsInode, true);
935 netfid = open_file->netfid;
936 netpid = open_file->pid;
937 pTcon = tlink_tcon(open_file->tlink);
938 goto set_via_filehandle;
941 tlink = cifs_sb_tlink(cifs_sb);
947 pTcon = tlink_tcon(tlink);
950 * NT4 apparently returns success on this call, but it doesn't
953 if (!(pTcon->ses->flags & CIFS_SES_NT4)) {
954 rc = CIFSSMBSetPathInfo(xid, pTcon, full_path,
955 &info_buf, cifs_sb->local_nls,
956 cifs_sb->mnt_cifs_flags &
957 CIFS_MOUNT_MAP_SPECIAL_CHR);
959 cifsInode->cifsAttrs = dosattr;
961 } else if (rc != -EOPNOTSUPP && rc != -EINVAL)
965 cFYI(1, "calling SetFileInfo since SetPathInfo for "
966 "times not supported by this server");
967 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
968 SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
969 CREATE_NOT_DIR, &netfid, &oplock,
970 NULL, cifs_sb->local_nls,
971 cifs_sb->mnt_cifs_flags &
972 CIFS_MOUNT_MAP_SPECIAL_CHR);
980 netpid = current->tgid;
983 rc = CIFSSMBSetFileInfo(xid, pTcon, &info_buf, netfid, netpid);
985 cifsInode->cifsAttrs = dosattr;
987 if (open_file == NULL)
988 CIFSSMBClose(xid, pTcon, netfid);
990 cifsFileInfo_put(open_file);
993 cifs_put_tlink(tlink);
998 * open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
999 * and rename it to a random name that hopefully won't conflict with
1003 cifs_rename_pending_delete(char *full_path, struct dentry *dentry,
1009 struct inode *inode = dentry->d_inode;
1010 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1011 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1012 struct tcon_link *tlink;
1013 struct cifs_tcon *tcon;
1014 __u32 dosattr, origattr;
1015 FILE_BASIC_INFO *info_buf = NULL;
1017 tlink = cifs_sb_tlink(cifs_sb);
1019 return PTR_ERR(tlink);
1020 tcon = tlink_tcon(tlink);
1022 rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
1023 DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
1024 &netfid, &oplock, NULL, cifs_sb->local_nls,
1025 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1029 origattr = cifsInode->cifsAttrs;
1031 origattr |= ATTR_NORMAL;
1033 dosattr = origattr & ~ATTR_READONLY;
1035 dosattr |= ATTR_NORMAL;
1036 dosattr |= ATTR_HIDDEN;
1038 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1039 if (dosattr != origattr) {
1040 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1041 if (info_buf == NULL) {
1045 info_buf->Attributes = cpu_to_le32(dosattr);
1046 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1048 /* although we would like to mark the file hidden
1049 if that fails we will still try to rename it */
1051 cifsInode->cifsAttrs = dosattr;
1053 dosattr = origattr; /* since not able to change them */
1056 /* rename the file */
1057 rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
1058 cifs_sb->mnt_cifs_flags &
1059 CIFS_MOUNT_MAP_SPECIAL_CHR);
1065 /* try to set DELETE_ON_CLOSE */
1066 if (!cifsInode->delete_pending) {
1067 rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
1070 * some samba versions return -ENOENT when we try to set the
1071 * file disposition here. Likely a samba bug, but work around
1072 * it for now. This means that some cifsXXX files may hang
1073 * around after they shouldn't.
1075 * BB: remove this hack after more servers have the fix
1083 cifsInode->delete_pending = true;
1087 CIFSSMBClose(xid, tcon, netfid);
1090 cifs_put_tlink(tlink);
1094 * reset everything back to the original state. Don't bother
1095 * dealing with errors here since we can't do anything about
1099 CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
1100 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1101 CIFS_MOUNT_MAP_SPECIAL_CHR);
1103 if (dosattr != origattr) {
1104 info_buf->Attributes = cpu_to_le32(origattr);
1105 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1107 cifsInode->cifsAttrs = origattr;
1115 * If dentry->d_inode is null (usually meaning the cached dentry
1116 * is a negative dentry) then we would attempt a standard SMB delete, but
1117 * if that fails we can not attempt the fall back mechanisms on EACCESS
1118 * but will return the EACCESS to the caller. Note that the VFS does not call
1119 * unlink on negative dentries currently.
1121 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1125 char *full_path = NULL;
1126 struct inode *inode = dentry->d_inode;
1127 struct cifsInodeInfo *cifs_inode;
1128 struct super_block *sb = dir->i_sb;
1129 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1130 struct tcon_link *tlink;
1131 struct cifs_tcon *tcon;
1132 struct iattr *attrs = NULL;
1133 __u32 dosattr = 0, origattr = 0;
1135 cFYI(1, "cifs_unlink, dir=0x%p, dentry=0x%p", dir, dentry);
1137 tlink = cifs_sb_tlink(cifs_sb);
1139 return PTR_ERR(tlink);
1140 tcon = tlink_tcon(tlink);
1144 /* Unlink can be called from rename so we can not take the
1145 * sb->s_vfs_rename_mutex here */
1146 full_path = build_path_from_dentry(dentry);
1147 if (full_path == NULL) {
1152 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1153 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1154 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1155 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1156 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1157 cFYI(1, "posix del rc %d", rc);
1158 if ((rc == 0) || (rc == -ENOENT))
1159 goto psx_del_no_retry;
1163 rc = CIFSSMBDelFile(xid, tcon, full_path, cifs_sb->local_nls,
1164 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1170 } else if (rc == -ENOENT) {
1172 } else if (rc == -ETXTBSY) {
1173 rc = cifs_rename_pending_delete(full_path, dentry, xid);
1176 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1177 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1178 if (attrs == NULL) {
1183 /* try to reset dos attributes */
1184 cifs_inode = CIFS_I(inode);
1185 origattr = cifs_inode->cifsAttrs;
1187 origattr |= ATTR_NORMAL;
1188 dosattr = origattr & ~ATTR_READONLY;
1190 dosattr |= ATTR_NORMAL;
1191 dosattr |= ATTR_HIDDEN;
1193 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1197 goto retry_std_delete;
1200 /* undo the setattr if we errored out and it's needed */
1201 if (rc != 0 && dosattr != 0)
1202 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1206 cifs_inode = CIFS_I(inode);
1207 cifs_inode->time = 0; /* will force revalidate to get info
1209 inode->i_ctime = current_fs_time(sb);
1211 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1212 cifs_inode = CIFS_I(dir);
1213 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1218 cifs_put_tlink(tlink);
1222 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1226 struct cifs_sb_info *cifs_sb;
1227 struct tcon_link *tlink;
1228 struct cifs_tcon *tcon;
1229 char *full_path = NULL;
1230 struct inode *newinode = NULL;
1231 struct cifs_fattr fattr;
1233 cFYI(1, "In cifs_mkdir, mode = 0x%hx inode = 0x%p", mode, inode);
1235 cifs_sb = CIFS_SB(inode->i_sb);
1236 tlink = cifs_sb_tlink(cifs_sb);
1238 return PTR_ERR(tlink);
1239 tcon = tlink_tcon(tlink);
1243 full_path = build_path_from_dentry(direntry);
1244 if (full_path == NULL) {
1249 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1250 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1252 FILE_UNIX_BASIC_INFO *pInfo =
1253 kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1254 if (pInfo == NULL) {
1259 mode &= ~current_umask();
1260 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT,
1261 mode, NULL /* netfid */, pInfo, &oplock,
1262 full_path, cifs_sb->local_nls,
1263 cifs_sb->mnt_cifs_flags &
1264 CIFS_MOUNT_MAP_SPECIAL_CHR);
1265 if (rc == -EOPNOTSUPP) {
1267 goto mkdir_retry_old;
1269 cFYI(1, "posix mkdir returned 0x%x", rc);
1272 if (pInfo->Type == cpu_to_le32(-1)) {
1273 /* no return info, go query for it */
1275 goto mkdir_get_info;
1277 /*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
1280 cifs_unix_basic_to_fattr(&fattr, pInfo, cifs_sb);
1281 cifs_fill_uniqueid(inode->i_sb, &fattr);
1282 newinode = cifs_iget(inode->i_sb, &fattr);
1285 goto mkdir_get_info;
1288 d_instantiate(direntry, newinode);
1290 #ifdef CONFIG_CIFS_DEBUG2
1291 cFYI(1, "instantiated dentry %p %s to inode %p",
1292 direntry, direntry->d_name.name, newinode);
1294 if (newinode->i_nlink != 2)
1295 cFYI(1, "unexpected number of links %d",
1303 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1304 rc = CIFSSMBMkDir(xid, tcon, full_path, cifs_sb->local_nls,
1305 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1307 cFYI(1, "cifs_mkdir returned 0x%x", rc);
1312 rc = cifs_get_inode_info_unix(&newinode, full_path,
1315 rc = cifs_get_inode_info(&newinode, full_path, NULL,
1316 inode->i_sb, xid, NULL);
1318 d_instantiate(direntry, newinode);
1319 /* setting nlink not necessary except in cases where we
1320 * failed to get it from the server or was set bogus */
1321 if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
1322 set_nlink(direntry->d_inode, 2);
1324 mode &= ~current_umask();
1325 /* must turn on setgid bit if parent dir has it */
1326 if (inode->i_mode & S_ISGID)
1329 if (tcon->unix_ext) {
1330 struct cifs_unix_set_info_args args = {
1332 .ctime = NO_CHANGE_64,
1333 .atime = NO_CHANGE_64,
1334 .mtime = NO_CHANGE_64,
1337 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1338 args.uid = (__u64)current_fsuid();
1339 if (inode->i_mode & S_ISGID)
1340 args.gid = (__u64)inode->i_gid;
1342 args.gid = (__u64)current_fsgid();
1344 args.uid = NO_CHANGE_64;
1345 args.gid = NO_CHANGE_64;
1347 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1349 cifs_sb->mnt_cifs_flags &
1350 CIFS_MOUNT_MAP_SPECIAL_CHR);
1352 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1353 (mode & S_IWUGO) == 0) {
1354 FILE_BASIC_INFO pInfo;
1355 struct cifsInodeInfo *cifsInode;
1358 memset(&pInfo, 0, sizeof(pInfo));
1359 cifsInode = CIFS_I(newinode);
1360 dosattrs = cifsInode->cifsAttrs|ATTR_READONLY;
1361 pInfo.Attributes = cpu_to_le32(dosattrs);
1362 tmprc = CIFSSMBSetPathInfo(xid, tcon,
1365 cifs_sb->mnt_cifs_flags &
1366 CIFS_MOUNT_MAP_SPECIAL_CHR);
1368 cifsInode->cifsAttrs = dosattrs;
1370 if (direntry->d_inode) {
1371 if (cifs_sb->mnt_cifs_flags &
1373 direntry->d_inode->i_mode =
1376 if (cifs_sb->mnt_cifs_flags &
1377 CIFS_MOUNT_SET_UID) {
1378 direntry->d_inode->i_uid =
1380 if (inode->i_mode & S_ISGID)
1381 direntry->d_inode->i_gid =
1384 direntry->d_inode->i_gid =
1392 * Force revalidate to get parent dir info when needed since cached
1393 * attributes are invalid now.
1395 CIFS_I(inode)->time = 0;
1398 cifs_put_tlink(tlink);
1402 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1406 struct cifs_sb_info *cifs_sb;
1407 struct tcon_link *tlink;
1408 struct cifs_tcon *pTcon;
1409 char *full_path = NULL;
1410 struct cifsInodeInfo *cifsInode;
1412 cFYI(1, "cifs_rmdir, inode = 0x%p", inode);
1416 full_path = build_path_from_dentry(direntry);
1417 if (full_path == NULL) {
1422 cifs_sb = CIFS_SB(inode->i_sb);
1423 tlink = cifs_sb_tlink(cifs_sb);
1424 if (IS_ERR(tlink)) {
1425 rc = PTR_ERR(tlink);
1428 pTcon = tlink_tcon(tlink);
1430 rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
1431 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1432 cifs_put_tlink(tlink);
1435 spin_lock(&direntry->d_inode->i_lock);
1436 i_size_write(direntry->d_inode, 0);
1437 clear_nlink(direntry->d_inode);
1438 spin_unlock(&direntry->d_inode->i_lock);
1441 cifsInode = CIFS_I(direntry->d_inode);
1442 /* force revalidate to go get info when needed */
1443 cifsInode->time = 0;
1445 cifsInode = CIFS_I(inode);
1447 * Force revalidate to get parent dir info when needed since cached
1448 * attributes are invalid now.
1450 cifsInode->time = 0;
1452 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1453 current_fs_time(inode->i_sb);
1462 cifs_do_rename(unsigned int xid, struct dentry *from_dentry,
1463 const char *fromPath, struct dentry *to_dentry,
1466 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1467 struct tcon_link *tlink;
1468 struct cifs_tcon *pTcon;
1472 tlink = cifs_sb_tlink(cifs_sb);
1474 return PTR_ERR(tlink);
1475 pTcon = tlink_tcon(tlink);
1477 /* try path-based rename first */
1478 rc = CIFSSMBRename(xid, pTcon, fromPath, toPath, cifs_sb->local_nls,
1479 cifs_sb->mnt_cifs_flags &
1480 CIFS_MOUNT_MAP_SPECIAL_CHR);
1483 * don't bother with rename by filehandle unless file is busy and
1484 * source Note that cross directory moves do not work with
1485 * rename by filehandle to various Windows servers.
1487 if (rc == 0 || rc != -ETXTBSY)
1488 goto do_rename_exit;
1490 /* open-file renames don't work across directories */
1491 if (to_dentry->d_parent != from_dentry->d_parent)
1492 goto do_rename_exit;
1494 /* open the file to be renamed -- we need DELETE perms */
1495 rc = CIFSSMBOpen(xid, pTcon, fromPath, FILE_OPEN, DELETE,
1496 CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1497 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1498 CIFS_MOUNT_MAP_SPECIAL_CHR);
1501 rc = CIFSSMBRenameOpenFile(xid, pTcon, srcfid,
1502 (const char *) to_dentry->d_name.name,
1503 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1504 CIFS_MOUNT_MAP_SPECIAL_CHR);
1506 CIFSSMBClose(xid, pTcon, srcfid);
1509 cifs_put_tlink(tlink);
1513 int cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1514 struct inode *target_dir, struct dentry *target_dentry)
1516 char *fromName = NULL;
1517 char *toName = NULL;
1518 struct cifs_sb_info *cifs_sb;
1519 struct tcon_link *tlink;
1520 struct cifs_tcon *tcon;
1521 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1522 FILE_UNIX_BASIC_INFO *info_buf_target;
1526 cifs_sb = CIFS_SB(source_dir->i_sb);
1527 tlink = cifs_sb_tlink(cifs_sb);
1529 return PTR_ERR(tlink);
1530 tcon = tlink_tcon(tlink);
1535 * we already have the rename sem so we do not need to
1536 * grab it again here to protect the path integrity
1538 fromName = build_path_from_dentry(source_dentry);
1539 if (fromName == NULL) {
1541 goto cifs_rename_exit;
1544 toName = build_path_from_dentry(target_dentry);
1545 if (toName == NULL) {
1547 goto cifs_rename_exit;
1550 rc = cifs_do_rename(xid, source_dentry, fromName,
1551 target_dentry, toName);
1553 if (rc == -EEXIST && tcon->unix_ext) {
1555 * Are src and dst hardlinks of same inode? We can
1556 * only tell with unix extensions enabled
1559 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1561 if (info_buf_source == NULL) {
1563 goto cifs_rename_exit;
1566 info_buf_target = info_buf_source + 1;
1567 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, fromName,
1570 cifs_sb->mnt_cifs_flags &
1571 CIFS_MOUNT_MAP_SPECIAL_CHR);
1575 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, toName,
1578 cifs_sb->mnt_cifs_flags &
1579 CIFS_MOUNT_MAP_SPECIAL_CHR);
1581 if (tmprc == 0 && (info_buf_source->UniqueId ==
1582 info_buf_target->UniqueId)) {
1583 /* same file, POSIX says that this is a noop */
1585 goto cifs_rename_exit;
1587 } /* else ... BB we could add the same check for Windows by
1588 checking the UniqueId via FILE_INTERNAL_INFO */
1591 /* Try unlinking the target dentry if it's not negative */
1592 if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
1593 tmprc = cifs_unlink(target_dir, target_dentry);
1595 goto cifs_rename_exit;
1597 rc = cifs_do_rename(xid, source_dentry, fromName,
1598 target_dentry, toName);
1602 kfree(info_buf_source);
1606 cifs_put_tlink(tlink);
1611 cifs_inode_needs_reval(struct inode *inode)
1613 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1614 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1616 if (cifs_i->clientCanCacheRead)
1619 if (!lookupCacheEnabled)
1622 if (cifs_i->time == 0)
1625 if (!time_in_range(jiffies, cifs_i->time,
1626 cifs_i->time + cifs_sb->actimeo))
1629 /* hardlinked files w/ noserverino get "special" treatment */
1630 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1631 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1638 * Zap the cache. Called when invalid_mapping flag is set.
1641 cifs_invalidate_mapping(struct inode *inode)
1644 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1646 cifs_i->invalid_mapping = false;
1648 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1649 rc = invalidate_inode_pages2(inode->i_mapping);
1651 cERROR(1, "%s: could not invalidate inode %p", __func__,
1653 cifs_i->invalid_mapping = true;
1657 cifs_fscache_reset_inode_cookie(inode);
1661 int cifs_revalidate_file_attr(struct file *filp)
1664 struct inode *inode = filp->f_path.dentry->d_inode;
1665 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1667 if (!cifs_inode_needs_reval(inode))
1670 if (tlink_tcon(cfile->tlink)->unix_ext)
1671 rc = cifs_get_file_info_unix(filp);
1673 rc = cifs_get_file_info(filp);
1678 int cifs_revalidate_dentry_attr(struct dentry *dentry)
1682 struct inode *inode = dentry->d_inode;
1683 struct super_block *sb = dentry->d_sb;
1684 char *full_path = NULL;
1689 if (!cifs_inode_needs_reval(inode))
1694 /* can not safely grab the rename sem here if rename calls revalidate
1695 since that would deadlock */
1696 full_path = build_path_from_dentry(dentry);
1697 if (full_path == NULL) {
1702 cFYI(1, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time "
1703 "%ld jiffies %ld", full_path, inode, inode->i_count.counter,
1704 dentry, dentry->d_time, jiffies);
1706 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1707 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1709 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1718 int cifs_revalidate_file(struct file *filp)
1721 struct inode *inode = filp->f_path.dentry->d_inode;
1723 rc = cifs_revalidate_file_attr(filp);
1727 if (CIFS_I(inode)->invalid_mapping)
1728 rc = cifs_invalidate_mapping(inode);
1732 /* revalidate a dentry's inode attributes */
1733 int cifs_revalidate_dentry(struct dentry *dentry)
1736 struct inode *inode = dentry->d_inode;
1738 rc = cifs_revalidate_dentry_attr(dentry);
1742 if (CIFS_I(inode)->invalid_mapping)
1743 rc = cifs_invalidate_mapping(inode);
1747 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1750 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1751 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1752 struct inode *inode = dentry->d_inode;
1756 * We need to be sure that all dirty pages are written and the server
1757 * has actual ctime, mtime and file length.
1759 if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping &&
1760 inode->i_mapping->nrpages != 0) {
1761 rc = filemap_fdatawait(inode->i_mapping);
1763 mapping_set_error(inode->i_mapping, rc);
1768 rc = cifs_revalidate_dentry_attr(dentry);
1772 generic_fillattr(inode, stat);
1773 stat->blksize = CIFS_MAX_MSGSIZE;
1774 stat->ino = CIFS_I(inode)->uniqueid;
1777 * If on a multiuser mount without unix extensions, and the admin hasn't
1778 * overridden them, set the ownership to the fsuid/fsgid of the current
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();
1791 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1793 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1794 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1798 page = grab_cache_page(mapping, index);
1802 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1804 page_cache_release(page);
1808 static void cifs_setsize(struct inode *inode, loff_t offset)
1812 spin_lock(&inode->i_lock);
1813 oldsize = inode->i_size;
1814 i_size_write(inode, offset);
1815 spin_unlock(&inode->i_lock);
1817 truncate_pagecache(inode, oldsize, offset);
1821 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1822 unsigned int xid, char *full_path)
1825 struct cifsFileInfo *open_file;
1826 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1827 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1828 struct tcon_link *tlink = NULL;
1829 struct cifs_tcon *pTcon = NULL;
1830 struct cifs_io_parms io_parms;
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;
1853 io_parms.netfid = nfid;
1854 io_parms.pid = npid;
1855 io_parms.tcon = pTcon;
1856 io_parms.offset = 0;
1857 io_parms.length = attrs->ia_size;
1858 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written,
1860 cFYI(1, "Wrt seteof rc %d", rc);
1866 if (pTcon == NULL) {
1867 tlink = cifs_sb_tlink(cifs_sb);
1869 return PTR_ERR(tlink);
1870 pTcon = tlink_tcon(tlink);
1873 /* Set file size by pathname rather than by handle
1874 either because no valid, writeable file handle for
1875 it was found or because there was an error setting
1877 rc = CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size,
1878 false, cifs_sb->local_nls,
1879 cifs_sb->mnt_cifs_flags &
1880 CIFS_MOUNT_MAP_SPECIAL_CHR);
1881 cFYI(1, "SetEOF by path (setattrs) rc = %d", rc);
1882 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1886 rc = SMBLegacyOpen(xid, pTcon, full_path,
1887 FILE_OPEN, GENERIC_WRITE,
1888 CREATE_NOT_DIR, &netfid, &oplock, NULL,
1890 cifs_sb->mnt_cifs_flags &
1891 CIFS_MOUNT_MAP_SPECIAL_CHR);
1893 unsigned int bytes_written;
1895 io_parms.netfid = netfid;
1896 io_parms.pid = current->tgid;
1897 io_parms.tcon = pTcon;
1898 io_parms.offset = 0;
1899 io_parms.length = attrs->ia_size;
1900 rc = CIFSSMBWrite(xid, &io_parms,
1903 cFYI(1, "wrt seteof rc %d", rc);
1904 CIFSSMBClose(xid, pTcon, netfid);
1908 cifs_put_tlink(tlink);
1912 cifsInode->server_eof = attrs->ia_size;
1913 cifs_setsize(inode, attrs->ia_size);
1914 cifs_truncate_page(inode->i_mapping, inode->i_size);
1921 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1925 char *full_path = NULL;
1926 struct inode *inode = direntry->d_inode;
1927 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1928 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1929 struct tcon_link *tlink;
1930 struct cifs_tcon *pTcon;
1931 struct cifs_unix_set_info_args *args = NULL;
1932 struct cifsFileInfo *open_file;
1934 cFYI(1, "setattr_unix on file %s attrs->ia_valid=0x%x",
1935 direntry->d_name.name, attrs->ia_valid);
1939 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
1940 attrs->ia_valid |= ATTR_FORCE;
1942 rc = inode_change_ok(inode, attrs);
1946 full_path = build_path_from_dentry(direntry);
1947 if (full_path == NULL) {
1953 * Attempt to flush data before changing attributes. We need to do
1954 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1955 * ownership or mode then we may also need to do this. Here, we take
1956 * the safe way out and just do the flush on all setattr requests. If
1957 * the flush returns error, store it to report later and continue.
1959 * BB: This should be smarter. Why bother flushing pages that
1960 * will be truncated anyway? Also, should we error out here if
1961 * the flush returns error?
1963 rc = filemap_write_and_wait(inode->i_mapping);
1964 mapping_set_error(inode->i_mapping, rc);
1967 if (attrs->ia_valid & ATTR_SIZE) {
1968 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1973 /* skip mode change if it's just for clearing setuid/setgid */
1974 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1975 attrs->ia_valid &= ~ATTR_MODE;
1977 args = kmalloc(sizeof(*args), GFP_KERNEL);
1983 /* set up the struct */
1984 if (attrs->ia_valid & ATTR_MODE)
1985 args->mode = attrs->ia_mode;
1987 args->mode = NO_CHANGE_64;
1989 if (attrs->ia_valid & ATTR_UID)
1990 args->uid = attrs->ia_uid;
1992 args->uid = NO_CHANGE_64;
1994 if (attrs->ia_valid & ATTR_GID)
1995 args->gid = attrs->ia_gid;
1997 args->gid = NO_CHANGE_64;
1999 if (attrs->ia_valid & ATTR_ATIME)
2000 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2002 args->atime = NO_CHANGE_64;
2004 if (attrs->ia_valid & ATTR_MTIME)
2005 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2007 args->mtime = NO_CHANGE_64;
2009 if (attrs->ia_valid & ATTR_CTIME)
2010 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2012 args->ctime = NO_CHANGE_64;
2015 open_file = find_writable_file(cifsInode, true);
2017 u16 nfid = open_file->netfid;
2018 u32 npid = open_file->pid;
2019 pTcon = tlink_tcon(open_file->tlink);
2020 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2021 cifsFileInfo_put(open_file);
2023 tlink = cifs_sb_tlink(cifs_sb);
2024 if (IS_ERR(tlink)) {
2025 rc = PTR_ERR(tlink);
2028 pTcon = tlink_tcon(tlink);
2029 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2031 cifs_sb->mnt_cifs_flags &
2032 CIFS_MOUNT_MAP_SPECIAL_CHR);
2033 cifs_put_tlink(tlink);
2039 if ((attrs->ia_valid & ATTR_SIZE) &&
2040 attrs->ia_size != i_size_read(inode))
2041 truncate_setsize(inode, attrs->ia_size);
2043 setattr_copy(inode, attrs);
2044 mark_inode_dirty(inode);
2046 /* force revalidate when any of these times are set since some
2047 of the fs types (eg ext3, fat) do not have fine enough
2048 time granularity to match protocol, and we do not have a
2049 a way (yet) to query the server fs's time granularity (and
2050 whether it rounds times down).
2052 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2053 cifsInode->time = 0;
2062 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2065 uid_t uid = NO_CHANGE_32;
2066 gid_t gid = NO_CHANGE_32;
2067 struct inode *inode = direntry->d_inode;
2068 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2069 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2070 char *full_path = NULL;
2073 __u64 mode = NO_CHANGE_64;
2077 cFYI(1, "setattr on file %s attrs->iavalid 0x%x",
2078 direntry->d_name.name, attrs->ia_valid);
2080 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2081 attrs->ia_valid |= ATTR_FORCE;
2083 rc = inode_change_ok(inode, attrs);
2089 full_path = build_path_from_dentry(direntry);
2090 if (full_path == NULL) {
2097 * Attempt to flush data before changing attributes. We need to do
2098 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2099 * ownership or mode then we may also need to do this. Here, we take
2100 * the safe way out and just do the flush on all setattr requests. If
2101 * the flush returns error, store it to report later and continue.
2103 * BB: This should be smarter. Why bother flushing pages that
2104 * will be truncated anyway? Also, should we error out here if
2105 * the flush returns error?
2107 rc = filemap_write_and_wait(inode->i_mapping);
2108 mapping_set_error(inode->i_mapping, rc);
2111 if (attrs->ia_valid & ATTR_SIZE) {
2112 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2114 goto cifs_setattr_exit;
2117 if (attrs->ia_valid & ATTR_UID)
2118 uid = attrs->ia_uid;
2120 if (attrs->ia_valid & ATTR_GID)
2121 gid = attrs->ia_gid;
2123 #ifdef CONFIG_CIFS_ACL
2124 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2125 if (uid != NO_CHANGE_32 || gid != NO_CHANGE_32) {
2126 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2129 cFYI(1, "%s: Setting id failed with error: %d",
2131 goto cifs_setattr_exit;
2135 #endif /* CONFIG_CIFS_ACL */
2136 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2137 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2139 /* skip mode change if it's just for clearing setuid/setgid */
2140 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2141 attrs->ia_valid &= ~ATTR_MODE;
2143 if (attrs->ia_valid & ATTR_MODE) {
2144 mode = attrs->ia_mode;
2146 #ifdef CONFIG_CIFS_ACL
2147 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2148 rc = id_mode_to_cifs_acl(inode, full_path, mode,
2149 NO_CHANGE_32, NO_CHANGE_32);
2151 cFYI(1, "%s: Setting ACL failed with error: %d",
2153 goto cifs_setattr_exit;
2156 #endif /* CONFIG_CIFS_ACL */
2157 if (((mode & S_IWUGO) == 0) &&
2158 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2160 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2162 /* fix up mode if we're not using dynperm */
2163 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2164 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2165 } else if ((mode & S_IWUGO) &&
2166 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2168 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2169 /* Attributes of 0 are ignored */
2171 dosattr |= ATTR_NORMAL;
2173 /* reset local inode permissions to normal */
2174 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2175 attrs->ia_mode &= ~(S_IALLUGO);
2176 if (S_ISDIR(inode->i_mode))
2178 cifs_sb->mnt_dir_mode;
2181 cifs_sb->mnt_file_mode;
2183 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2184 /* ignore mode change - ATTR_READONLY hasn't changed */
2185 attrs->ia_valid &= ~ATTR_MODE;
2189 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2190 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2191 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2192 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2194 /* Even if error on time set, no sense failing the call if
2195 the server would set the time to a reasonable value anyway,
2196 and this check ensures that we are not being called from
2197 sys_utimes in which case we ought to fail the call back to
2198 the user when the server rejects the call */
2199 if ((rc) && (attrs->ia_valid &
2200 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2204 /* do not need local check to inode_check_ok since the server does
2207 goto cifs_setattr_exit;
2209 if ((attrs->ia_valid & ATTR_SIZE) &&
2210 attrs->ia_size != i_size_read(inode))
2211 truncate_setsize(inode, attrs->ia_size);
2213 setattr_copy(inode, attrs);
2214 mark_inode_dirty(inode);
2223 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2225 struct inode *inode = direntry->d_inode;
2226 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2227 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2229 if (pTcon->unix_ext)
2230 return cifs_setattr_unix(direntry, attrs);
2232 return cifs_setattr_nounix(direntry, attrs);
2234 /* BB: add cifs_setattr_legacy for really old servers */
2238 void cifs_delete_inode(struct inode *inode)
2240 cFYI(1, "In cifs_delete_inode, inode = 0x%p", inode);
2241 /* may have to add back in if and when safe distributed caching of
2242 directories added e.g. via FindNotify */