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 cifs_dbg(FYI, "%s: revalidating inode %llu\n",
95 __func__, cifs_i->uniqueid);
97 if (inode->i_state & I_NEW) {
98 cifs_dbg(FYI, "%s: inode %llu is new\n",
99 __func__, cifs_i->uniqueid);
103 /* don't bother with revalidation if we have an oplock */
104 if (cifs_i->clientCanCacheRead) {
105 cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
106 __func__, cifs_i->uniqueid);
110 /* revalidate if mtime or size have changed */
111 if (timespec_equal(&inode->i_mtime, &fattr->cf_mtime) &&
112 cifs_i->server_eof == fattr->cf_eof) {
113 cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
114 __func__, cifs_i->uniqueid);
118 cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
119 __func__, cifs_i->uniqueid);
120 cifs_i->invalid_mapping = true;
123 /* populate an inode with info from a cifs_fattr struct */
125 cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
127 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
128 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
130 cifs_revalidate_cache(inode, fattr);
132 spin_lock(&inode->i_lock);
133 inode->i_atime = fattr->cf_atime;
134 inode->i_mtime = fattr->cf_mtime;
135 inode->i_ctime = fattr->cf_ctime;
136 inode->i_rdev = fattr->cf_rdev;
137 set_nlink(inode, fattr->cf_nlink);
138 inode->i_uid = fattr->cf_uid;
139 inode->i_gid = fattr->cf_gid;
141 /* if dynperm is set, don't clobber existing mode */
142 if (inode->i_state & I_NEW ||
143 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
144 inode->i_mode = fattr->cf_mode;
146 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
148 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
151 cifs_i->time = jiffies;
153 cifs_i->delete_pending = fattr->cf_flags & CIFS_FATTR_DELETE_PENDING;
155 cifs_i->server_eof = fattr->cf_eof;
157 * Can't safely change the file size here if the client is writing to
158 * it due to potential races.
160 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
161 i_size_write(inode, fattr->cf_eof);
164 * i_blocks is not related to (i_size / i_blksize),
165 * but instead 512 byte (2**9) size is required for
166 * calculating num blocks.
168 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
170 spin_unlock(&inode->i_lock);
172 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
173 inode->i_flags |= S_AUTOMOUNT;
178 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
180 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
182 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
185 fattr->cf_uniqueid = iunique(sb, ROOT_I);
188 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
190 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
191 struct cifs_sb_info *cifs_sb)
193 memset(fattr, 0, sizeof(*fattr));
194 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
195 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
196 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
198 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
199 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
200 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
201 fattr->cf_mode = le64_to_cpu(info->Permissions);
204 * Since we set the inode type below we need to mask off
205 * to avoid strange results if bits set above.
207 fattr->cf_mode &= ~S_IFMT;
208 switch (le32_to_cpu(info->Type)) {
210 fattr->cf_mode |= S_IFREG;
211 fattr->cf_dtype = DT_REG;
214 fattr->cf_mode |= S_IFLNK;
215 fattr->cf_dtype = DT_LNK;
218 fattr->cf_mode |= S_IFDIR;
219 fattr->cf_dtype = DT_DIR;
222 fattr->cf_mode |= S_IFCHR;
223 fattr->cf_dtype = DT_CHR;
224 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
225 le64_to_cpu(info->DevMinor) & MINORMASK);
228 fattr->cf_mode |= S_IFBLK;
229 fattr->cf_dtype = DT_BLK;
230 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
231 le64_to_cpu(info->DevMinor) & MINORMASK);
234 fattr->cf_mode |= S_IFIFO;
235 fattr->cf_dtype = DT_FIFO;
238 fattr->cf_mode |= S_IFSOCK;
239 fattr->cf_dtype = DT_SOCK;
242 /* safest to call it a file if we do not know */
243 fattr->cf_mode |= S_IFREG;
244 fattr->cf_dtype = DT_REG;
245 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
249 fattr->cf_uid = cifs_sb->mnt_uid;
250 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
251 u64 id = le64_to_cpu(info->Uid);
252 if (id < ((uid_t)-1)) {
253 kuid_t uid = make_kuid(&init_user_ns, id);
259 fattr->cf_gid = cifs_sb->mnt_gid;
260 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
261 u64 id = le64_to_cpu(info->Gid);
262 if (id < ((gid_t)-1)) {
263 kgid_t gid = make_kgid(&init_user_ns, id);
269 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
273 * Fill a cifs_fattr struct with fake inode info.
275 * Needed to setup cifs_fattr data for the directory which is the
276 * junction to the new submount (ie to setup the fake directory
277 * which represents a DFS referral).
280 cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
282 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
284 cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
286 memset(fattr, 0, sizeof(*fattr));
287 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
288 fattr->cf_uid = cifs_sb->mnt_uid;
289 fattr->cf_gid = cifs_sb->mnt_gid;
290 fattr->cf_atime = CURRENT_TIME;
291 fattr->cf_ctime = CURRENT_TIME;
292 fattr->cf_mtime = CURRENT_TIME;
294 fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
298 cifs_get_file_info_unix(struct file *filp)
302 FILE_UNIX_BASIC_INFO find_data;
303 struct cifs_fattr fattr;
304 struct inode *inode = file_inode(filp);
305 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
306 struct cifsFileInfo *cfile = filp->private_data;
307 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
310 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
312 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
313 } else if (rc == -EREMOTE) {
314 cifs_create_dfs_fattr(&fattr, inode->i_sb);
318 cifs_fattr_to_inode(inode, &fattr);
323 int cifs_get_inode_info_unix(struct inode **pinode,
324 const unsigned char *full_path,
325 struct super_block *sb, unsigned int xid)
328 FILE_UNIX_BASIC_INFO find_data;
329 struct cifs_fattr fattr;
330 struct cifs_tcon *tcon;
331 struct tcon_link *tlink;
332 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
334 cifs_dbg(FYI, "Getting info on %s\n", full_path);
336 tlink = cifs_sb_tlink(cifs_sb);
338 return PTR_ERR(tlink);
339 tcon = tlink_tcon(tlink);
341 /* could have done a find first instead but this returns more info */
342 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
343 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
344 CIFS_MOUNT_MAP_SPECIAL_CHR);
345 cifs_put_tlink(tlink);
348 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
349 } else if (rc == -EREMOTE) {
350 cifs_create_dfs_fattr(&fattr, sb);
356 /* check for Minshall+French symlinks */
357 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
358 int tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
360 cifs_dbg(FYI, "CIFSCheckMFSymlink: %d\n", tmprc);
363 if (*pinode == NULL) {
365 cifs_fill_uniqueid(sb, &fattr);
366 *pinode = cifs_iget(sb, &fattr);
370 /* we already have inode, update it */
371 cifs_fattr_to_inode(*pinode, &fattr);
378 cifs_sfu_type(struct cifs_fattr *fattr, const unsigned char *path,
379 struct cifs_sb_info *cifs_sb, unsigned int xid)
384 struct tcon_link *tlink;
385 struct cifs_tcon *tcon;
386 struct cifs_io_parms io_parms;
388 unsigned int bytes_read;
393 fattr->cf_mode &= ~S_IFMT;
395 if (fattr->cf_eof == 0) {
396 fattr->cf_mode |= S_IFIFO;
397 fattr->cf_dtype = DT_FIFO;
399 } else if (fattr->cf_eof < 8) {
400 fattr->cf_mode |= S_IFREG;
401 fattr->cf_dtype = DT_REG;
402 return -EINVAL; /* EOPNOTSUPP? */
405 tlink = cifs_sb_tlink(cifs_sb);
407 return PTR_ERR(tlink);
408 tcon = tlink_tcon(tlink);
410 rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, GENERIC_READ,
411 CREATE_NOT_DIR, &netfid, &oplock, NULL,
413 cifs_sb->mnt_cifs_flags &
414 CIFS_MOUNT_MAP_SPECIAL_CHR);
416 int buf_type = CIFS_NO_BUFFER;
418 io_parms.netfid = netfid;
419 io_parms.pid = current->tgid;
420 io_parms.tcon = tcon;
422 io_parms.length = 24;
423 rc = CIFSSMBRead(xid, &io_parms, &bytes_read, &pbuf,
425 if ((rc == 0) && (bytes_read >= 8)) {
426 if (memcmp("IntxBLK", pbuf, 8) == 0) {
427 cifs_dbg(FYI, "Block device\n");
428 fattr->cf_mode |= S_IFBLK;
429 fattr->cf_dtype = DT_BLK;
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("IntxCHR", pbuf, 8) == 0) {
439 cifs_dbg(FYI, "Char device\n");
440 fattr->cf_mode |= S_IFCHR;
441 fattr->cf_dtype = DT_CHR;
442 if (bytes_read == 24) {
443 /* we have enough to decode dev num */
444 __u64 mjr; /* major */
445 __u64 mnr; /* minor */
446 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
447 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
448 fattr->cf_rdev = MKDEV(mjr, mnr);
450 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
451 cifs_dbg(FYI, "Symlink\n");
452 fattr->cf_mode |= S_IFLNK;
453 fattr->cf_dtype = DT_LNK;
455 fattr->cf_mode |= S_IFREG; /* file? */
456 fattr->cf_dtype = DT_REG;
460 fattr->cf_mode |= S_IFREG; /* then it is a file */
461 fattr->cf_dtype = DT_REG;
462 rc = -EOPNOTSUPP; /* or some unknown SFU type */
464 CIFSSMBClose(xid, tcon, netfid);
466 cifs_put_tlink(tlink);
470 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
473 * Fetch mode bits as provided by SFU.
475 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
477 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
478 struct cifs_sb_info *cifs_sb, unsigned int xid)
480 #ifdef CONFIG_CIFS_XATTR
484 struct tcon_link *tlink;
485 struct cifs_tcon *tcon;
487 tlink = cifs_sb_tlink(cifs_sb);
489 return PTR_ERR(tlink);
490 tcon = tlink_tcon(tlink);
492 rc = CIFSSMBQAllEAs(xid, tcon, path, "SETFILEBITS",
493 ea_value, 4 /* size of buf */, cifs_sb->local_nls,
494 cifs_sb->mnt_cifs_flags &
495 CIFS_MOUNT_MAP_SPECIAL_CHR);
496 cifs_put_tlink(tlink);
500 mode = le32_to_cpu(*((__le32 *)ea_value));
501 fattr->cf_mode &= ~SFBITS_MASK;
502 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
503 mode, fattr->cf_mode);
504 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
505 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
514 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
516 cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
517 struct cifs_sb_info *cifs_sb, bool adjust_tz)
519 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
521 memset(fattr, 0, sizeof(*fattr));
522 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
523 if (info->DeletePending)
524 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
526 if (info->LastAccessTime)
527 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
529 fattr->cf_atime = CURRENT_TIME;
531 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
532 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
535 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
536 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
539 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
540 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
541 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
543 if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
544 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
545 fattr->cf_dtype = DT_DIR;
547 * Server can return wrong NumberOfLinks value for directories
548 * when Unix extensions are disabled - fake it.
552 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
553 fattr->cf_dtype = DT_REG;
555 /* clear write bits if ATTR_READONLY is set */
556 if (fattr->cf_cifsattrs & ATTR_READONLY)
557 fattr->cf_mode &= ~(S_IWUGO);
559 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
562 fattr->cf_uid = cifs_sb->mnt_uid;
563 fattr->cf_gid = cifs_sb->mnt_gid;
567 cifs_get_file_info(struct file *filp)
571 FILE_ALL_INFO find_data;
572 struct cifs_fattr fattr;
573 struct inode *inode = file_inode(filp);
574 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
575 struct cifsFileInfo *cfile = filp->private_data;
576 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
577 struct TCP_Server_Info *server = tcon->ses->server;
579 if (!server->ops->query_file_info)
583 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
586 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false);
589 cifs_create_dfs_fattr(&fattr, inode->i_sb);
595 * FIXME: legacy server -- fall back to path-based call?
596 * for now, just skip revalidating and mark inode for
600 CIFS_I(inode)->time = 0;
606 * don't bother with SFU junk here -- just mark inode as needing
609 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
610 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
611 cifs_fattr_to_inode(inode, &fattr);
618 cifs_get_inode_info(struct inode **inode, const char *full_path,
619 FILE_ALL_INFO *data, struct super_block *sb, int xid,
622 bool validinum = false;
624 int rc = 0, tmprc = ENOSYS;
625 struct cifs_tcon *tcon;
626 struct TCP_Server_Info *server;
627 struct tcon_link *tlink;
628 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
630 bool adjust_tz = false;
631 struct cifs_fattr fattr;
632 struct cifs_search_info *srchinf = NULL;
634 tlink = cifs_sb_tlink(cifs_sb);
636 return PTR_ERR(tlink);
637 tcon = tlink_tcon(tlink);
638 server = tcon->ses->server;
640 cifs_dbg(FYI, "Getting info on %s\n", full_path);
642 if ((data == NULL) && (*inode != NULL)) {
643 if (CIFS_I(*inode)->clientCanCacheRead) {
644 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
649 /* if inode info is not passed, get it from server */
651 if (!server->ops->query_path_info) {
655 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
660 data = (FILE_ALL_INFO *)buf;
661 rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path,
666 cifs_all_info_to_fattr(&fattr, (FILE_ALL_INFO *)data, cifs_sb,
668 } else if (rc == -EREMOTE) {
669 cifs_create_dfs_fattr(&fattr, sb);
671 } else if (rc == -EACCES && backup_cred(cifs_sb)) {
672 srchinf = kzalloc(sizeof(struct cifs_search_info),
674 if (srchinf == NULL) {
679 srchinf->endOfSearch = false;
680 srchinf->info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
682 srchflgs = CIFS_SEARCH_CLOSE_ALWAYS |
683 CIFS_SEARCH_CLOSE_AT_END |
684 CIFS_SEARCH_BACKUP_SEARCH;
686 rc = CIFSFindFirst(xid, tcon, full_path,
687 cifs_sb, NULL, srchflgs, srchinf, false);
690 (FILE_ALL_INFO *)srchinf->srch_entries_start;
692 cifs_dir_info_to_fattr(&fattr,
693 (FILE_DIRECTORY_INFO *)data, cifs_sb);
694 fattr.cf_uniqueid = le64_to_cpu(
695 ((SEARCH_ID_FULL_DIR_INFO *)data)->UniqueId);
698 cifs_buf_release(srchinf->ntwrk_buf_start);
705 * If an inode wasn't passed in, then get the inode number
707 * Is an i_ino of zero legal? Can we use that to check if the server
708 * supports returning inode numbers? Are there other sanity checks we
709 * can use to ensure that the server is really filling in that field?
711 if (*inode == NULL) {
712 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
713 if (validinum == false) {
714 if (server->ops->get_srv_inum)
715 tmprc = server->ops->get_srv_inum(xid,
716 tcon, cifs_sb, full_path,
717 &fattr.cf_uniqueid, data);
719 cifs_dbg(FYI, "GetSrvInodeNum rc %d\n",
721 fattr.cf_uniqueid = iunique(sb, ROOT_I);
722 cifs_autodisable_serverino(cifs_sb);
726 fattr.cf_uniqueid = iunique(sb, ROOT_I);
728 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
730 /* query for SFU type info if supported and needed */
731 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
732 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
733 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
735 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
738 #ifdef CONFIG_CIFS_ACL
739 /* fill in 0777 bits from ACL */
740 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
741 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, full_path, fid);
743 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
748 #endif /* CONFIG_CIFS_ACL */
750 /* fill in remaining high mode bits e.g. SUID, VTX */
751 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
752 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
754 /* check for Minshall+French symlinks */
755 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
756 tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
758 cifs_dbg(FYI, "CIFSCheckMFSymlink: %d\n", tmprc);
762 *inode = cifs_iget(sb, &fattr);
766 cifs_fattr_to_inode(*inode, &fattr);
771 cifs_put_tlink(tlink);
775 static const struct inode_operations cifs_ipc_inode_ops = {
776 .lookup = cifs_lookup,
780 cifs_find_inode(struct inode *inode, void *opaque)
782 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
784 /* don't match inode with different uniqueid */
785 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
788 /* use createtime like an i_generation field */
789 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
792 /* don't match inode of different type */
793 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
796 /* if it's not a directory or has no dentries, then flag it */
797 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
798 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
804 cifs_init_inode(struct inode *inode, void *opaque)
806 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
808 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
809 CIFS_I(inode)->createtime = fattr->cf_createtime;
814 * walk dentry list for an inode and report whether it has aliases that
815 * are hashed. We use this to determine if a directory inode can actually
819 inode_has_hashed_dentries(struct inode *inode)
821 struct dentry *dentry;
823 spin_lock(&inode->i_lock);
824 hlist_for_each_entry(dentry, &inode->i_dentry, d_alias) {
825 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
826 spin_unlock(&inode->i_lock);
830 spin_unlock(&inode->i_lock);
834 /* Given fattrs, get a corresponding inode */
836 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
842 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
844 /* hash down to 32-bits on 32-bit arch */
845 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
847 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
849 /* was there a potentially problematic inode collision? */
850 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
851 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
853 if (inode_has_hashed_dentries(inode)) {
854 cifs_autodisable_serverino(CIFS_SB(sb));
856 fattr->cf_uniqueid = iunique(sb, ROOT_I);
857 goto retry_iget5_locked;
861 cifs_fattr_to_inode(inode, fattr);
862 if (sb->s_flags & MS_NOATIME)
863 inode->i_flags |= S_NOATIME | S_NOCMTIME;
864 if (inode->i_state & I_NEW) {
866 if (S_ISREG(inode->i_mode))
867 inode->i_data.backing_dev_info = sb->s_bdi;
868 #ifdef CONFIG_CIFS_FSCACHE
869 /* initialize per-inode cache cookie pointer */
870 CIFS_I(inode)->fscache = NULL;
872 unlock_new_inode(inode);
879 /* gets root inode */
880 struct inode *cifs_root_iget(struct super_block *sb)
883 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
884 struct inode *inode = NULL;
886 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
890 rc = cifs_get_inode_info_unix(&inode, "", sb, xid);
892 rc = cifs_get_inode_info(&inode, "", NULL, sb, xid, NULL);
899 #ifdef CONFIG_CIFS_FSCACHE
900 /* populate tcon->resource_id */
901 tcon->resource_id = CIFS_I(inode)->uniqueid;
904 if (rc && tcon->ipc) {
905 cifs_dbg(FYI, "ipc connection - fake read inode\n");
906 spin_lock(&inode->i_lock);
907 inode->i_mode |= S_IFDIR;
909 inode->i_op = &cifs_ipc_inode_ops;
910 inode->i_fop = &simple_dir_operations;
911 inode->i_uid = cifs_sb->mnt_uid;
912 inode->i_gid = cifs_sb->mnt_gid;
913 spin_unlock(&inode->i_lock);
920 /* can not call macro free_xid here since in a void func
921 * TODO: This is no longer true
928 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
929 char *full_path, __u32 dosattr)
931 bool set_time = false;
932 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
933 struct TCP_Server_Info *server;
934 FILE_BASIC_INFO info_buf;
939 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
940 if (!server->ops->set_file_info)
943 if (attrs->ia_valid & ATTR_ATIME) {
945 info_buf.LastAccessTime =
946 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
948 info_buf.LastAccessTime = 0;
950 if (attrs->ia_valid & ATTR_MTIME) {
952 info_buf.LastWriteTime =
953 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
955 info_buf.LastWriteTime = 0;
958 * Samba throws this field away, but windows may actually use it.
959 * Do not set ctime unless other time stamps are changed explicitly
960 * (i.e. by utimes()) since we would then have a mix of client and
963 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
964 cifs_dbg(FYI, "CIFS - CTIME changed\n");
965 info_buf.ChangeTime =
966 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
968 info_buf.ChangeTime = 0;
970 info_buf.CreationTime = 0; /* don't change */
971 info_buf.Attributes = cpu_to_le32(dosattr);
973 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
977 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
978 * and rename it to a random name that hopefully won't conflict with
982 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
983 const unsigned int xid)
988 struct inode *inode = dentry->d_inode;
989 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
990 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
991 struct tcon_link *tlink;
992 struct cifs_tcon *tcon;
993 __u32 dosattr, origattr;
994 FILE_BASIC_INFO *info_buf = NULL;
996 tlink = cifs_sb_tlink(cifs_sb);
998 return PTR_ERR(tlink);
999 tcon = tlink_tcon(tlink);
1002 * We cannot rename the file if the server doesn't support
1003 * CAP_INFOLEVEL_PASSTHRU
1005 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1010 rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
1011 DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
1012 &netfid, &oplock, NULL, cifs_sb->local_nls,
1013 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1017 origattr = cifsInode->cifsAttrs;
1019 origattr |= ATTR_NORMAL;
1021 dosattr = origattr & ~ATTR_READONLY;
1023 dosattr |= ATTR_NORMAL;
1024 dosattr |= ATTR_HIDDEN;
1026 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1027 if (dosattr != origattr) {
1028 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1029 if (info_buf == NULL) {
1033 info_buf->Attributes = cpu_to_le32(dosattr);
1034 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1036 /* although we would like to mark the file hidden
1037 if that fails we will still try to rename it */
1039 cifsInode->cifsAttrs = dosattr;
1041 dosattr = origattr; /* since not able to change them */
1044 /* rename the file */
1045 rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
1046 cifs_sb->mnt_cifs_flags &
1047 CIFS_MOUNT_MAP_SPECIAL_CHR);
1053 /* try to set DELETE_ON_CLOSE */
1054 if (!cifsInode->delete_pending) {
1055 rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
1058 * some samba versions return -ENOENT when we try to set the
1059 * file disposition here. Likely a samba bug, but work around
1060 * it for now. This means that some cifsXXX files may hang
1061 * around after they shouldn't.
1063 * BB: remove this hack after more servers have the fix
1071 cifsInode->delete_pending = true;
1075 CIFSSMBClose(xid, tcon, netfid);
1078 cifs_put_tlink(tlink);
1082 * reset everything back to the original state. Don't bother
1083 * dealing with errors here since we can't do anything about
1087 CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
1088 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1089 CIFS_MOUNT_MAP_SPECIAL_CHR);
1091 if (dosattr != origattr) {
1092 info_buf->Attributes = cpu_to_le32(origattr);
1093 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1095 cifsInode->cifsAttrs = origattr;
1101 /* copied from fs/nfs/dir.c with small changes */
1103 cifs_drop_nlink(struct inode *inode)
1105 spin_lock(&inode->i_lock);
1106 if (inode->i_nlink > 0)
1108 spin_unlock(&inode->i_lock);
1112 * If dentry->d_inode is null (usually meaning the cached dentry
1113 * is a negative dentry) then we would attempt a standard SMB delete, but
1114 * if that fails we can not attempt the fall back mechanisms on EACCESS
1115 * but will return the EACCESS to the caller. Note that the VFS does not call
1116 * unlink on negative dentries currently.
1118 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1122 char *full_path = NULL;
1123 struct inode *inode = dentry->d_inode;
1124 struct cifsInodeInfo *cifs_inode;
1125 struct super_block *sb = dir->i_sb;
1126 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1127 struct tcon_link *tlink;
1128 struct cifs_tcon *tcon;
1129 struct TCP_Server_Info *server;
1130 struct iattr *attrs = NULL;
1131 __u32 dosattr = 0, origattr = 0;
1133 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1135 tlink = cifs_sb_tlink(cifs_sb);
1137 return PTR_ERR(tlink);
1138 tcon = tlink_tcon(tlink);
1139 server = tcon->ses->server;
1143 /* Unlink can be called from rename so we can not take the
1144 * sb->s_vfs_rename_mutex here */
1145 full_path = build_path_from_dentry(dentry);
1146 if (full_path == NULL) {
1151 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1152 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1153 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1154 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1155 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1156 cifs_dbg(FYI, "posix del rc %d\n", rc);
1157 if ((rc == 0) || (rc == -ENOENT))
1158 goto psx_del_no_retry;
1162 if (!server->ops->unlink) {
1164 goto psx_del_no_retry;
1167 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1172 cifs_drop_nlink(inode);
1173 } else if (rc == -ENOENT) {
1175 } else if (rc == -EBUSY) {
1176 if (server->ops->rename_pending_delete) {
1177 rc = server->ops->rename_pending_delete(full_path,
1180 cifs_drop_nlink(inode);
1182 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1183 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1184 if (attrs == NULL) {
1189 /* try to reset dos attributes */
1190 cifs_inode = CIFS_I(inode);
1191 origattr = cifs_inode->cifsAttrs;
1193 origattr |= ATTR_NORMAL;
1194 dosattr = origattr & ~ATTR_READONLY;
1196 dosattr |= ATTR_NORMAL;
1197 dosattr |= ATTR_HIDDEN;
1199 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1203 goto retry_std_delete;
1206 /* undo the setattr if we errored out and it's needed */
1207 if (rc != 0 && dosattr != 0)
1208 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1212 cifs_inode = CIFS_I(inode);
1213 cifs_inode->time = 0; /* will force revalidate to get info
1215 inode->i_ctime = current_fs_time(sb);
1217 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1218 cifs_inode = CIFS_I(dir);
1219 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1224 cifs_put_tlink(tlink);
1229 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1230 const char *full_path, struct cifs_sb_info *cifs_sb,
1231 struct cifs_tcon *tcon, const unsigned int xid)
1234 struct inode *inode = NULL;
1237 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1240 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1247 * setting nlink not necessary except in cases where we failed to get it
1248 * from the server or was set bogus. Also, since this is a brand new
1249 * inode, no need to grab the i_lock before setting the i_nlink.
1251 if (inode->i_nlink < 2)
1252 set_nlink(inode, 2);
1253 mode &= ~current_umask();
1254 /* must turn on setgid bit if parent dir has it */
1255 if (parent->i_mode & S_ISGID)
1258 if (tcon->unix_ext) {
1259 struct cifs_unix_set_info_args args = {
1261 .ctime = NO_CHANGE_64,
1262 .atime = NO_CHANGE_64,
1263 .mtime = NO_CHANGE_64,
1266 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1267 args.uid = current_fsuid();
1268 if (parent->i_mode & S_ISGID)
1269 args.gid = parent->i_gid;
1271 args.gid = current_fsgid();
1273 args.uid = INVALID_UID; /* no change */
1274 args.gid = INVALID_GID; /* no change */
1276 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1278 cifs_sb->mnt_cifs_flags &
1279 CIFS_MOUNT_MAP_SPECIAL_CHR);
1281 struct TCP_Server_Info *server = tcon->ses->server;
1282 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1283 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1284 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1286 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1287 inode->i_mode = (mode | S_IFDIR);
1289 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1290 inode->i_uid = current_fsuid();
1291 if (inode->i_mode & S_ISGID)
1292 inode->i_gid = parent->i_gid;
1294 inode->i_gid = current_fsgid();
1297 d_instantiate(dentry, inode);
1302 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1303 const char *full_path, struct cifs_sb_info *cifs_sb,
1304 struct cifs_tcon *tcon, const unsigned int xid)
1308 FILE_UNIX_BASIC_INFO *info = NULL;
1309 struct inode *newinode = NULL;
1310 struct cifs_fattr fattr;
1312 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1315 goto posix_mkdir_out;
1318 mode &= ~current_umask();
1319 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1320 NULL /* netfid */, info, &oplock, full_path,
1321 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1322 CIFS_MOUNT_MAP_SPECIAL_CHR);
1323 if (rc == -EOPNOTSUPP)
1324 goto posix_mkdir_out;
1326 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1328 goto posix_mkdir_out;
1331 if (info->Type == cpu_to_le32(-1))
1332 /* no return info, go query for it */
1333 goto posix_mkdir_get_info;
1335 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1336 * need to set uid/gid.
1339 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1340 cifs_fill_uniqueid(inode->i_sb, &fattr);
1341 newinode = cifs_iget(inode->i_sb, &fattr);
1343 goto posix_mkdir_get_info;
1345 d_instantiate(dentry, newinode);
1347 #ifdef CONFIG_CIFS_DEBUG2
1348 cifs_dbg(FYI, "instantiated dentry %p %s to inode %p\n",
1349 dentry, dentry->d_name.name, newinode);
1351 if (newinode->i_nlink != 2)
1352 cifs_dbg(FYI, "unexpected number of links %d\n",
1359 posix_mkdir_get_info:
1360 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1362 goto posix_mkdir_out;
1365 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1369 struct cifs_sb_info *cifs_sb;
1370 struct tcon_link *tlink;
1371 struct cifs_tcon *tcon;
1372 struct TCP_Server_Info *server;
1375 cifs_dbg(FYI, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1378 cifs_sb = CIFS_SB(inode->i_sb);
1379 tlink = cifs_sb_tlink(cifs_sb);
1381 return PTR_ERR(tlink);
1382 tcon = tlink_tcon(tlink);
1386 full_path = build_path_from_dentry(direntry);
1387 if (full_path == NULL) {
1392 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1393 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1394 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1396 if (rc != -EOPNOTSUPP)
1400 server = tcon->ses->server;
1402 if (!server->ops->mkdir) {
1407 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1408 rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
1410 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1415 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1419 * Force revalidate to get parent dir info when needed since cached
1420 * attributes are invalid now.
1422 CIFS_I(inode)->time = 0;
1425 cifs_put_tlink(tlink);
1429 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1433 struct cifs_sb_info *cifs_sb;
1434 struct tcon_link *tlink;
1435 struct cifs_tcon *tcon;
1436 struct TCP_Server_Info *server;
1437 char *full_path = NULL;
1438 struct cifsInodeInfo *cifsInode;
1440 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1444 full_path = build_path_from_dentry(direntry);
1445 if (full_path == NULL) {
1450 cifs_sb = CIFS_SB(inode->i_sb);
1451 tlink = cifs_sb_tlink(cifs_sb);
1452 if (IS_ERR(tlink)) {
1453 rc = PTR_ERR(tlink);
1456 tcon = tlink_tcon(tlink);
1457 server = tcon->ses->server;
1459 if (!server->ops->rmdir) {
1461 cifs_put_tlink(tlink);
1465 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1466 cifs_put_tlink(tlink);
1469 spin_lock(&direntry->d_inode->i_lock);
1470 i_size_write(direntry->d_inode, 0);
1471 clear_nlink(direntry->d_inode);
1472 spin_unlock(&direntry->d_inode->i_lock);
1475 cifsInode = CIFS_I(direntry->d_inode);
1476 /* force revalidate to go get info when needed */
1477 cifsInode->time = 0;
1479 cifsInode = CIFS_I(inode);
1481 * Force revalidate to get parent dir info when needed since cached
1482 * attributes are invalid now.
1484 cifsInode->time = 0;
1486 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1487 current_fs_time(inode->i_sb);
1496 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1497 const char *from_path, struct dentry *to_dentry,
1498 const char *to_path)
1500 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1501 struct tcon_link *tlink;
1502 struct cifs_tcon *tcon;
1503 struct TCP_Server_Info *server;
1507 tlink = cifs_sb_tlink(cifs_sb);
1509 return PTR_ERR(tlink);
1510 tcon = tlink_tcon(tlink);
1511 server = tcon->ses->server;
1513 if (!server->ops->rename)
1516 /* try path-based rename first */
1517 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1520 * Don't bother with rename by filehandle unless file is busy and
1521 * source. Note that cross directory moves do not work with
1522 * rename by filehandle to various Windows servers.
1524 if (rc == 0 || rc != -EBUSY)
1525 goto do_rename_exit;
1527 /* open-file renames don't work across directories */
1528 if (to_dentry->d_parent != from_dentry->d_parent)
1529 goto do_rename_exit;
1531 /* open the file to be renamed -- we need DELETE perms */
1532 rc = CIFSSMBOpen(xid, tcon, from_path, FILE_OPEN, DELETE,
1533 CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1534 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1535 CIFS_MOUNT_MAP_SPECIAL_CHR);
1537 rc = CIFSSMBRenameOpenFile(xid, tcon, srcfid,
1538 (const char *) to_dentry->d_name.name,
1539 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1540 CIFS_MOUNT_MAP_SPECIAL_CHR);
1541 CIFSSMBClose(xid, tcon, srcfid);
1544 cifs_put_tlink(tlink);
1549 cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1550 struct inode *target_dir, struct dentry *target_dentry)
1552 char *from_name = NULL;
1553 char *to_name = NULL;
1554 struct cifs_sb_info *cifs_sb;
1555 struct tcon_link *tlink;
1556 struct cifs_tcon *tcon;
1557 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1558 FILE_UNIX_BASIC_INFO *info_buf_target;
1562 cifs_sb = CIFS_SB(source_dir->i_sb);
1563 tlink = cifs_sb_tlink(cifs_sb);
1565 return PTR_ERR(tlink);
1566 tcon = tlink_tcon(tlink);
1571 * we already have the rename sem so we do not need to
1572 * grab it again here to protect the path integrity
1574 from_name = build_path_from_dentry(source_dentry);
1575 if (from_name == NULL) {
1577 goto cifs_rename_exit;
1580 to_name = build_path_from_dentry(target_dentry);
1581 if (to_name == NULL) {
1583 goto cifs_rename_exit;
1586 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1589 if (rc == -EEXIST && tcon->unix_ext) {
1591 * Are src and dst hardlinks of same inode? We can only tell
1592 * with unix extensions enabled.
1595 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1597 if (info_buf_source == NULL) {
1599 goto cifs_rename_exit;
1602 info_buf_target = info_buf_source + 1;
1603 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1606 cifs_sb->mnt_cifs_flags &
1607 CIFS_MOUNT_MAP_SPECIAL_CHR);
1611 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1614 cifs_sb->mnt_cifs_flags &
1615 CIFS_MOUNT_MAP_SPECIAL_CHR);
1617 if (tmprc == 0 && (info_buf_source->UniqueId ==
1618 info_buf_target->UniqueId)) {
1619 /* same file, POSIX says that this is a noop */
1621 goto cifs_rename_exit;
1625 * else ... BB we could add the same check for Windows by
1626 * checking the UniqueId via FILE_INTERNAL_INFO
1630 /* Try unlinking the target dentry if it's not negative */
1631 if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
1632 tmprc = cifs_unlink(target_dir, target_dentry);
1634 goto cifs_rename_exit;
1635 rc = cifs_do_rename(xid, source_dentry, from_name,
1636 target_dentry, to_name);
1640 kfree(info_buf_source);
1644 cifs_put_tlink(tlink);
1649 cifs_inode_needs_reval(struct inode *inode)
1651 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1652 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1654 if (cifs_i->clientCanCacheRead)
1657 if (!lookupCacheEnabled)
1660 if (cifs_i->time == 0)
1663 if (!time_in_range(jiffies, cifs_i->time,
1664 cifs_i->time + cifs_sb->actimeo))
1667 /* hardlinked files w/ noserverino get "special" treatment */
1668 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1669 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1676 * Zap the cache. Called when invalid_mapping flag is set.
1679 cifs_invalidate_mapping(struct inode *inode)
1682 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1684 cifs_i->invalid_mapping = false;
1686 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1687 rc = invalidate_inode_pages2(inode->i_mapping);
1689 cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1691 cifs_i->invalid_mapping = true;
1695 cifs_fscache_reset_inode_cookie(inode);
1699 int cifs_revalidate_file_attr(struct file *filp)
1702 struct inode *inode = file_inode(filp);
1703 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1705 if (!cifs_inode_needs_reval(inode))
1708 if (tlink_tcon(cfile->tlink)->unix_ext)
1709 rc = cifs_get_file_info_unix(filp);
1711 rc = cifs_get_file_info(filp);
1716 int cifs_revalidate_dentry_attr(struct dentry *dentry)
1720 struct inode *inode = dentry->d_inode;
1721 struct super_block *sb = dentry->d_sb;
1722 char *full_path = NULL;
1727 if (!cifs_inode_needs_reval(inode))
1732 /* can not safely grab the rename sem here if rename calls revalidate
1733 since that would deadlock */
1734 full_path = build_path_from_dentry(dentry);
1735 if (full_path == NULL) {
1740 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1741 full_path, inode, inode->i_count.counter,
1742 dentry, dentry->d_time, jiffies);
1744 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1745 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1747 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1756 int cifs_revalidate_file(struct file *filp)
1759 struct inode *inode = file_inode(filp);
1761 rc = cifs_revalidate_file_attr(filp);
1765 if (CIFS_I(inode)->invalid_mapping)
1766 rc = cifs_invalidate_mapping(inode);
1770 /* revalidate a dentry's inode attributes */
1771 int cifs_revalidate_dentry(struct dentry *dentry)
1774 struct inode *inode = dentry->d_inode;
1776 rc = cifs_revalidate_dentry_attr(dentry);
1780 if (CIFS_I(inode)->invalid_mapping)
1781 rc = cifs_invalidate_mapping(inode);
1785 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1788 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1789 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1790 struct inode *inode = dentry->d_inode;
1794 * We need to be sure that all dirty pages are written and the server
1795 * has actual ctime, mtime and file length.
1797 if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping &&
1798 inode->i_mapping->nrpages != 0) {
1799 rc = filemap_fdatawait(inode->i_mapping);
1801 mapping_set_error(inode->i_mapping, rc);
1806 rc = cifs_revalidate_dentry_attr(dentry);
1810 generic_fillattr(inode, stat);
1811 stat->blksize = CIFS_MAX_MSGSIZE;
1812 stat->ino = CIFS_I(inode)->uniqueid;
1815 * If on a multiuser mount without unix extensions or cifsacl being
1816 * enabled, and the admin hasn't overridden them, set the ownership
1817 * to the fsuid/fsgid of the current process.
1819 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
1820 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1822 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1823 stat->uid = current_fsuid();
1824 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1825 stat->gid = current_fsgid();
1830 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1832 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1833 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1837 page = grab_cache_page(mapping, index);
1841 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1843 page_cache_release(page);
1847 static void cifs_setsize(struct inode *inode, loff_t offset)
1851 spin_lock(&inode->i_lock);
1852 oldsize = inode->i_size;
1853 i_size_write(inode, offset);
1854 spin_unlock(&inode->i_lock);
1856 truncate_pagecache(inode, oldsize, offset);
1860 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1861 unsigned int xid, char *full_path)
1864 struct cifsFileInfo *open_file;
1865 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1866 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1867 struct tcon_link *tlink = NULL;
1868 struct cifs_tcon *tcon = NULL;
1869 struct TCP_Server_Info *server;
1870 struct cifs_io_parms io_parms;
1873 * To avoid spurious oplock breaks from server, in the case of
1874 * inodes that we already have open, avoid doing path based
1875 * setting of file size if we can do it by handle.
1876 * This keeps our caching token (oplock) and avoids timeouts
1877 * when the local oplock break takes longer to flush
1878 * writebehind data than the SMB timeout for the SetPathInfo
1879 * request would allow
1881 open_file = find_writable_file(cifsInode, true);
1883 tcon = tlink_tcon(open_file->tlink);
1884 server = tcon->ses->server;
1885 if (server->ops->set_file_size)
1886 rc = server->ops->set_file_size(xid, tcon, open_file,
1887 attrs->ia_size, false);
1890 cifsFileInfo_put(open_file);
1891 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
1892 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1893 unsigned int bytes_written;
1895 io_parms.netfid = open_file->fid.netfid;
1896 io_parms.pid = open_file->pid;
1897 io_parms.tcon = tcon;
1898 io_parms.offset = 0;
1899 io_parms.length = attrs->ia_size;
1900 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written,
1902 cifs_dbg(FYI, "Wrt seteof rc %d\n", rc);
1911 tlink = cifs_sb_tlink(cifs_sb);
1913 return PTR_ERR(tlink);
1914 tcon = tlink_tcon(tlink);
1915 server = tcon->ses->server;
1919 * Set file size by pathname rather than by handle either because no
1920 * valid, writeable file handle for it was found or because there was
1921 * an error setting it by handle.
1923 if (server->ops->set_path_size)
1924 rc = server->ops->set_path_size(xid, tcon, full_path,
1925 attrs->ia_size, cifs_sb, false);
1928 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
1929 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1933 rc = SMBLegacyOpen(xid, tcon, full_path, FILE_OPEN,
1934 GENERIC_WRITE, CREATE_NOT_DIR, &netfid,
1935 &oplock, NULL, cifs_sb->local_nls,
1936 cifs_sb->mnt_cifs_flags &
1937 CIFS_MOUNT_MAP_SPECIAL_CHR);
1939 unsigned int bytes_written;
1941 io_parms.netfid = netfid;
1942 io_parms.pid = current->tgid;
1943 io_parms.tcon = tcon;
1944 io_parms.offset = 0;
1945 io_parms.length = attrs->ia_size;
1946 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written, NULL,
1948 cifs_dbg(FYI, "wrt seteof rc %d\n", rc);
1949 CIFSSMBClose(xid, tcon, netfid);
1953 cifs_put_tlink(tlink);
1957 cifsInode->server_eof = attrs->ia_size;
1958 cifs_setsize(inode, attrs->ia_size);
1959 cifs_truncate_page(inode->i_mapping, inode->i_size);
1966 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1970 char *full_path = NULL;
1971 struct inode *inode = direntry->d_inode;
1972 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1973 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1974 struct tcon_link *tlink;
1975 struct cifs_tcon *pTcon;
1976 struct cifs_unix_set_info_args *args = NULL;
1977 struct cifsFileInfo *open_file;
1979 cifs_dbg(FYI, "setattr_unix on file %s attrs->ia_valid=0x%x\n",
1980 direntry->d_name.name, attrs->ia_valid);
1984 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
1985 attrs->ia_valid |= ATTR_FORCE;
1987 rc = inode_change_ok(inode, attrs);
1991 full_path = build_path_from_dentry(direntry);
1992 if (full_path == NULL) {
1998 * Attempt to flush data before changing attributes. We need to do
1999 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2000 * ownership or mode then we may also need to do this. Here, we take
2001 * the safe way out and just do the flush on all setattr requests. If
2002 * the flush returns error, store it to report later and continue.
2004 * BB: This should be smarter. Why bother flushing pages that
2005 * will be truncated anyway? Also, should we error out here if
2006 * the flush returns error?
2008 rc = filemap_write_and_wait(inode->i_mapping);
2009 mapping_set_error(inode->i_mapping, rc);
2012 if (attrs->ia_valid & ATTR_SIZE) {
2013 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2018 /* skip mode change if it's just for clearing setuid/setgid */
2019 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2020 attrs->ia_valid &= ~ATTR_MODE;
2022 args = kmalloc(sizeof(*args), GFP_KERNEL);
2028 /* set up the struct */
2029 if (attrs->ia_valid & ATTR_MODE)
2030 args->mode = attrs->ia_mode;
2032 args->mode = NO_CHANGE_64;
2034 if (attrs->ia_valid & ATTR_UID)
2035 args->uid = attrs->ia_uid;
2037 args->uid = INVALID_UID; /* no change */
2039 if (attrs->ia_valid & ATTR_GID)
2040 args->gid = attrs->ia_gid;
2042 args->gid = INVALID_GID; /* no change */
2044 if (attrs->ia_valid & ATTR_ATIME)
2045 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2047 args->atime = NO_CHANGE_64;
2049 if (attrs->ia_valid & ATTR_MTIME)
2050 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2052 args->mtime = NO_CHANGE_64;
2054 if (attrs->ia_valid & ATTR_CTIME)
2055 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2057 args->ctime = NO_CHANGE_64;
2060 open_file = find_writable_file(cifsInode, true);
2062 u16 nfid = open_file->fid.netfid;
2063 u32 npid = open_file->pid;
2064 pTcon = tlink_tcon(open_file->tlink);
2065 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2066 cifsFileInfo_put(open_file);
2068 tlink = cifs_sb_tlink(cifs_sb);
2069 if (IS_ERR(tlink)) {
2070 rc = PTR_ERR(tlink);
2073 pTcon = tlink_tcon(tlink);
2074 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2076 cifs_sb->mnt_cifs_flags &
2077 CIFS_MOUNT_MAP_SPECIAL_CHR);
2078 cifs_put_tlink(tlink);
2084 if ((attrs->ia_valid & ATTR_SIZE) &&
2085 attrs->ia_size != i_size_read(inode))
2086 truncate_setsize(inode, attrs->ia_size);
2088 setattr_copy(inode, attrs);
2089 mark_inode_dirty(inode);
2091 /* force revalidate when any of these times are set since some
2092 of the fs types (eg ext3, fat) do not have fine enough
2093 time granularity to match protocol, and we do not have a
2094 a way (yet) to query the server fs's time granularity (and
2095 whether it rounds times down).
2097 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2098 cifsInode->time = 0;
2107 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2110 kuid_t uid = INVALID_UID;
2111 kgid_t gid = INVALID_GID;
2112 struct inode *inode = direntry->d_inode;
2113 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2114 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2115 char *full_path = NULL;
2118 __u64 mode = NO_CHANGE_64;
2122 cifs_dbg(FYI, "setattr on file %s attrs->iavalid 0x%x\n",
2123 direntry->d_name.name, attrs->ia_valid);
2125 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2126 attrs->ia_valid |= ATTR_FORCE;
2128 rc = inode_change_ok(inode, attrs);
2134 full_path = build_path_from_dentry(direntry);
2135 if (full_path == NULL) {
2142 * Attempt to flush data before changing attributes. We need to do
2143 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2144 * ownership or mode then we may also need to do this. Here, we take
2145 * the safe way out and just do the flush on all setattr requests. If
2146 * the flush returns error, store it to report later and continue.
2148 * BB: This should be smarter. Why bother flushing pages that
2149 * will be truncated anyway? Also, should we error out here if
2150 * the flush returns error?
2152 rc = filemap_write_and_wait(inode->i_mapping);
2153 mapping_set_error(inode->i_mapping, rc);
2156 if (attrs->ia_valid & ATTR_SIZE) {
2157 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2159 goto cifs_setattr_exit;
2162 if (attrs->ia_valid & ATTR_UID)
2163 uid = attrs->ia_uid;
2165 if (attrs->ia_valid & ATTR_GID)
2166 gid = attrs->ia_gid;
2168 #ifdef CONFIG_CIFS_ACL
2169 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2170 if (uid_valid(uid) || gid_valid(gid)) {
2171 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2174 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2176 goto cifs_setattr_exit;
2180 #endif /* CONFIG_CIFS_ACL */
2181 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2182 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2184 /* skip mode change if it's just for clearing setuid/setgid */
2185 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2186 attrs->ia_valid &= ~ATTR_MODE;
2188 if (attrs->ia_valid & ATTR_MODE) {
2189 mode = attrs->ia_mode;
2191 #ifdef CONFIG_CIFS_ACL
2192 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2193 rc = id_mode_to_cifs_acl(inode, full_path, mode,
2194 INVALID_UID, INVALID_GID);
2196 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2198 goto cifs_setattr_exit;
2201 #endif /* CONFIG_CIFS_ACL */
2202 if (((mode & S_IWUGO) == 0) &&
2203 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2205 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2207 /* fix up mode if we're not using dynperm */
2208 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2209 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2210 } else if ((mode & S_IWUGO) &&
2211 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2213 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2214 /* Attributes of 0 are ignored */
2216 dosattr |= ATTR_NORMAL;
2218 /* reset local inode permissions to normal */
2219 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2220 attrs->ia_mode &= ~(S_IALLUGO);
2221 if (S_ISDIR(inode->i_mode))
2223 cifs_sb->mnt_dir_mode;
2226 cifs_sb->mnt_file_mode;
2228 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2229 /* ignore mode change - ATTR_READONLY hasn't changed */
2230 attrs->ia_valid &= ~ATTR_MODE;
2234 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2235 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2236 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2237 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2239 /* Even if error on time set, no sense failing the call if
2240 the server would set the time to a reasonable value anyway,
2241 and this check ensures that we are not being called from
2242 sys_utimes in which case we ought to fail the call back to
2243 the user when the server rejects the call */
2244 if ((rc) && (attrs->ia_valid &
2245 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2249 /* do not need local check to inode_check_ok since the server does
2252 goto cifs_setattr_exit;
2254 if ((attrs->ia_valid & ATTR_SIZE) &&
2255 attrs->ia_size != i_size_read(inode))
2256 truncate_setsize(inode, attrs->ia_size);
2258 setattr_copy(inode, attrs);
2259 mark_inode_dirty(inode);
2268 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2270 struct inode *inode = direntry->d_inode;
2271 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2272 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2274 if (pTcon->unix_ext)
2275 return cifs_setattr_unix(direntry, attrs);
2277 return cifs_setattr_nounix(direntry, attrs);
2279 /* BB: add cifs_setattr_legacy for really old servers */
2283 void cifs_delete_inode(struct inode *inode)
2285 cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2286 /* may have to add back in if and when safe distributed caching of
2287 directories added e.g. via FindNotify */