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, const bool is_dfs_referral)
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_NO_BRL)
48 inode->i_fop = &cifs_file_nobrl_ops;
49 else { /* not direct, send byte range locks */
50 inode->i_fop = &cifs_file_ops;
54 /* check if server can support readpages */
55 if (cifs_sb_tcon(cifs_sb)->ses->server->maxBuf <
56 PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
57 inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
59 inode->i_data.a_ops = &cifs_addr_ops;
62 #ifdef CONFIG_CIFS_DFS_UPCALL
63 if (is_dfs_referral) {
64 inode->i_op = &cifs_dfs_referral_inode_operations;
66 #else /* NO DFS support, treat as a directory */
69 inode->i_op = &cifs_dir_inode_ops;
70 inode->i_fop = &cifs_dir_ops;
74 inode->i_op = &cifs_symlink_inode_ops;
77 init_special_inode(inode, inode->i_mode, inode->i_rdev);
82 /* check inode attributes against fattr. If they don't match, tag the
83 * inode for cache invalidation
86 cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
88 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
90 cFYI(1, "%s: revalidating inode %llu", __func__, cifs_i->uniqueid);
92 if (inode->i_state & I_NEW) {
93 cFYI(1, "%s: inode %llu is new", __func__, cifs_i->uniqueid);
97 /* don't bother with revalidation if we have an oplock */
98 if (cifs_i->clientCanCacheRead) {
99 cFYI(1, "%s: inode %llu is oplocked", __func__,
104 /* revalidate if mtime or size have changed */
105 if (timespec_equal(&inode->i_mtime, &fattr->cf_mtime) &&
106 cifs_i->server_eof == fattr->cf_eof) {
107 cFYI(1, "%s: inode %llu is unchanged", __func__,
112 cFYI(1, "%s: invalidating inode %llu mapping", __func__,
114 cifs_i->invalid_mapping = true;
117 /* populate an inode with info from a cifs_fattr struct */
119 cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
121 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
122 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
123 unsigned long oldtime = cifs_i->time;
125 cifs_revalidate_cache(inode, fattr);
127 inode->i_atime = fattr->cf_atime;
128 inode->i_mtime = fattr->cf_mtime;
129 inode->i_ctime = fattr->cf_ctime;
130 inode->i_rdev = fattr->cf_rdev;
131 inode->i_nlink = fattr->cf_nlink;
132 inode->i_uid = fattr->cf_uid;
133 inode->i_gid = fattr->cf_gid;
135 /* if dynperm is set, don't clobber existing mode */
136 if (inode->i_state & I_NEW ||
137 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
138 inode->i_mode = fattr->cf_mode;
140 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
142 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
145 cifs_i->time = jiffies;
147 cFYI(1, "inode 0x%p old_time=%ld new_time=%ld", inode,
148 oldtime, cifs_i->time);
150 cifs_i->delete_pending = fattr->cf_flags & CIFS_FATTR_DELETE_PENDING;
152 cifs_i->server_eof = fattr->cf_eof;
154 * Can't safely change the file size here if the client is writing to
155 * it due to potential races.
157 spin_lock(&inode->i_lock);
158 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
159 i_size_write(inode, fattr->cf_eof);
162 * i_blocks is not related to (i_size / i_blksize),
163 * but instead 512 byte (2**9) size is required for
164 * calculating num blocks.
166 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
168 spin_unlock(&inode->i_lock);
170 cifs_set_ops(inode, fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL);
174 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
176 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
178 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
181 fattr->cf_uniqueid = iunique(sb, ROOT_I);
184 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
186 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
187 struct cifs_sb_info *cifs_sb)
189 memset(fattr, 0, sizeof(*fattr));
190 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
191 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
192 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
194 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
195 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
196 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
197 fattr->cf_mode = le64_to_cpu(info->Permissions);
200 * Since we set the inode type below we need to mask off
201 * to avoid strange results if bits set above.
203 fattr->cf_mode &= ~S_IFMT;
204 switch (le32_to_cpu(info->Type)) {
206 fattr->cf_mode |= S_IFREG;
207 fattr->cf_dtype = DT_REG;
210 fattr->cf_mode |= S_IFLNK;
211 fattr->cf_dtype = DT_LNK;
214 fattr->cf_mode |= S_IFDIR;
215 fattr->cf_dtype = DT_DIR;
218 fattr->cf_mode |= S_IFCHR;
219 fattr->cf_dtype = DT_CHR;
220 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
221 le64_to_cpu(info->DevMinor) & MINORMASK);
224 fattr->cf_mode |= S_IFBLK;
225 fattr->cf_dtype = DT_BLK;
226 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
227 le64_to_cpu(info->DevMinor) & MINORMASK);
230 fattr->cf_mode |= S_IFIFO;
231 fattr->cf_dtype = DT_FIFO;
234 fattr->cf_mode |= S_IFSOCK;
235 fattr->cf_dtype = DT_SOCK;
238 /* safest to call it a file if we do not know */
239 fattr->cf_mode |= S_IFREG;
240 fattr->cf_dtype = DT_REG;
241 cFYI(1, "unknown type %d", le32_to_cpu(info->Type));
245 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
246 fattr->cf_uid = cifs_sb->mnt_uid;
248 fattr->cf_uid = le64_to_cpu(info->Uid);
250 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
251 fattr->cf_gid = cifs_sb->mnt_gid;
253 fattr->cf_gid = le64_to_cpu(info->Gid);
255 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
259 * Fill a cifs_fattr struct with fake inode info.
261 * Needed to setup cifs_fattr data for the directory which is the
262 * junction to the new submount (ie to setup the fake directory
263 * which represents a DFS referral).
266 cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
268 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
270 cFYI(1, "creating fake fattr for DFS referral");
272 memset(fattr, 0, sizeof(*fattr));
273 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
274 fattr->cf_uid = cifs_sb->mnt_uid;
275 fattr->cf_gid = cifs_sb->mnt_gid;
276 fattr->cf_atime = CURRENT_TIME;
277 fattr->cf_ctime = CURRENT_TIME;
278 fattr->cf_mtime = CURRENT_TIME;
280 fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
283 int cifs_get_file_info_unix(struct file *filp)
287 FILE_UNIX_BASIC_INFO find_data;
288 struct cifs_fattr fattr;
289 struct inode *inode = filp->f_path.dentry->d_inode;
290 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
291 struct cifsFileInfo *cfile = filp->private_data;
292 struct cifsTconInfo *tcon = cfile->tcon;
295 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->netfid, &find_data);
297 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
298 } else if (rc == -EREMOTE) {
299 cifs_create_dfs_fattr(&fattr, inode->i_sb);
303 cifs_fattr_to_inode(inode, &fattr);
308 int cifs_get_inode_info_unix(struct inode **pinode,
309 const unsigned char *full_path,
310 struct super_block *sb, int xid)
313 FILE_UNIX_BASIC_INFO find_data;
314 struct cifs_fattr fattr;
315 struct cifsTconInfo *tcon;
316 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
318 tcon = cifs_sb_tcon(cifs_sb);
320 cFYI(1, "Getting info on %s", full_path);
322 /* could have done a find first instead but this returns more info */
323 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
324 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
325 CIFS_MOUNT_MAP_SPECIAL_CHR);
328 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
329 } else if (rc == -EREMOTE) {
330 cifs_create_dfs_fattr(&fattr, sb);
336 /* check for Minshall+French symlinks */
337 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
338 int tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
340 cFYI(1, "CIFSCheckMFSymlink: %d", tmprc);
343 if (*pinode == NULL) {
345 cifs_fill_uniqueid(sb, &fattr);
346 *pinode = cifs_iget(sb, &fattr);
350 /* we already have inode, update it */
351 cifs_fattr_to_inode(*pinode, &fattr);
358 cifs_sfu_type(struct cifs_fattr *fattr, const unsigned char *path,
359 struct cifs_sb_info *cifs_sb, int xid)
364 struct cifsTconInfo *pTcon = cifs_sb_tcon(cifs_sb);
366 unsigned int bytes_read;
371 fattr->cf_mode &= ~S_IFMT;
373 if (fattr->cf_eof == 0) {
374 fattr->cf_mode |= S_IFIFO;
375 fattr->cf_dtype = DT_FIFO;
377 } else if (fattr->cf_eof < 8) {
378 fattr->cf_mode |= S_IFREG;
379 fattr->cf_dtype = DT_REG;
380 return -EINVAL; /* EOPNOTSUPP? */
383 rc = CIFSSMBOpen(xid, pTcon, path, FILE_OPEN, GENERIC_READ,
384 CREATE_NOT_DIR, &netfid, &oplock, NULL,
386 cifs_sb->mnt_cifs_flags &
387 CIFS_MOUNT_MAP_SPECIAL_CHR);
389 int buf_type = CIFS_NO_BUFFER;
391 rc = CIFSSMBRead(xid, pTcon, netfid,
392 24 /* length */, 0 /* offset */,
393 &bytes_read, &pbuf, &buf_type);
394 if ((rc == 0) && (bytes_read >= 8)) {
395 if (memcmp("IntxBLK", pbuf, 8) == 0) {
396 cFYI(1, "Block device");
397 fattr->cf_mode |= S_IFBLK;
398 fattr->cf_dtype = DT_BLK;
399 if (bytes_read == 24) {
400 /* we have enough to decode dev num */
401 __u64 mjr; /* major */
402 __u64 mnr; /* minor */
403 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
404 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
405 fattr->cf_rdev = MKDEV(mjr, mnr);
407 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
408 cFYI(1, "Char device");
409 fattr->cf_mode |= S_IFCHR;
410 fattr->cf_dtype = DT_CHR;
411 if (bytes_read == 24) {
412 /* we have enough to decode dev num */
413 __u64 mjr; /* major */
414 __u64 mnr; /* minor */
415 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
416 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
417 fattr->cf_rdev = MKDEV(mjr, mnr);
419 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
421 fattr->cf_mode |= S_IFLNK;
422 fattr->cf_dtype = DT_LNK;
424 fattr->cf_mode |= S_IFREG; /* file? */
425 fattr->cf_dtype = DT_REG;
429 fattr->cf_mode |= S_IFREG; /* then it is a file */
430 fattr->cf_dtype = DT_REG;
431 rc = -EOPNOTSUPP; /* or some unknown SFU type */
433 CIFSSMBClose(xid, pTcon, netfid);
438 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
441 * Fetch mode bits as provided by SFU.
443 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
445 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
446 struct cifs_sb_info *cifs_sb, int xid)
448 #ifdef CONFIG_CIFS_XATTR
453 rc = CIFSSMBQAllEAs(xid, cifs_sb_tcon(cifs_sb), path, "SETFILEBITS",
454 ea_value, 4 /* size of buf */, cifs_sb->local_nls,
455 cifs_sb->mnt_cifs_flags &
456 CIFS_MOUNT_MAP_SPECIAL_CHR);
460 mode = le32_to_cpu(*((__le32 *)ea_value));
461 fattr->cf_mode &= ~SFBITS_MASK;
462 cFYI(1, "special bits 0%o org mode 0%o", mode,
464 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
465 cFYI(1, "special mode bits 0%o", mode);
474 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
476 cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
477 struct cifs_sb_info *cifs_sb, bool adjust_tz)
479 memset(fattr, 0, sizeof(*fattr));
480 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
481 if (info->DeletePending)
482 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
484 if (info->LastAccessTime)
485 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
487 fattr->cf_atime = CURRENT_TIME;
489 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
490 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
493 fattr->cf_ctime.tv_sec += cifs_sb_tcon(cifs_sb)->ses->server->timeAdj;
494 fattr->cf_mtime.tv_sec += cifs_sb_tcon(cifs_sb)->ses->server->timeAdj;
497 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
498 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
500 if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
501 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
502 fattr->cf_dtype = DT_DIR;
504 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
505 fattr->cf_dtype = DT_REG;
507 /* clear write bits if ATTR_READONLY is set */
508 if (fattr->cf_cifsattrs & ATTR_READONLY)
509 fattr->cf_mode &= ~(S_IWUGO);
512 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
514 fattr->cf_uid = cifs_sb->mnt_uid;
515 fattr->cf_gid = cifs_sb->mnt_gid;
518 int cifs_get_file_info(struct file *filp)
522 FILE_ALL_INFO find_data;
523 struct cifs_fattr fattr;
524 struct inode *inode = filp->f_path.dentry->d_inode;
525 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
526 struct cifsFileInfo *cfile = filp->private_data;
527 struct cifsTconInfo *tcon = cfile->tcon;
530 rc = CIFSSMBQFileInfo(xid, tcon, cfile->netfid, &find_data);
531 if (rc == -EOPNOTSUPP || rc == -EINVAL) {
533 * FIXME: legacy server -- fall back to path-based call?
534 * for now, just skip revalidating and mark inode for
538 CIFS_I(inode)->time = 0;
540 } else if (rc == -EREMOTE) {
541 cifs_create_dfs_fattr(&fattr, inode->i_sb);
547 * don't bother with SFU junk here -- just mark inode as needing
550 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false);
551 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
552 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
553 cifs_fattr_to_inode(inode, &fattr);
559 int cifs_get_inode_info(struct inode **pinode,
560 const unsigned char *full_path, FILE_ALL_INFO *pfindData,
561 struct super_block *sb, int xid, const __u16 *pfid)
564 struct cifsTconInfo *pTcon;
565 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
567 bool adjustTZ = false;
568 struct cifs_fattr fattr;
570 pTcon = cifs_sb_tcon(cifs_sb);
571 cFYI(1, "Getting info on %s", full_path);
573 if ((pfindData == NULL) && (*pinode != NULL)) {
574 if (CIFS_I(*pinode)->clientCanCacheRead) {
575 cFYI(1, "No need to revalidate cached inode sizes");
580 /* if file info not passed in then get it from server */
581 if (pfindData == NULL) {
582 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
585 pfindData = (FILE_ALL_INFO *)buf;
587 /* could do find first instead but this returns more info */
588 rc = CIFSSMBQPathInfo(xid, pTcon, full_path, pfindData,
590 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
591 CIFS_MOUNT_MAP_SPECIAL_CHR);
592 /* BB optimize code so we do not make the above call
593 when server claims no NT SMB support and the above call
594 failed at least once - set flag in tcon or mount */
595 if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
596 rc = SMBQueryInformation(xid, pTcon, full_path,
597 pfindData, cifs_sb->local_nls,
598 cifs_sb->mnt_cifs_flags &
599 CIFS_MOUNT_MAP_SPECIAL_CHR);
605 cifs_all_info_to_fattr(&fattr, (FILE_ALL_INFO *) pfindData,
607 } else if (rc == -EREMOTE) {
608 cifs_create_dfs_fattr(&fattr, sb);
615 * If an inode wasn't passed in, then get the inode number
617 * Is an i_ino of zero legal? Can we use that to check if the server
618 * supports returning inode numbers? Are there other sanity checks we
619 * can use to ensure that the server is really filling in that field?
621 * We can not use the IndexNumber field by default from Windows or
622 * Samba (in ALL_INFO buf) but we can request it explicitly. The SNIA
623 * CIFS spec claims that this value is unique within the scope of a
624 * share, and the windows docs hint that it's actually unique
627 * There may be higher info levels that work but are there Windows
628 * server or network appliances for which IndexNumber field is not
631 if (*pinode == NULL) {
632 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
635 rc1 = CIFSGetSrvInodeNumber(xid, pTcon,
636 full_path, &fattr.cf_uniqueid,
638 cifs_sb->mnt_cifs_flags &
639 CIFS_MOUNT_MAP_SPECIAL_CHR);
640 if (rc1 || !fattr.cf_uniqueid) {
641 cFYI(1, "GetSrvInodeNum rc %d", rc1);
642 fattr.cf_uniqueid = iunique(sb, ROOT_I);
643 cifs_autodisable_serverino(cifs_sb);
646 fattr.cf_uniqueid = iunique(sb, ROOT_I);
649 fattr.cf_uniqueid = CIFS_I(*pinode)->uniqueid;
652 /* query for SFU type info if supported and needed */
653 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
654 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
655 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
657 cFYI(1, "cifs_sfu_type failed: %d", tmprc);
660 #ifdef CONFIG_CIFS_EXPERIMENTAL
661 /* fill in 0777 bits from ACL */
662 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
663 cFYI(1, "Getting mode bits from ACL");
664 cifs_acl_to_fattr(cifs_sb, &fattr, *pinode, full_path, pfid);
668 /* fill in remaining high mode bits e.g. SUID, VTX */
669 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
670 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
672 /* check for Minshall+French symlinks */
673 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
674 tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
676 cFYI(1, "CIFSCheckMFSymlink: %d", tmprc);
680 *pinode = cifs_iget(sb, &fattr);
684 cifs_fattr_to_inode(*pinode, &fattr);
692 static const struct inode_operations cifs_ipc_inode_ops = {
693 .lookup = cifs_lookup,
696 char *cifs_build_path_to_root(struct cifs_sb_info *cifs_sb)
698 int pplen = cifs_sb->prepathlen;
700 char *full_path = NULL;
702 /* if no prefix path, simply set path to the root of share to "" */
704 full_path = kmalloc(1, GFP_KERNEL);
710 if (cifs_sb_tcon(cifs_sb) && (cifs_sb_tcon(cifs_sb)->Flags & SMB_SHARE_IS_IN_DFS))
711 dfsplen = strnlen(cifs_sb_tcon(cifs_sb)->treeName, MAX_TREE_SIZE + 1);
715 full_path = kmalloc(dfsplen + pplen + 1, GFP_KERNEL);
716 if (full_path == NULL)
720 strncpy(full_path, cifs_sb_tcon(cifs_sb)->treeName, dfsplen);
721 /* switch slash direction in prepath depending on whether
722 * windows or posix style path names
724 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
726 for (i = 0; i < dfsplen; i++) {
727 if (full_path[i] == '\\')
732 strncpy(full_path + dfsplen, cifs_sb->prepath, pplen);
733 full_path[dfsplen + pplen] = 0; /* add trailing null */
738 cifs_find_inode(struct inode *inode, void *opaque)
740 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
742 /* don't match inode with different uniqueid */
743 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
746 /* don't match inode of different type */
747 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
750 /* if it's not a directory or has no dentries, then flag it */
751 if (S_ISDIR(inode->i_mode) && !list_empty(&inode->i_dentry))
752 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
758 cifs_init_inode(struct inode *inode, void *opaque)
760 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
762 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
767 * walk dentry list for an inode and report whether it has aliases that
768 * are hashed. We use this to determine if a directory inode can actually
772 inode_has_hashed_dentries(struct inode *inode)
774 struct dentry *dentry;
776 spin_lock(&dcache_lock);
777 list_for_each_entry(dentry, &inode->i_dentry, d_alias) {
778 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
779 spin_unlock(&dcache_lock);
783 spin_unlock(&dcache_lock);
787 /* Given fattrs, get a corresponding inode */
789 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
795 cFYI(1, "looking for uniqueid=%llu", fattr->cf_uniqueid);
797 /* hash down to 32-bits on 32-bit arch */
798 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
800 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
802 /* was there a potentially problematic inode collision? */
803 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
804 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
806 if (inode_has_hashed_dentries(inode)) {
807 cifs_autodisable_serverino(CIFS_SB(sb));
809 fattr->cf_uniqueid = iunique(sb, ROOT_I);
810 goto retry_iget5_locked;
814 cifs_fattr_to_inode(inode, fattr);
815 if (sb->s_flags & MS_NOATIME)
816 inode->i_flags |= S_NOATIME | S_NOCMTIME;
817 if (inode->i_state & I_NEW) {
819 #ifdef CONFIG_CIFS_FSCACHE
820 /* initialize per-inode cache cookie pointer */
821 CIFS_I(inode)->fscache = NULL;
823 unlock_new_inode(inode);
830 /* gets root inode */
831 struct inode *cifs_root_iget(struct super_block *sb, unsigned long ino)
834 struct cifs_sb_info *cifs_sb;
835 struct inode *inode = NULL;
839 cifs_sb = CIFS_SB(sb);
840 full_path = cifs_build_path_to_root(cifs_sb);
841 if (full_path == NULL)
842 return ERR_PTR(-ENOMEM);
845 if (cifs_sb_tcon(cifs_sb)->unix_ext)
846 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
848 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
854 #ifdef CONFIG_CIFS_FSCACHE
855 /* populate tcon->resource_id */
856 cifs_sb_tcon(cifs_sb)->resource_id = CIFS_I(inode)->uniqueid;
859 if (rc && cifs_sb_tcon(cifs_sb)->ipc) {
860 cFYI(1, "ipc connection - fake read inode");
861 inode->i_mode |= S_IFDIR;
863 inode->i_op = &cifs_ipc_inode_ops;
864 inode->i_fop = &simple_dir_operations;
865 inode->i_uid = cifs_sb->mnt_uid;
866 inode->i_gid = cifs_sb->mnt_gid;
876 /* can not call macro FreeXid here since in a void func
877 * TODO: This is no longer true
884 cifs_set_file_info(struct inode *inode, struct iattr *attrs, int xid,
885 char *full_path, __u32 dosattr)
891 bool set_time = false;
892 struct cifsFileInfo *open_file;
893 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
894 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
895 struct cifsTconInfo *pTcon;
896 FILE_BASIC_INFO info_buf;
901 if (attrs->ia_valid & ATTR_ATIME) {
903 info_buf.LastAccessTime =
904 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
906 info_buf.LastAccessTime = 0;
908 if (attrs->ia_valid & ATTR_MTIME) {
910 info_buf.LastWriteTime =
911 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
913 info_buf.LastWriteTime = 0;
916 * Samba throws this field away, but windows may actually use it.
917 * Do not set ctime unless other time stamps are changed explicitly
918 * (i.e. by utimes()) since we would then have a mix of client and
921 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
922 cFYI(1, "CIFS - CTIME changed");
923 info_buf.ChangeTime =
924 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
926 info_buf.ChangeTime = 0;
928 info_buf.CreationTime = 0; /* don't change */
929 info_buf.Attributes = cpu_to_le32(dosattr);
932 * If the file is already open for write, just use that fileid
934 open_file = find_writable_file(cifsInode);
936 netfid = open_file->netfid;
937 netpid = open_file->pid;
938 pTcon = open_file->tcon;
939 goto set_via_filehandle;
942 pTcon = cifs_sb_tcon(cifs_sb);
945 * NT4 apparently returns success on this call, but it doesn't
948 if (!(pTcon->ses->flags & CIFS_SES_NT4)) {
949 rc = CIFSSMBSetPathInfo(xid, pTcon, full_path,
950 &info_buf, cifs_sb->local_nls,
951 cifs_sb->mnt_cifs_flags &
952 CIFS_MOUNT_MAP_SPECIAL_CHR);
954 cifsInode->cifsAttrs = dosattr;
956 } else if (rc != -EOPNOTSUPP && rc != -EINVAL)
960 cFYI(1, "calling SetFileInfo since SetPathInfo for "
961 "times not supported by this server");
962 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
963 SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
964 CREATE_NOT_DIR, &netfid, &oplock,
965 NULL, cifs_sb->local_nls,
966 cifs_sb->mnt_cifs_flags &
967 CIFS_MOUNT_MAP_SPECIAL_CHR);
975 netpid = current->tgid;
978 rc = CIFSSMBSetFileInfo(xid, pTcon, &info_buf, netfid, netpid);
980 cifsInode->cifsAttrs = dosattr;
982 if (open_file == NULL)
983 CIFSSMBClose(xid, pTcon, netfid);
985 cifsFileInfo_put(open_file);
991 * open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
992 * and rename it to a random name that hopefully won't conflict with
996 cifs_rename_pending_delete(char *full_path, struct dentry *dentry, int xid)
1001 struct inode *inode = dentry->d_inode;
1002 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1003 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1004 struct cifsTconInfo *tcon = cifs_sb_tcon(cifs_sb);
1005 __u32 dosattr, origattr;
1006 FILE_BASIC_INFO *info_buf = NULL;
1008 rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
1009 DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
1010 &netfid, &oplock, NULL, cifs_sb->local_nls,
1011 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1015 origattr = cifsInode->cifsAttrs;
1017 origattr |= ATTR_NORMAL;
1019 dosattr = origattr & ~ATTR_READONLY;
1021 dosattr |= ATTR_NORMAL;
1022 dosattr |= ATTR_HIDDEN;
1024 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1025 if (dosattr != origattr) {
1026 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1027 if (info_buf == NULL) {
1031 info_buf->Attributes = cpu_to_le32(dosattr);
1032 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1034 /* although we would like to mark the file hidden
1035 if that fails we will still try to rename it */
1037 cifsInode->cifsAttrs = dosattr;
1039 dosattr = origattr; /* since not able to change them */
1042 /* rename the file */
1043 rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
1044 cifs_sb->mnt_cifs_flags &
1045 CIFS_MOUNT_MAP_SPECIAL_CHR);
1051 /* try to set DELETE_ON_CLOSE */
1052 if (!cifsInode->delete_pending) {
1053 rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
1056 * some samba versions return -ENOENT when we try to set the
1057 * file disposition here. Likely a samba bug, but work around
1058 * it for now. This means that some cifsXXX files may hang
1059 * around after they shouldn't.
1061 * BB: remove this hack after more servers have the fix
1069 cifsInode->delete_pending = true;
1073 CIFSSMBClose(xid, tcon, netfid);
1079 * reset everything back to the original state. Don't bother
1080 * dealing with errors here since we can't do anything about
1084 CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
1085 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1086 CIFS_MOUNT_MAP_SPECIAL_CHR);
1088 if (dosattr != origattr) {
1089 info_buf->Attributes = cpu_to_le32(origattr);
1090 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1092 cifsInode->cifsAttrs = origattr;
1100 * If dentry->d_inode is null (usually meaning the cached dentry
1101 * is a negative dentry) then we would attempt a standard SMB delete, but
1102 * if that fails we can not attempt the fall back mechanisms on EACCESS
1103 * but will return the EACCESS to the caller. Note that the VFS does not call
1104 * unlink on negative dentries currently.
1106 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1110 char *full_path = NULL;
1111 struct inode *inode = dentry->d_inode;
1112 struct cifsInodeInfo *cifs_inode;
1113 struct super_block *sb = dir->i_sb;
1114 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1115 struct cifsTconInfo *tcon = cifs_sb_tcon(cifs_sb);
1116 struct iattr *attrs = NULL;
1117 __u32 dosattr = 0, origattr = 0;
1119 cFYI(1, "cifs_unlink, dir=0x%p, dentry=0x%p", dir, dentry);
1123 /* Unlink can be called from rename so we can not take the
1124 * sb->s_vfs_rename_mutex here */
1125 full_path = build_path_from_dentry(dentry);
1126 if (full_path == NULL) {
1132 if ((tcon->ses->capabilities & CAP_UNIX) &&
1133 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1134 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1135 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1136 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1137 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1138 cFYI(1, "posix del rc %d", rc);
1139 if ((rc == 0) || (rc == -ENOENT))
1140 goto psx_del_no_retry;
1144 rc = CIFSSMBDelFile(xid, tcon, full_path, cifs_sb->local_nls,
1145 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1151 } else if (rc == -ENOENT) {
1153 } else if (rc == -ETXTBSY) {
1154 rc = cifs_rename_pending_delete(full_path, dentry, xid);
1157 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1158 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1159 if (attrs == NULL) {
1164 /* try to reset dos attributes */
1165 cifs_inode = CIFS_I(inode);
1166 origattr = cifs_inode->cifsAttrs;
1168 origattr |= ATTR_NORMAL;
1169 dosattr = origattr & ~ATTR_READONLY;
1171 dosattr |= ATTR_NORMAL;
1172 dosattr |= ATTR_HIDDEN;
1174 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1178 goto retry_std_delete;
1181 /* undo the setattr if we errored out and it's needed */
1182 if (rc != 0 && dosattr != 0)
1183 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1187 cifs_inode = CIFS_I(inode);
1188 cifs_inode->time = 0; /* will force revalidate to get info
1190 inode->i_ctime = current_fs_time(sb);
1192 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1193 cifs_inode = CIFS_I(dir);
1194 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1202 int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
1206 struct cifs_sb_info *cifs_sb;
1207 struct cifsTconInfo *pTcon;
1208 char *full_path = NULL;
1209 struct inode *newinode = NULL;
1210 struct cifs_fattr fattr;
1212 cFYI(1, "In cifs_mkdir, mode = 0x%x inode = 0x%p", mode, inode);
1216 cifs_sb = CIFS_SB(inode->i_sb);
1217 pTcon = cifs_sb_tcon(cifs_sb);
1219 full_path = build_path_from_dentry(direntry);
1220 if (full_path == NULL) {
1226 if ((pTcon->ses->capabilities & CAP_UNIX) &&
1227 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1228 le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
1230 FILE_UNIX_BASIC_INFO *pInfo =
1231 kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1232 if (pInfo == NULL) {
1237 mode &= ~current_umask();
1238 rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
1239 mode, NULL /* netfid */, pInfo, &oplock,
1240 full_path, cifs_sb->local_nls,
1241 cifs_sb->mnt_cifs_flags &
1242 CIFS_MOUNT_MAP_SPECIAL_CHR);
1243 if (rc == -EOPNOTSUPP) {
1245 goto mkdir_retry_old;
1247 cFYI(1, "posix mkdir returned 0x%x", rc);
1250 if (pInfo->Type == cpu_to_le32(-1)) {
1251 /* no return info, go query for it */
1253 goto mkdir_get_info;
1255 /*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
1259 direntry->d_op = &cifs_ci_dentry_ops;
1261 direntry->d_op = &cifs_dentry_ops;
1263 cifs_unix_basic_to_fattr(&fattr, pInfo, cifs_sb);
1264 cifs_fill_uniqueid(inode->i_sb, &fattr);
1265 newinode = cifs_iget(inode->i_sb, &fattr);
1268 goto mkdir_get_info;
1271 d_instantiate(direntry, newinode);
1273 #ifdef CONFIG_CIFS_DEBUG2
1274 cFYI(1, "instantiated dentry %p %s to inode %p",
1275 direntry, direntry->d_name.name, newinode);
1277 if (newinode->i_nlink != 2)
1278 cFYI(1, "unexpected number of links %d",
1286 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1287 rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
1288 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1290 cFYI(1, "cifs_mkdir returned 0x%x", rc);
1295 if (pTcon->unix_ext)
1296 rc = cifs_get_inode_info_unix(&newinode, full_path,
1299 rc = cifs_get_inode_info(&newinode, full_path, NULL,
1300 inode->i_sb, xid, NULL);
1303 direntry->d_op = &cifs_ci_dentry_ops;
1305 direntry->d_op = &cifs_dentry_ops;
1306 d_instantiate(direntry, newinode);
1307 /* setting nlink not necessary except in cases where we
1308 * failed to get it from the server or was set bogus */
1309 if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
1310 direntry->d_inode->i_nlink = 2;
1312 mode &= ~current_umask();
1313 /* must turn on setgid bit if parent dir has it */
1314 if (inode->i_mode & S_ISGID)
1317 if (pTcon->unix_ext) {
1318 struct cifs_unix_set_info_args args = {
1320 .ctime = NO_CHANGE_64,
1321 .atime = NO_CHANGE_64,
1322 .mtime = NO_CHANGE_64,
1325 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1326 args.uid = (__u64)current_fsuid();
1327 if (inode->i_mode & S_ISGID)
1328 args.gid = (__u64)inode->i_gid;
1330 args.gid = (__u64)current_fsgid();
1332 args.uid = NO_CHANGE_64;
1333 args.gid = NO_CHANGE_64;
1335 CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
1337 cifs_sb->mnt_cifs_flags &
1338 CIFS_MOUNT_MAP_SPECIAL_CHR);
1340 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1341 (mode & S_IWUGO) == 0) {
1342 FILE_BASIC_INFO pInfo;
1343 struct cifsInodeInfo *cifsInode;
1346 memset(&pInfo, 0, sizeof(pInfo));
1347 cifsInode = CIFS_I(newinode);
1348 dosattrs = cifsInode->cifsAttrs|ATTR_READONLY;
1349 pInfo.Attributes = cpu_to_le32(dosattrs);
1350 tmprc = CIFSSMBSetPathInfo(xid, pTcon,
1353 cifs_sb->mnt_cifs_flags &
1354 CIFS_MOUNT_MAP_SPECIAL_CHR);
1356 cifsInode->cifsAttrs = dosattrs;
1358 if (direntry->d_inode) {
1359 if (cifs_sb->mnt_cifs_flags &
1361 direntry->d_inode->i_mode =
1364 if (cifs_sb->mnt_cifs_flags &
1365 CIFS_MOUNT_SET_UID) {
1366 direntry->d_inode->i_uid =
1368 if (inode->i_mode & S_ISGID)
1369 direntry->d_inode->i_gid =
1372 direntry->d_inode->i_gid =
1384 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1388 struct cifs_sb_info *cifs_sb;
1389 struct cifsTconInfo *pTcon;
1390 char *full_path = NULL;
1391 struct cifsInodeInfo *cifsInode;
1393 cFYI(1, "cifs_rmdir, inode = 0x%p", inode);
1397 cifs_sb = CIFS_SB(inode->i_sb);
1398 pTcon = cifs_sb_tcon(cifs_sb);
1400 full_path = build_path_from_dentry(direntry);
1401 if (full_path == NULL) {
1407 rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
1408 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1412 spin_lock(&direntry->d_inode->i_lock);
1413 i_size_write(direntry->d_inode, 0);
1414 clear_nlink(direntry->d_inode);
1415 spin_unlock(&direntry->d_inode->i_lock);
1418 cifsInode = CIFS_I(direntry->d_inode);
1419 cifsInode->time = 0; /* force revalidate to go get info when
1422 cifsInode = CIFS_I(inode);
1423 cifsInode->time = 0; /* force revalidate to get parent dir info
1424 since cached search results now invalid */
1426 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1427 current_fs_time(inode->i_sb);
1435 cifs_do_rename(int xid, struct dentry *from_dentry, const char *fromPath,
1436 struct dentry *to_dentry, const char *toPath)
1438 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1439 struct cifsTconInfo *pTcon = cifs_sb_tcon(cifs_sb);
1443 /* try path-based rename first */
1444 rc = CIFSSMBRename(xid, pTcon, fromPath, toPath, cifs_sb->local_nls,
1445 cifs_sb->mnt_cifs_flags &
1446 CIFS_MOUNT_MAP_SPECIAL_CHR);
1449 * don't bother with rename by filehandle unless file is busy and
1450 * source Note that cross directory moves do not work with
1451 * rename by filehandle to various Windows servers.
1453 if (rc == 0 || rc != -ETXTBSY)
1456 /* open-file renames don't work across directories */
1457 if (to_dentry->d_parent != from_dentry->d_parent)
1460 /* open the file to be renamed -- we need DELETE perms */
1461 rc = CIFSSMBOpen(xid, pTcon, fromPath, FILE_OPEN, DELETE,
1462 CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1463 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1464 CIFS_MOUNT_MAP_SPECIAL_CHR);
1467 rc = CIFSSMBRenameOpenFile(xid, pTcon, srcfid,
1468 (const char *) to_dentry->d_name.name,
1469 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1470 CIFS_MOUNT_MAP_SPECIAL_CHR);
1472 CIFSSMBClose(xid, pTcon, srcfid);
1478 int cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1479 struct inode *target_dir, struct dentry *target_dentry)
1481 char *fromName = NULL;
1482 char *toName = NULL;
1483 struct cifs_sb_info *cifs_sb;
1484 struct cifsTconInfo *tcon;
1485 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1486 FILE_UNIX_BASIC_INFO *info_buf_target;
1489 cifs_sb = CIFS_SB(source_dir->i_sb);
1490 tcon = cifs_sb_tcon(cifs_sb);
1495 * we already have the rename sem so we do not need to
1496 * grab it again here to protect the path integrity
1498 fromName = build_path_from_dentry(source_dentry);
1499 if (fromName == NULL) {
1501 goto cifs_rename_exit;
1504 toName = build_path_from_dentry(target_dentry);
1505 if (toName == NULL) {
1507 goto cifs_rename_exit;
1510 rc = cifs_do_rename(xid, source_dentry, fromName,
1511 target_dentry, toName);
1513 if (rc == -EEXIST && tcon->unix_ext) {
1515 * Are src and dst hardlinks of same inode? We can
1516 * only tell with unix extensions enabled
1519 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1521 if (info_buf_source == NULL) {
1523 goto cifs_rename_exit;
1526 info_buf_target = info_buf_source + 1;
1527 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, fromName,
1530 cifs_sb->mnt_cifs_flags &
1531 CIFS_MOUNT_MAP_SPECIAL_CHR);
1535 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, toName,
1538 cifs_sb->mnt_cifs_flags &
1539 CIFS_MOUNT_MAP_SPECIAL_CHR);
1541 if (tmprc == 0 && (info_buf_source->UniqueId ==
1542 info_buf_target->UniqueId)) {
1543 /* same file, POSIX says that this is a noop */
1545 goto cifs_rename_exit;
1547 } /* else ... BB we could add the same check for Windows by
1548 checking the UniqueId via FILE_INTERNAL_INFO */
1551 /* Try unlinking the target dentry if it's not negative */
1552 if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
1553 tmprc = cifs_unlink(target_dir, target_dentry);
1555 goto cifs_rename_exit;
1557 rc = cifs_do_rename(xid, source_dentry, fromName,
1558 target_dentry, toName);
1562 kfree(info_buf_source);
1570 cifs_inode_needs_reval(struct inode *inode)
1572 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1574 if (cifs_i->clientCanCacheRead)
1577 if (!lookupCacheEnabled)
1580 if (cifs_i->time == 0)
1583 /* FIXME: the actimeo should be tunable */
1584 if (time_after_eq(jiffies, cifs_i->time + HZ))
1587 /* hardlinked files w/ noserverino get "special" treatment */
1588 if (!(CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1589 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1595 /* check invalid_mapping flag and zap the cache if it's set */
1597 cifs_invalidate_mapping(struct inode *inode)
1600 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1602 cifs_i->invalid_mapping = false;
1604 /* write back any cached data */
1605 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1606 rc = filemap_write_and_wait(inode->i_mapping);
1608 cifs_i->write_behind_rc = rc;
1610 invalidate_remote_inode(inode);
1611 cifs_fscache_reset_inode_cookie(inode);
1614 int cifs_revalidate_file(struct file *filp)
1617 struct inode *inode = filp->f_path.dentry->d_inode;
1618 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1620 if (!cifs_inode_needs_reval(inode))
1623 if (cfile->tcon->unix_ext)
1624 rc = cifs_get_file_info_unix(filp);
1626 rc = cifs_get_file_info(filp);
1629 if (CIFS_I(inode)->invalid_mapping)
1630 cifs_invalidate_mapping(inode);
1635 /* revalidate a dentry's inode attributes */
1636 int cifs_revalidate_dentry(struct dentry *dentry)
1640 char *full_path = NULL;
1641 struct inode *inode = dentry->d_inode;
1642 struct super_block *sb = dentry->d_sb;
1649 if (!cifs_inode_needs_reval(inode))
1652 /* can not safely grab the rename sem here if rename calls revalidate
1653 since that would deadlock */
1654 full_path = build_path_from_dentry(dentry);
1655 if (full_path == NULL) {
1660 cFYI(1, "Revalidate: %s inode 0x%p count %d dentry: 0x%p d_time %ld "
1661 "jiffies %ld", full_path, inode, inode->i_count.counter,
1662 dentry, dentry->d_time, jiffies);
1664 if (cifs_sb_tcon(CIFS_SB(sb))->unix_ext)
1665 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1667 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1671 if (CIFS_I(inode)->invalid_mapping)
1672 cifs_invalidate_mapping(inode);
1679 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1682 int err = cifs_revalidate_dentry(dentry);
1684 generic_fillattr(dentry->d_inode, stat);
1685 stat->blksize = CIFS_MAX_MSGSIZE;
1686 stat->ino = CIFS_I(dentry->d_inode)->uniqueid;
1691 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1693 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1694 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1698 page = grab_cache_page(mapping, index);
1702 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1704 page_cache_release(page);
1708 static void cifs_setsize(struct inode *inode, loff_t offset)
1712 spin_lock(&inode->i_lock);
1713 oldsize = inode->i_size;
1714 i_size_write(inode, offset);
1715 spin_unlock(&inode->i_lock);
1717 truncate_pagecache(inode, oldsize, offset);
1721 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1722 int xid, char *full_path)
1725 struct cifsFileInfo *open_file;
1726 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1727 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1728 struct cifsTconInfo *pTcon = NULL;
1731 * To avoid spurious oplock breaks from server, in the case of
1732 * inodes that we already have open, avoid doing path based
1733 * setting of file size if we can do it by handle.
1734 * This keeps our caching token (oplock) and avoids timeouts
1735 * when the local oplock break takes longer to flush
1736 * writebehind data than the SMB timeout for the SetPathInfo
1737 * request would allow
1739 open_file = find_writable_file(cifsInode);
1741 __u16 nfid = open_file->netfid;
1742 __u32 npid = open_file->pid;
1743 pTcon = open_file->tcon;
1744 rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size, nfid,
1746 cifsFileInfo_put(open_file);
1747 cFYI(1, "SetFSize for attrs rc = %d", rc);
1748 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1749 unsigned int bytes_written;
1750 rc = CIFSSMBWrite(xid, pTcon, nfid, 0, attrs->ia_size,
1751 &bytes_written, NULL, NULL, 1);
1752 cFYI(1, "Wrt seteof rc %d", rc);
1759 pTcon = cifs_sb_tcon(cifs_sb);
1761 /* Set file size by pathname rather than by handle
1762 either because no valid, writeable file handle for
1763 it was found or because there was an error setting
1765 rc = CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size,
1766 false, cifs_sb->local_nls,
1767 cifs_sb->mnt_cifs_flags &
1768 CIFS_MOUNT_MAP_SPECIAL_CHR);
1769 cFYI(1, "SetEOF by path (setattrs) rc = %d", rc);
1770 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1774 rc = SMBLegacyOpen(xid, pTcon, full_path,
1775 FILE_OPEN, GENERIC_WRITE,
1776 CREATE_NOT_DIR, &netfid, &oplock, NULL,
1778 cifs_sb->mnt_cifs_flags &
1779 CIFS_MOUNT_MAP_SPECIAL_CHR);
1781 unsigned int bytes_written;
1782 rc = CIFSSMBWrite(xid, pTcon, netfid, 0,
1784 &bytes_written, NULL,
1786 cFYI(1, "wrt seteof rc %d", rc);
1787 CIFSSMBClose(xid, pTcon, netfid);
1793 cifsInode->server_eof = attrs->ia_size;
1794 cifs_setsize(inode, attrs->ia_size);
1795 cifs_truncate_page(inode->i_mapping, inode->i_size);
1802 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1806 char *full_path = NULL;
1807 struct inode *inode = direntry->d_inode;
1808 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1809 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1810 struct cifsTconInfo *pTcon;
1811 struct cifs_unix_set_info_args *args = NULL;
1812 struct cifsFileInfo *open_file;
1814 cFYI(1, "setattr_unix on file %s attrs->ia_valid=0x%x",
1815 direntry->d_name.name, attrs->ia_valid);
1819 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
1820 attrs->ia_valid |= ATTR_FORCE;
1822 rc = inode_change_ok(inode, attrs);
1826 full_path = build_path_from_dentry(direntry);
1827 if (full_path == NULL) {
1833 * Attempt to flush data before changing attributes. We need to do
1834 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1835 * ownership or mode then we may also need to do this. Here, we take
1836 * the safe way out and just do the flush on all setattr requests. If
1837 * the flush returns error, store it to report later and continue.
1839 * BB: This should be smarter. Why bother flushing pages that
1840 * will be truncated anyway? Also, should we error out here if
1841 * the flush returns error?
1843 rc = filemap_write_and_wait(inode->i_mapping);
1845 cifsInode->write_behind_rc = rc;
1849 if (attrs->ia_valid & ATTR_SIZE) {
1850 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1855 /* skip mode change if it's just for clearing setuid/setgid */
1856 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1857 attrs->ia_valid &= ~ATTR_MODE;
1859 args = kmalloc(sizeof(*args), GFP_KERNEL);
1865 /* set up the struct */
1866 if (attrs->ia_valid & ATTR_MODE)
1867 args->mode = attrs->ia_mode;
1869 args->mode = NO_CHANGE_64;
1871 if (attrs->ia_valid & ATTR_UID)
1872 args->uid = attrs->ia_uid;
1874 args->uid = NO_CHANGE_64;
1876 if (attrs->ia_valid & ATTR_GID)
1877 args->gid = attrs->ia_gid;
1879 args->gid = NO_CHANGE_64;
1881 if (attrs->ia_valid & ATTR_ATIME)
1882 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
1884 args->atime = NO_CHANGE_64;
1886 if (attrs->ia_valid & ATTR_MTIME)
1887 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
1889 args->mtime = NO_CHANGE_64;
1891 if (attrs->ia_valid & ATTR_CTIME)
1892 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
1894 args->ctime = NO_CHANGE_64;
1897 open_file = find_writable_file(cifsInode);
1899 u16 nfid = open_file->netfid;
1900 u32 npid = open_file->pid;
1901 pTcon = open_file->tcon;
1902 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
1903 cifsFileInfo_put(open_file);
1905 pTcon = cifs_sb_tcon(cifs_sb);
1906 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
1908 cifs_sb->mnt_cifs_flags &
1909 CIFS_MOUNT_MAP_SPECIAL_CHR);
1915 if ((attrs->ia_valid & ATTR_SIZE) &&
1916 attrs->ia_size != i_size_read(inode))
1917 truncate_setsize(inode, attrs->ia_size);
1919 setattr_copy(inode, attrs);
1920 mark_inode_dirty(inode);
1922 /* force revalidate when any of these times are set since some
1923 of the fs types (eg ext3, fat) do not have fine enough
1924 time granularity to match protocol, and we do not have a
1925 a way (yet) to query the server fs's time granularity (and
1926 whether it rounds times down).
1928 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
1929 cifsInode->time = 0;
1938 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
1941 struct inode *inode = direntry->d_inode;
1942 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1943 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1944 char *full_path = NULL;
1947 __u64 mode = NO_CHANGE_64;
1951 cFYI(1, "setattr on file %s attrs->iavalid 0x%x",
1952 direntry->d_name.name, attrs->ia_valid);
1954 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
1955 attrs->ia_valid |= ATTR_FORCE;
1957 rc = inode_change_ok(inode, attrs);
1963 full_path = build_path_from_dentry(direntry);
1964 if (full_path == NULL) {
1971 * Attempt to flush data before changing attributes. We need to do
1972 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1973 * ownership or mode then we may also need to do this. Here, we take
1974 * the safe way out and just do the flush on all setattr requests. If
1975 * the flush returns error, store it to report later and continue.
1977 * BB: This should be smarter. Why bother flushing pages that
1978 * will be truncated anyway? Also, should we error out here if
1979 * the flush returns error?
1981 rc = filemap_write_and_wait(inode->i_mapping);
1983 cifsInode->write_behind_rc = rc;
1987 if (attrs->ia_valid & ATTR_SIZE) {
1988 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1990 goto cifs_setattr_exit;
1994 * Without unix extensions we can't send ownership changes to the
1995 * server, so silently ignore them. This is consistent with how
1996 * local DOS/Windows filesystems behave (VFAT, NTFS, etc). With
1997 * CIFSACL support + proper Windows to Unix idmapping, we may be
1998 * able to support this in the future.
2000 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2001 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2003 /* skip mode change if it's just for clearing setuid/setgid */
2004 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2005 attrs->ia_valid &= ~ATTR_MODE;
2007 if (attrs->ia_valid & ATTR_MODE) {
2008 cFYI(1, "Mode changed to 0%o", attrs->ia_mode);
2009 mode = attrs->ia_mode;
2012 if (attrs->ia_valid & ATTR_MODE) {
2014 #ifdef CONFIG_CIFS_EXPERIMENTAL
2015 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
2016 rc = mode_to_acl(inode, full_path, mode);
2019 if (((mode & S_IWUGO) == 0) &&
2020 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2022 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2024 /* fix up mode if we're not using dynperm */
2025 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2026 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2027 } else if ((mode & S_IWUGO) &&
2028 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2030 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2031 /* Attributes of 0 are ignored */
2033 dosattr |= ATTR_NORMAL;
2035 /* reset local inode permissions to normal */
2036 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2037 attrs->ia_mode &= ~(S_IALLUGO);
2038 if (S_ISDIR(inode->i_mode))
2040 cifs_sb->mnt_dir_mode;
2043 cifs_sb->mnt_file_mode;
2045 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2046 /* ignore mode change - ATTR_READONLY hasn't changed */
2047 attrs->ia_valid &= ~ATTR_MODE;
2051 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2052 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2053 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2054 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2056 /* Even if error on time set, no sense failing the call if
2057 the server would set the time to a reasonable value anyway,
2058 and this check ensures that we are not being called from
2059 sys_utimes in which case we ought to fail the call back to
2060 the user when the server rejects the call */
2061 if ((rc) && (attrs->ia_valid &
2062 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2066 /* do not need local check to inode_check_ok since the server does
2069 goto cifs_setattr_exit;
2071 if ((attrs->ia_valid & ATTR_SIZE) &&
2072 attrs->ia_size != i_size_read(inode))
2073 truncate_setsize(inode, attrs->ia_size);
2075 setattr_copy(inode, attrs);
2076 mark_inode_dirty(inode);
2086 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2088 struct inode *inode = direntry->d_inode;
2089 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2090 struct cifsTconInfo *pTcon = cifs_sb_tcon(cifs_sb);
2092 if (pTcon->unix_ext)
2093 return cifs_setattr_unix(direntry, attrs);
2095 return cifs_setattr_nounix(direntry, attrs);
2097 /* BB: add cifs_setattr_legacy for really old servers */
2101 void cifs_delete_inode(struct inode *inode)
2103 cFYI(1, "In cifs_delete_inode, inode = 0x%p", inode);
2104 /* may have to add back in if and when safe distributed caching of
2105 directories added e.g. via FindNotify */