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 ((tcon->ses->capabilities & CAP_UNIX) &&
1153 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1154 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1155 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1156 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1157 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1158 cFYI(1, "posix del rc %d", rc);
1159 if ((rc == 0) || (rc == -ENOENT))
1160 goto psx_del_no_retry;
1164 rc = CIFSSMBDelFile(xid, tcon, full_path, cifs_sb->local_nls,
1165 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1171 } else if (rc == -ENOENT) {
1173 } else if (rc == -ETXTBSY) {
1174 rc = cifs_rename_pending_delete(full_path, dentry, xid);
1177 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1178 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1179 if (attrs == NULL) {
1184 /* try to reset dos attributes */
1185 cifs_inode = CIFS_I(inode);
1186 origattr = cifs_inode->cifsAttrs;
1188 origattr |= ATTR_NORMAL;
1189 dosattr = origattr & ~ATTR_READONLY;
1191 dosattr |= ATTR_NORMAL;
1192 dosattr |= ATTR_HIDDEN;
1194 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1198 goto retry_std_delete;
1201 /* undo the setattr if we errored out and it's needed */
1202 if (rc != 0 && dosattr != 0)
1203 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1207 cifs_inode = CIFS_I(inode);
1208 cifs_inode->time = 0; /* will force revalidate to get info
1210 inode->i_ctime = current_fs_time(sb);
1212 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1213 cifs_inode = CIFS_I(dir);
1214 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1219 cifs_put_tlink(tlink);
1223 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1227 struct cifs_sb_info *cifs_sb;
1228 struct tcon_link *tlink;
1229 struct cifs_tcon *pTcon;
1230 char *full_path = NULL;
1231 struct inode *newinode = NULL;
1232 struct cifs_fattr fattr;
1234 cFYI(1, "In cifs_mkdir, mode = 0x%hx inode = 0x%p", mode, inode);
1236 cifs_sb = CIFS_SB(inode->i_sb);
1237 tlink = cifs_sb_tlink(cifs_sb);
1239 return PTR_ERR(tlink);
1240 pTcon = tlink_tcon(tlink);
1244 full_path = build_path_from_dentry(direntry);
1245 if (full_path == NULL) {
1250 if ((pTcon->ses->capabilities & CAP_UNIX) &&
1251 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1252 le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
1254 FILE_UNIX_BASIC_INFO *pInfo =
1255 kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1256 if (pInfo == NULL) {
1261 mode &= ~current_umask();
1262 rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
1263 mode, NULL /* netfid */, pInfo, &oplock,
1264 full_path, cifs_sb->local_nls,
1265 cifs_sb->mnt_cifs_flags &
1266 CIFS_MOUNT_MAP_SPECIAL_CHR);
1267 if (rc == -EOPNOTSUPP) {
1269 goto mkdir_retry_old;
1271 cFYI(1, "posix mkdir returned 0x%x", rc);
1274 if (pInfo->Type == cpu_to_le32(-1)) {
1275 /* no return info, go query for it */
1277 goto mkdir_get_info;
1279 /*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
1282 cifs_unix_basic_to_fattr(&fattr, pInfo, cifs_sb);
1283 cifs_fill_uniqueid(inode->i_sb, &fattr);
1284 newinode = cifs_iget(inode->i_sb, &fattr);
1287 goto mkdir_get_info;
1290 d_instantiate(direntry, newinode);
1292 #ifdef CONFIG_CIFS_DEBUG2
1293 cFYI(1, "instantiated dentry %p %s to inode %p",
1294 direntry, direntry->d_name.name, newinode);
1296 if (newinode->i_nlink != 2)
1297 cFYI(1, "unexpected number of links %d",
1305 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1306 rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
1307 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1309 cFYI(1, "cifs_mkdir returned 0x%x", rc);
1313 if (pTcon->unix_ext)
1314 rc = cifs_get_inode_info_unix(&newinode, full_path,
1317 rc = cifs_get_inode_info(&newinode, full_path, NULL,
1318 inode->i_sb, xid, NULL);
1320 d_instantiate(direntry, newinode);
1321 /* setting nlink not necessary except in cases where we
1322 * failed to get it from the server or was set bogus */
1323 if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
1324 set_nlink(direntry->d_inode, 2);
1326 mode &= ~current_umask();
1327 /* must turn on setgid bit if parent dir has it */
1328 if (inode->i_mode & S_ISGID)
1331 if (pTcon->unix_ext) {
1332 struct cifs_unix_set_info_args args = {
1334 .ctime = NO_CHANGE_64,
1335 .atime = NO_CHANGE_64,
1336 .mtime = NO_CHANGE_64,
1339 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1340 args.uid = (__u64)current_fsuid();
1341 if (inode->i_mode & S_ISGID)
1342 args.gid = (__u64)inode->i_gid;
1344 args.gid = (__u64)current_fsgid();
1346 args.uid = NO_CHANGE_64;
1347 args.gid = NO_CHANGE_64;
1349 CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
1351 cifs_sb->mnt_cifs_flags &
1352 CIFS_MOUNT_MAP_SPECIAL_CHR);
1354 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1355 (mode & S_IWUGO) == 0) {
1356 FILE_BASIC_INFO pInfo;
1357 struct cifsInodeInfo *cifsInode;
1360 memset(&pInfo, 0, sizeof(pInfo));
1361 cifsInode = CIFS_I(newinode);
1362 dosattrs = cifsInode->cifsAttrs|ATTR_READONLY;
1363 pInfo.Attributes = cpu_to_le32(dosattrs);
1364 tmprc = CIFSSMBSetPathInfo(xid, pTcon,
1367 cifs_sb->mnt_cifs_flags &
1368 CIFS_MOUNT_MAP_SPECIAL_CHR);
1370 cifsInode->cifsAttrs = dosattrs;
1372 if (direntry->d_inode) {
1373 if (cifs_sb->mnt_cifs_flags &
1375 direntry->d_inode->i_mode =
1378 if (cifs_sb->mnt_cifs_flags &
1379 CIFS_MOUNT_SET_UID) {
1380 direntry->d_inode->i_uid =
1382 if (inode->i_mode & S_ISGID)
1383 direntry->d_inode->i_gid =
1386 direntry->d_inode->i_gid =
1394 * Force revalidate to get parent dir info when needed since cached
1395 * attributes are invalid now.
1397 CIFS_I(inode)->time = 0;
1400 cifs_put_tlink(tlink);
1404 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1408 struct cifs_sb_info *cifs_sb;
1409 struct tcon_link *tlink;
1410 struct cifs_tcon *pTcon;
1411 char *full_path = NULL;
1412 struct cifsInodeInfo *cifsInode;
1414 cFYI(1, "cifs_rmdir, inode = 0x%p", inode);
1418 full_path = build_path_from_dentry(direntry);
1419 if (full_path == NULL) {
1424 cifs_sb = CIFS_SB(inode->i_sb);
1425 tlink = cifs_sb_tlink(cifs_sb);
1426 if (IS_ERR(tlink)) {
1427 rc = PTR_ERR(tlink);
1430 pTcon = tlink_tcon(tlink);
1432 rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
1433 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1434 cifs_put_tlink(tlink);
1437 spin_lock(&direntry->d_inode->i_lock);
1438 i_size_write(direntry->d_inode, 0);
1439 clear_nlink(direntry->d_inode);
1440 spin_unlock(&direntry->d_inode->i_lock);
1443 cifsInode = CIFS_I(direntry->d_inode);
1444 /* force revalidate to go get info when needed */
1445 cifsInode->time = 0;
1447 cifsInode = CIFS_I(inode);
1449 * Force revalidate to get parent dir info when needed since cached
1450 * attributes are invalid now.
1452 cifsInode->time = 0;
1454 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1455 current_fs_time(inode->i_sb);
1464 cifs_do_rename(unsigned int xid, struct dentry *from_dentry,
1465 const char *fromPath, struct dentry *to_dentry,
1468 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1469 struct tcon_link *tlink;
1470 struct cifs_tcon *pTcon;
1474 tlink = cifs_sb_tlink(cifs_sb);
1476 return PTR_ERR(tlink);
1477 pTcon = tlink_tcon(tlink);
1479 /* try path-based rename first */
1480 rc = CIFSSMBRename(xid, pTcon, fromPath, toPath, cifs_sb->local_nls,
1481 cifs_sb->mnt_cifs_flags &
1482 CIFS_MOUNT_MAP_SPECIAL_CHR);
1485 * don't bother with rename by filehandle unless file is busy and
1486 * source Note that cross directory moves do not work with
1487 * rename by filehandle to various Windows servers.
1489 if (rc == 0 || rc != -ETXTBSY)
1490 goto do_rename_exit;
1492 /* open-file renames don't work across directories */
1493 if (to_dentry->d_parent != from_dentry->d_parent)
1494 goto do_rename_exit;
1496 /* open the file to be renamed -- we need DELETE perms */
1497 rc = CIFSSMBOpen(xid, pTcon, fromPath, FILE_OPEN, DELETE,
1498 CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1499 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1500 CIFS_MOUNT_MAP_SPECIAL_CHR);
1503 rc = CIFSSMBRenameOpenFile(xid, pTcon, srcfid,
1504 (const char *) to_dentry->d_name.name,
1505 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1506 CIFS_MOUNT_MAP_SPECIAL_CHR);
1508 CIFSSMBClose(xid, pTcon, srcfid);
1511 cifs_put_tlink(tlink);
1515 int cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1516 struct inode *target_dir, struct dentry *target_dentry)
1518 char *fromName = NULL;
1519 char *toName = NULL;
1520 struct cifs_sb_info *cifs_sb;
1521 struct tcon_link *tlink;
1522 struct cifs_tcon *tcon;
1523 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1524 FILE_UNIX_BASIC_INFO *info_buf_target;
1528 cifs_sb = CIFS_SB(source_dir->i_sb);
1529 tlink = cifs_sb_tlink(cifs_sb);
1531 return PTR_ERR(tlink);
1532 tcon = tlink_tcon(tlink);
1537 * we already have the rename sem so we do not need to
1538 * grab it again here to protect the path integrity
1540 fromName = build_path_from_dentry(source_dentry);
1541 if (fromName == NULL) {
1543 goto cifs_rename_exit;
1546 toName = build_path_from_dentry(target_dentry);
1547 if (toName == NULL) {
1549 goto cifs_rename_exit;
1552 rc = cifs_do_rename(xid, source_dentry, fromName,
1553 target_dentry, toName);
1555 if (rc == -EEXIST && tcon->unix_ext) {
1557 * Are src and dst hardlinks of same inode? We can
1558 * only tell with unix extensions enabled
1561 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1563 if (info_buf_source == NULL) {
1565 goto cifs_rename_exit;
1568 info_buf_target = info_buf_source + 1;
1569 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, fromName,
1572 cifs_sb->mnt_cifs_flags &
1573 CIFS_MOUNT_MAP_SPECIAL_CHR);
1577 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, toName,
1580 cifs_sb->mnt_cifs_flags &
1581 CIFS_MOUNT_MAP_SPECIAL_CHR);
1583 if (tmprc == 0 && (info_buf_source->UniqueId ==
1584 info_buf_target->UniqueId)) {
1585 /* same file, POSIX says that this is a noop */
1587 goto cifs_rename_exit;
1589 } /* else ... BB we could add the same check for Windows by
1590 checking the UniqueId via FILE_INTERNAL_INFO */
1593 /* Try unlinking the target dentry if it's not negative */
1594 if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
1595 tmprc = cifs_unlink(target_dir, target_dentry);
1597 goto cifs_rename_exit;
1599 rc = cifs_do_rename(xid, source_dentry, fromName,
1600 target_dentry, toName);
1604 kfree(info_buf_source);
1608 cifs_put_tlink(tlink);
1613 cifs_inode_needs_reval(struct inode *inode)
1615 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1616 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1618 if (cifs_i->clientCanCacheRead)
1621 if (!lookupCacheEnabled)
1624 if (cifs_i->time == 0)
1627 if (!time_in_range(jiffies, cifs_i->time,
1628 cifs_i->time + cifs_sb->actimeo))
1631 /* hardlinked files w/ noserverino get "special" treatment */
1632 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1633 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1640 * Zap the cache. Called when invalid_mapping flag is set.
1643 cifs_invalidate_mapping(struct inode *inode)
1646 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1648 cifs_i->invalid_mapping = false;
1650 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1651 rc = invalidate_inode_pages2(inode->i_mapping);
1653 cERROR(1, "%s: could not invalidate inode %p", __func__,
1655 cifs_i->invalid_mapping = true;
1659 cifs_fscache_reset_inode_cookie(inode);
1663 int cifs_revalidate_file_attr(struct file *filp)
1666 struct inode *inode = filp->f_path.dentry->d_inode;
1667 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1669 if (!cifs_inode_needs_reval(inode))
1672 if (tlink_tcon(cfile->tlink)->unix_ext)
1673 rc = cifs_get_file_info_unix(filp);
1675 rc = cifs_get_file_info(filp);
1680 int cifs_revalidate_dentry_attr(struct dentry *dentry)
1684 struct inode *inode = dentry->d_inode;
1685 struct super_block *sb = dentry->d_sb;
1686 char *full_path = NULL;
1691 if (!cifs_inode_needs_reval(inode))
1696 /* can not safely grab the rename sem here if rename calls revalidate
1697 since that would deadlock */
1698 full_path = build_path_from_dentry(dentry);
1699 if (full_path == NULL) {
1704 cFYI(1, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time "
1705 "%ld jiffies %ld", full_path, inode, inode->i_count.counter,
1706 dentry, dentry->d_time, jiffies);
1708 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1709 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1711 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1720 int cifs_revalidate_file(struct file *filp)
1723 struct inode *inode = filp->f_path.dentry->d_inode;
1725 rc = cifs_revalidate_file_attr(filp);
1729 if (CIFS_I(inode)->invalid_mapping)
1730 rc = cifs_invalidate_mapping(inode);
1734 /* revalidate a dentry's inode attributes */
1735 int cifs_revalidate_dentry(struct dentry *dentry)
1738 struct inode *inode = dentry->d_inode;
1740 rc = cifs_revalidate_dentry_attr(dentry);
1744 if (CIFS_I(inode)->invalid_mapping)
1745 rc = cifs_invalidate_mapping(inode);
1749 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1752 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1753 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1754 struct inode *inode = dentry->d_inode;
1758 * We need to be sure that all dirty pages are written and the server
1759 * has actual ctime, mtime and file length.
1761 if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping &&
1762 inode->i_mapping->nrpages != 0) {
1763 rc = filemap_fdatawait(inode->i_mapping);
1765 mapping_set_error(inode->i_mapping, rc);
1770 rc = cifs_revalidate_dentry_attr(dentry);
1774 generic_fillattr(inode, stat);
1775 stat->blksize = CIFS_MAX_MSGSIZE;
1776 stat->ino = CIFS_I(inode)->uniqueid;
1779 * If on a multiuser mount without unix extensions, and the admin hasn't
1780 * overridden them, set the ownership to the fsuid/fsgid of the current
1783 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
1785 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1786 stat->uid = current_fsuid();
1787 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1788 stat->gid = current_fsgid();
1793 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1795 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1796 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1800 page = grab_cache_page(mapping, index);
1804 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1806 page_cache_release(page);
1810 static void cifs_setsize(struct inode *inode, loff_t offset)
1814 spin_lock(&inode->i_lock);
1815 oldsize = inode->i_size;
1816 i_size_write(inode, offset);
1817 spin_unlock(&inode->i_lock);
1819 truncate_pagecache(inode, oldsize, offset);
1823 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1824 unsigned int xid, char *full_path)
1827 struct cifsFileInfo *open_file;
1828 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1829 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1830 struct tcon_link *tlink = NULL;
1831 struct cifs_tcon *pTcon = NULL;
1832 struct cifs_io_parms io_parms;
1835 * To avoid spurious oplock breaks from server, in the case of
1836 * inodes that we already have open, avoid doing path based
1837 * setting of file size if we can do it by handle.
1838 * This keeps our caching token (oplock) and avoids timeouts
1839 * when the local oplock break takes longer to flush
1840 * writebehind data than the SMB timeout for the SetPathInfo
1841 * request would allow
1843 open_file = find_writable_file(cifsInode, true);
1845 __u16 nfid = open_file->netfid;
1846 __u32 npid = open_file->pid;
1847 pTcon = tlink_tcon(open_file->tlink);
1848 rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size, nfid,
1850 cifsFileInfo_put(open_file);
1851 cFYI(1, "SetFSize for attrs rc = %d", rc);
1852 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1853 unsigned int bytes_written;
1855 io_parms.netfid = nfid;
1856 io_parms.pid = npid;
1857 io_parms.tcon = pTcon;
1858 io_parms.offset = 0;
1859 io_parms.length = attrs->ia_size;
1860 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written,
1862 cFYI(1, "Wrt seteof rc %d", rc);
1868 if (pTcon == NULL) {
1869 tlink = cifs_sb_tlink(cifs_sb);
1871 return PTR_ERR(tlink);
1872 pTcon = tlink_tcon(tlink);
1875 /* Set file size by pathname rather than by handle
1876 either because no valid, writeable file handle for
1877 it was found or because there was an error setting
1879 rc = CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size,
1880 false, cifs_sb->local_nls,
1881 cifs_sb->mnt_cifs_flags &
1882 CIFS_MOUNT_MAP_SPECIAL_CHR);
1883 cFYI(1, "SetEOF by path (setattrs) rc = %d", rc);
1884 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1888 rc = SMBLegacyOpen(xid, pTcon, full_path,
1889 FILE_OPEN, GENERIC_WRITE,
1890 CREATE_NOT_DIR, &netfid, &oplock, NULL,
1892 cifs_sb->mnt_cifs_flags &
1893 CIFS_MOUNT_MAP_SPECIAL_CHR);
1895 unsigned int bytes_written;
1897 io_parms.netfid = netfid;
1898 io_parms.pid = current->tgid;
1899 io_parms.tcon = pTcon;
1900 io_parms.offset = 0;
1901 io_parms.length = attrs->ia_size;
1902 rc = CIFSSMBWrite(xid, &io_parms,
1905 cFYI(1, "wrt seteof rc %d", rc);
1906 CIFSSMBClose(xid, pTcon, netfid);
1910 cifs_put_tlink(tlink);
1914 cifsInode->server_eof = attrs->ia_size;
1915 cifs_setsize(inode, attrs->ia_size);
1916 cifs_truncate_page(inode->i_mapping, inode->i_size);
1923 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1927 char *full_path = NULL;
1928 struct inode *inode = direntry->d_inode;
1929 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1930 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1931 struct tcon_link *tlink;
1932 struct cifs_tcon *pTcon;
1933 struct cifs_unix_set_info_args *args = NULL;
1934 struct cifsFileInfo *open_file;
1936 cFYI(1, "setattr_unix on file %s attrs->ia_valid=0x%x",
1937 direntry->d_name.name, attrs->ia_valid);
1941 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
1942 attrs->ia_valid |= ATTR_FORCE;
1944 rc = inode_change_ok(inode, attrs);
1948 full_path = build_path_from_dentry(direntry);
1949 if (full_path == NULL) {
1955 * Attempt to flush data before changing attributes. We need to do
1956 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1957 * ownership or mode then we may also need to do this. Here, we take
1958 * the safe way out and just do the flush on all setattr requests. If
1959 * the flush returns error, store it to report later and continue.
1961 * BB: This should be smarter. Why bother flushing pages that
1962 * will be truncated anyway? Also, should we error out here if
1963 * the flush returns error?
1965 rc = filemap_write_and_wait(inode->i_mapping);
1966 mapping_set_error(inode->i_mapping, rc);
1969 if (attrs->ia_valid & ATTR_SIZE) {
1970 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1975 /* skip mode change if it's just for clearing setuid/setgid */
1976 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1977 attrs->ia_valid &= ~ATTR_MODE;
1979 args = kmalloc(sizeof(*args), GFP_KERNEL);
1985 /* set up the struct */
1986 if (attrs->ia_valid & ATTR_MODE)
1987 args->mode = attrs->ia_mode;
1989 args->mode = NO_CHANGE_64;
1991 if (attrs->ia_valid & ATTR_UID)
1992 args->uid = attrs->ia_uid;
1994 args->uid = NO_CHANGE_64;
1996 if (attrs->ia_valid & ATTR_GID)
1997 args->gid = attrs->ia_gid;
1999 args->gid = NO_CHANGE_64;
2001 if (attrs->ia_valid & ATTR_ATIME)
2002 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2004 args->atime = NO_CHANGE_64;
2006 if (attrs->ia_valid & ATTR_MTIME)
2007 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2009 args->mtime = NO_CHANGE_64;
2011 if (attrs->ia_valid & ATTR_CTIME)
2012 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2014 args->ctime = NO_CHANGE_64;
2017 open_file = find_writable_file(cifsInode, true);
2019 u16 nfid = open_file->netfid;
2020 u32 npid = open_file->pid;
2021 pTcon = tlink_tcon(open_file->tlink);
2022 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2023 cifsFileInfo_put(open_file);
2025 tlink = cifs_sb_tlink(cifs_sb);
2026 if (IS_ERR(tlink)) {
2027 rc = PTR_ERR(tlink);
2030 pTcon = tlink_tcon(tlink);
2031 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2033 cifs_sb->mnt_cifs_flags &
2034 CIFS_MOUNT_MAP_SPECIAL_CHR);
2035 cifs_put_tlink(tlink);
2041 if ((attrs->ia_valid & ATTR_SIZE) &&
2042 attrs->ia_size != i_size_read(inode))
2043 truncate_setsize(inode, attrs->ia_size);
2045 setattr_copy(inode, attrs);
2046 mark_inode_dirty(inode);
2048 /* force revalidate when any of these times are set since some
2049 of the fs types (eg ext3, fat) do not have fine enough
2050 time granularity to match protocol, and we do not have a
2051 a way (yet) to query the server fs's time granularity (and
2052 whether it rounds times down).
2054 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2055 cifsInode->time = 0;
2064 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2067 uid_t uid = NO_CHANGE_32;
2068 gid_t gid = NO_CHANGE_32;
2069 struct inode *inode = direntry->d_inode;
2070 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2071 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2072 char *full_path = NULL;
2075 __u64 mode = NO_CHANGE_64;
2079 cFYI(1, "setattr on file %s attrs->iavalid 0x%x",
2080 direntry->d_name.name, attrs->ia_valid);
2082 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2083 attrs->ia_valid |= ATTR_FORCE;
2085 rc = inode_change_ok(inode, attrs);
2091 full_path = build_path_from_dentry(direntry);
2092 if (full_path == NULL) {
2099 * Attempt to flush data before changing attributes. We need to do
2100 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2101 * ownership or mode then we may also need to do this. Here, we take
2102 * the safe way out and just do the flush on all setattr requests. If
2103 * the flush returns error, store it to report later and continue.
2105 * BB: This should be smarter. Why bother flushing pages that
2106 * will be truncated anyway? Also, should we error out here if
2107 * the flush returns error?
2109 rc = filemap_write_and_wait(inode->i_mapping);
2110 mapping_set_error(inode->i_mapping, rc);
2113 if (attrs->ia_valid & ATTR_SIZE) {
2114 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2116 goto cifs_setattr_exit;
2119 if (attrs->ia_valid & ATTR_UID)
2120 uid = attrs->ia_uid;
2122 if (attrs->ia_valid & ATTR_GID)
2123 gid = attrs->ia_gid;
2125 #ifdef CONFIG_CIFS_ACL
2126 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2127 if (uid != NO_CHANGE_32 || gid != NO_CHANGE_32) {
2128 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2131 cFYI(1, "%s: Setting id failed with error: %d",
2133 goto cifs_setattr_exit;
2137 #endif /* CONFIG_CIFS_ACL */
2138 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2139 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2141 /* skip mode change if it's just for clearing setuid/setgid */
2142 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2143 attrs->ia_valid &= ~ATTR_MODE;
2145 if (attrs->ia_valid & ATTR_MODE) {
2146 mode = attrs->ia_mode;
2148 #ifdef CONFIG_CIFS_ACL
2149 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2150 rc = id_mode_to_cifs_acl(inode, full_path, mode,
2151 NO_CHANGE_32, NO_CHANGE_32);
2153 cFYI(1, "%s: Setting ACL failed with error: %d",
2155 goto cifs_setattr_exit;
2158 #endif /* CONFIG_CIFS_ACL */
2159 if (((mode & S_IWUGO) == 0) &&
2160 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2162 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2164 /* fix up mode if we're not using dynperm */
2165 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2166 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2167 } else if ((mode & S_IWUGO) &&
2168 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2170 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2171 /* Attributes of 0 are ignored */
2173 dosattr |= ATTR_NORMAL;
2175 /* reset local inode permissions to normal */
2176 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2177 attrs->ia_mode &= ~(S_IALLUGO);
2178 if (S_ISDIR(inode->i_mode))
2180 cifs_sb->mnt_dir_mode;
2183 cifs_sb->mnt_file_mode;
2185 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2186 /* ignore mode change - ATTR_READONLY hasn't changed */
2187 attrs->ia_valid &= ~ATTR_MODE;
2191 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2192 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2193 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2194 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2196 /* Even if error on time set, no sense failing the call if
2197 the server would set the time to a reasonable value anyway,
2198 and this check ensures that we are not being called from
2199 sys_utimes in which case we ought to fail the call back to
2200 the user when the server rejects the call */
2201 if ((rc) && (attrs->ia_valid &
2202 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2206 /* do not need local check to inode_check_ok since the server does
2209 goto cifs_setattr_exit;
2211 if ((attrs->ia_valid & ATTR_SIZE) &&
2212 attrs->ia_size != i_size_read(inode))
2213 truncate_setsize(inode, attrs->ia_size);
2215 setattr_copy(inode, attrs);
2216 mark_inode_dirty(inode);
2225 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2227 struct inode *inode = direntry->d_inode;
2228 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2229 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2231 if (pTcon->unix_ext)
2232 return cifs_setattr_unix(direntry, attrs);
2234 return cifs_setattr_nounix(direntry, attrs);
2236 /* BB: add cifs_setattr_legacy for really old servers */
2240 void cifs_delete_inode(struct inode *inode)
2242 cFYI(1, "In cifs_delete_inode, inode = 0x%p", inode);
2243 /* may have to add back in if and when safe distributed caching of
2244 directories added e.g. via FindNotify */