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);
561 if (fattr->cf_nlink < 1) {
562 cifs_dbg(1, "replacing bogus file nlink value %u\n",
568 fattr->cf_uid = cifs_sb->mnt_uid;
569 fattr->cf_gid = cifs_sb->mnt_gid;
573 cifs_get_file_info(struct file *filp)
577 FILE_ALL_INFO find_data;
578 struct cifs_fattr fattr;
579 struct inode *inode = file_inode(filp);
580 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
581 struct cifsFileInfo *cfile = filp->private_data;
582 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
583 struct TCP_Server_Info *server = tcon->ses->server;
585 if (!server->ops->query_file_info)
589 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
592 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false);
595 cifs_create_dfs_fattr(&fattr, inode->i_sb);
601 * FIXME: legacy server -- fall back to path-based call?
602 * for now, just skip revalidating and mark inode for
606 CIFS_I(inode)->time = 0;
612 * don't bother with SFU junk here -- just mark inode as needing
615 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
616 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
617 cifs_fattr_to_inode(inode, &fattr);
624 cifs_get_inode_info(struct inode **inode, const char *full_path,
625 FILE_ALL_INFO *data, struct super_block *sb, int xid,
628 bool validinum = false;
630 int rc = 0, tmprc = ENOSYS;
631 struct cifs_tcon *tcon;
632 struct TCP_Server_Info *server;
633 struct tcon_link *tlink;
634 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
636 bool adjust_tz = false;
637 struct cifs_fattr fattr;
638 struct cifs_search_info *srchinf = NULL;
640 tlink = cifs_sb_tlink(cifs_sb);
642 return PTR_ERR(tlink);
643 tcon = tlink_tcon(tlink);
644 server = tcon->ses->server;
646 cifs_dbg(FYI, "Getting info on %s\n", full_path);
648 if ((data == NULL) && (*inode != NULL)) {
649 if (CIFS_I(*inode)->clientCanCacheRead) {
650 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
655 /* if inode info is not passed, get it from server */
657 if (!server->ops->query_path_info) {
661 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
666 data = (FILE_ALL_INFO *)buf;
667 rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path,
672 cifs_all_info_to_fattr(&fattr, (FILE_ALL_INFO *)data, cifs_sb,
674 } else if (rc == -EREMOTE) {
675 cifs_create_dfs_fattr(&fattr, sb);
677 } else if (rc == -EACCES && backup_cred(cifs_sb)) {
678 srchinf = kzalloc(sizeof(struct cifs_search_info),
680 if (srchinf == NULL) {
685 srchinf->endOfSearch = false;
686 srchinf->info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
688 srchflgs = CIFS_SEARCH_CLOSE_ALWAYS |
689 CIFS_SEARCH_CLOSE_AT_END |
690 CIFS_SEARCH_BACKUP_SEARCH;
692 rc = CIFSFindFirst(xid, tcon, full_path,
693 cifs_sb, NULL, srchflgs, srchinf, false);
696 (FILE_ALL_INFO *)srchinf->srch_entries_start;
698 cifs_dir_info_to_fattr(&fattr,
699 (FILE_DIRECTORY_INFO *)data, cifs_sb);
700 fattr.cf_uniqueid = le64_to_cpu(
701 ((SEARCH_ID_FULL_DIR_INFO *)data)->UniqueId);
704 cifs_buf_release(srchinf->ntwrk_buf_start);
711 * If an inode wasn't passed in, then get the inode number
713 * Is an i_ino of zero legal? Can we use that to check if the server
714 * supports returning inode numbers? Are there other sanity checks we
715 * can use to ensure that the server is really filling in that field?
717 if (*inode == NULL) {
718 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
719 if (validinum == false) {
720 if (server->ops->get_srv_inum)
721 tmprc = server->ops->get_srv_inum(xid,
722 tcon, cifs_sb, full_path,
723 &fattr.cf_uniqueid, data);
725 cifs_dbg(FYI, "GetSrvInodeNum rc %d\n",
727 fattr.cf_uniqueid = iunique(sb, ROOT_I);
728 cifs_autodisable_serverino(cifs_sb);
732 fattr.cf_uniqueid = iunique(sb, ROOT_I);
734 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
736 /* query for SFU type info if supported and needed */
737 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
738 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
739 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
741 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
744 #ifdef CONFIG_CIFS_ACL
745 /* fill in 0777 bits from ACL */
746 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
747 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, full_path, fid);
749 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
754 #endif /* CONFIG_CIFS_ACL */
756 /* fill in remaining high mode bits e.g. SUID, VTX */
757 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
758 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
760 /* check for Minshall+French symlinks */
761 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
762 tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
764 cifs_dbg(FYI, "CIFSCheckMFSymlink: %d\n", tmprc);
768 *inode = cifs_iget(sb, &fattr);
772 cifs_fattr_to_inode(*inode, &fattr);
777 cifs_put_tlink(tlink);
781 static const struct inode_operations cifs_ipc_inode_ops = {
782 .lookup = cifs_lookup,
786 cifs_find_inode(struct inode *inode, void *opaque)
788 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
790 /* don't match inode with different uniqueid */
791 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
794 /* use createtime like an i_generation field */
795 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
798 /* don't match inode of different type */
799 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
802 /* if it's not a directory or has no dentries, then flag it */
803 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
804 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
810 cifs_init_inode(struct inode *inode, void *opaque)
812 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
814 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
815 CIFS_I(inode)->createtime = fattr->cf_createtime;
820 * walk dentry list for an inode and report whether it has aliases that
821 * are hashed. We use this to determine if a directory inode can actually
825 inode_has_hashed_dentries(struct inode *inode)
827 struct dentry *dentry;
829 spin_lock(&inode->i_lock);
830 hlist_for_each_entry(dentry, &inode->i_dentry, d_alias) {
831 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
832 spin_unlock(&inode->i_lock);
836 spin_unlock(&inode->i_lock);
840 /* Given fattrs, get a corresponding inode */
842 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
848 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
850 /* hash down to 32-bits on 32-bit arch */
851 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
853 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
855 /* was there a potentially problematic inode collision? */
856 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
857 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
859 if (inode_has_hashed_dentries(inode)) {
860 cifs_autodisable_serverino(CIFS_SB(sb));
862 fattr->cf_uniqueid = iunique(sb, ROOT_I);
863 goto retry_iget5_locked;
867 cifs_fattr_to_inode(inode, fattr);
868 if (sb->s_flags & MS_NOATIME)
869 inode->i_flags |= S_NOATIME | S_NOCMTIME;
870 if (inode->i_state & I_NEW) {
872 if (S_ISREG(inode->i_mode))
873 inode->i_data.backing_dev_info = sb->s_bdi;
874 #ifdef CONFIG_CIFS_FSCACHE
875 /* initialize per-inode cache cookie pointer */
876 CIFS_I(inode)->fscache = NULL;
878 unlock_new_inode(inode);
885 /* gets root inode */
886 struct inode *cifs_root_iget(struct super_block *sb)
889 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
890 struct inode *inode = NULL;
892 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
896 rc = cifs_get_inode_info_unix(&inode, "", sb, xid);
898 rc = cifs_get_inode_info(&inode, "", NULL, sb, xid, NULL);
905 #ifdef CONFIG_CIFS_FSCACHE
906 /* populate tcon->resource_id */
907 tcon->resource_id = CIFS_I(inode)->uniqueid;
910 if (rc && tcon->ipc) {
911 cifs_dbg(FYI, "ipc connection - fake read inode\n");
912 spin_lock(&inode->i_lock);
913 inode->i_mode |= S_IFDIR;
915 inode->i_op = &cifs_ipc_inode_ops;
916 inode->i_fop = &simple_dir_operations;
917 inode->i_uid = cifs_sb->mnt_uid;
918 inode->i_gid = cifs_sb->mnt_gid;
919 spin_unlock(&inode->i_lock);
926 /* can not call macro free_xid here since in a void func
927 * TODO: This is no longer true
934 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
935 char *full_path, __u32 dosattr)
937 bool set_time = false;
938 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
939 struct TCP_Server_Info *server;
940 FILE_BASIC_INFO info_buf;
945 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
946 if (!server->ops->set_file_info)
949 if (attrs->ia_valid & ATTR_ATIME) {
951 info_buf.LastAccessTime =
952 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
954 info_buf.LastAccessTime = 0;
956 if (attrs->ia_valid & ATTR_MTIME) {
958 info_buf.LastWriteTime =
959 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
961 info_buf.LastWriteTime = 0;
964 * Samba throws this field away, but windows may actually use it.
965 * Do not set ctime unless other time stamps are changed explicitly
966 * (i.e. by utimes()) since we would then have a mix of client and
969 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
970 cifs_dbg(FYI, "CIFS - CTIME changed\n");
971 info_buf.ChangeTime =
972 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
974 info_buf.ChangeTime = 0;
976 info_buf.CreationTime = 0; /* don't change */
977 info_buf.Attributes = cpu_to_le32(dosattr);
979 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
983 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
984 * and rename it to a random name that hopefully won't conflict with
988 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
989 const unsigned int xid)
994 struct inode *inode = dentry->d_inode;
995 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
996 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
997 struct tcon_link *tlink;
998 struct cifs_tcon *tcon;
999 __u32 dosattr, origattr;
1000 FILE_BASIC_INFO *info_buf = NULL;
1002 tlink = cifs_sb_tlink(cifs_sb);
1004 return PTR_ERR(tlink);
1005 tcon = tlink_tcon(tlink);
1008 * We cannot rename the file if the server doesn't support
1009 * CAP_INFOLEVEL_PASSTHRU
1011 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1016 rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
1017 DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
1018 &netfid, &oplock, NULL, cifs_sb->local_nls,
1019 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1023 origattr = cifsInode->cifsAttrs;
1025 origattr |= ATTR_NORMAL;
1027 dosattr = origattr & ~ATTR_READONLY;
1029 dosattr |= ATTR_NORMAL;
1030 dosattr |= ATTR_HIDDEN;
1032 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1033 if (dosattr != origattr) {
1034 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1035 if (info_buf == NULL) {
1039 info_buf->Attributes = cpu_to_le32(dosattr);
1040 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1042 /* although we would like to mark the file hidden
1043 if that fails we will still try to rename it */
1045 cifsInode->cifsAttrs = dosattr;
1047 dosattr = origattr; /* since not able to change them */
1050 /* rename the file */
1051 rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
1052 cifs_sb->mnt_cifs_flags &
1053 CIFS_MOUNT_MAP_SPECIAL_CHR);
1059 /* try to set DELETE_ON_CLOSE */
1060 if (!cifsInode->delete_pending) {
1061 rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
1064 * some samba versions return -ENOENT when we try to set the
1065 * file disposition here. Likely a samba bug, but work around
1066 * it for now. This means that some cifsXXX files may hang
1067 * around after they shouldn't.
1069 * BB: remove this hack after more servers have the fix
1077 cifsInode->delete_pending = true;
1081 CIFSSMBClose(xid, tcon, netfid);
1084 cifs_put_tlink(tlink);
1088 * reset everything back to the original state. Don't bother
1089 * dealing with errors here since we can't do anything about
1093 CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
1094 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1095 CIFS_MOUNT_MAP_SPECIAL_CHR);
1097 if (dosattr != origattr) {
1098 info_buf->Attributes = cpu_to_le32(origattr);
1099 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1101 cifsInode->cifsAttrs = origattr;
1107 /* copied from fs/nfs/dir.c with small changes */
1109 cifs_drop_nlink(struct inode *inode)
1111 spin_lock(&inode->i_lock);
1112 if (inode->i_nlink > 0)
1114 spin_unlock(&inode->i_lock);
1118 * If dentry->d_inode is null (usually meaning the cached dentry
1119 * is a negative dentry) then we would attempt a standard SMB delete, but
1120 * if that fails we can not attempt the fall back mechanisms on EACCESS
1121 * but will return the EACCESS to the caller. Note that the VFS does not call
1122 * unlink on negative dentries currently.
1124 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1128 char *full_path = NULL;
1129 struct inode *inode = dentry->d_inode;
1130 struct cifsInodeInfo *cifs_inode;
1131 struct super_block *sb = dir->i_sb;
1132 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1133 struct tcon_link *tlink;
1134 struct cifs_tcon *tcon;
1135 struct TCP_Server_Info *server;
1136 struct iattr *attrs = NULL;
1137 __u32 dosattr = 0, origattr = 0;
1139 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1141 tlink = cifs_sb_tlink(cifs_sb);
1143 return PTR_ERR(tlink);
1144 tcon = tlink_tcon(tlink);
1145 server = tcon->ses->server;
1149 /* Unlink can be called from rename so we can not take the
1150 * sb->s_vfs_rename_mutex here */
1151 full_path = build_path_from_dentry(dentry);
1152 if (full_path == NULL) {
1157 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1158 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1159 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1160 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1161 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1162 cifs_dbg(FYI, "posix del rc %d\n", rc);
1163 if ((rc == 0) || (rc == -ENOENT))
1164 goto psx_del_no_retry;
1168 if (!server->ops->unlink) {
1170 goto psx_del_no_retry;
1173 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1178 cifs_drop_nlink(inode);
1179 } else if (rc == -ENOENT) {
1181 } else if (rc == -EBUSY) {
1182 if (server->ops->rename_pending_delete) {
1183 rc = server->ops->rename_pending_delete(full_path,
1186 cifs_drop_nlink(inode);
1188 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1189 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1190 if (attrs == NULL) {
1195 /* try to reset dos attributes */
1196 cifs_inode = CIFS_I(inode);
1197 origattr = cifs_inode->cifsAttrs;
1199 origattr |= ATTR_NORMAL;
1200 dosattr = origattr & ~ATTR_READONLY;
1202 dosattr |= ATTR_NORMAL;
1203 dosattr |= ATTR_HIDDEN;
1205 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1209 goto retry_std_delete;
1212 /* undo the setattr if we errored out and it's needed */
1213 if (rc != 0 && dosattr != 0)
1214 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1218 cifs_inode = CIFS_I(inode);
1219 cifs_inode->time = 0; /* will force revalidate to get info
1221 inode->i_ctime = current_fs_time(sb);
1223 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1224 cifs_inode = CIFS_I(dir);
1225 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1230 cifs_put_tlink(tlink);
1235 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1236 const char *full_path, struct cifs_sb_info *cifs_sb,
1237 struct cifs_tcon *tcon, const unsigned int xid)
1240 struct inode *inode = NULL;
1243 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1246 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1253 * setting nlink not necessary except in cases where we failed to get it
1254 * from the server or was set bogus. Also, since this is a brand new
1255 * inode, no need to grab the i_lock before setting the i_nlink.
1257 if (inode->i_nlink < 2)
1258 set_nlink(inode, 2);
1259 mode &= ~current_umask();
1260 /* must turn on setgid bit if parent dir has it */
1261 if (parent->i_mode & S_ISGID)
1264 if (tcon->unix_ext) {
1265 struct cifs_unix_set_info_args args = {
1267 .ctime = NO_CHANGE_64,
1268 .atime = NO_CHANGE_64,
1269 .mtime = NO_CHANGE_64,
1272 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1273 args.uid = current_fsuid();
1274 if (parent->i_mode & S_ISGID)
1275 args.gid = parent->i_gid;
1277 args.gid = current_fsgid();
1279 args.uid = INVALID_UID; /* no change */
1280 args.gid = INVALID_GID; /* no change */
1282 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1284 cifs_sb->mnt_cifs_flags &
1285 CIFS_MOUNT_MAP_SPECIAL_CHR);
1287 struct TCP_Server_Info *server = tcon->ses->server;
1288 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1289 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1290 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1292 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1293 inode->i_mode = (mode | S_IFDIR);
1295 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1296 inode->i_uid = current_fsuid();
1297 if (inode->i_mode & S_ISGID)
1298 inode->i_gid = parent->i_gid;
1300 inode->i_gid = current_fsgid();
1303 d_instantiate(dentry, inode);
1308 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1309 const char *full_path, struct cifs_sb_info *cifs_sb,
1310 struct cifs_tcon *tcon, const unsigned int xid)
1314 FILE_UNIX_BASIC_INFO *info = NULL;
1315 struct inode *newinode = NULL;
1316 struct cifs_fattr fattr;
1318 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1321 goto posix_mkdir_out;
1324 mode &= ~current_umask();
1325 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1326 NULL /* netfid */, info, &oplock, full_path,
1327 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1328 CIFS_MOUNT_MAP_SPECIAL_CHR);
1329 if (rc == -EOPNOTSUPP)
1330 goto posix_mkdir_out;
1332 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1334 goto posix_mkdir_out;
1337 if (info->Type == cpu_to_le32(-1))
1338 /* no return info, go query for it */
1339 goto posix_mkdir_get_info;
1341 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1342 * need to set uid/gid.
1345 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1346 cifs_fill_uniqueid(inode->i_sb, &fattr);
1347 newinode = cifs_iget(inode->i_sb, &fattr);
1349 goto posix_mkdir_get_info;
1351 d_instantiate(dentry, newinode);
1353 #ifdef CONFIG_CIFS_DEBUG2
1354 cifs_dbg(FYI, "instantiated dentry %p %s to inode %p\n",
1355 dentry, dentry->d_name.name, newinode);
1357 if (newinode->i_nlink != 2)
1358 cifs_dbg(FYI, "unexpected number of links %d\n",
1365 posix_mkdir_get_info:
1366 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1368 goto posix_mkdir_out;
1371 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1375 struct cifs_sb_info *cifs_sb;
1376 struct tcon_link *tlink;
1377 struct cifs_tcon *tcon;
1378 struct TCP_Server_Info *server;
1381 cifs_dbg(FYI, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1384 cifs_sb = CIFS_SB(inode->i_sb);
1385 tlink = cifs_sb_tlink(cifs_sb);
1387 return PTR_ERR(tlink);
1388 tcon = tlink_tcon(tlink);
1392 full_path = build_path_from_dentry(direntry);
1393 if (full_path == NULL) {
1398 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1399 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1400 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1402 if (rc != -EOPNOTSUPP)
1406 server = tcon->ses->server;
1408 if (!server->ops->mkdir) {
1413 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1414 rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
1416 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1421 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1425 * Force revalidate to get parent dir info when needed since cached
1426 * attributes are invalid now.
1428 CIFS_I(inode)->time = 0;
1431 cifs_put_tlink(tlink);
1435 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1439 struct cifs_sb_info *cifs_sb;
1440 struct tcon_link *tlink;
1441 struct cifs_tcon *tcon;
1442 struct TCP_Server_Info *server;
1443 char *full_path = NULL;
1444 struct cifsInodeInfo *cifsInode;
1446 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1450 full_path = build_path_from_dentry(direntry);
1451 if (full_path == NULL) {
1456 cifs_sb = CIFS_SB(inode->i_sb);
1457 tlink = cifs_sb_tlink(cifs_sb);
1458 if (IS_ERR(tlink)) {
1459 rc = PTR_ERR(tlink);
1462 tcon = tlink_tcon(tlink);
1463 server = tcon->ses->server;
1465 if (!server->ops->rmdir) {
1467 cifs_put_tlink(tlink);
1471 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1472 cifs_put_tlink(tlink);
1475 spin_lock(&direntry->d_inode->i_lock);
1476 i_size_write(direntry->d_inode, 0);
1477 clear_nlink(direntry->d_inode);
1478 spin_unlock(&direntry->d_inode->i_lock);
1481 cifsInode = CIFS_I(direntry->d_inode);
1482 /* force revalidate to go get info when needed */
1483 cifsInode->time = 0;
1485 cifsInode = CIFS_I(inode);
1487 * Force revalidate to get parent dir info when needed since cached
1488 * attributes are invalid now.
1490 cifsInode->time = 0;
1492 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1493 current_fs_time(inode->i_sb);
1502 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1503 const char *from_path, struct dentry *to_dentry,
1504 const char *to_path)
1506 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1507 struct tcon_link *tlink;
1508 struct cifs_tcon *tcon;
1509 struct TCP_Server_Info *server;
1513 tlink = cifs_sb_tlink(cifs_sb);
1515 return PTR_ERR(tlink);
1516 tcon = tlink_tcon(tlink);
1517 server = tcon->ses->server;
1519 if (!server->ops->rename)
1522 /* try path-based rename first */
1523 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1526 * Don't bother with rename by filehandle unless file is busy and
1527 * source. Note that cross directory moves do not work with
1528 * rename by filehandle to various Windows servers.
1530 if (rc == 0 || rc != -EBUSY)
1531 goto do_rename_exit;
1533 /* open-file renames don't work across directories */
1534 if (to_dentry->d_parent != from_dentry->d_parent)
1535 goto do_rename_exit;
1537 /* open the file to be renamed -- we need DELETE perms */
1538 rc = CIFSSMBOpen(xid, tcon, from_path, FILE_OPEN, DELETE,
1539 CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1540 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1541 CIFS_MOUNT_MAP_SPECIAL_CHR);
1543 rc = CIFSSMBRenameOpenFile(xid, tcon, srcfid,
1544 (const char *) to_dentry->d_name.name,
1545 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1546 CIFS_MOUNT_MAP_SPECIAL_CHR);
1547 CIFSSMBClose(xid, tcon, srcfid);
1550 cifs_put_tlink(tlink);
1555 cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1556 struct inode *target_dir, struct dentry *target_dentry)
1558 char *from_name = NULL;
1559 char *to_name = NULL;
1560 struct cifs_sb_info *cifs_sb;
1561 struct tcon_link *tlink;
1562 struct cifs_tcon *tcon;
1563 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1564 FILE_UNIX_BASIC_INFO *info_buf_target;
1568 cifs_sb = CIFS_SB(source_dir->i_sb);
1569 tlink = cifs_sb_tlink(cifs_sb);
1571 return PTR_ERR(tlink);
1572 tcon = tlink_tcon(tlink);
1577 * we already have the rename sem so we do not need to
1578 * grab it again here to protect the path integrity
1580 from_name = build_path_from_dentry(source_dentry);
1581 if (from_name == NULL) {
1583 goto cifs_rename_exit;
1586 to_name = build_path_from_dentry(target_dentry);
1587 if (to_name == NULL) {
1589 goto cifs_rename_exit;
1592 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1595 if (rc == -EEXIST && tcon->unix_ext) {
1597 * Are src and dst hardlinks of same inode? We can only tell
1598 * with unix extensions enabled.
1601 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1603 if (info_buf_source == NULL) {
1605 goto cifs_rename_exit;
1608 info_buf_target = info_buf_source + 1;
1609 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1612 cifs_sb->mnt_cifs_flags &
1613 CIFS_MOUNT_MAP_SPECIAL_CHR);
1617 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1620 cifs_sb->mnt_cifs_flags &
1621 CIFS_MOUNT_MAP_SPECIAL_CHR);
1623 if (tmprc == 0 && (info_buf_source->UniqueId ==
1624 info_buf_target->UniqueId)) {
1625 /* same file, POSIX says that this is a noop */
1627 goto cifs_rename_exit;
1631 * else ... BB we could add the same check for Windows by
1632 * checking the UniqueId via FILE_INTERNAL_INFO
1636 /* Try unlinking the target dentry if it's not negative */
1637 if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
1638 tmprc = cifs_unlink(target_dir, target_dentry);
1640 goto cifs_rename_exit;
1641 rc = cifs_do_rename(xid, source_dentry, from_name,
1642 target_dentry, to_name);
1646 kfree(info_buf_source);
1650 cifs_put_tlink(tlink);
1655 cifs_inode_needs_reval(struct inode *inode)
1657 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1658 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1660 if (cifs_i->clientCanCacheRead)
1663 if (!lookupCacheEnabled)
1666 if (cifs_i->time == 0)
1669 if (!time_in_range(jiffies, cifs_i->time,
1670 cifs_i->time + cifs_sb->actimeo))
1673 /* hardlinked files w/ noserverino get "special" treatment */
1674 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1675 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1682 * Zap the cache. Called when invalid_mapping flag is set.
1685 cifs_invalidate_mapping(struct inode *inode)
1688 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1690 cifs_i->invalid_mapping = false;
1692 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1693 rc = invalidate_inode_pages2(inode->i_mapping);
1695 cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1697 cifs_i->invalid_mapping = true;
1701 cifs_fscache_reset_inode_cookie(inode);
1705 int cifs_revalidate_file_attr(struct file *filp)
1708 struct inode *inode = file_inode(filp);
1709 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1711 if (!cifs_inode_needs_reval(inode))
1714 if (tlink_tcon(cfile->tlink)->unix_ext)
1715 rc = cifs_get_file_info_unix(filp);
1717 rc = cifs_get_file_info(filp);
1722 int cifs_revalidate_dentry_attr(struct dentry *dentry)
1726 struct inode *inode = dentry->d_inode;
1727 struct super_block *sb = dentry->d_sb;
1728 char *full_path = NULL;
1733 if (!cifs_inode_needs_reval(inode))
1738 /* can not safely grab the rename sem here if rename calls revalidate
1739 since that would deadlock */
1740 full_path = build_path_from_dentry(dentry);
1741 if (full_path == NULL) {
1746 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1747 full_path, inode, inode->i_count.counter,
1748 dentry, dentry->d_time, jiffies);
1750 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1751 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1753 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1762 int cifs_revalidate_file(struct file *filp)
1765 struct inode *inode = file_inode(filp);
1767 rc = cifs_revalidate_file_attr(filp);
1771 if (CIFS_I(inode)->invalid_mapping)
1772 rc = cifs_invalidate_mapping(inode);
1776 /* revalidate a dentry's inode attributes */
1777 int cifs_revalidate_dentry(struct dentry *dentry)
1780 struct inode *inode = dentry->d_inode;
1782 rc = cifs_revalidate_dentry_attr(dentry);
1786 if (CIFS_I(inode)->invalid_mapping)
1787 rc = cifs_invalidate_mapping(inode);
1791 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1794 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1795 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1796 struct inode *inode = dentry->d_inode;
1800 * We need to be sure that all dirty pages are written and the server
1801 * has actual ctime, mtime and file length.
1803 if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping &&
1804 inode->i_mapping->nrpages != 0) {
1805 rc = filemap_fdatawait(inode->i_mapping);
1807 mapping_set_error(inode->i_mapping, rc);
1812 rc = cifs_revalidate_dentry_attr(dentry);
1816 generic_fillattr(inode, stat);
1817 stat->blksize = CIFS_MAX_MSGSIZE;
1818 stat->ino = CIFS_I(inode)->uniqueid;
1821 * If on a multiuser mount without unix extensions or cifsacl being
1822 * enabled, and the admin hasn't overridden them, set the ownership
1823 * to the fsuid/fsgid of the current process.
1825 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
1826 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1828 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1829 stat->uid = current_fsuid();
1830 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1831 stat->gid = current_fsgid();
1836 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1838 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1839 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1843 page = grab_cache_page(mapping, index);
1847 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1849 page_cache_release(page);
1853 static void cifs_setsize(struct inode *inode, loff_t offset)
1857 spin_lock(&inode->i_lock);
1858 oldsize = inode->i_size;
1859 i_size_write(inode, offset);
1860 spin_unlock(&inode->i_lock);
1862 truncate_pagecache(inode, oldsize, offset);
1866 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1867 unsigned int xid, char *full_path)
1870 struct cifsFileInfo *open_file;
1871 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1872 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1873 struct tcon_link *tlink = NULL;
1874 struct cifs_tcon *tcon = NULL;
1875 struct TCP_Server_Info *server;
1876 struct cifs_io_parms io_parms;
1879 * To avoid spurious oplock breaks from server, in the case of
1880 * inodes that we already have open, avoid doing path based
1881 * setting of file size if we can do it by handle.
1882 * This keeps our caching token (oplock) and avoids timeouts
1883 * when the local oplock break takes longer to flush
1884 * writebehind data than the SMB timeout for the SetPathInfo
1885 * request would allow
1887 open_file = find_writable_file(cifsInode, true);
1889 tcon = tlink_tcon(open_file->tlink);
1890 server = tcon->ses->server;
1891 if (server->ops->set_file_size)
1892 rc = server->ops->set_file_size(xid, tcon, open_file,
1893 attrs->ia_size, false);
1896 cifsFileInfo_put(open_file);
1897 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
1898 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1899 unsigned int bytes_written;
1901 io_parms.netfid = open_file->fid.netfid;
1902 io_parms.pid = open_file->pid;
1903 io_parms.tcon = tcon;
1904 io_parms.offset = 0;
1905 io_parms.length = attrs->ia_size;
1906 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written,
1908 cifs_dbg(FYI, "Wrt seteof rc %d\n", rc);
1917 tlink = cifs_sb_tlink(cifs_sb);
1919 return PTR_ERR(tlink);
1920 tcon = tlink_tcon(tlink);
1921 server = tcon->ses->server;
1925 * Set file size by pathname rather than by handle either because no
1926 * valid, writeable file handle for it was found or because there was
1927 * an error setting it by handle.
1929 if (server->ops->set_path_size)
1930 rc = server->ops->set_path_size(xid, tcon, full_path,
1931 attrs->ia_size, cifs_sb, false);
1934 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
1935 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1939 rc = SMBLegacyOpen(xid, tcon, full_path, FILE_OPEN,
1940 GENERIC_WRITE, CREATE_NOT_DIR, &netfid,
1941 &oplock, NULL, cifs_sb->local_nls,
1942 cifs_sb->mnt_cifs_flags &
1943 CIFS_MOUNT_MAP_SPECIAL_CHR);
1945 unsigned int bytes_written;
1947 io_parms.netfid = netfid;
1948 io_parms.pid = current->tgid;
1949 io_parms.tcon = tcon;
1950 io_parms.offset = 0;
1951 io_parms.length = attrs->ia_size;
1952 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written, NULL,
1954 cifs_dbg(FYI, "wrt seteof rc %d\n", rc);
1955 CIFSSMBClose(xid, tcon, netfid);
1959 cifs_put_tlink(tlink);
1963 cifsInode->server_eof = attrs->ia_size;
1964 cifs_setsize(inode, attrs->ia_size);
1965 cifs_truncate_page(inode->i_mapping, inode->i_size);
1972 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1976 char *full_path = NULL;
1977 struct inode *inode = direntry->d_inode;
1978 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1979 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1980 struct tcon_link *tlink;
1981 struct cifs_tcon *pTcon;
1982 struct cifs_unix_set_info_args *args = NULL;
1983 struct cifsFileInfo *open_file;
1985 cifs_dbg(FYI, "setattr_unix on file %s attrs->ia_valid=0x%x\n",
1986 direntry->d_name.name, attrs->ia_valid);
1990 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
1991 attrs->ia_valid |= ATTR_FORCE;
1993 rc = inode_change_ok(inode, attrs);
1997 full_path = build_path_from_dentry(direntry);
1998 if (full_path == NULL) {
2004 * Attempt to flush data before changing attributes. We need to do
2005 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2006 * ownership or mode then we may also need to do this. Here, we take
2007 * the safe way out and just do the flush on all setattr requests. If
2008 * the flush returns error, store it to report later and continue.
2010 * BB: This should be smarter. Why bother flushing pages that
2011 * will be truncated anyway? Also, should we error out here if
2012 * the flush returns error?
2014 rc = filemap_write_and_wait(inode->i_mapping);
2015 mapping_set_error(inode->i_mapping, rc);
2018 if (attrs->ia_valid & ATTR_SIZE) {
2019 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2024 /* skip mode change if it's just for clearing setuid/setgid */
2025 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2026 attrs->ia_valid &= ~ATTR_MODE;
2028 args = kmalloc(sizeof(*args), GFP_KERNEL);
2034 /* set up the struct */
2035 if (attrs->ia_valid & ATTR_MODE)
2036 args->mode = attrs->ia_mode;
2038 args->mode = NO_CHANGE_64;
2040 if (attrs->ia_valid & ATTR_UID)
2041 args->uid = attrs->ia_uid;
2043 args->uid = INVALID_UID; /* no change */
2045 if (attrs->ia_valid & ATTR_GID)
2046 args->gid = attrs->ia_gid;
2048 args->gid = INVALID_GID; /* no change */
2050 if (attrs->ia_valid & ATTR_ATIME)
2051 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2053 args->atime = NO_CHANGE_64;
2055 if (attrs->ia_valid & ATTR_MTIME)
2056 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2058 args->mtime = NO_CHANGE_64;
2060 if (attrs->ia_valid & ATTR_CTIME)
2061 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2063 args->ctime = NO_CHANGE_64;
2066 open_file = find_writable_file(cifsInode, true);
2068 u16 nfid = open_file->fid.netfid;
2069 u32 npid = open_file->pid;
2070 pTcon = tlink_tcon(open_file->tlink);
2071 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2072 cifsFileInfo_put(open_file);
2074 tlink = cifs_sb_tlink(cifs_sb);
2075 if (IS_ERR(tlink)) {
2076 rc = PTR_ERR(tlink);
2079 pTcon = tlink_tcon(tlink);
2080 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2082 cifs_sb->mnt_cifs_flags &
2083 CIFS_MOUNT_MAP_SPECIAL_CHR);
2084 cifs_put_tlink(tlink);
2090 if ((attrs->ia_valid & ATTR_SIZE) &&
2091 attrs->ia_size != i_size_read(inode))
2092 truncate_setsize(inode, attrs->ia_size);
2094 setattr_copy(inode, attrs);
2095 mark_inode_dirty(inode);
2097 /* force revalidate when any of these times are set since some
2098 of the fs types (eg ext3, fat) do not have fine enough
2099 time granularity to match protocol, and we do not have a
2100 a way (yet) to query the server fs's time granularity (and
2101 whether it rounds times down).
2103 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2104 cifsInode->time = 0;
2113 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2116 kuid_t uid = INVALID_UID;
2117 kgid_t gid = INVALID_GID;
2118 struct inode *inode = direntry->d_inode;
2119 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2120 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2121 char *full_path = NULL;
2124 __u64 mode = NO_CHANGE_64;
2128 cifs_dbg(FYI, "setattr on file %s attrs->iavalid 0x%x\n",
2129 direntry->d_name.name, attrs->ia_valid);
2131 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2132 attrs->ia_valid |= ATTR_FORCE;
2134 rc = inode_change_ok(inode, attrs);
2140 full_path = build_path_from_dentry(direntry);
2141 if (full_path == NULL) {
2148 * Attempt to flush data before changing attributes. We need to do
2149 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2150 * ownership or mode then we may also need to do this. Here, we take
2151 * the safe way out and just do the flush on all setattr requests. If
2152 * the flush returns error, store it to report later and continue.
2154 * BB: This should be smarter. Why bother flushing pages that
2155 * will be truncated anyway? Also, should we error out here if
2156 * the flush returns error?
2158 rc = filemap_write_and_wait(inode->i_mapping);
2159 mapping_set_error(inode->i_mapping, rc);
2162 if (attrs->ia_valid & ATTR_SIZE) {
2163 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2165 goto cifs_setattr_exit;
2168 if (attrs->ia_valid & ATTR_UID)
2169 uid = attrs->ia_uid;
2171 if (attrs->ia_valid & ATTR_GID)
2172 gid = attrs->ia_gid;
2174 #ifdef CONFIG_CIFS_ACL
2175 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2176 if (uid_valid(uid) || gid_valid(gid)) {
2177 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2180 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2182 goto cifs_setattr_exit;
2186 #endif /* CONFIG_CIFS_ACL */
2187 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2188 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2190 /* skip mode change if it's just for clearing setuid/setgid */
2191 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2192 attrs->ia_valid &= ~ATTR_MODE;
2194 if (attrs->ia_valid & ATTR_MODE) {
2195 mode = attrs->ia_mode;
2197 #ifdef CONFIG_CIFS_ACL
2198 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2199 rc = id_mode_to_cifs_acl(inode, full_path, mode,
2200 INVALID_UID, INVALID_GID);
2202 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2204 goto cifs_setattr_exit;
2207 #endif /* CONFIG_CIFS_ACL */
2208 if (((mode & S_IWUGO) == 0) &&
2209 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2211 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2213 /* fix up mode if we're not using dynperm */
2214 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2215 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2216 } else if ((mode & S_IWUGO) &&
2217 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2219 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2220 /* Attributes of 0 are ignored */
2222 dosattr |= ATTR_NORMAL;
2224 /* reset local inode permissions to normal */
2225 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2226 attrs->ia_mode &= ~(S_IALLUGO);
2227 if (S_ISDIR(inode->i_mode))
2229 cifs_sb->mnt_dir_mode;
2232 cifs_sb->mnt_file_mode;
2234 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2235 /* ignore mode change - ATTR_READONLY hasn't changed */
2236 attrs->ia_valid &= ~ATTR_MODE;
2240 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2241 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2242 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2243 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2245 /* Even if error on time set, no sense failing the call if
2246 the server would set the time to a reasonable value anyway,
2247 and this check ensures that we are not being called from
2248 sys_utimes in which case we ought to fail the call back to
2249 the user when the server rejects the call */
2250 if ((rc) && (attrs->ia_valid &
2251 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2255 /* do not need local check to inode_check_ok since the server does
2258 goto cifs_setattr_exit;
2260 if ((attrs->ia_valid & ATTR_SIZE) &&
2261 attrs->ia_size != i_size_read(inode))
2262 truncate_setsize(inode, attrs->ia_size);
2264 setattr_copy(inode, attrs);
2265 mark_inode_dirty(inode);
2274 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2276 struct inode *inode = direntry->d_inode;
2277 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2278 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2280 if (pTcon->unix_ext)
2281 return cifs_setattr_unix(direntry, attrs);
2283 return cifs_setattr_nounix(direntry, attrs);
2285 /* BB: add cifs_setattr_legacy for really old servers */
2289 void cifs_delete_inode(struct inode *inode)
2291 cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2292 /* may have to add back in if and when safe distributed caching of
2293 directories added e.g. via FindNotify */