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);
128 cifs_revalidate_cache(inode, fattr);
130 spin_lock(&inode->i_lock);
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 cifs_i->delete_pending = fattr->cf_flags & CIFS_FATTR_DELETE_PENDING;
153 cifs_i->server_eof = fattr->cf_eof;
155 * Can't safely change the file size here if the client is writing to
156 * it due to potential races.
158 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
159 i_size_write(inode, fattr->cf_eof);
162 * i_blocks is not related to (i_size / i_blksize),
163 * but instead 512 byte (2**9) size is required for
164 * calculating num blocks.
166 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
168 spin_unlock(&inode->i_lock);
170 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
171 inode->i_flags |= S_AUTOMOUNT;
176 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
178 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
180 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
183 fattr->cf_uniqueid = iunique(sb, ROOT_I);
186 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
188 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
189 struct cifs_sb_info *cifs_sb)
191 memset(fattr, 0, sizeof(*fattr));
192 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
193 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
194 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
196 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
197 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
198 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
199 fattr->cf_mode = le64_to_cpu(info->Permissions);
202 * Since we set the inode type below we need to mask off
203 * to avoid strange results if bits set above.
205 fattr->cf_mode &= ~S_IFMT;
206 switch (le32_to_cpu(info->Type)) {
208 fattr->cf_mode |= S_IFREG;
209 fattr->cf_dtype = DT_REG;
212 fattr->cf_mode |= S_IFLNK;
213 fattr->cf_dtype = DT_LNK;
216 fattr->cf_mode |= S_IFDIR;
217 fattr->cf_dtype = DT_DIR;
220 fattr->cf_mode |= S_IFCHR;
221 fattr->cf_dtype = DT_CHR;
222 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
223 le64_to_cpu(info->DevMinor) & MINORMASK);
226 fattr->cf_mode |= S_IFBLK;
227 fattr->cf_dtype = DT_BLK;
228 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
229 le64_to_cpu(info->DevMinor) & MINORMASK);
232 fattr->cf_mode |= S_IFIFO;
233 fattr->cf_dtype = DT_FIFO;
236 fattr->cf_mode |= S_IFSOCK;
237 fattr->cf_dtype = DT_SOCK;
240 /* safest to call it a file if we do not know */
241 fattr->cf_mode |= S_IFREG;
242 fattr->cf_dtype = DT_REG;
243 cFYI(1, "unknown type %d", le32_to_cpu(info->Type));
247 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
248 fattr->cf_uid = cifs_sb->mnt_uid;
250 fattr->cf_uid = le64_to_cpu(info->Uid);
252 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
253 fattr->cf_gid = cifs_sb->mnt_gid;
255 fattr->cf_gid = le64_to_cpu(info->Gid);
257 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
261 * Fill a cifs_fattr struct with fake inode info.
263 * Needed to setup cifs_fattr data for the directory which is the
264 * junction to the new submount (ie to setup the fake directory
265 * which represents a DFS referral).
268 cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
270 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
272 cFYI(1, "creating fake fattr for DFS referral");
274 memset(fattr, 0, sizeof(*fattr));
275 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
276 fattr->cf_uid = cifs_sb->mnt_uid;
277 fattr->cf_gid = cifs_sb->mnt_gid;
278 fattr->cf_atime = CURRENT_TIME;
279 fattr->cf_ctime = CURRENT_TIME;
280 fattr->cf_mtime = CURRENT_TIME;
282 fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
286 cifs_get_file_info_unix(struct file *filp)
290 FILE_UNIX_BASIC_INFO find_data;
291 struct cifs_fattr fattr;
292 struct inode *inode = filp->f_path.dentry->d_inode;
293 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
294 struct cifsFileInfo *cfile = filp->private_data;
295 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
298 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
300 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
301 } else if (rc == -EREMOTE) {
302 cifs_create_dfs_fattr(&fattr, inode->i_sb);
306 cifs_fattr_to_inode(inode, &fattr);
311 int cifs_get_inode_info_unix(struct inode **pinode,
312 const unsigned char *full_path,
313 struct super_block *sb, unsigned int xid)
316 FILE_UNIX_BASIC_INFO find_data;
317 struct cifs_fattr fattr;
318 struct cifs_tcon *tcon;
319 struct tcon_link *tlink;
320 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
322 cFYI(1, "Getting info on %s", full_path);
324 tlink = cifs_sb_tlink(cifs_sb);
326 return PTR_ERR(tlink);
327 tcon = tlink_tcon(tlink);
329 /* could have done a find first instead but this returns more info */
330 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
331 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
332 CIFS_MOUNT_MAP_SPECIAL_CHR);
333 cifs_put_tlink(tlink);
336 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
337 } else if (rc == -EREMOTE) {
338 cifs_create_dfs_fattr(&fattr, sb);
344 /* check for Minshall+French symlinks */
345 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
346 int tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
348 cFYI(1, "CIFSCheckMFSymlink: %d", tmprc);
351 if (*pinode == NULL) {
353 cifs_fill_uniqueid(sb, &fattr);
354 *pinode = cifs_iget(sb, &fattr);
358 /* we already have inode, update it */
359 cifs_fattr_to_inode(*pinode, &fattr);
366 cifs_sfu_type(struct cifs_fattr *fattr, const unsigned char *path,
367 struct cifs_sb_info *cifs_sb, unsigned int xid)
372 struct tcon_link *tlink;
373 struct cifs_tcon *tcon;
374 struct cifs_io_parms io_parms;
376 unsigned int bytes_read;
381 fattr->cf_mode &= ~S_IFMT;
383 if (fattr->cf_eof == 0) {
384 fattr->cf_mode |= S_IFIFO;
385 fattr->cf_dtype = DT_FIFO;
387 } else if (fattr->cf_eof < 8) {
388 fattr->cf_mode |= S_IFREG;
389 fattr->cf_dtype = DT_REG;
390 return -EINVAL; /* EOPNOTSUPP? */
393 tlink = cifs_sb_tlink(cifs_sb);
395 return PTR_ERR(tlink);
396 tcon = tlink_tcon(tlink);
398 rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, GENERIC_READ,
399 CREATE_NOT_DIR, &netfid, &oplock, NULL,
401 cifs_sb->mnt_cifs_flags &
402 CIFS_MOUNT_MAP_SPECIAL_CHR);
404 int buf_type = CIFS_NO_BUFFER;
406 io_parms.netfid = netfid;
407 io_parms.pid = current->tgid;
408 io_parms.tcon = tcon;
410 io_parms.length = 24;
411 rc = CIFSSMBRead(xid, &io_parms, &bytes_read, &pbuf,
413 if ((rc == 0) && (bytes_read >= 8)) {
414 if (memcmp("IntxBLK", pbuf, 8) == 0) {
415 cFYI(1, "Block device");
416 fattr->cf_mode |= S_IFBLK;
417 fattr->cf_dtype = DT_BLK;
418 if (bytes_read == 24) {
419 /* we have enough to decode dev num */
420 __u64 mjr; /* major */
421 __u64 mnr; /* minor */
422 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
423 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
424 fattr->cf_rdev = MKDEV(mjr, mnr);
426 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
427 cFYI(1, "Char device");
428 fattr->cf_mode |= S_IFCHR;
429 fattr->cf_dtype = DT_CHR;
430 if (bytes_read == 24) {
431 /* we have enough to decode dev num */
432 __u64 mjr; /* major */
433 __u64 mnr; /* minor */
434 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
435 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
436 fattr->cf_rdev = MKDEV(mjr, mnr);
438 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
440 fattr->cf_mode |= S_IFLNK;
441 fattr->cf_dtype = DT_LNK;
443 fattr->cf_mode |= S_IFREG; /* file? */
444 fattr->cf_dtype = DT_REG;
448 fattr->cf_mode |= S_IFREG; /* then it is a file */
449 fattr->cf_dtype = DT_REG;
450 rc = -EOPNOTSUPP; /* or some unknown SFU type */
452 CIFSSMBClose(xid, tcon, netfid);
454 cifs_put_tlink(tlink);
458 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
461 * Fetch mode bits as provided by SFU.
463 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
465 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
466 struct cifs_sb_info *cifs_sb, unsigned int xid)
468 #ifdef CONFIG_CIFS_XATTR
472 struct tcon_link *tlink;
473 struct cifs_tcon *tcon;
475 tlink = cifs_sb_tlink(cifs_sb);
477 return PTR_ERR(tlink);
478 tcon = tlink_tcon(tlink);
480 rc = CIFSSMBQAllEAs(xid, tcon, path, "SETFILEBITS",
481 ea_value, 4 /* size of buf */, cifs_sb->local_nls,
482 cifs_sb->mnt_cifs_flags &
483 CIFS_MOUNT_MAP_SPECIAL_CHR);
484 cifs_put_tlink(tlink);
488 mode = le32_to_cpu(*((__le32 *)ea_value));
489 fattr->cf_mode &= ~SFBITS_MASK;
490 cFYI(1, "special bits 0%o org mode 0%o", mode,
492 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
493 cFYI(1, "special mode bits 0%o", mode);
502 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
504 cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
505 struct cifs_sb_info *cifs_sb, bool adjust_tz)
507 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
509 memset(fattr, 0, sizeof(*fattr));
510 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
511 if (info->DeletePending)
512 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
514 if (info->LastAccessTime)
515 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
517 fattr->cf_atime = CURRENT_TIME;
519 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
520 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
523 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
524 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
527 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
528 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
529 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
531 if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
532 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
533 fattr->cf_dtype = DT_DIR;
535 * Server can return wrong NumberOfLinks value for directories
536 * when Unix extensions are disabled - fake it.
540 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
541 fattr->cf_dtype = DT_REG;
543 /* clear write bits if ATTR_READONLY is set */
544 if (fattr->cf_cifsattrs & ATTR_READONLY)
545 fattr->cf_mode &= ~(S_IWUGO);
547 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
550 fattr->cf_uid = cifs_sb->mnt_uid;
551 fattr->cf_gid = cifs_sb->mnt_gid;
555 cifs_get_file_info(struct file *filp)
559 FILE_ALL_INFO find_data;
560 struct cifs_fattr fattr;
561 struct inode *inode = filp->f_path.dentry->d_inode;
562 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
563 struct cifsFileInfo *cfile = filp->private_data;
564 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
565 struct TCP_Server_Info *server = tcon->ses->server;
567 if (!server->ops->query_file_info)
571 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
574 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false);
577 cifs_create_dfs_fattr(&fattr, inode->i_sb);
583 * FIXME: legacy server -- fall back to path-based call?
584 * for now, just skip revalidating and mark inode for
588 CIFS_I(inode)->time = 0;
594 * don't bother with SFU junk here -- just mark inode as needing
597 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
598 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
599 cifs_fattr_to_inode(inode, &fattr);
606 cifs_get_inode_info(struct inode **inode, const char *full_path,
607 FILE_ALL_INFO *data, struct super_block *sb, int xid,
611 struct cifs_tcon *tcon;
612 struct TCP_Server_Info *server;
613 struct tcon_link *tlink;
614 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
616 bool adjust_tz = false;
617 struct cifs_fattr fattr;
619 tlink = cifs_sb_tlink(cifs_sb);
621 return PTR_ERR(tlink);
622 tcon = tlink_tcon(tlink);
623 server = tcon->ses->server;
625 cFYI(1, "Getting info on %s", full_path);
627 if ((data == NULL) && (*inode != NULL)) {
628 if (CIFS_I(*inode)->clientCanCacheRead) {
629 cFYI(1, "No need to revalidate cached inode sizes");
634 /* if inode info is not passed, get it from server */
636 if (!server->ops->query_path_info) {
640 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
645 data = (FILE_ALL_INFO *)buf;
646 rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path,
651 cifs_all_info_to_fattr(&fattr, (FILE_ALL_INFO *)data, cifs_sb,
653 } else if (rc == -EREMOTE) {
654 cifs_create_dfs_fattr(&fattr, sb);
661 * If an inode wasn't passed in, then get the inode number
663 * Is an i_ino of zero legal? Can we use that to check if the server
664 * supports returning inode numbers? Are there other sanity checks we
665 * can use to ensure that the server is really filling in that field?
667 if (*inode == NULL) {
668 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
669 if (server->ops->get_srv_inum)
670 tmprc = server->ops->get_srv_inum(xid, tcon,
671 cifs_sb, full_path, &fattr.cf_uniqueid,
675 if (tmprc || !fattr.cf_uniqueid) {
676 cFYI(1, "GetSrvInodeNum rc %d", tmprc);
677 fattr.cf_uniqueid = iunique(sb, ROOT_I);
678 cifs_autodisable_serverino(cifs_sb);
681 fattr.cf_uniqueid = iunique(sb, ROOT_I);
684 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
687 /* query for SFU type info if supported and needed */
688 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
689 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
690 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
692 cFYI(1, "cifs_sfu_type failed: %d", tmprc);
695 #ifdef CONFIG_CIFS_ACL
696 /* fill in 0777 bits from ACL */
697 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
698 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, full_path, fid);
700 cFYI(1, "%s: Getting ACL failed with error: %d",
705 #endif /* CONFIG_CIFS_ACL */
707 /* fill in remaining high mode bits e.g. SUID, VTX */
708 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
709 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
711 /* check for Minshall+French symlinks */
712 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
713 tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
715 cFYI(1, "CIFSCheckMFSymlink: %d", tmprc);
719 *inode = cifs_iget(sb, &fattr);
723 cifs_fattr_to_inode(*inode, &fattr);
728 cifs_put_tlink(tlink);
732 static const struct inode_operations cifs_ipc_inode_ops = {
733 .lookup = cifs_lookup,
737 cifs_find_inode(struct inode *inode, void *opaque)
739 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
741 /* don't match inode with different uniqueid */
742 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
745 /* use createtime like an i_generation field */
746 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
749 /* don't match inode of different type */
750 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
753 /* if it's not a directory or has no dentries, then flag it */
754 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
755 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
761 cifs_init_inode(struct inode *inode, void *opaque)
763 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
765 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
766 CIFS_I(inode)->createtime = fattr->cf_createtime;
771 * walk dentry list for an inode and report whether it has aliases that
772 * are hashed. We use this to determine if a directory inode can actually
776 inode_has_hashed_dentries(struct inode *inode)
778 struct dentry *dentry;
779 struct hlist_node *p;
781 spin_lock(&inode->i_lock);
782 hlist_for_each_entry(dentry, p, &inode->i_dentry, d_alias) {
783 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
784 spin_unlock(&inode->i_lock);
788 spin_unlock(&inode->i_lock);
792 /* Given fattrs, get a corresponding inode */
794 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
800 cFYI(1, "looking for uniqueid=%llu", fattr->cf_uniqueid);
802 /* hash down to 32-bits on 32-bit arch */
803 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
805 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
807 /* was there a potentially problematic inode collision? */
808 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
809 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
811 if (inode_has_hashed_dentries(inode)) {
812 cifs_autodisable_serverino(CIFS_SB(sb));
814 fattr->cf_uniqueid = iunique(sb, ROOT_I);
815 goto retry_iget5_locked;
819 cifs_fattr_to_inode(inode, fattr);
820 if (sb->s_flags & MS_NOATIME)
821 inode->i_flags |= S_NOATIME | S_NOCMTIME;
822 if (inode->i_state & I_NEW) {
824 if (S_ISREG(inode->i_mode))
825 inode->i_data.backing_dev_info = sb->s_bdi;
826 #ifdef CONFIG_CIFS_FSCACHE
827 /* initialize per-inode cache cookie pointer */
828 CIFS_I(inode)->fscache = NULL;
830 unlock_new_inode(inode);
837 /* gets root inode */
838 struct inode *cifs_root_iget(struct super_block *sb)
841 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
842 struct inode *inode = NULL;
844 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
848 rc = cifs_get_inode_info_unix(&inode, "", sb, xid);
850 rc = cifs_get_inode_info(&inode, "", NULL, sb, xid, NULL);
857 #ifdef CONFIG_CIFS_FSCACHE
858 /* populate tcon->resource_id */
859 tcon->resource_id = CIFS_I(inode)->uniqueid;
862 if (rc && tcon->ipc) {
863 cFYI(1, "ipc connection - fake read inode");
864 spin_lock(&inode->i_lock);
865 inode->i_mode |= S_IFDIR;
867 inode->i_op = &cifs_ipc_inode_ops;
868 inode->i_fop = &simple_dir_operations;
869 inode->i_uid = cifs_sb->mnt_uid;
870 inode->i_gid = cifs_sb->mnt_gid;
871 spin_unlock(&inode->i_lock);
878 /* can not call macro free_xid here since in a void func
879 * TODO: This is no longer true
886 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
887 char *full_path, __u32 dosattr)
889 bool set_time = false;
890 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
891 struct TCP_Server_Info *server;
892 FILE_BASIC_INFO info_buf;
897 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
898 if (!server->ops->set_file_info)
901 if (attrs->ia_valid & ATTR_ATIME) {
903 info_buf.LastAccessTime =
904 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
906 info_buf.LastAccessTime = 0;
908 if (attrs->ia_valid & ATTR_MTIME) {
910 info_buf.LastWriteTime =
911 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
913 info_buf.LastWriteTime = 0;
916 * Samba throws this field away, but windows may actually use it.
917 * Do not set ctime unless other time stamps are changed explicitly
918 * (i.e. by utimes()) since we would then have a mix of client and
921 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
922 cFYI(1, "CIFS - CTIME changed");
923 info_buf.ChangeTime =
924 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
926 info_buf.ChangeTime = 0;
928 info_buf.CreationTime = 0; /* don't change */
929 info_buf.Attributes = cpu_to_le32(dosattr);
931 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
935 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
936 * and rename it to a random name that hopefully won't conflict with
940 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
941 const unsigned int xid)
946 struct inode *inode = dentry->d_inode;
947 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
948 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
949 struct tcon_link *tlink;
950 struct cifs_tcon *tcon;
951 __u32 dosattr, origattr;
952 FILE_BASIC_INFO *info_buf = NULL;
954 tlink = cifs_sb_tlink(cifs_sb);
956 return PTR_ERR(tlink);
957 tcon = tlink_tcon(tlink);
959 rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
960 DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
961 &netfid, &oplock, NULL, cifs_sb->local_nls,
962 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
966 origattr = cifsInode->cifsAttrs;
968 origattr |= ATTR_NORMAL;
970 dosattr = origattr & ~ATTR_READONLY;
972 dosattr |= ATTR_NORMAL;
973 dosattr |= ATTR_HIDDEN;
975 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
976 if (dosattr != origattr) {
977 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
978 if (info_buf == NULL) {
982 info_buf->Attributes = cpu_to_le32(dosattr);
983 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
985 /* although we would like to mark the file hidden
986 if that fails we will still try to rename it */
988 cifsInode->cifsAttrs = dosattr;
990 dosattr = origattr; /* since not able to change them */
993 /* rename the file */
994 rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
995 cifs_sb->mnt_cifs_flags &
996 CIFS_MOUNT_MAP_SPECIAL_CHR);
1002 /* try to set DELETE_ON_CLOSE */
1003 if (!cifsInode->delete_pending) {
1004 rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
1007 * some samba versions return -ENOENT when we try to set the
1008 * file disposition here. Likely a samba bug, but work around
1009 * it for now. This means that some cifsXXX files may hang
1010 * around after they shouldn't.
1012 * BB: remove this hack after more servers have the fix
1020 cifsInode->delete_pending = true;
1024 CIFSSMBClose(xid, tcon, netfid);
1027 cifs_put_tlink(tlink);
1031 * reset everything back to the original state. Don't bother
1032 * dealing with errors here since we can't do anything about
1036 CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
1037 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1038 CIFS_MOUNT_MAP_SPECIAL_CHR);
1040 if (dosattr != origattr) {
1041 info_buf->Attributes = cpu_to_le32(origattr);
1042 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1044 cifsInode->cifsAttrs = origattr;
1050 /* copied from fs/nfs/dir.c with small changes */
1052 cifs_drop_nlink(struct inode *inode)
1054 spin_lock(&inode->i_lock);
1055 if (inode->i_nlink > 0)
1057 spin_unlock(&inode->i_lock);
1061 * If dentry->d_inode is null (usually meaning the cached dentry
1062 * is a negative dentry) then we would attempt a standard SMB delete, but
1063 * if that fails we can not attempt the fall back mechanisms on EACCESS
1064 * but will return the EACCESS to the caller. Note that the VFS does not call
1065 * unlink on negative dentries currently.
1067 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1071 char *full_path = NULL;
1072 struct inode *inode = dentry->d_inode;
1073 struct cifsInodeInfo *cifs_inode;
1074 struct super_block *sb = dir->i_sb;
1075 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1076 struct tcon_link *tlink;
1077 struct cifs_tcon *tcon;
1078 struct TCP_Server_Info *server;
1079 struct iattr *attrs = NULL;
1080 __u32 dosattr = 0, origattr = 0;
1082 cFYI(1, "cifs_unlink, dir=0x%p, dentry=0x%p", dir, dentry);
1084 tlink = cifs_sb_tlink(cifs_sb);
1086 return PTR_ERR(tlink);
1087 tcon = tlink_tcon(tlink);
1088 server = tcon->ses->server;
1092 /* Unlink can be called from rename so we can not take the
1093 * sb->s_vfs_rename_mutex here */
1094 full_path = build_path_from_dentry(dentry);
1095 if (full_path == NULL) {
1100 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1101 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1102 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1103 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1104 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1105 cFYI(1, "posix del rc %d", rc);
1106 if ((rc == 0) || (rc == -ENOENT))
1107 goto psx_del_no_retry;
1111 if (!server->ops->unlink) {
1113 goto psx_del_no_retry;
1116 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1121 cifs_drop_nlink(inode);
1122 } else if (rc == -ENOENT) {
1124 } else if (rc == -ETXTBSY) {
1125 if (server->ops->rename_pending_delete) {
1126 rc = server->ops->rename_pending_delete(full_path,
1129 cifs_drop_nlink(inode);
1132 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1133 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1134 if (attrs == NULL) {
1139 /* try to reset dos attributes */
1140 cifs_inode = CIFS_I(inode);
1141 origattr = cifs_inode->cifsAttrs;
1143 origattr |= ATTR_NORMAL;
1144 dosattr = origattr & ~ATTR_READONLY;
1146 dosattr |= ATTR_NORMAL;
1147 dosattr |= ATTR_HIDDEN;
1149 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1153 goto retry_std_delete;
1156 /* undo the setattr if we errored out and it's needed */
1157 if (rc != 0 && dosattr != 0)
1158 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1162 cifs_inode = CIFS_I(inode);
1163 cifs_inode->time = 0; /* will force revalidate to get info
1165 inode->i_ctime = current_fs_time(sb);
1167 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1168 cifs_inode = CIFS_I(dir);
1169 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1174 cifs_put_tlink(tlink);
1179 cifs_mkdir_qinfo(struct inode *inode, struct dentry *dentry, umode_t mode,
1180 const char *full_path, struct cifs_sb_info *cifs_sb,
1181 struct cifs_tcon *tcon, const unsigned int xid)
1184 struct inode *newinode = NULL;
1187 rc = cifs_get_inode_info_unix(&newinode, full_path, inode->i_sb,
1190 rc = cifs_get_inode_info(&newinode, full_path, NULL,
1191 inode->i_sb, xid, NULL);
1195 d_instantiate(dentry, newinode);
1197 * setting nlink not necessary except in cases where we failed to get it
1198 * from the server or was set bogus
1200 spin_lock(&dentry->d_inode->i_lock);
1201 if ((dentry->d_inode) && (dentry->d_inode->i_nlink < 2))
1202 set_nlink(dentry->d_inode, 2);
1203 spin_unlock(&dentry->d_inode->i_lock);
1204 mode &= ~current_umask();
1205 /* must turn on setgid bit if parent dir has it */
1206 if (inode->i_mode & S_ISGID)
1209 if (tcon->unix_ext) {
1210 struct cifs_unix_set_info_args args = {
1212 .ctime = NO_CHANGE_64,
1213 .atime = NO_CHANGE_64,
1214 .mtime = NO_CHANGE_64,
1217 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1218 args.uid = (__u64)current_fsuid();
1219 if (inode->i_mode & S_ISGID)
1220 args.gid = (__u64)inode->i_gid;
1222 args.gid = (__u64)current_fsgid();
1224 args.uid = NO_CHANGE_64;
1225 args.gid = NO_CHANGE_64;
1227 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1229 cifs_sb->mnt_cifs_flags &
1230 CIFS_MOUNT_MAP_SPECIAL_CHR);
1232 struct TCP_Server_Info *server = tcon->ses->server;
1233 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1234 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1235 server->ops->mkdir_setinfo(newinode, full_path, cifs_sb,
1237 if (dentry->d_inode) {
1238 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1239 dentry->d_inode->i_mode = (mode | S_IFDIR);
1241 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1242 dentry->d_inode->i_uid = current_fsuid();
1243 if (inode->i_mode & S_ISGID)
1244 dentry->d_inode->i_gid = inode->i_gid;
1246 dentry->d_inode->i_gid =
1255 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1256 const char *full_path, struct cifs_sb_info *cifs_sb,
1257 struct cifs_tcon *tcon, const unsigned int xid)
1261 FILE_UNIX_BASIC_INFO *info = NULL;
1262 struct inode *newinode = NULL;
1263 struct cifs_fattr fattr;
1265 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1268 goto posix_mkdir_out;
1271 mode &= ~current_umask();
1272 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1273 NULL /* netfid */, info, &oplock, full_path,
1274 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1275 CIFS_MOUNT_MAP_SPECIAL_CHR);
1276 if (rc == -EOPNOTSUPP)
1277 goto posix_mkdir_out;
1279 cFYI(1, "posix mkdir returned 0x%x", rc);
1281 goto posix_mkdir_out;
1284 if (info->Type == cpu_to_le32(-1))
1285 /* no return info, go query for it */
1286 goto posix_mkdir_get_info;
1288 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1289 * need to set uid/gid.
1292 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1293 cifs_fill_uniqueid(inode->i_sb, &fattr);
1294 newinode = cifs_iget(inode->i_sb, &fattr);
1296 goto posix_mkdir_get_info;
1298 d_instantiate(dentry, newinode);
1300 #ifdef CONFIG_CIFS_DEBUG2
1301 cFYI(1, "instantiated dentry %p %s to inode %p", dentry,
1302 dentry->d_name.name, newinode);
1304 if (newinode->i_nlink != 2)
1305 cFYI(1, "unexpected number of links %d", newinode->i_nlink);
1311 posix_mkdir_get_info:
1312 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1314 goto posix_mkdir_out;
1317 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1321 struct cifs_sb_info *cifs_sb;
1322 struct tcon_link *tlink;
1323 struct cifs_tcon *tcon;
1324 struct TCP_Server_Info *server;
1327 cFYI(1, "In cifs_mkdir, mode = 0x%hx inode = 0x%p", mode, inode);
1329 cifs_sb = CIFS_SB(inode->i_sb);
1330 tlink = cifs_sb_tlink(cifs_sb);
1332 return PTR_ERR(tlink);
1333 tcon = tlink_tcon(tlink);
1337 full_path = build_path_from_dentry(direntry);
1338 if (full_path == NULL) {
1343 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1344 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1345 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1347 if (rc != -EOPNOTSUPP)
1351 server = tcon->ses->server;
1353 if (!server->ops->mkdir) {
1358 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1359 rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
1361 cFYI(1, "cifs_mkdir returned 0x%x", rc);
1366 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1370 * Force revalidate to get parent dir info when needed since cached
1371 * attributes are invalid now.
1373 CIFS_I(inode)->time = 0;
1376 cifs_put_tlink(tlink);
1380 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1384 struct cifs_sb_info *cifs_sb;
1385 struct tcon_link *tlink;
1386 struct cifs_tcon *tcon;
1387 struct TCP_Server_Info *server;
1388 char *full_path = NULL;
1389 struct cifsInodeInfo *cifsInode;
1391 cFYI(1, "cifs_rmdir, inode = 0x%p", inode);
1395 full_path = build_path_from_dentry(direntry);
1396 if (full_path == NULL) {
1401 cifs_sb = CIFS_SB(inode->i_sb);
1402 tlink = cifs_sb_tlink(cifs_sb);
1403 if (IS_ERR(tlink)) {
1404 rc = PTR_ERR(tlink);
1407 tcon = tlink_tcon(tlink);
1408 server = tcon->ses->server;
1410 if (!server->ops->rmdir) {
1412 cifs_put_tlink(tlink);
1416 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1417 cifs_put_tlink(tlink);
1420 spin_lock(&direntry->d_inode->i_lock);
1421 i_size_write(direntry->d_inode, 0);
1422 clear_nlink(direntry->d_inode);
1423 spin_unlock(&direntry->d_inode->i_lock);
1426 cifsInode = CIFS_I(direntry->d_inode);
1427 /* force revalidate to go get info when needed */
1428 cifsInode->time = 0;
1430 cifsInode = CIFS_I(inode);
1432 * Force revalidate to get parent dir info when needed since cached
1433 * attributes are invalid now.
1435 cifsInode->time = 0;
1437 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1438 current_fs_time(inode->i_sb);
1447 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1448 const char *from_path, struct dentry *to_dentry,
1449 const char *to_path)
1451 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1452 struct tcon_link *tlink;
1453 struct cifs_tcon *tcon;
1454 struct TCP_Server_Info *server;
1458 tlink = cifs_sb_tlink(cifs_sb);
1460 return PTR_ERR(tlink);
1461 tcon = tlink_tcon(tlink);
1462 server = tcon->ses->server;
1464 if (!server->ops->rename)
1467 /* try path-based rename first */
1468 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1471 * Don't bother with rename by filehandle unless file is busy and
1472 * source. Note that cross directory moves do not work with
1473 * rename by filehandle to various Windows servers.
1475 if (rc == 0 || rc != -ETXTBSY)
1476 goto do_rename_exit;
1478 /* open-file renames don't work across directories */
1479 if (to_dentry->d_parent != from_dentry->d_parent)
1480 goto do_rename_exit;
1482 /* open the file to be renamed -- we need DELETE perms */
1483 rc = CIFSSMBOpen(xid, tcon, from_path, FILE_OPEN, DELETE,
1484 CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1485 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1486 CIFS_MOUNT_MAP_SPECIAL_CHR);
1488 rc = CIFSSMBRenameOpenFile(xid, tcon, srcfid,
1489 (const char *) to_dentry->d_name.name,
1490 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1491 CIFS_MOUNT_MAP_SPECIAL_CHR);
1492 CIFSSMBClose(xid, tcon, srcfid);
1495 cifs_put_tlink(tlink);
1500 cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1501 struct inode *target_dir, struct dentry *target_dentry)
1503 char *from_name = NULL;
1504 char *to_name = NULL;
1505 struct cifs_sb_info *cifs_sb;
1506 struct tcon_link *tlink;
1507 struct cifs_tcon *tcon;
1508 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1509 FILE_UNIX_BASIC_INFO *info_buf_target;
1513 cifs_sb = CIFS_SB(source_dir->i_sb);
1514 tlink = cifs_sb_tlink(cifs_sb);
1516 return PTR_ERR(tlink);
1517 tcon = tlink_tcon(tlink);
1522 * we already have the rename sem so we do not need to
1523 * grab it again here to protect the path integrity
1525 from_name = build_path_from_dentry(source_dentry);
1526 if (from_name == NULL) {
1528 goto cifs_rename_exit;
1531 to_name = build_path_from_dentry(target_dentry);
1532 if (to_name == NULL) {
1534 goto cifs_rename_exit;
1537 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1540 if (rc == -EEXIST && tcon->unix_ext) {
1542 * Are src and dst hardlinks of same inode? We can only tell
1543 * with unix extensions enabled.
1546 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1548 if (info_buf_source == NULL) {
1550 goto cifs_rename_exit;
1553 info_buf_target = info_buf_source + 1;
1554 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1557 cifs_sb->mnt_cifs_flags &
1558 CIFS_MOUNT_MAP_SPECIAL_CHR);
1562 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1565 cifs_sb->mnt_cifs_flags &
1566 CIFS_MOUNT_MAP_SPECIAL_CHR);
1568 if (tmprc == 0 && (info_buf_source->UniqueId ==
1569 info_buf_target->UniqueId)) {
1570 /* same file, POSIX says that this is a noop */
1572 goto cifs_rename_exit;
1576 * else ... BB we could add the same check for Windows by
1577 * checking the UniqueId via FILE_INTERNAL_INFO
1581 /* Try unlinking the target dentry if it's not negative */
1582 if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
1583 tmprc = cifs_unlink(target_dir, target_dentry);
1585 goto cifs_rename_exit;
1586 rc = cifs_do_rename(xid, source_dentry, from_name,
1587 target_dentry, to_name);
1591 kfree(info_buf_source);
1595 cifs_put_tlink(tlink);
1600 cifs_inode_needs_reval(struct inode *inode)
1602 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1603 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1605 if (cifs_i->clientCanCacheRead)
1608 if (!lookupCacheEnabled)
1611 if (cifs_i->time == 0)
1614 if (!time_in_range(jiffies, cifs_i->time,
1615 cifs_i->time + cifs_sb->actimeo))
1618 /* hardlinked files w/ noserverino get "special" treatment */
1619 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1620 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1627 * Zap the cache. Called when invalid_mapping flag is set.
1630 cifs_invalidate_mapping(struct inode *inode)
1633 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1635 cifs_i->invalid_mapping = false;
1637 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1638 rc = invalidate_inode_pages2(inode->i_mapping);
1640 cERROR(1, "%s: could not invalidate inode %p", __func__,
1642 cifs_i->invalid_mapping = true;
1646 cifs_fscache_reset_inode_cookie(inode);
1650 int cifs_revalidate_file_attr(struct file *filp)
1653 struct inode *inode = filp->f_path.dentry->d_inode;
1654 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1656 if (!cifs_inode_needs_reval(inode))
1659 if (tlink_tcon(cfile->tlink)->unix_ext)
1660 rc = cifs_get_file_info_unix(filp);
1662 rc = cifs_get_file_info(filp);
1667 int cifs_revalidate_dentry_attr(struct dentry *dentry)
1671 struct inode *inode = dentry->d_inode;
1672 struct super_block *sb = dentry->d_sb;
1673 char *full_path = NULL;
1678 if (!cifs_inode_needs_reval(inode))
1683 /* can not safely grab the rename sem here if rename calls revalidate
1684 since that would deadlock */
1685 full_path = build_path_from_dentry(dentry);
1686 if (full_path == NULL) {
1691 cFYI(1, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time "
1692 "%ld jiffies %ld", full_path, inode, inode->i_count.counter,
1693 dentry, dentry->d_time, jiffies);
1695 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1696 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1698 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1707 int cifs_revalidate_file(struct file *filp)
1710 struct inode *inode = filp->f_path.dentry->d_inode;
1712 rc = cifs_revalidate_file_attr(filp);
1716 if (CIFS_I(inode)->invalid_mapping)
1717 rc = cifs_invalidate_mapping(inode);
1721 /* revalidate a dentry's inode attributes */
1722 int cifs_revalidate_dentry(struct dentry *dentry)
1725 struct inode *inode = dentry->d_inode;
1727 rc = cifs_revalidate_dentry_attr(dentry);
1731 if (CIFS_I(inode)->invalid_mapping)
1732 rc = cifs_invalidate_mapping(inode);
1736 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1739 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1740 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1741 struct inode *inode = dentry->d_inode;
1745 * We need to be sure that all dirty pages are written and the server
1746 * has actual ctime, mtime and file length.
1748 if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping &&
1749 inode->i_mapping->nrpages != 0) {
1750 rc = filemap_fdatawait(inode->i_mapping);
1752 mapping_set_error(inode->i_mapping, rc);
1757 rc = cifs_revalidate_dentry_attr(dentry);
1761 generic_fillattr(inode, stat);
1762 stat->blksize = CIFS_MAX_MSGSIZE;
1763 stat->ino = CIFS_I(inode)->uniqueid;
1766 * If on a multiuser mount without unix extensions, and the admin hasn't
1767 * overridden them, set the ownership to the fsuid/fsgid of the current
1770 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
1772 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1773 stat->uid = current_fsuid();
1774 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1775 stat->gid = current_fsgid();
1780 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1782 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1783 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1787 page = grab_cache_page(mapping, index);
1791 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1793 page_cache_release(page);
1797 static void cifs_setsize(struct inode *inode, loff_t offset)
1801 spin_lock(&inode->i_lock);
1802 oldsize = inode->i_size;
1803 i_size_write(inode, offset);
1804 spin_unlock(&inode->i_lock);
1806 truncate_pagecache(inode, oldsize, offset);
1810 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1811 unsigned int xid, char *full_path)
1814 struct cifsFileInfo *open_file;
1815 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1816 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1817 struct tcon_link *tlink = NULL;
1818 struct cifs_tcon *tcon = NULL;
1819 struct TCP_Server_Info *server;
1820 struct cifs_io_parms io_parms;
1823 * To avoid spurious oplock breaks from server, in the case of
1824 * inodes that we already have open, avoid doing path based
1825 * setting of file size if we can do it by handle.
1826 * This keeps our caching token (oplock) and avoids timeouts
1827 * when the local oplock break takes longer to flush
1828 * writebehind data than the SMB timeout for the SetPathInfo
1829 * request would allow
1831 open_file = find_writable_file(cifsInode, true);
1833 tcon = tlink_tcon(open_file->tlink);
1834 server = tcon->ses->server;
1835 if (server->ops->set_file_size)
1836 rc = server->ops->set_file_size(xid, tcon, open_file,
1837 attrs->ia_size, false);
1840 cifsFileInfo_put(open_file);
1841 cFYI(1, "SetFSize for attrs rc = %d", rc);
1842 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1843 unsigned int bytes_written;
1845 io_parms.netfid = open_file->fid.netfid;
1846 io_parms.pid = open_file->pid;
1847 io_parms.tcon = tcon;
1848 io_parms.offset = 0;
1849 io_parms.length = attrs->ia_size;
1850 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written,
1852 cFYI(1, "Wrt seteof rc %d", rc);
1861 tlink = cifs_sb_tlink(cifs_sb);
1863 return PTR_ERR(tlink);
1864 tcon = tlink_tcon(tlink);
1865 server = tcon->ses->server;
1869 * Set file size by pathname rather than by handle either because no
1870 * valid, writeable file handle for it was found or because there was
1871 * an error setting it by handle.
1873 if (server->ops->set_path_size)
1874 rc = server->ops->set_path_size(xid, tcon, full_path,
1875 attrs->ia_size, cifs_sb, false);
1878 cFYI(1, "SetEOF by path (setattrs) rc = %d", rc);
1879 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1883 rc = SMBLegacyOpen(xid, tcon, full_path, FILE_OPEN,
1884 GENERIC_WRITE, CREATE_NOT_DIR, &netfid,
1885 &oplock, NULL, cifs_sb->local_nls,
1886 cifs_sb->mnt_cifs_flags &
1887 CIFS_MOUNT_MAP_SPECIAL_CHR);
1889 unsigned int bytes_written;
1891 io_parms.netfid = netfid;
1892 io_parms.pid = current->tgid;
1893 io_parms.tcon = tcon;
1894 io_parms.offset = 0;
1895 io_parms.length = attrs->ia_size;
1896 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written, NULL,
1898 cFYI(1, "wrt seteof rc %d", rc);
1899 CIFSSMBClose(xid, tcon, netfid);
1903 cifs_put_tlink(tlink);
1907 cifsInode->server_eof = attrs->ia_size;
1908 cifs_setsize(inode, attrs->ia_size);
1909 cifs_truncate_page(inode->i_mapping, inode->i_size);
1916 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1920 char *full_path = NULL;
1921 struct inode *inode = direntry->d_inode;
1922 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1923 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1924 struct tcon_link *tlink;
1925 struct cifs_tcon *pTcon;
1926 struct cifs_unix_set_info_args *args = NULL;
1927 struct cifsFileInfo *open_file;
1929 cFYI(1, "setattr_unix on file %s attrs->ia_valid=0x%x",
1930 direntry->d_name.name, attrs->ia_valid);
1934 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
1935 attrs->ia_valid |= ATTR_FORCE;
1937 rc = inode_change_ok(inode, attrs);
1941 full_path = build_path_from_dentry(direntry);
1942 if (full_path == NULL) {
1948 * Attempt to flush data before changing attributes. We need to do
1949 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1950 * ownership or mode then we may also need to do this. Here, we take
1951 * the safe way out and just do the flush on all setattr requests. If
1952 * the flush returns error, store it to report later and continue.
1954 * BB: This should be smarter. Why bother flushing pages that
1955 * will be truncated anyway? Also, should we error out here if
1956 * the flush returns error?
1958 rc = filemap_write_and_wait(inode->i_mapping);
1959 mapping_set_error(inode->i_mapping, rc);
1962 if (attrs->ia_valid & ATTR_SIZE) {
1963 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1968 /* skip mode change if it's just for clearing setuid/setgid */
1969 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1970 attrs->ia_valid &= ~ATTR_MODE;
1972 args = kmalloc(sizeof(*args), GFP_KERNEL);
1978 /* set up the struct */
1979 if (attrs->ia_valid & ATTR_MODE)
1980 args->mode = attrs->ia_mode;
1982 args->mode = NO_CHANGE_64;
1984 if (attrs->ia_valid & ATTR_UID)
1985 args->uid = attrs->ia_uid;
1987 args->uid = NO_CHANGE_64;
1989 if (attrs->ia_valid & ATTR_GID)
1990 args->gid = attrs->ia_gid;
1992 args->gid = NO_CHANGE_64;
1994 if (attrs->ia_valid & ATTR_ATIME)
1995 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
1997 args->atime = NO_CHANGE_64;
1999 if (attrs->ia_valid & ATTR_MTIME)
2000 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2002 args->mtime = NO_CHANGE_64;
2004 if (attrs->ia_valid & ATTR_CTIME)
2005 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2007 args->ctime = NO_CHANGE_64;
2010 open_file = find_writable_file(cifsInode, true);
2012 u16 nfid = open_file->fid.netfid;
2013 u32 npid = open_file->pid;
2014 pTcon = tlink_tcon(open_file->tlink);
2015 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2016 cifsFileInfo_put(open_file);
2018 tlink = cifs_sb_tlink(cifs_sb);
2019 if (IS_ERR(tlink)) {
2020 rc = PTR_ERR(tlink);
2023 pTcon = tlink_tcon(tlink);
2024 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2026 cifs_sb->mnt_cifs_flags &
2027 CIFS_MOUNT_MAP_SPECIAL_CHR);
2028 cifs_put_tlink(tlink);
2034 if ((attrs->ia_valid & ATTR_SIZE) &&
2035 attrs->ia_size != i_size_read(inode))
2036 truncate_setsize(inode, attrs->ia_size);
2038 setattr_copy(inode, attrs);
2039 mark_inode_dirty(inode);
2041 /* force revalidate when any of these times are set since some
2042 of the fs types (eg ext3, fat) do not have fine enough
2043 time granularity to match protocol, and we do not have a
2044 a way (yet) to query the server fs's time granularity (and
2045 whether it rounds times down).
2047 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2048 cifsInode->time = 0;
2057 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2060 uid_t uid = NO_CHANGE_32;
2061 gid_t gid = NO_CHANGE_32;
2062 struct inode *inode = direntry->d_inode;
2063 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2064 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2065 char *full_path = NULL;
2068 __u64 mode = NO_CHANGE_64;
2072 cFYI(1, "setattr on file %s attrs->iavalid 0x%x",
2073 direntry->d_name.name, attrs->ia_valid);
2075 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2076 attrs->ia_valid |= ATTR_FORCE;
2078 rc = inode_change_ok(inode, attrs);
2084 full_path = build_path_from_dentry(direntry);
2085 if (full_path == NULL) {
2092 * Attempt to flush data before changing attributes. We need to do
2093 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2094 * ownership or mode then we may also need to do this. Here, we take
2095 * the safe way out and just do the flush on all setattr requests. If
2096 * the flush returns error, store it to report later and continue.
2098 * BB: This should be smarter. Why bother flushing pages that
2099 * will be truncated anyway? Also, should we error out here if
2100 * the flush returns error?
2102 rc = filemap_write_and_wait(inode->i_mapping);
2103 mapping_set_error(inode->i_mapping, rc);
2106 if (attrs->ia_valid & ATTR_SIZE) {
2107 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2109 goto cifs_setattr_exit;
2112 if (attrs->ia_valid & ATTR_UID)
2113 uid = attrs->ia_uid;
2115 if (attrs->ia_valid & ATTR_GID)
2116 gid = attrs->ia_gid;
2118 #ifdef CONFIG_CIFS_ACL
2119 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2120 if (uid != NO_CHANGE_32 || gid != NO_CHANGE_32) {
2121 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2124 cFYI(1, "%s: Setting id failed with error: %d",
2126 goto cifs_setattr_exit;
2130 #endif /* CONFIG_CIFS_ACL */
2131 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2132 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2134 /* skip mode change if it's just for clearing setuid/setgid */
2135 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2136 attrs->ia_valid &= ~ATTR_MODE;
2138 if (attrs->ia_valid & ATTR_MODE) {
2139 mode = attrs->ia_mode;
2141 #ifdef CONFIG_CIFS_ACL
2142 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2143 rc = id_mode_to_cifs_acl(inode, full_path, mode,
2144 NO_CHANGE_32, NO_CHANGE_32);
2146 cFYI(1, "%s: Setting ACL failed with error: %d",
2148 goto cifs_setattr_exit;
2151 #endif /* CONFIG_CIFS_ACL */
2152 if (((mode & S_IWUGO) == 0) &&
2153 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2155 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2157 /* fix up mode if we're not using dynperm */
2158 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2159 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2160 } else if ((mode & S_IWUGO) &&
2161 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2163 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2164 /* Attributes of 0 are ignored */
2166 dosattr |= ATTR_NORMAL;
2168 /* reset local inode permissions to normal */
2169 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2170 attrs->ia_mode &= ~(S_IALLUGO);
2171 if (S_ISDIR(inode->i_mode))
2173 cifs_sb->mnt_dir_mode;
2176 cifs_sb->mnt_file_mode;
2178 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2179 /* ignore mode change - ATTR_READONLY hasn't changed */
2180 attrs->ia_valid &= ~ATTR_MODE;
2184 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2185 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2186 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2187 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2189 /* Even if error on time set, no sense failing the call if
2190 the server would set the time to a reasonable value anyway,
2191 and this check ensures that we are not being called from
2192 sys_utimes in which case we ought to fail the call back to
2193 the user when the server rejects the call */
2194 if ((rc) && (attrs->ia_valid &
2195 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2199 /* do not need local check to inode_check_ok since the server does
2202 goto cifs_setattr_exit;
2204 if ((attrs->ia_valid & ATTR_SIZE) &&
2205 attrs->ia_size != i_size_read(inode))
2206 truncate_setsize(inode, attrs->ia_size);
2208 setattr_copy(inode, attrs);
2209 mark_inode_dirty(inode);
2218 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2220 struct inode *inode = direntry->d_inode;
2221 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2222 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2224 if (pTcon->unix_ext)
2225 return cifs_setattr_unix(direntry, attrs);
2227 return cifs_setattr_nounix(direntry, attrs);
2229 /* BB: add cifs_setattr_legacy for really old servers */
2233 void cifs_delete_inode(struct inode *inode)
2235 cFYI(1, "In cifs_delete_inode, inode = 0x%p", inode);
2236 /* may have to add back in if and when safe distributed caching of
2237 directories added e.g. via FindNotify */