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;
174 if (inode->i_state & I_NEW)
179 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
181 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
183 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
186 fattr->cf_uniqueid = iunique(sb, ROOT_I);
189 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
191 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
192 struct cifs_sb_info *cifs_sb)
194 memset(fattr, 0, sizeof(*fattr));
195 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
196 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
197 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
199 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
200 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
201 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
202 fattr->cf_mode = le64_to_cpu(info->Permissions);
205 * Since we set the inode type below we need to mask off
206 * to avoid strange results if bits set above.
208 fattr->cf_mode &= ~S_IFMT;
209 switch (le32_to_cpu(info->Type)) {
211 fattr->cf_mode |= S_IFREG;
212 fattr->cf_dtype = DT_REG;
215 fattr->cf_mode |= S_IFLNK;
216 fattr->cf_dtype = DT_LNK;
219 fattr->cf_mode |= S_IFDIR;
220 fattr->cf_dtype = DT_DIR;
223 fattr->cf_mode |= S_IFCHR;
224 fattr->cf_dtype = DT_CHR;
225 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
226 le64_to_cpu(info->DevMinor) & MINORMASK);
229 fattr->cf_mode |= S_IFBLK;
230 fattr->cf_dtype = DT_BLK;
231 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
232 le64_to_cpu(info->DevMinor) & MINORMASK);
235 fattr->cf_mode |= S_IFIFO;
236 fattr->cf_dtype = DT_FIFO;
239 fattr->cf_mode |= S_IFSOCK;
240 fattr->cf_dtype = DT_SOCK;
243 /* safest to call it a file if we do not know */
244 fattr->cf_mode |= S_IFREG;
245 fattr->cf_dtype = DT_REG;
246 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
250 fattr->cf_uid = cifs_sb->mnt_uid;
251 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
252 u64 id = le64_to_cpu(info->Uid);
253 if (id < ((uid_t)-1)) {
254 kuid_t uid = make_kuid(&init_user_ns, id);
260 fattr->cf_gid = cifs_sb->mnt_gid;
261 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
262 u64 id = le64_to_cpu(info->Gid);
263 if (id < ((gid_t)-1)) {
264 kgid_t gid = make_kgid(&init_user_ns, id);
270 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
274 * Fill a cifs_fattr struct with fake inode info.
276 * Needed to setup cifs_fattr data for the directory which is the
277 * junction to the new submount (ie to setup the fake directory
278 * which represents a DFS referral).
281 cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
283 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
285 cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
287 memset(fattr, 0, sizeof(*fattr));
288 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
289 fattr->cf_uid = cifs_sb->mnt_uid;
290 fattr->cf_gid = cifs_sb->mnt_gid;
291 fattr->cf_atime = CURRENT_TIME;
292 fattr->cf_ctime = CURRENT_TIME;
293 fattr->cf_mtime = CURRENT_TIME;
295 fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
299 cifs_get_file_info_unix(struct file *filp)
303 FILE_UNIX_BASIC_INFO find_data;
304 struct cifs_fattr fattr;
305 struct inode *inode = file_inode(filp);
306 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
307 struct cifsFileInfo *cfile = filp->private_data;
308 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
311 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
313 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
314 } else if (rc == -EREMOTE) {
315 cifs_create_dfs_fattr(&fattr, inode->i_sb);
319 cifs_fattr_to_inode(inode, &fattr);
324 int cifs_get_inode_info_unix(struct inode **pinode,
325 const unsigned char *full_path,
326 struct super_block *sb, unsigned int xid)
329 FILE_UNIX_BASIC_INFO find_data;
330 struct cifs_fattr fattr;
331 struct cifs_tcon *tcon;
332 struct tcon_link *tlink;
333 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
335 cifs_dbg(FYI, "Getting info on %s\n", full_path);
337 tlink = cifs_sb_tlink(cifs_sb);
339 return PTR_ERR(tlink);
340 tcon = tlink_tcon(tlink);
342 /* could have done a find first instead but this returns more info */
343 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
344 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
345 CIFS_MOUNT_MAP_SPECIAL_CHR);
346 cifs_put_tlink(tlink);
349 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
350 } else if (rc == -EREMOTE) {
351 cifs_create_dfs_fattr(&fattr, sb);
357 /* check for Minshall+French symlinks */
358 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
359 int tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
361 cifs_dbg(FYI, "CIFSCheckMFSymlink: %d\n", tmprc);
364 if (*pinode == NULL) {
366 cifs_fill_uniqueid(sb, &fattr);
367 *pinode = cifs_iget(sb, &fattr);
371 /* we already have inode, update it */
372 cifs_fattr_to_inode(*pinode, &fattr);
379 cifs_sfu_type(struct cifs_fattr *fattr, const unsigned char *path,
380 struct cifs_sb_info *cifs_sb, unsigned int xid)
385 struct tcon_link *tlink;
386 struct cifs_tcon *tcon;
387 struct cifs_io_parms io_parms;
389 unsigned int bytes_read;
394 fattr->cf_mode &= ~S_IFMT;
396 if (fattr->cf_eof == 0) {
397 fattr->cf_mode |= S_IFIFO;
398 fattr->cf_dtype = DT_FIFO;
400 } else if (fattr->cf_eof < 8) {
401 fattr->cf_mode |= S_IFREG;
402 fattr->cf_dtype = DT_REG;
403 return -EINVAL; /* EOPNOTSUPP? */
406 tlink = cifs_sb_tlink(cifs_sb);
408 return PTR_ERR(tlink);
409 tcon = tlink_tcon(tlink);
411 rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, GENERIC_READ,
412 CREATE_NOT_DIR, &netfid, &oplock, NULL,
414 cifs_sb->mnt_cifs_flags &
415 CIFS_MOUNT_MAP_SPECIAL_CHR);
417 int buf_type = CIFS_NO_BUFFER;
419 io_parms.netfid = netfid;
420 io_parms.pid = current->tgid;
421 io_parms.tcon = tcon;
423 io_parms.length = 24;
424 rc = CIFSSMBRead(xid, &io_parms, &bytes_read, &pbuf,
426 if ((rc == 0) && (bytes_read >= 8)) {
427 if (memcmp("IntxBLK", pbuf, 8) == 0) {
428 cifs_dbg(FYI, "Block device\n");
429 fattr->cf_mode |= S_IFBLK;
430 fattr->cf_dtype = DT_BLK;
431 if (bytes_read == 24) {
432 /* we have enough to decode dev num */
433 __u64 mjr; /* major */
434 __u64 mnr; /* minor */
435 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
436 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
437 fattr->cf_rdev = MKDEV(mjr, mnr);
439 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
440 cifs_dbg(FYI, "Char device\n");
441 fattr->cf_mode |= S_IFCHR;
442 fattr->cf_dtype = DT_CHR;
443 if (bytes_read == 24) {
444 /* we have enough to decode dev num */
445 __u64 mjr; /* major */
446 __u64 mnr; /* minor */
447 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
448 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
449 fattr->cf_rdev = MKDEV(mjr, mnr);
451 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
452 cifs_dbg(FYI, "Symlink\n");
453 fattr->cf_mode |= S_IFLNK;
454 fattr->cf_dtype = DT_LNK;
456 fattr->cf_mode |= S_IFREG; /* file? */
457 fattr->cf_dtype = DT_REG;
461 fattr->cf_mode |= S_IFREG; /* then it is a file */
462 fattr->cf_dtype = DT_REG;
463 rc = -EOPNOTSUPP; /* or some unknown SFU type */
465 CIFSSMBClose(xid, tcon, netfid);
467 cifs_put_tlink(tlink);
471 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
474 * Fetch mode bits as provided by SFU.
476 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
478 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
479 struct cifs_sb_info *cifs_sb, unsigned int xid)
481 #ifdef CONFIG_CIFS_XATTR
485 struct tcon_link *tlink;
486 struct cifs_tcon *tcon;
488 tlink = cifs_sb_tlink(cifs_sb);
490 return PTR_ERR(tlink);
491 tcon = tlink_tcon(tlink);
493 rc = CIFSSMBQAllEAs(xid, tcon, path, "SETFILEBITS",
494 ea_value, 4 /* size of buf */, cifs_sb->local_nls,
495 cifs_sb->mnt_cifs_flags &
496 CIFS_MOUNT_MAP_SPECIAL_CHR);
497 cifs_put_tlink(tlink);
501 mode = le32_to_cpu(*((__le32 *)ea_value));
502 fattr->cf_mode &= ~SFBITS_MASK;
503 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
504 mode, fattr->cf_mode);
505 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
506 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
515 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
517 cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
518 struct cifs_sb_info *cifs_sb, bool adjust_tz)
520 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
522 memset(fattr, 0, sizeof(*fattr));
523 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
524 if (info->DeletePending)
525 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
527 if (info->LastAccessTime)
528 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
530 fattr->cf_atime = CURRENT_TIME;
532 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
533 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
536 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
537 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
540 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
541 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
542 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
544 if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
545 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
546 fattr->cf_dtype = DT_DIR;
548 * Server can return wrong NumberOfLinks value for directories
549 * when Unix extensions are disabled - fake it.
553 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
554 fattr->cf_dtype = DT_REG;
556 /* clear write bits if ATTR_READONLY is set */
557 if (fattr->cf_cifsattrs & ATTR_READONLY)
558 fattr->cf_mode &= ~(S_IWUGO);
560 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
563 fattr->cf_uid = cifs_sb->mnt_uid;
564 fattr->cf_gid = cifs_sb->mnt_gid;
568 cifs_get_file_info(struct file *filp)
572 FILE_ALL_INFO find_data;
573 struct cifs_fattr fattr;
574 struct inode *inode = file_inode(filp);
575 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
576 struct cifsFileInfo *cfile = filp->private_data;
577 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
578 struct TCP_Server_Info *server = tcon->ses->server;
580 if (!server->ops->query_file_info)
584 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
587 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false);
590 cifs_create_dfs_fattr(&fattr, inode->i_sb);
596 * FIXME: legacy server -- fall back to path-based call?
597 * for now, just skip revalidating and mark inode for
601 CIFS_I(inode)->time = 0;
607 * don't bother with SFU junk here -- just mark inode as needing
610 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
611 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
612 cifs_fattr_to_inode(inode, &fattr);
619 cifs_get_inode_info(struct inode **inode, const char *full_path,
620 FILE_ALL_INFO *data, struct super_block *sb, int xid,
623 bool validinum = false;
625 int rc = 0, tmprc = ENOSYS;
626 struct cifs_tcon *tcon;
627 struct TCP_Server_Info *server;
628 struct tcon_link *tlink;
629 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
631 bool adjust_tz = false;
632 struct cifs_fattr fattr;
633 struct cifs_search_info *srchinf = NULL;
635 tlink = cifs_sb_tlink(cifs_sb);
637 return PTR_ERR(tlink);
638 tcon = tlink_tcon(tlink);
639 server = tcon->ses->server;
641 cifs_dbg(FYI, "Getting info on %s\n", full_path);
643 if ((data == NULL) && (*inode != NULL)) {
644 if (CIFS_I(*inode)->clientCanCacheRead) {
645 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
650 /* if inode info is not passed, get it from server */
652 if (!server->ops->query_path_info) {
656 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
661 data = (FILE_ALL_INFO *)buf;
662 rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path,
667 cifs_all_info_to_fattr(&fattr, (FILE_ALL_INFO *)data, cifs_sb,
669 } else if (rc == -EREMOTE) {
670 cifs_create_dfs_fattr(&fattr, sb);
672 } else if (rc == -EACCES && backup_cred(cifs_sb)) {
673 srchinf = kzalloc(sizeof(struct cifs_search_info),
675 if (srchinf == NULL) {
680 srchinf->endOfSearch = false;
681 srchinf->info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
683 srchflgs = CIFS_SEARCH_CLOSE_ALWAYS |
684 CIFS_SEARCH_CLOSE_AT_END |
685 CIFS_SEARCH_BACKUP_SEARCH;
687 rc = CIFSFindFirst(xid, tcon, full_path,
688 cifs_sb, NULL, srchflgs, srchinf, false);
691 (FILE_ALL_INFO *)srchinf->srch_entries_start;
693 cifs_dir_info_to_fattr(&fattr,
694 (FILE_DIRECTORY_INFO *)data, cifs_sb);
695 fattr.cf_uniqueid = le64_to_cpu(
696 ((SEARCH_ID_FULL_DIR_INFO *)data)->UniqueId);
699 cifs_buf_release(srchinf->ntwrk_buf_start);
706 * If an inode wasn't passed in, then get the inode number
708 * Is an i_ino of zero legal? Can we use that to check if the server
709 * supports returning inode numbers? Are there other sanity checks we
710 * can use to ensure that the server is really filling in that field?
712 if (*inode == NULL) {
713 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
714 if (validinum == false) {
715 if (server->ops->get_srv_inum)
716 tmprc = server->ops->get_srv_inum(xid,
717 tcon, cifs_sb, full_path,
718 &fattr.cf_uniqueid, data);
720 cifs_dbg(FYI, "GetSrvInodeNum rc %d\n",
722 fattr.cf_uniqueid = iunique(sb, ROOT_I);
723 cifs_autodisable_serverino(cifs_sb);
727 fattr.cf_uniqueid = iunique(sb, ROOT_I);
729 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
731 /* query for SFU type info if supported and needed */
732 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
733 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
734 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
736 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
739 #ifdef CONFIG_CIFS_ACL
740 /* fill in 0777 bits from ACL */
741 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
742 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, full_path, fid);
744 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
749 #endif /* CONFIG_CIFS_ACL */
751 /* fill in remaining high mode bits e.g. SUID, VTX */
752 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
753 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
755 /* check for Minshall+French symlinks */
756 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
757 tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
759 cifs_dbg(FYI, "CIFSCheckMFSymlink: %d\n", tmprc);
763 *inode = cifs_iget(sb, &fattr);
767 cifs_fattr_to_inode(*inode, &fattr);
772 cifs_put_tlink(tlink);
776 static const struct inode_operations cifs_ipc_inode_ops = {
777 .lookup = cifs_lookup,
781 cifs_find_inode(struct inode *inode, void *opaque)
783 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
785 /* don't match inode with different uniqueid */
786 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
789 /* use createtime like an i_generation field */
790 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
793 /* don't match inode of different type */
794 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
797 /* if it's not a directory or has no dentries, then flag it */
798 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
799 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
805 cifs_init_inode(struct inode *inode, void *opaque)
807 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
809 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
810 CIFS_I(inode)->createtime = fattr->cf_createtime;
815 * walk dentry list for an inode and report whether it has aliases that
816 * are hashed. We use this to determine if a directory inode can actually
820 inode_has_hashed_dentries(struct inode *inode)
822 struct dentry *dentry;
824 spin_lock(&inode->i_lock);
825 hlist_for_each_entry(dentry, &inode->i_dentry, d_alias) {
826 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
827 spin_unlock(&inode->i_lock);
831 spin_unlock(&inode->i_lock);
835 /* Given fattrs, get a corresponding inode */
837 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
843 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
845 /* hash down to 32-bits on 32-bit arch */
846 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
848 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
850 /* was there a potentially problematic inode collision? */
851 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
852 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
854 if (inode_has_hashed_dentries(inode)) {
855 cifs_autodisable_serverino(CIFS_SB(sb));
857 fattr->cf_uniqueid = iunique(sb, ROOT_I);
858 goto retry_iget5_locked;
862 cifs_fattr_to_inode(inode, fattr);
863 if (sb->s_flags & MS_NOATIME)
864 inode->i_flags |= S_NOATIME | S_NOCMTIME;
865 if (inode->i_state & I_NEW) {
867 if (S_ISREG(inode->i_mode))
868 inode->i_data.backing_dev_info = sb->s_bdi;
869 #ifdef CONFIG_CIFS_FSCACHE
870 /* initialize per-inode cache cookie pointer */
871 CIFS_I(inode)->fscache = NULL;
873 unlock_new_inode(inode);
880 /* gets root inode */
881 struct inode *cifs_root_iget(struct super_block *sb)
884 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
885 struct inode *inode = NULL;
887 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
891 rc = cifs_get_inode_info_unix(&inode, "", sb, xid);
893 rc = cifs_get_inode_info(&inode, "", NULL, sb, xid, NULL);
900 #ifdef CONFIG_CIFS_FSCACHE
901 /* populate tcon->resource_id */
902 tcon->resource_id = CIFS_I(inode)->uniqueid;
905 if (rc && tcon->ipc) {
906 cifs_dbg(FYI, "ipc connection - fake read inode\n");
907 spin_lock(&inode->i_lock);
908 inode->i_mode |= S_IFDIR;
910 inode->i_op = &cifs_ipc_inode_ops;
911 inode->i_fop = &simple_dir_operations;
912 inode->i_uid = cifs_sb->mnt_uid;
913 inode->i_gid = cifs_sb->mnt_gid;
914 spin_unlock(&inode->i_lock);
921 /* can not call macro free_xid here since in a void func
922 * TODO: This is no longer true
929 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
930 char *full_path, __u32 dosattr)
932 bool set_time = false;
933 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
934 struct TCP_Server_Info *server;
935 FILE_BASIC_INFO info_buf;
940 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
941 if (!server->ops->set_file_info)
944 if (attrs->ia_valid & ATTR_ATIME) {
946 info_buf.LastAccessTime =
947 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
949 info_buf.LastAccessTime = 0;
951 if (attrs->ia_valid & ATTR_MTIME) {
953 info_buf.LastWriteTime =
954 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
956 info_buf.LastWriteTime = 0;
959 * Samba throws this field away, but windows may actually use it.
960 * Do not set ctime unless other time stamps are changed explicitly
961 * (i.e. by utimes()) since we would then have a mix of client and
964 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
965 cifs_dbg(FYI, "CIFS - CTIME changed\n");
966 info_buf.ChangeTime =
967 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
969 info_buf.ChangeTime = 0;
971 info_buf.CreationTime = 0; /* don't change */
972 info_buf.Attributes = cpu_to_le32(dosattr);
974 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
978 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
979 * and rename it to a random name that hopefully won't conflict with
983 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
984 const unsigned int xid)
989 struct inode *inode = dentry->d_inode;
990 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
991 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
992 struct tcon_link *tlink;
993 struct cifs_tcon *tcon;
994 __u32 dosattr, origattr;
995 FILE_BASIC_INFO *info_buf = NULL;
997 tlink = cifs_sb_tlink(cifs_sb);
999 return PTR_ERR(tlink);
1000 tcon = tlink_tcon(tlink);
1003 * We cannot rename the file if the server doesn't support
1004 * CAP_INFOLEVEL_PASSTHRU
1006 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1011 rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
1012 DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
1013 &netfid, &oplock, NULL, cifs_sb->local_nls,
1014 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1018 origattr = cifsInode->cifsAttrs;
1020 origattr |= ATTR_NORMAL;
1022 dosattr = origattr & ~ATTR_READONLY;
1024 dosattr |= ATTR_NORMAL;
1025 dosattr |= ATTR_HIDDEN;
1027 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1028 if (dosattr != origattr) {
1029 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1030 if (info_buf == NULL) {
1034 info_buf->Attributes = cpu_to_le32(dosattr);
1035 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1037 /* although we would like to mark the file hidden
1038 if that fails we will still try to rename it */
1040 cifsInode->cifsAttrs = dosattr;
1042 dosattr = origattr; /* since not able to change them */
1045 /* rename the file */
1046 rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
1047 cifs_sb->mnt_cifs_flags &
1048 CIFS_MOUNT_MAP_SPECIAL_CHR);
1054 /* try to set DELETE_ON_CLOSE */
1055 if (!cifsInode->delete_pending) {
1056 rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
1059 * some samba versions return -ENOENT when we try to set the
1060 * file disposition here. Likely a samba bug, but work around
1061 * it for now. This means that some cifsXXX files may hang
1062 * around after they shouldn't.
1064 * BB: remove this hack after more servers have the fix
1072 cifsInode->delete_pending = true;
1076 CIFSSMBClose(xid, tcon, netfid);
1079 cifs_put_tlink(tlink);
1083 * reset everything back to the original state. Don't bother
1084 * dealing with errors here since we can't do anything about
1088 CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
1089 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1090 CIFS_MOUNT_MAP_SPECIAL_CHR);
1092 if (dosattr != origattr) {
1093 info_buf->Attributes = cpu_to_le32(origattr);
1094 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1096 cifsInode->cifsAttrs = origattr;
1102 /* copied from fs/nfs/dir.c with small changes */
1104 cifs_drop_nlink(struct inode *inode)
1106 spin_lock(&inode->i_lock);
1107 if (inode->i_nlink > 0)
1109 spin_unlock(&inode->i_lock);
1113 * If dentry->d_inode is null (usually meaning the cached dentry
1114 * is a negative dentry) then we would attempt a standard SMB delete, but
1115 * if that fails we can not attempt the fall back mechanisms on EACCESS
1116 * but will return the EACCESS to the caller. Note that the VFS does not call
1117 * unlink on negative dentries currently.
1119 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1123 char *full_path = NULL;
1124 struct inode *inode = dentry->d_inode;
1125 struct cifsInodeInfo *cifs_inode;
1126 struct super_block *sb = dir->i_sb;
1127 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1128 struct tcon_link *tlink;
1129 struct cifs_tcon *tcon;
1130 struct TCP_Server_Info *server;
1131 struct iattr *attrs = NULL;
1132 __u32 dosattr = 0, origattr = 0;
1134 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1136 tlink = cifs_sb_tlink(cifs_sb);
1138 return PTR_ERR(tlink);
1139 tcon = tlink_tcon(tlink);
1140 server = tcon->ses->server;
1144 /* Unlink can be called from rename so we can not take the
1145 * sb->s_vfs_rename_mutex here */
1146 full_path = build_path_from_dentry(dentry);
1147 if (full_path == NULL) {
1152 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1153 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1154 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1155 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1156 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1157 cifs_dbg(FYI, "posix del rc %d\n", rc);
1158 if ((rc == 0) || (rc == -ENOENT))
1159 goto psx_del_no_retry;
1163 if (!server->ops->unlink) {
1165 goto psx_del_no_retry;
1168 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1173 cifs_drop_nlink(inode);
1174 } else if (rc == -ENOENT) {
1176 } else if (rc == -EBUSY) {
1177 if (server->ops->rename_pending_delete) {
1178 rc = server->ops->rename_pending_delete(full_path,
1181 cifs_drop_nlink(inode);
1183 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1184 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1185 if (attrs == NULL) {
1190 /* try to reset dos attributes */
1191 cifs_inode = CIFS_I(inode);
1192 origattr = cifs_inode->cifsAttrs;
1194 origattr |= ATTR_NORMAL;
1195 dosattr = origattr & ~ATTR_READONLY;
1197 dosattr |= ATTR_NORMAL;
1198 dosattr |= ATTR_HIDDEN;
1200 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1204 goto retry_std_delete;
1207 /* undo the setattr if we errored out and it's needed */
1208 if (rc != 0 && dosattr != 0)
1209 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1213 cifs_inode = CIFS_I(inode);
1214 cifs_inode->time = 0; /* will force revalidate to get info
1216 inode->i_ctime = current_fs_time(sb);
1218 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1219 cifs_inode = CIFS_I(dir);
1220 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1225 cifs_put_tlink(tlink);
1230 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1231 const char *full_path, struct cifs_sb_info *cifs_sb,
1232 struct cifs_tcon *tcon, const unsigned int xid)
1235 struct inode *inode = NULL;
1238 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1241 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1248 * setting nlink not necessary except in cases where we failed to get it
1249 * from the server or was set bogus. Also, since this is a brand new
1250 * inode, no need to grab the i_lock before setting the i_nlink.
1252 if (inode->i_nlink < 2)
1253 set_nlink(inode, 2);
1254 mode &= ~current_umask();
1255 /* must turn on setgid bit if parent dir has it */
1256 if (parent->i_mode & S_ISGID)
1259 if (tcon->unix_ext) {
1260 struct cifs_unix_set_info_args args = {
1262 .ctime = NO_CHANGE_64,
1263 .atime = NO_CHANGE_64,
1264 .mtime = NO_CHANGE_64,
1267 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1268 args.uid = current_fsuid();
1269 if (parent->i_mode & S_ISGID)
1270 args.gid = parent->i_gid;
1272 args.gid = current_fsgid();
1274 args.uid = INVALID_UID; /* no change */
1275 args.gid = INVALID_GID; /* no change */
1277 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1279 cifs_sb->mnt_cifs_flags &
1280 CIFS_MOUNT_MAP_SPECIAL_CHR);
1282 struct TCP_Server_Info *server = tcon->ses->server;
1283 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1284 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1285 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1287 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1288 inode->i_mode = (mode | S_IFDIR);
1290 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1291 inode->i_uid = current_fsuid();
1292 if (inode->i_mode & S_ISGID)
1293 inode->i_gid = parent->i_gid;
1295 inode->i_gid = current_fsgid();
1298 d_instantiate(dentry, inode);
1303 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1304 const char *full_path, struct cifs_sb_info *cifs_sb,
1305 struct cifs_tcon *tcon, const unsigned int xid)
1309 FILE_UNIX_BASIC_INFO *info = NULL;
1310 struct inode *newinode = NULL;
1311 struct cifs_fattr fattr;
1313 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1316 goto posix_mkdir_out;
1319 mode &= ~current_umask();
1320 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1321 NULL /* netfid */, info, &oplock, full_path,
1322 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1323 CIFS_MOUNT_MAP_SPECIAL_CHR);
1324 if (rc == -EOPNOTSUPP)
1325 goto posix_mkdir_out;
1327 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1329 goto posix_mkdir_out;
1332 if (info->Type == cpu_to_le32(-1))
1333 /* no return info, go query for it */
1334 goto posix_mkdir_get_info;
1336 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1337 * need to set uid/gid.
1340 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1341 cifs_fill_uniqueid(inode->i_sb, &fattr);
1342 newinode = cifs_iget(inode->i_sb, &fattr);
1344 goto posix_mkdir_get_info;
1346 d_instantiate(dentry, newinode);
1348 #ifdef CONFIG_CIFS_DEBUG2
1349 cifs_dbg(FYI, "instantiated dentry %p %s to inode %p\n",
1350 dentry, dentry->d_name.name, newinode);
1352 if (newinode->i_nlink != 2)
1353 cifs_dbg(FYI, "unexpected number of links %d\n",
1360 posix_mkdir_get_info:
1361 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1363 goto posix_mkdir_out;
1366 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1370 struct cifs_sb_info *cifs_sb;
1371 struct tcon_link *tlink;
1372 struct cifs_tcon *tcon;
1373 struct TCP_Server_Info *server;
1376 cifs_dbg(FYI, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1379 cifs_sb = CIFS_SB(inode->i_sb);
1380 tlink = cifs_sb_tlink(cifs_sb);
1382 return PTR_ERR(tlink);
1383 tcon = tlink_tcon(tlink);
1387 full_path = build_path_from_dentry(direntry);
1388 if (full_path == NULL) {
1393 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1394 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1395 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1397 if (rc != -EOPNOTSUPP)
1401 server = tcon->ses->server;
1403 if (!server->ops->mkdir) {
1408 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1409 rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
1411 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1416 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1420 * Force revalidate to get parent dir info when needed since cached
1421 * attributes are invalid now.
1423 CIFS_I(inode)->time = 0;
1426 cifs_put_tlink(tlink);
1430 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1434 struct cifs_sb_info *cifs_sb;
1435 struct tcon_link *tlink;
1436 struct cifs_tcon *tcon;
1437 struct TCP_Server_Info *server;
1438 char *full_path = NULL;
1439 struct cifsInodeInfo *cifsInode;
1441 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1445 full_path = build_path_from_dentry(direntry);
1446 if (full_path == NULL) {
1451 cifs_sb = CIFS_SB(inode->i_sb);
1452 tlink = cifs_sb_tlink(cifs_sb);
1453 if (IS_ERR(tlink)) {
1454 rc = PTR_ERR(tlink);
1457 tcon = tlink_tcon(tlink);
1458 server = tcon->ses->server;
1460 if (!server->ops->rmdir) {
1462 cifs_put_tlink(tlink);
1466 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1467 cifs_put_tlink(tlink);
1470 spin_lock(&direntry->d_inode->i_lock);
1471 i_size_write(direntry->d_inode, 0);
1472 clear_nlink(direntry->d_inode);
1473 spin_unlock(&direntry->d_inode->i_lock);
1476 cifsInode = CIFS_I(direntry->d_inode);
1477 /* force revalidate to go get info when needed */
1478 cifsInode->time = 0;
1480 cifsInode = CIFS_I(inode);
1482 * Force revalidate to get parent dir info when needed since cached
1483 * attributes are invalid now.
1485 cifsInode->time = 0;
1487 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1488 current_fs_time(inode->i_sb);
1497 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1498 const char *from_path, struct dentry *to_dentry,
1499 const char *to_path)
1501 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1502 struct tcon_link *tlink;
1503 struct cifs_tcon *tcon;
1504 struct TCP_Server_Info *server;
1508 tlink = cifs_sb_tlink(cifs_sb);
1510 return PTR_ERR(tlink);
1511 tcon = tlink_tcon(tlink);
1512 server = tcon->ses->server;
1514 if (!server->ops->rename)
1517 /* try path-based rename first */
1518 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1521 * Don't bother with rename by filehandle unless file is busy and
1522 * source. Note that cross directory moves do not work with
1523 * rename by filehandle to various Windows servers.
1525 if (rc == 0 || rc != -EBUSY)
1526 goto do_rename_exit;
1528 /* open-file renames don't work across directories */
1529 if (to_dentry->d_parent != from_dentry->d_parent)
1530 goto do_rename_exit;
1532 /* open the file to be renamed -- we need DELETE perms */
1533 rc = CIFSSMBOpen(xid, tcon, from_path, FILE_OPEN, DELETE,
1534 CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1535 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1536 CIFS_MOUNT_MAP_SPECIAL_CHR);
1538 rc = CIFSSMBRenameOpenFile(xid, tcon, srcfid,
1539 (const char *) to_dentry->d_name.name,
1540 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1541 CIFS_MOUNT_MAP_SPECIAL_CHR);
1542 CIFSSMBClose(xid, tcon, srcfid);
1545 cifs_put_tlink(tlink);
1550 cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1551 struct inode *target_dir, struct dentry *target_dentry)
1553 char *from_name = NULL;
1554 char *to_name = NULL;
1555 struct cifs_sb_info *cifs_sb;
1556 struct tcon_link *tlink;
1557 struct cifs_tcon *tcon;
1558 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1559 FILE_UNIX_BASIC_INFO *info_buf_target;
1563 cifs_sb = CIFS_SB(source_dir->i_sb);
1564 tlink = cifs_sb_tlink(cifs_sb);
1566 return PTR_ERR(tlink);
1567 tcon = tlink_tcon(tlink);
1572 * we already have the rename sem so we do not need to
1573 * grab it again here to protect the path integrity
1575 from_name = build_path_from_dentry(source_dentry);
1576 if (from_name == NULL) {
1578 goto cifs_rename_exit;
1581 to_name = build_path_from_dentry(target_dentry);
1582 if (to_name == NULL) {
1584 goto cifs_rename_exit;
1587 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1590 if (rc == -EEXIST && tcon->unix_ext) {
1592 * Are src and dst hardlinks of same inode? We can only tell
1593 * with unix extensions enabled.
1596 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1598 if (info_buf_source == NULL) {
1600 goto cifs_rename_exit;
1603 info_buf_target = info_buf_source + 1;
1604 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1607 cifs_sb->mnt_cifs_flags &
1608 CIFS_MOUNT_MAP_SPECIAL_CHR);
1612 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1615 cifs_sb->mnt_cifs_flags &
1616 CIFS_MOUNT_MAP_SPECIAL_CHR);
1618 if (tmprc == 0 && (info_buf_source->UniqueId ==
1619 info_buf_target->UniqueId)) {
1620 /* same file, POSIX says that this is a noop */
1622 goto cifs_rename_exit;
1626 * else ... BB we could add the same check for Windows by
1627 * checking the UniqueId via FILE_INTERNAL_INFO
1631 /* Try unlinking the target dentry if it's not negative */
1632 if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
1633 tmprc = cifs_unlink(target_dir, target_dentry);
1635 goto cifs_rename_exit;
1636 rc = cifs_do_rename(xid, source_dentry, from_name,
1637 target_dentry, to_name);
1641 kfree(info_buf_source);
1645 cifs_put_tlink(tlink);
1650 cifs_inode_needs_reval(struct inode *inode)
1652 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1653 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1655 if (cifs_i->clientCanCacheRead)
1658 if (!lookupCacheEnabled)
1661 if (cifs_i->time == 0)
1664 if (!time_in_range(jiffies, cifs_i->time,
1665 cifs_i->time + cifs_sb->actimeo))
1668 /* hardlinked files w/ noserverino get "special" treatment */
1669 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1670 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1677 * Zap the cache. Called when invalid_mapping flag is set.
1680 cifs_invalidate_mapping(struct inode *inode)
1683 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1685 cifs_i->invalid_mapping = false;
1687 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1688 rc = invalidate_inode_pages2(inode->i_mapping);
1690 cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1692 cifs_i->invalid_mapping = true;
1696 cifs_fscache_reset_inode_cookie(inode);
1700 int cifs_revalidate_file_attr(struct file *filp)
1703 struct inode *inode = file_inode(filp);
1704 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1706 if (!cifs_inode_needs_reval(inode))
1709 if (tlink_tcon(cfile->tlink)->unix_ext)
1710 rc = cifs_get_file_info_unix(filp);
1712 rc = cifs_get_file_info(filp);
1717 int cifs_revalidate_dentry_attr(struct dentry *dentry)
1721 struct inode *inode = dentry->d_inode;
1722 struct super_block *sb = dentry->d_sb;
1723 char *full_path = NULL;
1728 if (!cifs_inode_needs_reval(inode))
1733 /* can not safely grab the rename sem here if rename calls revalidate
1734 since that would deadlock */
1735 full_path = build_path_from_dentry(dentry);
1736 if (full_path == NULL) {
1741 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1742 full_path, inode, inode->i_count.counter,
1743 dentry, dentry->d_time, jiffies);
1745 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1746 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1748 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1757 int cifs_revalidate_file(struct file *filp)
1760 struct inode *inode = file_inode(filp);
1762 rc = cifs_revalidate_file_attr(filp);
1766 if (CIFS_I(inode)->invalid_mapping)
1767 rc = cifs_invalidate_mapping(inode);
1771 /* revalidate a dentry's inode attributes */
1772 int cifs_revalidate_dentry(struct dentry *dentry)
1775 struct inode *inode = dentry->d_inode;
1777 rc = cifs_revalidate_dentry_attr(dentry);
1781 if (CIFS_I(inode)->invalid_mapping)
1782 rc = cifs_invalidate_mapping(inode);
1786 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1789 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1790 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1791 struct inode *inode = dentry->d_inode;
1795 * We need to be sure that all dirty pages are written and the server
1796 * has actual ctime, mtime and file length.
1798 if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping &&
1799 inode->i_mapping->nrpages != 0) {
1800 rc = filemap_fdatawait(inode->i_mapping);
1802 mapping_set_error(inode->i_mapping, rc);
1807 rc = cifs_revalidate_dentry_attr(dentry);
1811 generic_fillattr(inode, stat);
1812 stat->blksize = CIFS_MAX_MSGSIZE;
1813 stat->ino = CIFS_I(inode)->uniqueid;
1816 * If on a multiuser mount without unix extensions or cifsacl being
1817 * enabled, and the admin hasn't overridden them, set the ownership
1818 * to the fsuid/fsgid of the current process.
1820 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
1821 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1823 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1824 stat->uid = current_fsuid();
1825 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1826 stat->gid = current_fsgid();
1831 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1833 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1834 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1838 page = grab_cache_page(mapping, index);
1842 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1844 page_cache_release(page);
1848 static void cifs_setsize(struct inode *inode, loff_t offset)
1852 spin_lock(&inode->i_lock);
1853 oldsize = inode->i_size;
1854 i_size_write(inode, offset);
1855 spin_unlock(&inode->i_lock);
1857 truncate_pagecache(inode, oldsize, offset);
1861 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1862 unsigned int xid, char *full_path)
1865 struct cifsFileInfo *open_file;
1866 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1867 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1868 struct tcon_link *tlink = NULL;
1869 struct cifs_tcon *tcon = NULL;
1870 struct TCP_Server_Info *server;
1871 struct cifs_io_parms io_parms;
1874 * To avoid spurious oplock breaks from server, in the case of
1875 * inodes that we already have open, avoid doing path based
1876 * setting of file size if we can do it by handle.
1877 * This keeps our caching token (oplock) and avoids timeouts
1878 * when the local oplock break takes longer to flush
1879 * writebehind data than the SMB timeout for the SetPathInfo
1880 * request would allow
1882 open_file = find_writable_file(cifsInode, true);
1884 tcon = tlink_tcon(open_file->tlink);
1885 server = tcon->ses->server;
1886 if (server->ops->set_file_size)
1887 rc = server->ops->set_file_size(xid, tcon, open_file,
1888 attrs->ia_size, false);
1891 cifsFileInfo_put(open_file);
1892 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
1893 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1894 unsigned int bytes_written;
1896 io_parms.netfid = open_file->fid.netfid;
1897 io_parms.pid = open_file->pid;
1898 io_parms.tcon = tcon;
1899 io_parms.offset = 0;
1900 io_parms.length = attrs->ia_size;
1901 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written,
1903 cifs_dbg(FYI, "Wrt seteof rc %d\n", rc);
1912 tlink = cifs_sb_tlink(cifs_sb);
1914 return PTR_ERR(tlink);
1915 tcon = tlink_tcon(tlink);
1916 server = tcon->ses->server;
1920 * Set file size by pathname rather than by handle either because no
1921 * valid, writeable file handle for it was found or because there was
1922 * an error setting it by handle.
1924 if (server->ops->set_path_size)
1925 rc = server->ops->set_path_size(xid, tcon, full_path,
1926 attrs->ia_size, cifs_sb, false);
1929 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
1930 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1934 rc = SMBLegacyOpen(xid, tcon, full_path, FILE_OPEN,
1935 GENERIC_WRITE, CREATE_NOT_DIR, &netfid,
1936 &oplock, NULL, cifs_sb->local_nls,
1937 cifs_sb->mnt_cifs_flags &
1938 CIFS_MOUNT_MAP_SPECIAL_CHR);
1940 unsigned int bytes_written;
1942 io_parms.netfid = netfid;
1943 io_parms.pid = current->tgid;
1944 io_parms.tcon = tcon;
1945 io_parms.offset = 0;
1946 io_parms.length = attrs->ia_size;
1947 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written, NULL,
1949 cifs_dbg(FYI, "wrt seteof rc %d\n", rc);
1950 CIFSSMBClose(xid, tcon, netfid);
1954 cifs_put_tlink(tlink);
1958 cifsInode->server_eof = attrs->ia_size;
1959 cifs_setsize(inode, attrs->ia_size);
1960 cifs_truncate_page(inode->i_mapping, inode->i_size);
1967 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1971 char *full_path = NULL;
1972 struct inode *inode = direntry->d_inode;
1973 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1974 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1975 struct tcon_link *tlink;
1976 struct cifs_tcon *pTcon;
1977 struct cifs_unix_set_info_args *args = NULL;
1978 struct cifsFileInfo *open_file;
1980 cifs_dbg(FYI, "setattr_unix on file %s attrs->ia_valid=0x%x\n",
1981 direntry->d_name.name, attrs->ia_valid);
1985 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
1986 attrs->ia_valid |= ATTR_FORCE;
1988 rc = inode_change_ok(inode, attrs);
1992 full_path = build_path_from_dentry(direntry);
1993 if (full_path == NULL) {
1999 * Attempt to flush data before changing attributes. We need to do
2000 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2001 * ownership or mode then we may also need to do this. Here, we take
2002 * the safe way out and just do the flush on all setattr requests. If
2003 * the flush returns error, store it to report later and continue.
2005 * BB: This should be smarter. Why bother flushing pages that
2006 * will be truncated anyway? Also, should we error out here if
2007 * the flush returns error?
2009 rc = filemap_write_and_wait(inode->i_mapping);
2010 mapping_set_error(inode->i_mapping, rc);
2013 if (attrs->ia_valid & ATTR_SIZE) {
2014 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2019 /* skip mode change if it's just for clearing setuid/setgid */
2020 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2021 attrs->ia_valid &= ~ATTR_MODE;
2023 args = kmalloc(sizeof(*args), GFP_KERNEL);
2029 /* set up the struct */
2030 if (attrs->ia_valid & ATTR_MODE)
2031 args->mode = attrs->ia_mode;
2033 args->mode = NO_CHANGE_64;
2035 if (attrs->ia_valid & ATTR_UID)
2036 args->uid = attrs->ia_uid;
2038 args->uid = INVALID_UID; /* no change */
2040 if (attrs->ia_valid & ATTR_GID)
2041 args->gid = attrs->ia_gid;
2043 args->gid = INVALID_GID; /* no change */
2045 if (attrs->ia_valid & ATTR_ATIME)
2046 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2048 args->atime = NO_CHANGE_64;
2050 if (attrs->ia_valid & ATTR_MTIME)
2051 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2053 args->mtime = NO_CHANGE_64;
2055 if (attrs->ia_valid & ATTR_CTIME)
2056 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2058 args->ctime = NO_CHANGE_64;
2061 open_file = find_writable_file(cifsInode, true);
2063 u16 nfid = open_file->fid.netfid;
2064 u32 npid = open_file->pid;
2065 pTcon = tlink_tcon(open_file->tlink);
2066 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2067 cifsFileInfo_put(open_file);
2069 tlink = cifs_sb_tlink(cifs_sb);
2070 if (IS_ERR(tlink)) {
2071 rc = PTR_ERR(tlink);
2074 pTcon = tlink_tcon(tlink);
2075 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2077 cifs_sb->mnt_cifs_flags &
2078 CIFS_MOUNT_MAP_SPECIAL_CHR);
2079 cifs_put_tlink(tlink);
2085 if ((attrs->ia_valid & ATTR_SIZE) &&
2086 attrs->ia_size != i_size_read(inode))
2087 truncate_setsize(inode, attrs->ia_size);
2089 setattr_copy(inode, attrs);
2090 mark_inode_dirty(inode);
2092 /* force revalidate when any of these times are set since some
2093 of the fs types (eg ext3, fat) do not have fine enough
2094 time granularity to match protocol, and we do not have a
2095 a way (yet) to query the server fs's time granularity (and
2096 whether it rounds times down).
2098 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2099 cifsInode->time = 0;
2108 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2111 kuid_t uid = INVALID_UID;
2112 kgid_t gid = INVALID_GID;
2113 struct inode *inode = direntry->d_inode;
2114 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2115 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2116 char *full_path = NULL;
2119 __u64 mode = NO_CHANGE_64;
2123 cifs_dbg(FYI, "setattr on file %s attrs->iavalid 0x%x\n",
2124 direntry->d_name.name, attrs->ia_valid);
2126 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2127 attrs->ia_valid |= ATTR_FORCE;
2129 rc = inode_change_ok(inode, attrs);
2135 full_path = build_path_from_dentry(direntry);
2136 if (full_path == NULL) {
2143 * Attempt to flush data before changing attributes. We need to do
2144 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2145 * ownership or mode then we may also need to do this. Here, we take
2146 * the safe way out and just do the flush on all setattr requests. If
2147 * the flush returns error, store it to report later and continue.
2149 * BB: This should be smarter. Why bother flushing pages that
2150 * will be truncated anyway? Also, should we error out here if
2151 * the flush returns error?
2153 rc = filemap_write_and_wait(inode->i_mapping);
2154 mapping_set_error(inode->i_mapping, rc);
2157 if (attrs->ia_valid & ATTR_SIZE) {
2158 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2160 goto cifs_setattr_exit;
2163 if (attrs->ia_valid & ATTR_UID)
2164 uid = attrs->ia_uid;
2166 if (attrs->ia_valid & ATTR_GID)
2167 gid = attrs->ia_gid;
2169 #ifdef CONFIG_CIFS_ACL
2170 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2171 if (uid_valid(uid) || gid_valid(gid)) {
2172 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2175 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2177 goto cifs_setattr_exit;
2181 #endif /* CONFIG_CIFS_ACL */
2182 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2183 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2185 /* skip mode change if it's just for clearing setuid/setgid */
2186 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2187 attrs->ia_valid &= ~ATTR_MODE;
2189 if (attrs->ia_valid & ATTR_MODE) {
2190 mode = attrs->ia_mode;
2192 #ifdef CONFIG_CIFS_ACL
2193 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2194 rc = id_mode_to_cifs_acl(inode, full_path, mode,
2195 INVALID_UID, INVALID_GID);
2197 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2199 goto cifs_setattr_exit;
2202 #endif /* CONFIG_CIFS_ACL */
2203 if (((mode & S_IWUGO) == 0) &&
2204 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2206 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2208 /* fix up mode if we're not using dynperm */
2209 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2210 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2211 } else if ((mode & S_IWUGO) &&
2212 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2214 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2215 /* Attributes of 0 are ignored */
2217 dosattr |= ATTR_NORMAL;
2219 /* reset local inode permissions to normal */
2220 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2221 attrs->ia_mode &= ~(S_IALLUGO);
2222 if (S_ISDIR(inode->i_mode))
2224 cifs_sb->mnt_dir_mode;
2227 cifs_sb->mnt_file_mode;
2229 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2230 /* ignore mode change - ATTR_READONLY hasn't changed */
2231 attrs->ia_valid &= ~ATTR_MODE;
2235 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2236 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2237 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2238 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2240 /* Even if error on time set, no sense failing the call if
2241 the server would set the time to a reasonable value anyway,
2242 and this check ensures that we are not being called from
2243 sys_utimes in which case we ought to fail the call back to
2244 the user when the server rejects the call */
2245 if ((rc) && (attrs->ia_valid &
2246 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2250 /* do not need local check to inode_check_ok since the server does
2253 goto cifs_setattr_exit;
2255 if ((attrs->ia_valid & ATTR_SIZE) &&
2256 attrs->ia_size != i_size_read(inode))
2257 truncate_setsize(inode, attrs->ia_size);
2259 setattr_copy(inode, attrs);
2260 mark_inode_dirty(inode);
2269 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2271 struct inode *inode = direntry->d_inode;
2272 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2273 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2275 if (pTcon->unix_ext)
2276 return cifs_setattr_unix(direntry, attrs);
2278 return cifs_setattr_nounix(direntry, attrs);
2280 /* BB: add cifs_setattr_legacy for really old servers */
2284 void cifs_delete_inode(struct inode *inode)
2286 cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2287 /* may have to add back in if and when safe distributed caching of
2288 directories added e.g. via FindNotify */