138c8a9a5SSteve French // SPDX-License-Identifier: LGPL-2.1
238c8a9a5SSteve French /*
338c8a9a5SSteve French *
438c8a9a5SSteve French * Directory search handling
538c8a9a5SSteve French *
638c8a9a5SSteve French * Copyright (C) International Business Machines Corp., 2004, 2008
738c8a9a5SSteve French * Copyright (C) Red Hat, Inc., 2011
838c8a9a5SSteve French * Author(s): Steve French (sfrench@us.ibm.com)
938c8a9a5SSteve French *
1038c8a9a5SSteve French */
1138c8a9a5SSteve French #include <linux/fs.h>
1238c8a9a5SSteve French #include <linux/pagemap.h>
1338c8a9a5SSteve French #include <linux/slab.h>
1438c8a9a5SSteve French #include <linux/stat.h>
1538c8a9a5SSteve French #include "cifspdu.h"
1638c8a9a5SSteve French #include "cifsglob.h"
1738c8a9a5SSteve French #include "cifsproto.h"
1838c8a9a5SSteve French #include "cifs_unicode.h"
1938c8a9a5SSteve French #include "cifs_debug.h"
2038c8a9a5SSteve French #include "cifs_fs_sb.h"
2138c8a9a5SSteve French #include "cifsfs.h"
2238c8a9a5SSteve French #include "smb2proto.h"
2338c8a9a5SSteve French #include "fs_context.h"
2438c8a9a5SSteve French #include "cached_dir.h"
25db0f1c07SPaulo Alcantara #include "reparse.h"
2638c8a9a5SSteve French
2738c8a9a5SSteve French /*
2838c8a9a5SSteve French * To be safe - for UCS to UTF-8 with strings loaded with the rare long
2938c8a9a5SSteve French * characters alloc more to account for such multibyte target UTF-8
3038c8a9a5SSteve French * characters.
3138c8a9a5SSteve French */
3238c8a9a5SSteve French #define UNICODE_NAME_MAX ((4 * NAME_MAX) + 2)
3338c8a9a5SSteve French
3438c8a9a5SSteve French #ifdef CONFIG_CIFS_DEBUG2
dump_cifs_file_struct(struct file * file,char * label)3538c8a9a5SSteve French static void dump_cifs_file_struct(struct file *file, char *label)
3638c8a9a5SSteve French {
3738c8a9a5SSteve French struct cifsFileInfo *cf;
3838c8a9a5SSteve French
3938c8a9a5SSteve French if (file) {
4038c8a9a5SSteve French cf = file->private_data;
4138c8a9a5SSteve French if (cf == NULL) {
4238c8a9a5SSteve French cifs_dbg(FYI, "empty cifs private file data\n");
4338c8a9a5SSteve French return;
4438c8a9a5SSteve French }
4538c8a9a5SSteve French if (cf->invalidHandle)
4638c8a9a5SSteve French cifs_dbg(FYI, "Invalid handle\n");
4738c8a9a5SSteve French if (cf->srch_inf.endOfSearch)
4838c8a9a5SSteve French cifs_dbg(FYI, "end of search\n");
4938c8a9a5SSteve French if (cf->srch_inf.emptyDir)
5038c8a9a5SSteve French cifs_dbg(FYI, "empty dir\n");
5138c8a9a5SSteve French }
5238c8a9a5SSteve French }
5338c8a9a5SSteve French #else
dump_cifs_file_struct(struct file * file,char * label)5438c8a9a5SSteve French static inline void dump_cifs_file_struct(struct file *file, char *label)
5538c8a9a5SSteve French {
5638c8a9a5SSteve French }
5738c8a9a5SSteve French #endif /* DEBUG2 */
5838c8a9a5SSteve French
5938c8a9a5SSteve French /*
6038c8a9a5SSteve French * Attempt to preload the dcache with the results from the FIND_FIRST/NEXT
6138c8a9a5SSteve French *
6238c8a9a5SSteve French * Find the dentry that matches "name". If there isn't one, create one. If it's
6338c8a9a5SSteve French * a negative dentry or the uniqueid or filetype(mode) changed,
6438c8a9a5SSteve French * then drop it and recreate it.
6538c8a9a5SSteve French */
6638c8a9a5SSteve French static void
cifs_prime_dcache(struct dentry * parent,struct qstr * name,struct cifs_fattr * fattr)6738c8a9a5SSteve French cifs_prime_dcache(struct dentry *parent, struct qstr *name,
6838c8a9a5SSteve French struct cifs_fattr *fattr)
6938c8a9a5SSteve French {
7038c8a9a5SSteve French struct dentry *dentry, *alias;
7138c8a9a5SSteve French struct inode *inode;
7238c8a9a5SSteve French struct super_block *sb = parent->d_sb;
7338c8a9a5SSteve French struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
7438c8a9a5SSteve French DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
75b9e741acSPaulo Alcantara int rc;
7638c8a9a5SSteve French
7738c8a9a5SSteve French cifs_dbg(FYI, "%s: for %s\n", __func__, name->name);
7838c8a9a5SSteve French
7938c8a9a5SSteve French dentry = d_hash_and_lookup(parent, name);
8038c8a9a5SSteve French if (!dentry) {
8138c8a9a5SSteve French /*
8238c8a9a5SSteve French * If we know that the inode will need to be revalidated
8338c8a9a5SSteve French * immediately, then don't create a new dentry for it.
8438c8a9a5SSteve French * We'll end up doing an on the wire call either way and
8538c8a9a5SSteve French * this spares us an invalidation.
8638c8a9a5SSteve French */
8738c8a9a5SSteve French retry:
88b9e741acSPaulo Alcantara if ((fattr->cf_cifsattrs & ATTR_REPARSE) ||
89b9e741acSPaulo Alcantara (fattr->cf_flags & CIFS_FATTR_NEED_REVAL))
90b9e741acSPaulo Alcantara return;
91b9e741acSPaulo Alcantara
9238c8a9a5SSteve French dentry = d_alloc_parallel(parent, name, &wq);
9338c8a9a5SSteve French }
9438c8a9a5SSteve French if (IS_ERR(dentry))
9538c8a9a5SSteve French return;
9638c8a9a5SSteve French if (!d_in_lookup(dentry)) {
9738c8a9a5SSteve French inode = d_inode(dentry);
9838c8a9a5SSteve French if (inode) {
9938c8a9a5SSteve French if (d_mountpoint(dentry)) {
10038c8a9a5SSteve French dput(dentry);
10138c8a9a5SSteve French return;
10238c8a9a5SSteve French }
10338c8a9a5SSteve French /*
10438c8a9a5SSteve French * If we're generating inode numbers, then we don't
10538c8a9a5SSteve French * want to clobber the existing one with the one that
10638c8a9a5SSteve French * the readdir code created.
10738c8a9a5SSteve French */
10838c8a9a5SSteve French if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM))
10938c8a9a5SSteve French fattr->cf_uniqueid = CIFS_I(inode)->uniqueid;
11038c8a9a5SSteve French
111b9e741acSPaulo Alcantara /*
112b9e741acSPaulo Alcantara * Update inode in place if both i_ino and i_mode didn't
113b9e741acSPaulo Alcantara * change.
114b9e741acSPaulo Alcantara */
115b9e741acSPaulo Alcantara if (CIFS_I(inode)->uniqueid == fattr->cf_uniqueid) {
116b9e741acSPaulo Alcantara /*
117b9e741acSPaulo Alcantara * Query dir responses don't provide enough
118b9e741acSPaulo Alcantara * information about reparse points other than
119b9e741acSPaulo Alcantara * their reparse tags. Save an invalidation by
120de2cadf4SPaulo Alcantara * not clobbering some existing attributes when
121de2cadf4SPaulo Alcantara * reparse tag and ctime haven't changed.
122b9e741acSPaulo Alcantara */
123b9e741acSPaulo Alcantara rc = 0;
124b9e741acSPaulo Alcantara if (fattr->cf_cifsattrs & ATTR_REPARSE) {
125b9e741acSPaulo Alcantara if (likely(reparse_inode_match(inode, fattr))) {
126b9e741acSPaulo Alcantara fattr->cf_mode = inode->i_mode;
127de2cadf4SPaulo Alcantara fattr->cf_rdev = inode->i_rdev;
12897db4160SPaulo Alcantara fattr->cf_uid = inode->i_uid;
12997db4160SPaulo Alcantara fattr->cf_gid = inode->i_gid;
130b9e741acSPaulo Alcantara fattr->cf_eof = CIFS_I(inode)->server_eof;
131b9e741acSPaulo Alcantara fattr->cf_symlink_target = NULL;
132b9e741acSPaulo Alcantara } else {
133b9e741acSPaulo Alcantara CIFS_I(inode)->time = 0;
134b9e741acSPaulo Alcantara rc = -ESTALE;
135b9e741acSPaulo Alcantara }
136b9e741acSPaulo Alcantara }
1379179aa27SBharath SM if (!rc && !cifs_fattr_to_inode(inode, fattr, true)) {
13838c8a9a5SSteve French dput(dentry);
13938c8a9a5SSteve French return;
14038c8a9a5SSteve French }
14138c8a9a5SSteve French }
142b9e741acSPaulo Alcantara }
14338c8a9a5SSteve French d_invalidate(dentry);
14438c8a9a5SSteve French dput(dentry);
14538c8a9a5SSteve French goto retry;
14638c8a9a5SSteve French } else {
14738c8a9a5SSteve French inode = cifs_iget(sb, fattr);
14838c8a9a5SSteve French if (!inode)
14938c8a9a5SSteve French inode = ERR_PTR(-ENOMEM);
15038c8a9a5SSteve French alias = d_splice_alias(inode, dentry);
15138c8a9a5SSteve French d_lookup_done(dentry);
15238c8a9a5SSteve French if (alias && !IS_ERR(alias))
15338c8a9a5SSteve French dput(alias);
15438c8a9a5SSteve French }
15538c8a9a5SSteve French dput(dentry);
15638c8a9a5SSteve French }
15738c8a9a5SSteve French
15838c8a9a5SSteve French static void
cifs_fill_common_info(struct cifs_fattr * fattr,struct cifs_sb_info * cifs_sb)15938c8a9a5SSteve French cifs_fill_common_info(struct cifs_fattr *fattr, struct cifs_sb_info *cifs_sb)
16038c8a9a5SSteve French {
161df32e887SPaulo Alcantara struct cifs_open_info_data data = {
162df32e887SPaulo Alcantara .reparse = { .tag = fattr->cf_cifstag, },
163df32e887SPaulo Alcantara };
164df32e887SPaulo Alcantara
16538c8a9a5SSteve French fattr->cf_uid = cifs_sb->ctx->linux_uid;
16638c8a9a5SSteve French fattr->cf_gid = cifs_sb->ctx->linux_gid;
16738c8a9a5SSteve French
16838c8a9a5SSteve French /*
16938c8a9a5SSteve French * The IO_REPARSE_TAG_LX_ tags originally were used by WSL but they
17038c8a9a5SSteve French * are preferred by the Linux client in some cases since, unlike
17138c8a9a5SSteve French * the NFS reparse tag (or EAs), they don't require an extra query
17238c8a9a5SSteve French * to determine which type of special file they represent.
17338c8a9a5SSteve French * TODO: go through all documented reparse tags to see if we can
17438c8a9a5SSteve French * reasonably map some of them to directories vs. files vs. symlinks
17538c8a9a5SSteve French */
1765f71ebc4SPaulo Alcantara if ((fattr->cf_cifsattrs & ATTR_REPARSE) &&
177df32e887SPaulo Alcantara cifs_reparse_point_to_fattr(cifs_sb, fattr, &data))
1785f71ebc4SPaulo Alcantara goto out_reparse;
1795f71ebc4SPaulo Alcantara
18038c8a9a5SSteve French if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
18138c8a9a5SSteve French fattr->cf_mode = S_IFDIR | cifs_sb->ctx->dir_mode;
18238c8a9a5SSteve French fattr->cf_dtype = DT_DIR;
1835f71ebc4SPaulo Alcantara } else {
18438c8a9a5SSteve French fattr->cf_mode = S_IFREG | cifs_sb->ctx->file_mode;
18538c8a9a5SSteve French fattr->cf_dtype = DT_REG;
18638c8a9a5SSteve French }
18738c8a9a5SSteve French
1885f71ebc4SPaulo Alcantara out_reparse:
18938c8a9a5SSteve French /* non-unix readdir doesn't provide nlink */
19038c8a9a5SSteve French fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
19138c8a9a5SSteve French
19238c8a9a5SSteve French if (fattr->cf_cifsattrs & ATTR_READONLY)
19338c8a9a5SSteve French fattr->cf_mode &= ~S_IWUGO;
19438c8a9a5SSteve French
19538c8a9a5SSteve French /*
19638c8a9a5SSteve French * We of course don't get ACL info in FIND_FIRST/NEXT results, so
19738c8a9a5SSteve French * mark it for revalidation so that "ls -l" will look right. It might
19838c8a9a5SSteve French * be super-slow, but if we don't do this then the ownership of files
19938c8a9a5SSteve French * may look wrong since the inodes may not have timed out by the time
20038c8a9a5SSteve French * "ls" does a stat() call on them.
20138c8a9a5SSteve French */
20238c8a9a5SSteve French if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
20338c8a9a5SSteve French (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID))
20438c8a9a5SSteve French fattr->cf_flags |= CIFS_FATTR_NEED_REVAL;
20538c8a9a5SSteve French
20638c8a9a5SSteve French if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL &&
20738c8a9a5SSteve French fattr->cf_cifsattrs & ATTR_SYSTEM) {
20838c8a9a5SSteve French if (fattr->cf_eof == 0) {
20938c8a9a5SSteve French fattr->cf_mode &= ~S_IFMT;
21038c8a9a5SSteve French fattr->cf_mode |= S_IFIFO;
21138c8a9a5SSteve French fattr->cf_dtype = DT_FIFO;
21238c8a9a5SSteve French } else {
21338c8a9a5SSteve French /*
21438c8a9a5SSteve French * trying to get the type and mode via SFU can be slow,
21538c8a9a5SSteve French * so just call those regular files for now, and mark
21638c8a9a5SSteve French * for reval
21738c8a9a5SSteve French */
21838c8a9a5SSteve French fattr->cf_flags |= CIFS_FATTR_NEED_REVAL;
21938c8a9a5SSteve French }
22038c8a9a5SSteve French }
22138c8a9a5SSteve French }
22238c8a9a5SSteve French
22338c8a9a5SSteve French /* Fill a cifs_fattr struct with info from SMB_FIND_FILE_POSIX_INFO. */
22438c8a9a5SSteve French static void
cifs_posix_to_fattr(struct cifs_fattr * fattr,struct smb2_posix_info * info,struct cifs_sb_info * cifs_sb)22538c8a9a5SSteve French cifs_posix_to_fattr(struct cifs_fattr *fattr, struct smb2_posix_info *info,
22638c8a9a5SSteve French struct cifs_sb_info *cifs_sb)
22738c8a9a5SSteve French {
22838c8a9a5SSteve French struct smb2_posix_info_parsed parsed;
22938c8a9a5SSteve French
23038c8a9a5SSteve French posix_info_parse(info, NULL, &parsed);
23138c8a9a5SSteve French
23238c8a9a5SSteve French memset(fattr, 0, sizeof(*fattr));
23338c8a9a5SSteve French fattr->cf_uniqueid = le64_to_cpu(info->Inode);
23438c8a9a5SSteve French fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
23538c8a9a5SSteve French fattr->cf_eof = le64_to_cpu(info->EndOfFile);
23638c8a9a5SSteve French
23738c8a9a5SSteve French fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
23838c8a9a5SSteve French fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
23938c8a9a5SSteve French fattr->cf_ctime = cifs_NTtimeToUnix(info->CreationTime);
24038c8a9a5SSteve French
24138c8a9a5SSteve French fattr->cf_nlink = le32_to_cpu(info->HardLinks);
24238c8a9a5SSteve French fattr->cf_cifsattrs = le32_to_cpu(info->DosAttributes);
24338c8a9a5SSteve French
24438c8a9a5SSteve French /*
24538c8a9a5SSteve French * Since we set the inode type below we need to mask off
24638c8a9a5SSteve French * to avoid strange results if bits set above.
24738c8a9a5SSteve French * XXX: why not make server&client use the type bits?
24838c8a9a5SSteve French */
24938c8a9a5SSteve French fattr->cf_mode = le32_to_cpu(info->Mode) & ~S_IFMT;
25038c8a9a5SSteve French
25138c8a9a5SSteve French cifs_dbg(FYI, "posix fattr: dev %d, reparse %d, mode %o\n",
25238c8a9a5SSteve French le32_to_cpu(info->DeviceId),
25338c8a9a5SSteve French le32_to_cpu(info->ReparseTag),
25438c8a9a5SSteve French le32_to_cpu(info->Mode));
25538c8a9a5SSteve French
25638c8a9a5SSteve French if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
25738c8a9a5SSteve French fattr->cf_mode |= S_IFDIR;
25838c8a9a5SSteve French fattr->cf_dtype = DT_DIR;
25938c8a9a5SSteve French } else {
26038c8a9a5SSteve French /*
26138c8a9a5SSteve French * mark anything that is not a dir as regular
26238c8a9a5SSteve French * file. special files should have the REPARSE
26338c8a9a5SSteve French * attribute and will be marked as needing revaluation
26438c8a9a5SSteve French */
26538c8a9a5SSteve French fattr->cf_mode |= S_IFREG;
26638c8a9a5SSteve French fattr->cf_dtype = DT_REG;
26738c8a9a5SSteve French }
26838c8a9a5SSteve French
26938c8a9a5SSteve French sid_to_id(cifs_sb, &parsed.owner, fattr, SIDOWNER);
27038c8a9a5SSteve French sid_to_id(cifs_sb, &parsed.group, fattr, SIDGROUP);
27138c8a9a5SSteve French }
27238c8a9a5SSteve French
__dir_info_to_fattr(struct cifs_fattr * fattr,const void * info)27338c8a9a5SSteve French static void __dir_info_to_fattr(struct cifs_fattr *fattr, const void *info)
27438c8a9a5SSteve French {
27538c8a9a5SSteve French const FILE_DIRECTORY_INFO *fi = info;
27638c8a9a5SSteve French
27738c8a9a5SSteve French memset(fattr, 0, sizeof(*fattr));
27838c8a9a5SSteve French fattr->cf_cifsattrs = le32_to_cpu(fi->ExtFileAttributes);
27938c8a9a5SSteve French fattr->cf_eof = le64_to_cpu(fi->EndOfFile);
28038c8a9a5SSteve French fattr->cf_bytes = le64_to_cpu(fi->AllocationSize);
28138c8a9a5SSteve French fattr->cf_createtime = le64_to_cpu(fi->CreationTime);
28238c8a9a5SSteve French fattr->cf_atime = cifs_NTtimeToUnix(fi->LastAccessTime);
28338c8a9a5SSteve French fattr->cf_ctime = cifs_NTtimeToUnix(fi->ChangeTime);
28438c8a9a5SSteve French fattr->cf_mtime = cifs_NTtimeToUnix(fi->LastWriteTime);
28538c8a9a5SSteve French }
28638c8a9a5SSteve French
28738c8a9a5SSteve French void
cifs_dir_info_to_fattr(struct cifs_fattr * fattr,FILE_DIRECTORY_INFO * info,struct cifs_sb_info * cifs_sb)28838c8a9a5SSteve French cifs_dir_info_to_fattr(struct cifs_fattr *fattr, FILE_DIRECTORY_INFO *info,
28938c8a9a5SSteve French struct cifs_sb_info *cifs_sb)
29038c8a9a5SSteve French {
29138c8a9a5SSteve French __dir_info_to_fattr(fattr, info);
29238c8a9a5SSteve French cifs_fill_common_info(fattr, cifs_sb);
29338c8a9a5SSteve French }
29438c8a9a5SSteve French
cifs_fulldir_info_to_fattr(struct cifs_fattr * fattr,const void * info,struct cifs_sb_info * cifs_sb)29538c8a9a5SSteve French static void cifs_fulldir_info_to_fattr(struct cifs_fattr *fattr,
296cacc0a9cSPaulo Alcantara const void *info,
29738c8a9a5SSteve French struct cifs_sb_info *cifs_sb)
29838c8a9a5SSteve French {
299cacc0a9cSPaulo Alcantara const FILE_FULL_DIRECTORY_INFO *di = info;
300cacc0a9cSPaulo Alcantara
30138c8a9a5SSteve French __dir_info_to_fattr(fattr, info);
30238c8a9a5SSteve French
303cacc0a9cSPaulo Alcantara /* See MS-FSCC 2.4.14, 2.4.19 */
30438c8a9a5SSteve French if (fattr->cf_cifsattrs & ATTR_REPARSE)
305cacc0a9cSPaulo Alcantara fattr->cf_cifstag = le32_to_cpu(di->EaSize);
30638c8a9a5SSteve French cifs_fill_common_info(fattr, cifs_sb);
30738c8a9a5SSteve French }
30838c8a9a5SSteve French
30938c8a9a5SSteve French static void
cifs_std_info_to_fattr(struct cifs_fattr * fattr,FIND_FILE_STANDARD_INFO * info,struct cifs_sb_info * cifs_sb)31038c8a9a5SSteve French cifs_std_info_to_fattr(struct cifs_fattr *fattr, FIND_FILE_STANDARD_INFO *info,
31138c8a9a5SSteve French struct cifs_sb_info *cifs_sb)
31238c8a9a5SSteve French {
31338c8a9a5SSteve French int offset = cifs_sb_master_tcon(cifs_sb)->ses->server->timeAdj;
31438c8a9a5SSteve French
31538c8a9a5SSteve French memset(fattr, 0, sizeof(*fattr));
31638c8a9a5SSteve French fattr->cf_atime = cnvrtDosUnixTm(info->LastAccessDate,
31738c8a9a5SSteve French info->LastAccessTime, offset);
31838c8a9a5SSteve French fattr->cf_ctime = cnvrtDosUnixTm(info->LastWriteDate,
31938c8a9a5SSteve French info->LastWriteTime, offset);
32038c8a9a5SSteve French fattr->cf_mtime = cnvrtDosUnixTm(info->LastWriteDate,
32138c8a9a5SSteve French info->LastWriteTime, offset);
32238c8a9a5SSteve French
32338c8a9a5SSteve French fattr->cf_cifsattrs = le16_to_cpu(info->Attributes);
32438c8a9a5SSteve French fattr->cf_bytes = le32_to_cpu(info->AllocationSize);
32538c8a9a5SSteve French fattr->cf_eof = le32_to_cpu(info->DataSize);
32638c8a9a5SSteve French
32738c8a9a5SSteve French cifs_fill_common_info(fattr, cifs_sb);
32838c8a9a5SSteve French }
32938c8a9a5SSteve French
33038c8a9a5SSteve French static int
_initiate_cifs_search(const unsigned int xid,struct file * file,const char * full_path)33138c8a9a5SSteve French _initiate_cifs_search(const unsigned int xid, struct file *file,
33238c8a9a5SSteve French const char *full_path)
33338c8a9a5SSteve French {
33438c8a9a5SSteve French __u16 search_flags;
33538c8a9a5SSteve French int rc = 0;
33638c8a9a5SSteve French struct cifsFileInfo *cifsFile;
33738c8a9a5SSteve French struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
33838c8a9a5SSteve French struct tcon_link *tlink = NULL;
33938c8a9a5SSteve French struct cifs_tcon *tcon;
34038c8a9a5SSteve French struct TCP_Server_Info *server;
34138c8a9a5SSteve French
34238c8a9a5SSteve French if (file->private_data == NULL) {
34338c8a9a5SSteve French tlink = cifs_sb_tlink(cifs_sb);
34438c8a9a5SSteve French if (IS_ERR(tlink))
34538c8a9a5SSteve French return PTR_ERR(tlink);
34638c8a9a5SSteve French
34738c8a9a5SSteve French cifsFile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
34838c8a9a5SSteve French if (cifsFile == NULL) {
34938c8a9a5SSteve French rc = -ENOMEM;
35038c8a9a5SSteve French goto error_exit;
35138c8a9a5SSteve French }
35238c8a9a5SSteve French spin_lock_init(&cifsFile->file_info_lock);
35338c8a9a5SSteve French file->private_data = cifsFile;
35438c8a9a5SSteve French cifsFile->tlink = cifs_get_tlink(tlink);
35538c8a9a5SSteve French tcon = tlink_tcon(tlink);
35638c8a9a5SSteve French } else {
35738c8a9a5SSteve French cifsFile = file->private_data;
35838c8a9a5SSteve French tcon = tlink_tcon(cifsFile->tlink);
35938c8a9a5SSteve French }
36038c8a9a5SSteve French
36138c8a9a5SSteve French server = tcon->ses->server;
36238c8a9a5SSteve French
36338c8a9a5SSteve French if (!server->ops->query_dir_first) {
36438c8a9a5SSteve French rc = -ENOSYS;
36538c8a9a5SSteve French goto error_exit;
36638c8a9a5SSteve French }
36738c8a9a5SSteve French
36838c8a9a5SSteve French cifsFile->invalidHandle = true;
36938c8a9a5SSteve French cifsFile->srch_inf.endOfSearch = false;
37038c8a9a5SSteve French
37138c8a9a5SSteve French cifs_dbg(FYI, "Full path: %s start at: %lld\n", full_path, file->f_pos);
37238c8a9a5SSteve French
37338c8a9a5SSteve French ffirst_retry:
37438c8a9a5SSteve French /* test for Unix extensions */
37538c8a9a5SSteve French /* but now check for them on the share/mount not on the SMB session */
37638c8a9a5SSteve French /* if (cap_unix(tcon->ses) { */
37738c8a9a5SSteve French if (tcon->unix_ext)
37838c8a9a5SSteve French cifsFile->srch_inf.info_level = SMB_FIND_FILE_UNIX;
37938c8a9a5SSteve French else if (tcon->posix_extensions)
38038c8a9a5SSteve French cifsFile->srch_inf.info_level = SMB_FIND_FILE_POSIX_INFO;
38138c8a9a5SSteve French else if ((tcon->ses->capabilities &
38238c8a9a5SSteve French tcon->ses->server->vals->cap_nt_find) == 0) {
38338c8a9a5SSteve French cifsFile->srch_inf.info_level = SMB_FIND_FILE_INFO_STANDARD;
38438c8a9a5SSteve French } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
38538c8a9a5SSteve French cifsFile->srch_inf.info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
38638c8a9a5SSteve French } else /* not srvinos - BB fixme add check for backlevel? */ {
387cacc0a9cSPaulo Alcantara cifsFile->srch_inf.info_level = SMB_FIND_FILE_FULL_DIRECTORY_INFO;
38838c8a9a5SSteve French }
38938c8a9a5SSteve French
39038c8a9a5SSteve French search_flags = CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME;
39138c8a9a5SSteve French if (backup_cred(cifs_sb))
39238c8a9a5SSteve French search_flags |= CIFS_SEARCH_BACKUP_SEARCH;
39338c8a9a5SSteve French
39438c8a9a5SSteve French rc = server->ops->query_dir_first(xid, tcon, full_path, cifs_sb,
39538c8a9a5SSteve French &cifsFile->fid, search_flags,
39638c8a9a5SSteve French &cifsFile->srch_inf);
39738c8a9a5SSteve French
398b9e741acSPaulo Alcantara if (rc == 0) {
39938c8a9a5SSteve French cifsFile->invalidHandle = false;
400b9e741acSPaulo Alcantara } else if ((rc == -EOPNOTSUPP) &&
40138c8a9a5SSteve French (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
40238c8a9a5SSteve French cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM;
40338c8a9a5SSteve French goto ffirst_retry;
40438c8a9a5SSteve French }
40538c8a9a5SSteve French error_exit:
40638c8a9a5SSteve French cifs_put_tlink(tlink);
40738c8a9a5SSteve French return rc;
40838c8a9a5SSteve French }
40938c8a9a5SSteve French
41038c8a9a5SSteve French static int
initiate_cifs_search(const unsigned int xid,struct file * file,const char * full_path)41138c8a9a5SSteve French initiate_cifs_search(const unsigned int xid, struct file *file,
41238c8a9a5SSteve French const char *full_path)
41338c8a9a5SSteve French {
41438c8a9a5SSteve French int rc, retry_count = 0;
41538c8a9a5SSteve French
41638c8a9a5SSteve French do {
41738c8a9a5SSteve French rc = _initiate_cifs_search(xid, file, full_path);
41838c8a9a5SSteve French /*
41938c8a9a5SSteve French * If we don't have enough credits to start reading the
42038c8a9a5SSteve French * directory just try again after short wait.
42138c8a9a5SSteve French */
42238c8a9a5SSteve French if (rc != -EDEADLK)
42338c8a9a5SSteve French break;
42438c8a9a5SSteve French
42538c8a9a5SSteve French usleep_range(512, 2048);
42638c8a9a5SSteve French } while (retry_count++ < 5);
42738c8a9a5SSteve French
42838c8a9a5SSteve French return rc;
42938c8a9a5SSteve French }
43038c8a9a5SSteve French
43138c8a9a5SSteve French /* return length of unicode string in bytes */
cifs_unicode_bytelen(const char * str)43238c8a9a5SSteve French static int cifs_unicode_bytelen(const char *str)
43338c8a9a5SSteve French {
43438c8a9a5SSteve French int len;
43538c8a9a5SSteve French const __le16 *ustr = (const __le16 *)str;
43638c8a9a5SSteve French
43738c8a9a5SSteve French for (len = 0; len <= PATH_MAX; len++) {
43838c8a9a5SSteve French if (ustr[len] == 0)
43938c8a9a5SSteve French return len << 1;
44038c8a9a5SSteve French }
44138c8a9a5SSteve French cifs_dbg(FYI, "Unicode string longer than PATH_MAX found\n");
44238c8a9a5SSteve French return len << 1;
44338c8a9a5SSteve French }
44438c8a9a5SSteve French
nxt_dir_entry(char * old_entry,char * end_of_smb,int level)44538c8a9a5SSteve French static char *nxt_dir_entry(char *old_entry, char *end_of_smb, int level)
44638c8a9a5SSteve French {
44738c8a9a5SSteve French char *new_entry;
44838c8a9a5SSteve French FILE_DIRECTORY_INFO *pDirInfo = (FILE_DIRECTORY_INFO *)old_entry;
44938c8a9a5SSteve French
45038c8a9a5SSteve French if (level == SMB_FIND_FILE_INFO_STANDARD) {
45138c8a9a5SSteve French FIND_FILE_STANDARD_INFO *pfData;
45238c8a9a5SSteve French pfData = (FIND_FILE_STANDARD_INFO *)pDirInfo;
45338c8a9a5SSteve French
45438c8a9a5SSteve French new_entry = old_entry + sizeof(FIND_FILE_STANDARD_INFO) + 1 +
45538c8a9a5SSteve French pfData->FileNameLength;
45638c8a9a5SSteve French } else {
45738c8a9a5SSteve French u32 next_offset = le32_to_cpu(pDirInfo->NextEntryOffset);
45838c8a9a5SSteve French
45938c8a9a5SSteve French if (old_entry + next_offset < old_entry) {
46038c8a9a5SSteve French cifs_dbg(VFS, "Invalid offset %u\n", next_offset);
46138c8a9a5SSteve French return NULL;
46238c8a9a5SSteve French }
46338c8a9a5SSteve French new_entry = old_entry + next_offset;
46438c8a9a5SSteve French }
46538c8a9a5SSteve French cifs_dbg(FYI, "new entry %p old entry %p\n", new_entry, old_entry);
46638c8a9a5SSteve French /* validate that new_entry is not past end of SMB */
46738c8a9a5SSteve French if (new_entry >= end_of_smb) {
46838c8a9a5SSteve French cifs_dbg(VFS, "search entry %p began after end of SMB %p old entry %p\n",
46938c8a9a5SSteve French new_entry, end_of_smb, old_entry);
47038c8a9a5SSteve French return NULL;
47138c8a9a5SSteve French } else if (((level == SMB_FIND_FILE_INFO_STANDARD) &&
47238c8a9a5SSteve French (new_entry + sizeof(FIND_FILE_STANDARD_INFO) + 1 > end_of_smb))
47338c8a9a5SSteve French || ((level != SMB_FIND_FILE_INFO_STANDARD) &&
47438c8a9a5SSteve French (new_entry + sizeof(FILE_DIRECTORY_INFO) + 1 > end_of_smb))) {
47538c8a9a5SSteve French cifs_dbg(VFS, "search entry %p extends after end of SMB %p\n",
47638c8a9a5SSteve French new_entry, end_of_smb);
47738c8a9a5SSteve French return NULL;
47838c8a9a5SSteve French } else
47938c8a9a5SSteve French return new_entry;
48038c8a9a5SSteve French
48138c8a9a5SSteve French }
48238c8a9a5SSteve French
48338c8a9a5SSteve French struct cifs_dirent {
48438c8a9a5SSteve French const char *name;
48538c8a9a5SSteve French size_t namelen;
48638c8a9a5SSteve French u32 resume_key;
48738c8a9a5SSteve French u64 ino;
48838c8a9a5SSteve French };
48938c8a9a5SSteve French
cifs_fill_dirent_posix(struct cifs_dirent * de,const struct smb2_posix_info * info)49038c8a9a5SSteve French static void cifs_fill_dirent_posix(struct cifs_dirent *de,
49138c8a9a5SSteve French const struct smb2_posix_info *info)
49238c8a9a5SSteve French {
49338c8a9a5SSteve French struct smb2_posix_info_parsed parsed;
49438c8a9a5SSteve French
49538c8a9a5SSteve French /* payload should have already been checked at this point */
49638c8a9a5SSteve French if (posix_info_parse(info, NULL, &parsed) < 0) {
49738c8a9a5SSteve French cifs_dbg(VFS, "Invalid POSIX info payload\n");
49838c8a9a5SSteve French return;
49938c8a9a5SSteve French }
50038c8a9a5SSteve French
50138c8a9a5SSteve French de->name = parsed.name;
50238c8a9a5SSteve French de->namelen = parsed.name_len;
50338c8a9a5SSteve French de->resume_key = info->Ignored;
50438c8a9a5SSteve French de->ino = le64_to_cpu(info->Inode);
50538c8a9a5SSteve French }
50638c8a9a5SSteve French
cifs_fill_dirent_unix(struct cifs_dirent * de,const FILE_UNIX_INFO * info,bool is_unicode)50738c8a9a5SSteve French static void cifs_fill_dirent_unix(struct cifs_dirent *de,
50838c8a9a5SSteve French const FILE_UNIX_INFO *info, bool is_unicode)
50938c8a9a5SSteve French {
51038c8a9a5SSteve French de->name = &info->FileName[0];
51138c8a9a5SSteve French if (is_unicode)
51238c8a9a5SSteve French de->namelen = cifs_unicode_bytelen(de->name);
51338c8a9a5SSteve French else
51438c8a9a5SSteve French de->namelen = strnlen(de->name, PATH_MAX);
51538c8a9a5SSteve French de->resume_key = info->ResumeKey;
51638c8a9a5SSteve French de->ino = le64_to_cpu(info->basic.UniqueId);
51738c8a9a5SSteve French }
51838c8a9a5SSteve French
cifs_fill_dirent_dir(struct cifs_dirent * de,const FILE_DIRECTORY_INFO * info)51938c8a9a5SSteve French static void cifs_fill_dirent_dir(struct cifs_dirent *de,
52038c8a9a5SSteve French const FILE_DIRECTORY_INFO *info)
52138c8a9a5SSteve French {
52238c8a9a5SSteve French de->name = &info->FileName[0];
52338c8a9a5SSteve French de->namelen = le32_to_cpu(info->FileNameLength);
52438c8a9a5SSteve French de->resume_key = info->FileIndex;
52538c8a9a5SSteve French }
52638c8a9a5SSteve French
cifs_fill_dirent_full(struct cifs_dirent * de,const FILE_FULL_DIRECTORY_INFO * info)52738c8a9a5SSteve French static void cifs_fill_dirent_full(struct cifs_dirent *de,
52838c8a9a5SSteve French const FILE_FULL_DIRECTORY_INFO *info)
52938c8a9a5SSteve French {
53038c8a9a5SSteve French de->name = &info->FileName[0];
53138c8a9a5SSteve French de->namelen = le32_to_cpu(info->FileNameLength);
53238c8a9a5SSteve French de->resume_key = info->FileIndex;
53338c8a9a5SSteve French }
53438c8a9a5SSteve French
cifs_fill_dirent_search(struct cifs_dirent * de,const SEARCH_ID_FULL_DIR_INFO * info)53538c8a9a5SSteve French static void cifs_fill_dirent_search(struct cifs_dirent *de,
53638c8a9a5SSteve French const SEARCH_ID_FULL_DIR_INFO *info)
53738c8a9a5SSteve French {
53838c8a9a5SSteve French de->name = &info->FileName[0];
53938c8a9a5SSteve French de->namelen = le32_to_cpu(info->FileNameLength);
54038c8a9a5SSteve French de->resume_key = info->FileIndex;
54138c8a9a5SSteve French de->ino = le64_to_cpu(info->UniqueId);
54238c8a9a5SSteve French }
54338c8a9a5SSteve French
cifs_fill_dirent_both(struct cifs_dirent * de,const FILE_BOTH_DIRECTORY_INFO * info)54438c8a9a5SSteve French static void cifs_fill_dirent_both(struct cifs_dirent *de,
54538c8a9a5SSteve French const FILE_BOTH_DIRECTORY_INFO *info)
54638c8a9a5SSteve French {
54738c8a9a5SSteve French de->name = &info->FileName[0];
54838c8a9a5SSteve French de->namelen = le32_to_cpu(info->FileNameLength);
54938c8a9a5SSteve French de->resume_key = info->FileIndex;
55038c8a9a5SSteve French }
55138c8a9a5SSteve French
cifs_fill_dirent_std(struct cifs_dirent * de,const FIND_FILE_STANDARD_INFO * info)55238c8a9a5SSteve French static void cifs_fill_dirent_std(struct cifs_dirent *de,
55338c8a9a5SSteve French const FIND_FILE_STANDARD_INFO *info)
55438c8a9a5SSteve French {
55538c8a9a5SSteve French de->name = &info->FileName[0];
55638c8a9a5SSteve French /* one byte length, no endianess conversion */
55738c8a9a5SSteve French de->namelen = info->FileNameLength;
55838c8a9a5SSteve French de->resume_key = info->ResumeKey;
55938c8a9a5SSteve French }
56038c8a9a5SSteve French
cifs_fill_dirent(struct cifs_dirent * de,const void * info,u16 level,bool is_unicode)56138c8a9a5SSteve French static int cifs_fill_dirent(struct cifs_dirent *de, const void *info,
56238c8a9a5SSteve French u16 level, bool is_unicode)
56338c8a9a5SSteve French {
56438c8a9a5SSteve French memset(de, 0, sizeof(*de));
56538c8a9a5SSteve French
56638c8a9a5SSteve French switch (level) {
56738c8a9a5SSteve French case SMB_FIND_FILE_POSIX_INFO:
56838c8a9a5SSteve French cifs_fill_dirent_posix(de, info);
56938c8a9a5SSteve French break;
57038c8a9a5SSteve French case SMB_FIND_FILE_UNIX:
57138c8a9a5SSteve French cifs_fill_dirent_unix(de, info, is_unicode);
57238c8a9a5SSteve French break;
57338c8a9a5SSteve French case SMB_FIND_FILE_DIRECTORY_INFO:
57438c8a9a5SSteve French cifs_fill_dirent_dir(de, info);
57538c8a9a5SSteve French break;
57638c8a9a5SSteve French case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
57738c8a9a5SSteve French cifs_fill_dirent_full(de, info);
57838c8a9a5SSteve French break;
57938c8a9a5SSteve French case SMB_FIND_FILE_ID_FULL_DIR_INFO:
58038c8a9a5SSteve French cifs_fill_dirent_search(de, info);
58138c8a9a5SSteve French break;
58238c8a9a5SSteve French case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
58338c8a9a5SSteve French cifs_fill_dirent_both(de, info);
58438c8a9a5SSteve French break;
58538c8a9a5SSteve French case SMB_FIND_FILE_INFO_STANDARD:
58638c8a9a5SSteve French cifs_fill_dirent_std(de, info);
58738c8a9a5SSteve French break;
58838c8a9a5SSteve French default:
58938c8a9a5SSteve French cifs_dbg(FYI, "Unknown findfirst level %d\n", level);
59038c8a9a5SSteve French return -EINVAL;
59138c8a9a5SSteve French }
59238c8a9a5SSteve French
59338c8a9a5SSteve French return 0;
59438c8a9a5SSteve French }
59538c8a9a5SSteve French
59638c8a9a5SSteve French #define UNICODE_DOT cpu_to_le16(0x2e)
59738c8a9a5SSteve French
59838c8a9a5SSteve French /* return 0 if no match and 1 for . (current directory) and 2 for .. (parent) */
cifs_entry_is_dot(struct cifs_dirent * de,bool is_unicode)59938c8a9a5SSteve French static int cifs_entry_is_dot(struct cifs_dirent *de, bool is_unicode)
60038c8a9a5SSteve French {
60138c8a9a5SSteve French int rc = 0;
60238c8a9a5SSteve French
60338c8a9a5SSteve French if (!de->name)
60438c8a9a5SSteve French return 0;
60538c8a9a5SSteve French
60638c8a9a5SSteve French if (is_unicode) {
60738c8a9a5SSteve French __le16 *ufilename = (__le16 *)de->name;
60838c8a9a5SSteve French if (de->namelen == 2) {
60938c8a9a5SSteve French /* check for . */
61038c8a9a5SSteve French if (ufilename[0] == UNICODE_DOT)
61138c8a9a5SSteve French rc = 1;
61238c8a9a5SSteve French } else if (de->namelen == 4) {
61338c8a9a5SSteve French /* check for .. */
61438c8a9a5SSteve French if (ufilename[0] == UNICODE_DOT &&
61538c8a9a5SSteve French ufilename[1] == UNICODE_DOT)
61638c8a9a5SSteve French rc = 2;
61738c8a9a5SSteve French }
61838c8a9a5SSteve French } else /* ASCII */ {
61938c8a9a5SSteve French if (de->namelen == 1) {
62038c8a9a5SSteve French if (de->name[0] == '.')
62138c8a9a5SSteve French rc = 1;
62238c8a9a5SSteve French } else if (de->namelen == 2) {
62338c8a9a5SSteve French if (de->name[0] == '.' && de->name[1] == '.')
62438c8a9a5SSteve French rc = 2;
62538c8a9a5SSteve French }
62638c8a9a5SSteve French }
62738c8a9a5SSteve French
62838c8a9a5SSteve French return rc;
62938c8a9a5SSteve French }
63038c8a9a5SSteve French
63138c8a9a5SSteve French /* Check if directory that we are searching has changed so we can decide
63238c8a9a5SSteve French whether we can use the cached search results from the previous search */
is_dir_changed(struct file * file)63338c8a9a5SSteve French static int is_dir_changed(struct file *file)
63438c8a9a5SSteve French {
63538c8a9a5SSteve French struct inode *inode = file_inode(file);
63636f8070cSSteve French struct cifsInodeInfo *cifs_inode_info = CIFS_I(inode);
63738c8a9a5SSteve French
63836f8070cSSteve French if (cifs_inode_info->time == 0)
63936f8070cSSteve French return 1; /* directory was changed, e.g. unlink or new file */
64038c8a9a5SSteve French else
64138c8a9a5SSteve French return 0;
64238c8a9a5SSteve French
64338c8a9a5SSteve French }
64438c8a9a5SSteve French
cifs_save_resume_key(const char * current_entry,struct cifsFileInfo * file_info)64538c8a9a5SSteve French static int cifs_save_resume_key(const char *current_entry,
64638c8a9a5SSteve French struct cifsFileInfo *file_info)
64738c8a9a5SSteve French {
64838c8a9a5SSteve French struct cifs_dirent de;
64938c8a9a5SSteve French int rc;
65038c8a9a5SSteve French
65138c8a9a5SSteve French rc = cifs_fill_dirent(&de, current_entry, file_info->srch_inf.info_level,
65238c8a9a5SSteve French file_info->srch_inf.unicode);
65338c8a9a5SSteve French if (!rc) {
65438c8a9a5SSteve French file_info->srch_inf.presume_name = de.name;
65538c8a9a5SSteve French file_info->srch_inf.resume_name_len = de.namelen;
65638c8a9a5SSteve French file_info->srch_inf.resume_key = de.resume_key;
65738c8a9a5SSteve French }
65838c8a9a5SSteve French return rc;
65938c8a9a5SSteve French }
66038c8a9a5SSteve French
66138c8a9a5SSteve French /*
66238c8a9a5SSteve French * Find the corresponding entry in the search. Note that the SMB server returns
66338c8a9a5SSteve French * search entries for . and .. which complicates logic here if we choose to
66438c8a9a5SSteve French * parse for them and we do not assume that they are located in the findfirst
66538c8a9a5SSteve French * return buffer. We start counting in the buffer with entry 2 and increment for
66638c8a9a5SSteve French * every entry (do not increment for . or .. entry).
66738c8a9a5SSteve French */
66838c8a9a5SSteve French static int
find_cifs_entry(const unsigned int xid,struct cifs_tcon * tcon,loff_t pos,struct file * file,const char * full_path,char ** current_entry,int * num_to_ret)66938c8a9a5SSteve French find_cifs_entry(const unsigned int xid, struct cifs_tcon *tcon, loff_t pos,
67038c8a9a5SSteve French struct file *file, const char *full_path,
67138c8a9a5SSteve French char **current_entry, int *num_to_ret)
67238c8a9a5SSteve French {
67338c8a9a5SSteve French __u16 search_flags;
67438c8a9a5SSteve French int rc = 0;
67538c8a9a5SSteve French int pos_in_buf = 0;
67638c8a9a5SSteve French loff_t first_entry_in_buffer;
67738c8a9a5SSteve French loff_t index_to_find = pos;
67838c8a9a5SSteve French struct cifsFileInfo *cfile = file->private_data;
67938c8a9a5SSteve French struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
68038c8a9a5SSteve French struct TCP_Server_Info *server = tcon->ses->server;
68138c8a9a5SSteve French /* check if index in the buffer */
68238c8a9a5SSteve French
68338c8a9a5SSteve French if (!server->ops->query_dir_first || !server->ops->query_dir_next)
68438c8a9a5SSteve French return -ENOSYS;
68538c8a9a5SSteve French
68638c8a9a5SSteve French if ((cfile == NULL) || (current_entry == NULL) || (num_to_ret == NULL))
68738c8a9a5SSteve French return -ENOENT;
68838c8a9a5SSteve French
68938c8a9a5SSteve French *current_entry = NULL;
69038c8a9a5SSteve French first_entry_in_buffer = cfile->srch_inf.index_of_last_entry -
69138c8a9a5SSteve French cfile->srch_inf.entries_in_buffer;
69238c8a9a5SSteve French
69338c8a9a5SSteve French /*
69438c8a9a5SSteve French * If first entry in buf is zero then is first buffer
69538c8a9a5SSteve French * in search response data which means it is likely . and ..
69638c8a9a5SSteve French * will be in this buffer, although some servers do not return
69738c8a9a5SSteve French * . and .. for the root of a drive and for those we need
69838c8a9a5SSteve French * to start two entries earlier.
69938c8a9a5SSteve French */
70038c8a9a5SSteve French
70138c8a9a5SSteve French dump_cifs_file_struct(file, "In fce ");
70238c8a9a5SSteve French if (((index_to_find < cfile->srch_inf.index_of_last_entry) &&
70338c8a9a5SSteve French is_dir_changed(file)) || (index_to_find < first_entry_in_buffer)) {
70438c8a9a5SSteve French /* close and restart search */
70538c8a9a5SSteve French cifs_dbg(FYI, "search backing up - close and restart search\n");
70638c8a9a5SSteve French spin_lock(&cfile->file_info_lock);
70738c8a9a5SSteve French if (server->ops->dir_needs_close(cfile)) {
70838c8a9a5SSteve French cfile->invalidHandle = true;
70938c8a9a5SSteve French spin_unlock(&cfile->file_info_lock);
71038c8a9a5SSteve French if (server->ops->close_dir)
71138c8a9a5SSteve French server->ops->close_dir(xid, tcon, &cfile->fid);
71238c8a9a5SSteve French } else
71338c8a9a5SSteve French spin_unlock(&cfile->file_info_lock);
71438c8a9a5SSteve French if (cfile->srch_inf.ntwrk_buf_start) {
71538c8a9a5SSteve French cifs_dbg(FYI, "freeing SMB ff cache buf on search rewind\n");
71638c8a9a5SSteve French if (cfile->srch_inf.smallBuf)
71738c8a9a5SSteve French cifs_small_buf_release(cfile->srch_inf.
71838c8a9a5SSteve French ntwrk_buf_start);
71938c8a9a5SSteve French else
72038c8a9a5SSteve French cifs_buf_release(cfile->srch_inf.
72138c8a9a5SSteve French ntwrk_buf_start);
72238c8a9a5SSteve French cfile->srch_inf.ntwrk_buf_start = NULL;
72338c8a9a5SSteve French }
72438c8a9a5SSteve French rc = initiate_cifs_search(xid, file, full_path);
72538c8a9a5SSteve French if (rc) {
72638c8a9a5SSteve French cifs_dbg(FYI, "error %d reinitiating a search on rewind\n",
72738c8a9a5SSteve French rc);
72838c8a9a5SSteve French return rc;
72938c8a9a5SSteve French }
73038c8a9a5SSteve French /* FindFirst/Next set last_entry to NULL on malformed reply */
73138c8a9a5SSteve French if (cfile->srch_inf.last_entry)
73238c8a9a5SSteve French cifs_save_resume_key(cfile->srch_inf.last_entry, cfile);
73338c8a9a5SSteve French }
73438c8a9a5SSteve French
73538c8a9a5SSteve French search_flags = CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME;
73638c8a9a5SSteve French if (backup_cred(cifs_sb))
73738c8a9a5SSteve French search_flags |= CIFS_SEARCH_BACKUP_SEARCH;
73838c8a9a5SSteve French
73938c8a9a5SSteve French while ((index_to_find >= cfile->srch_inf.index_of_last_entry) &&
74038c8a9a5SSteve French (rc == 0) && !cfile->srch_inf.endOfSearch) {
74138c8a9a5SSteve French cifs_dbg(FYI, "calling findnext2\n");
74238c8a9a5SSteve French rc = server->ops->query_dir_next(xid, tcon, &cfile->fid,
74338c8a9a5SSteve French search_flags,
74438c8a9a5SSteve French &cfile->srch_inf);
74538c8a9a5SSteve French /* FindFirst/Next set last_entry to NULL on malformed reply */
74638c8a9a5SSteve French if (cfile->srch_inf.last_entry)
74738c8a9a5SSteve French cifs_save_resume_key(cfile->srch_inf.last_entry, cfile);
74838c8a9a5SSteve French if (rc)
74938c8a9a5SSteve French return -ENOENT;
75038c8a9a5SSteve French }
75138c8a9a5SSteve French if (index_to_find < cfile->srch_inf.index_of_last_entry) {
75238c8a9a5SSteve French /* we found the buffer that contains the entry */
75338c8a9a5SSteve French /* scan and find it */
75438c8a9a5SSteve French int i;
75538c8a9a5SSteve French char *cur_ent;
75638c8a9a5SSteve French char *end_of_smb;
75738c8a9a5SSteve French
75838c8a9a5SSteve French if (cfile->srch_inf.ntwrk_buf_start == NULL) {
75938c8a9a5SSteve French cifs_dbg(VFS, "ntwrk_buf_start is NULL during readdir\n");
76038c8a9a5SSteve French return -EIO;
76138c8a9a5SSteve French }
76238c8a9a5SSteve French
76338c8a9a5SSteve French end_of_smb = cfile->srch_inf.ntwrk_buf_start +
76438c8a9a5SSteve French server->ops->calc_smb_size(
76538c8a9a5SSteve French cfile->srch_inf.ntwrk_buf_start);
76638c8a9a5SSteve French
76738c8a9a5SSteve French cur_ent = cfile->srch_inf.srch_entries_start;
76838c8a9a5SSteve French first_entry_in_buffer = cfile->srch_inf.index_of_last_entry
76938c8a9a5SSteve French - cfile->srch_inf.entries_in_buffer;
77038c8a9a5SSteve French pos_in_buf = index_to_find - first_entry_in_buffer;
77138c8a9a5SSteve French cifs_dbg(FYI, "found entry - pos_in_buf %d\n", pos_in_buf);
77238c8a9a5SSteve French
77338c8a9a5SSteve French for (i = 0; (i < (pos_in_buf)) && (cur_ent != NULL); i++) {
77438c8a9a5SSteve French /* go entry by entry figuring out which is first */
77538c8a9a5SSteve French cur_ent = nxt_dir_entry(cur_ent, end_of_smb,
77638c8a9a5SSteve French cfile->srch_inf.info_level);
77738c8a9a5SSteve French }
77838c8a9a5SSteve French if ((cur_ent == NULL) && (i < pos_in_buf)) {
77938c8a9a5SSteve French /* BB fixme - check if we should flag this error */
78038c8a9a5SSteve French cifs_dbg(VFS, "reached end of buf searching for pos in buf %d index to find %lld rc %d\n",
78138c8a9a5SSteve French pos_in_buf, index_to_find, rc);
78238c8a9a5SSteve French }
78338c8a9a5SSteve French rc = 0;
78438c8a9a5SSteve French *current_entry = cur_ent;
78538c8a9a5SSteve French } else {
78638c8a9a5SSteve French cifs_dbg(FYI, "index not in buffer - could not findnext into it\n");
78738c8a9a5SSteve French return 0;
78838c8a9a5SSteve French }
78938c8a9a5SSteve French
79038c8a9a5SSteve French if (pos_in_buf >= cfile->srch_inf.entries_in_buffer) {
79138c8a9a5SSteve French cifs_dbg(FYI, "can not return entries pos_in_buf beyond last\n");
79238c8a9a5SSteve French *num_to_ret = 0;
79338c8a9a5SSteve French } else
79438c8a9a5SSteve French *num_to_ret = cfile->srch_inf.entries_in_buffer - pos_in_buf;
79538c8a9a5SSteve French
79638c8a9a5SSteve French return rc;
79738c8a9a5SSteve French }
79838c8a9a5SSteve French
emit_cached_dirents(struct cached_dirents * cde,struct dir_context * ctx)79938c8a9a5SSteve French static bool emit_cached_dirents(struct cached_dirents *cde,
80038c8a9a5SSteve French struct dir_context *ctx)
80138c8a9a5SSteve French {
80238c8a9a5SSteve French struct cached_dirent *dirent;
80338c8a9a5SSteve French bool rc;
80438c8a9a5SSteve French
80538c8a9a5SSteve French list_for_each_entry(dirent, &cde->entries, entry) {
80638c8a9a5SSteve French /*
80738c8a9a5SSteve French * Skip all early entries prior to the current lseek()
80838c8a9a5SSteve French * position.
80938c8a9a5SSteve French */
81038c8a9a5SSteve French if (ctx->pos > dirent->pos)
81138c8a9a5SSteve French continue;
81238c8a9a5SSteve French /*
81338c8a9a5SSteve French * We recorded the current ->pos value for the dirent
81438c8a9a5SSteve French * when we stored it in the cache.
81538c8a9a5SSteve French * However, this sequence of ->pos values may have holes
81638c8a9a5SSteve French * in it, for example dot-dirs returned from the server
81738c8a9a5SSteve French * are suppressed.
81838c8a9a5SSteve French * Handle this bu forcing ctx->pos to be the same as the
81938c8a9a5SSteve French * ->pos of the current dirent we emit from the cache.
82038c8a9a5SSteve French * This means that when we emit these entries from the cache
82138c8a9a5SSteve French * we now emit them with the same ->pos value as in the
82238c8a9a5SSteve French * initial scan.
82338c8a9a5SSteve French */
82438c8a9a5SSteve French ctx->pos = dirent->pos;
82538c8a9a5SSteve French rc = dir_emit(ctx, dirent->name, dirent->namelen,
82638c8a9a5SSteve French dirent->fattr.cf_uniqueid,
82738c8a9a5SSteve French dirent->fattr.cf_dtype);
82838c8a9a5SSteve French if (!rc)
82938c8a9a5SSteve French return rc;
83038c8a9a5SSteve French ctx->pos++;
83138c8a9a5SSteve French }
83238c8a9a5SSteve French return true;
83338c8a9a5SSteve French }
83438c8a9a5SSteve French
update_cached_dirents_count(struct cached_dirents * cde,struct dir_context * ctx)83538c8a9a5SSteve French static void update_cached_dirents_count(struct cached_dirents *cde,
83638c8a9a5SSteve French struct dir_context *ctx)
83738c8a9a5SSteve French {
83838c8a9a5SSteve French if (cde->ctx != ctx)
83938c8a9a5SSteve French return;
84038c8a9a5SSteve French if (cde->is_valid || cde->is_failed)
84138c8a9a5SSteve French return;
84238c8a9a5SSteve French
84338c8a9a5SSteve French cde->pos++;
84438c8a9a5SSteve French }
84538c8a9a5SSteve French
finished_cached_dirents_count(struct cached_dirents * cde,struct dir_context * ctx)84638c8a9a5SSteve French static void finished_cached_dirents_count(struct cached_dirents *cde,
84738c8a9a5SSteve French struct dir_context *ctx)
84838c8a9a5SSteve French {
84938c8a9a5SSteve French if (cde->ctx != ctx)
85038c8a9a5SSteve French return;
85138c8a9a5SSteve French if (cde->is_valid || cde->is_failed)
85238c8a9a5SSteve French return;
85338c8a9a5SSteve French if (ctx->pos != cde->pos)
85438c8a9a5SSteve French return;
85538c8a9a5SSteve French
85638c8a9a5SSteve French cde->is_valid = 1;
85738c8a9a5SSteve French }
85838c8a9a5SSteve French
add_cached_dirent(struct cached_dirents * cde,struct dir_context * ctx,const char * name,int namelen,struct cifs_fattr * fattr)85938c8a9a5SSteve French static void add_cached_dirent(struct cached_dirents *cde,
86038c8a9a5SSteve French struct dir_context *ctx,
86138c8a9a5SSteve French const char *name, int namelen,
86238c8a9a5SSteve French struct cifs_fattr *fattr)
86338c8a9a5SSteve French {
86438c8a9a5SSteve French struct cached_dirent *de;
86538c8a9a5SSteve French
86638c8a9a5SSteve French if (cde->ctx != ctx)
86738c8a9a5SSteve French return;
86838c8a9a5SSteve French if (cde->is_valid || cde->is_failed)
86938c8a9a5SSteve French return;
87038c8a9a5SSteve French if (ctx->pos != cde->pos) {
87138c8a9a5SSteve French cde->is_failed = 1;
87238c8a9a5SSteve French return;
87338c8a9a5SSteve French }
87438c8a9a5SSteve French de = kzalloc(sizeof(*de), GFP_ATOMIC);
87538c8a9a5SSteve French if (de == NULL) {
87638c8a9a5SSteve French cde->is_failed = 1;
87738c8a9a5SSteve French return;
87838c8a9a5SSteve French }
87938c8a9a5SSteve French de->namelen = namelen;
88038c8a9a5SSteve French de->name = kstrndup(name, namelen, GFP_ATOMIC);
88138c8a9a5SSteve French if (de->name == NULL) {
88238c8a9a5SSteve French kfree(de);
88338c8a9a5SSteve French cde->is_failed = 1;
88438c8a9a5SSteve French return;
88538c8a9a5SSteve French }
88638c8a9a5SSteve French de->pos = ctx->pos;
88738c8a9a5SSteve French
88838c8a9a5SSteve French memcpy(&de->fattr, fattr, sizeof(struct cifs_fattr));
88938c8a9a5SSteve French
89038c8a9a5SSteve French list_add_tail(&de->entry, &cde->entries);
89138c8a9a5SSteve French }
89238c8a9a5SSteve French
cifs_dir_emit(struct dir_context * ctx,const char * name,int namelen,struct cifs_fattr * fattr,struct cached_fid * cfid)89338c8a9a5SSteve French static bool cifs_dir_emit(struct dir_context *ctx,
89438c8a9a5SSteve French const char *name, int namelen,
89538c8a9a5SSteve French struct cifs_fattr *fattr,
89638c8a9a5SSteve French struct cached_fid *cfid)
89738c8a9a5SSteve French {
89838c8a9a5SSteve French bool rc;
89938c8a9a5SSteve French ino_t ino = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
90038c8a9a5SSteve French
90138c8a9a5SSteve French rc = dir_emit(ctx, name, namelen, ino, fattr->cf_dtype);
90238c8a9a5SSteve French if (!rc)
90338c8a9a5SSteve French return rc;
90438c8a9a5SSteve French
90538c8a9a5SSteve French if (cfid) {
90638c8a9a5SSteve French mutex_lock(&cfid->dirents.de_mutex);
90738c8a9a5SSteve French add_cached_dirent(&cfid->dirents, ctx, name, namelen,
90838c8a9a5SSteve French fattr);
90938c8a9a5SSteve French mutex_unlock(&cfid->dirents.de_mutex);
91038c8a9a5SSteve French }
91138c8a9a5SSteve French
91238c8a9a5SSteve French return rc;
91338c8a9a5SSteve French }
91438c8a9a5SSteve French
cifs_filldir(char * find_entry,struct file * file,struct dir_context * ctx,char * scratch_buf,unsigned int max_len,struct cached_fid * cfid)91538c8a9a5SSteve French static int cifs_filldir(char *find_entry, struct file *file,
91638c8a9a5SSteve French struct dir_context *ctx,
91738c8a9a5SSteve French char *scratch_buf, unsigned int max_len,
91838c8a9a5SSteve French struct cached_fid *cfid)
91938c8a9a5SSteve French {
92038c8a9a5SSteve French struct cifsFileInfo *file_info = file->private_data;
92138c8a9a5SSteve French struct super_block *sb = file_inode(file)->i_sb;
92238c8a9a5SSteve French struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
92338c8a9a5SSteve French struct cifs_dirent de = { NULL, };
92438c8a9a5SSteve French struct cifs_fattr fattr;
92538c8a9a5SSteve French struct qstr name;
92638c8a9a5SSteve French int rc = 0;
92738c8a9a5SSteve French
92838c8a9a5SSteve French rc = cifs_fill_dirent(&de, find_entry, file_info->srch_inf.info_level,
92938c8a9a5SSteve French file_info->srch_inf.unicode);
93038c8a9a5SSteve French if (rc)
93138c8a9a5SSteve French return rc;
93238c8a9a5SSteve French
93338c8a9a5SSteve French if (de.namelen > max_len) {
93438c8a9a5SSteve French cifs_dbg(VFS, "bad search response length %zd past smb end\n",
93538c8a9a5SSteve French de.namelen);
93638c8a9a5SSteve French return -EINVAL;
93738c8a9a5SSteve French }
93838c8a9a5SSteve French
93938c8a9a5SSteve French /* skip . and .. since we added them first */
94038c8a9a5SSteve French if (cifs_entry_is_dot(&de, file_info->srch_inf.unicode))
94138c8a9a5SSteve French return 0;
94238c8a9a5SSteve French
94338c8a9a5SSteve French if (file_info->srch_inf.unicode) {
94438c8a9a5SSteve French struct nls_table *nlt = cifs_sb->local_nls;
94538c8a9a5SSteve French int map_type;
94638c8a9a5SSteve French
94738c8a9a5SSteve French map_type = cifs_remap(cifs_sb);
94838c8a9a5SSteve French name.name = scratch_buf;
94938c8a9a5SSteve French name.len =
95038c8a9a5SSteve French cifs_from_utf16((char *)name.name, (__le16 *)de.name,
95138c8a9a5SSteve French UNICODE_NAME_MAX,
95238c8a9a5SSteve French min_t(size_t, de.namelen,
95338c8a9a5SSteve French (size_t)max_len), nlt, map_type);
95438c8a9a5SSteve French name.len -= nls_nullsize(nlt);
95538c8a9a5SSteve French } else {
95638c8a9a5SSteve French name.name = de.name;
95738c8a9a5SSteve French name.len = de.namelen;
95838c8a9a5SSteve French }
95938c8a9a5SSteve French
96038c8a9a5SSteve French switch (file_info->srch_inf.info_level) {
96138c8a9a5SSteve French case SMB_FIND_FILE_POSIX_INFO:
96238c8a9a5SSteve French cifs_posix_to_fattr(&fattr,
96338c8a9a5SSteve French (struct smb2_posix_info *)find_entry,
96438c8a9a5SSteve French cifs_sb);
96538c8a9a5SSteve French break;
96638c8a9a5SSteve French case SMB_FIND_FILE_UNIX:
96738c8a9a5SSteve French cifs_unix_basic_to_fattr(&fattr,
96838c8a9a5SSteve French &((FILE_UNIX_INFO *)find_entry)->basic,
96938c8a9a5SSteve French cifs_sb);
97038c8a9a5SSteve French if (S_ISLNK(fattr.cf_mode))
97138c8a9a5SSteve French fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
97238c8a9a5SSteve French break;
97338c8a9a5SSteve French case SMB_FIND_FILE_INFO_STANDARD:
97438c8a9a5SSteve French cifs_std_info_to_fattr(&fattr,
97538c8a9a5SSteve French (FIND_FILE_STANDARD_INFO *)find_entry,
97638c8a9a5SSteve French cifs_sb);
97738c8a9a5SSteve French break;
978cacc0a9cSPaulo Alcantara case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
97938c8a9a5SSteve French case SMB_FIND_FILE_ID_FULL_DIR_INFO:
980cacc0a9cSPaulo Alcantara cifs_fulldir_info_to_fattr(&fattr, find_entry, cifs_sb);
98138c8a9a5SSteve French break;
98238c8a9a5SSteve French default:
98338c8a9a5SSteve French cifs_dir_info_to_fattr(&fattr,
98438c8a9a5SSteve French (FILE_DIRECTORY_INFO *)find_entry,
98538c8a9a5SSteve French cifs_sb);
98638c8a9a5SSteve French break;
98738c8a9a5SSteve French }
98838c8a9a5SSteve French
98938c8a9a5SSteve French if (de.ino && (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
99038c8a9a5SSteve French fattr.cf_uniqueid = de.ino;
99138c8a9a5SSteve French } else {
99238c8a9a5SSteve French fattr.cf_uniqueid = iunique(sb, ROOT_I);
99338c8a9a5SSteve French cifs_autodisable_serverino(cifs_sb);
99438c8a9a5SSteve French }
99538c8a9a5SSteve French
99638c8a9a5SSteve French if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) &&
99738c8a9a5SSteve French couldbe_mf_symlink(&fattr))
99838c8a9a5SSteve French /*
99938c8a9a5SSteve French * trying to get the type and mode can be slow,
100038c8a9a5SSteve French * so just call those regular files for now, and mark
100138c8a9a5SSteve French * for reval
100238c8a9a5SSteve French */
100338c8a9a5SSteve French fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
100438c8a9a5SSteve French
100538c8a9a5SSteve French cifs_prime_dcache(file_dentry(file), &name, &fattr);
100638c8a9a5SSteve French
100738c8a9a5SSteve French return !cifs_dir_emit(ctx, name.name, name.len,
100838c8a9a5SSteve French &fattr, cfid);
100938c8a9a5SSteve French }
101038c8a9a5SSteve French
101138c8a9a5SSteve French
cifs_readdir(struct file * file,struct dir_context * ctx)101238c8a9a5SSteve French int cifs_readdir(struct file *file, struct dir_context *ctx)
101338c8a9a5SSteve French {
101438c8a9a5SSteve French int rc = 0;
101538c8a9a5SSteve French unsigned int xid;
101638c8a9a5SSteve French int i;
101738c8a9a5SSteve French struct tcon_link *tlink = NULL;
101838c8a9a5SSteve French struct cifs_tcon *tcon;
101938c8a9a5SSteve French struct cifsFileInfo *cifsFile;
102038c8a9a5SSteve French char *current_entry;
102138c8a9a5SSteve French int num_to_fill = 0;
102238c8a9a5SSteve French char *tmp_buf = NULL;
102338c8a9a5SSteve French char *end_of_smb;
102438c8a9a5SSteve French unsigned int max_len;
102538c8a9a5SSteve French const char *full_path;
102638c8a9a5SSteve French void *page = alloc_dentry_path();
102738c8a9a5SSteve French struct cached_fid *cfid = NULL;
102838c8a9a5SSteve French struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
102938c8a9a5SSteve French
103038c8a9a5SSteve French xid = get_xid();
103138c8a9a5SSteve French
103238c8a9a5SSteve French full_path = build_path_from_dentry(file_dentry(file), page);
103338c8a9a5SSteve French if (IS_ERR(full_path)) {
103438c8a9a5SSteve French rc = PTR_ERR(full_path);
103538c8a9a5SSteve French goto rddir2_exit;
103638c8a9a5SSteve French }
103738c8a9a5SSteve French
103838c8a9a5SSteve French if (file->private_data == NULL) {
103938c8a9a5SSteve French tlink = cifs_sb_tlink(cifs_sb);
104038c8a9a5SSteve French if (IS_ERR(tlink))
104138c8a9a5SSteve French goto cache_not_found;
104238c8a9a5SSteve French tcon = tlink_tcon(tlink);
104338c8a9a5SSteve French } else {
104438c8a9a5SSteve French cifsFile = file->private_data;
104538c8a9a5SSteve French tcon = tlink_tcon(cifsFile->tlink);
104638c8a9a5SSteve French }
104738c8a9a5SSteve French
104838c8a9a5SSteve French rc = open_cached_dir(xid, tcon, full_path, cifs_sb, false, &cfid);
104938c8a9a5SSteve French cifs_put_tlink(tlink);
105038c8a9a5SSteve French if (rc)
105138c8a9a5SSteve French goto cache_not_found;
105238c8a9a5SSteve French
105338c8a9a5SSteve French mutex_lock(&cfid->dirents.de_mutex);
105438c8a9a5SSteve French /*
105538c8a9a5SSteve French * If this was reading from the start of the directory
105638c8a9a5SSteve French * we need to initialize scanning and storing the
105738c8a9a5SSteve French * directory content.
105838c8a9a5SSteve French */
105938c8a9a5SSteve French if (ctx->pos == 0 && cfid->dirents.ctx == NULL) {
106038c8a9a5SSteve French cfid->dirents.ctx = ctx;
106138c8a9a5SSteve French cfid->dirents.pos = 2;
106238c8a9a5SSteve French }
106338c8a9a5SSteve French /*
106438c8a9a5SSteve French * If we already have the entire directory cached then
106538c8a9a5SSteve French * we can just serve the cache.
106638c8a9a5SSteve French */
106738c8a9a5SSteve French if (cfid->dirents.is_valid) {
106838c8a9a5SSteve French if (!dir_emit_dots(file, ctx)) {
106938c8a9a5SSteve French mutex_unlock(&cfid->dirents.de_mutex);
107038c8a9a5SSteve French goto rddir2_exit;
107138c8a9a5SSteve French }
107238c8a9a5SSteve French emit_cached_dirents(&cfid->dirents, ctx);
107338c8a9a5SSteve French mutex_unlock(&cfid->dirents.de_mutex);
107438c8a9a5SSteve French goto rddir2_exit;
107538c8a9a5SSteve French }
107638c8a9a5SSteve French mutex_unlock(&cfid->dirents.de_mutex);
107738c8a9a5SSteve French
107838c8a9a5SSteve French /* Drop the cache while calling initiate_cifs_search and
107938c8a9a5SSteve French * find_cifs_entry in case there will be reconnects during
108038c8a9a5SSteve French * query_directory.
108138c8a9a5SSteve French */
108238c8a9a5SSteve French close_cached_dir(cfid);
108338c8a9a5SSteve French cfid = NULL;
108438c8a9a5SSteve French
108538c8a9a5SSteve French cache_not_found:
108638c8a9a5SSteve French /*
108738c8a9a5SSteve French * Ensure FindFirst doesn't fail before doing filldir() for '.' and
108838c8a9a5SSteve French * '..'. Otherwise we won't be able to notify VFS in case of failure.
108938c8a9a5SSteve French */
109038c8a9a5SSteve French if (file->private_data == NULL) {
109138c8a9a5SSteve French rc = initiate_cifs_search(xid, file, full_path);
109238c8a9a5SSteve French cifs_dbg(FYI, "initiate cifs search rc %d\n", rc);
109338c8a9a5SSteve French if (rc)
109438c8a9a5SSteve French goto rddir2_exit;
109538c8a9a5SSteve French }
109638c8a9a5SSteve French
109738c8a9a5SSteve French if (!dir_emit_dots(file, ctx))
109838c8a9a5SSteve French goto rddir2_exit;
109938c8a9a5SSteve French
110038c8a9a5SSteve French /* 1) If search is active,
110138c8a9a5SSteve French is in current search buffer?
110238c8a9a5SSteve French if it before then restart search
110338c8a9a5SSteve French if after then keep searching till find it */
110438c8a9a5SSteve French cifsFile = file->private_data;
110538c8a9a5SSteve French if (cifsFile->srch_inf.endOfSearch) {
110638c8a9a5SSteve French if (cifsFile->srch_inf.emptyDir) {
110738c8a9a5SSteve French cifs_dbg(FYI, "End of search, empty dir\n");
110838c8a9a5SSteve French rc = 0;
110938c8a9a5SSteve French goto rddir2_exit;
111038c8a9a5SSteve French }
111138c8a9a5SSteve French } /* else {
111238c8a9a5SSteve French cifsFile->invalidHandle = true;
111338c8a9a5SSteve French tcon->ses->server->close(xid, tcon, &cifsFile->fid);
111438c8a9a5SSteve French } */
111538c8a9a5SSteve French
111638c8a9a5SSteve French tcon = tlink_tcon(cifsFile->tlink);
111738c8a9a5SSteve French rc = find_cifs_entry(xid, tcon, ctx->pos, file, full_path,
111838c8a9a5SSteve French ¤t_entry, &num_to_fill);
111938c8a9a5SSteve French open_cached_dir(xid, tcon, full_path, cifs_sb, false, &cfid);
112038c8a9a5SSteve French if (rc) {
112138c8a9a5SSteve French cifs_dbg(FYI, "fce error %d\n", rc);
112238c8a9a5SSteve French goto rddir2_exit;
112338c8a9a5SSteve French } else if (current_entry != NULL) {
112438c8a9a5SSteve French cifs_dbg(FYI, "entry %lld found\n", ctx->pos);
112538c8a9a5SSteve French } else {
112638c8a9a5SSteve French if (cfid) {
112738c8a9a5SSteve French mutex_lock(&cfid->dirents.de_mutex);
112838c8a9a5SSteve French finished_cached_dirents_count(&cfid->dirents, ctx);
112938c8a9a5SSteve French mutex_unlock(&cfid->dirents.de_mutex);
113038c8a9a5SSteve French }
113138c8a9a5SSteve French cifs_dbg(FYI, "Could not find entry\n");
113238c8a9a5SSteve French goto rddir2_exit;
113338c8a9a5SSteve French }
113438c8a9a5SSteve French cifs_dbg(FYI, "loop through %d times filling dir for net buf %p\n",
113538c8a9a5SSteve French num_to_fill, cifsFile->srch_inf.ntwrk_buf_start);
113638c8a9a5SSteve French max_len = tcon->ses->server->ops->calc_smb_size(
113738c8a9a5SSteve French cifsFile->srch_inf.ntwrk_buf_start);
113838c8a9a5SSteve French end_of_smb = cifsFile->srch_inf.ntwrk_buf_start + max_len;
113938c8a9a5SSteve French
114038c8a9a5SSteve French tmp_buf = kmalloc(UNICODE_NAME_MAX, GFP_KERNEL);
114138c8a9a5SSteve French if (tmp_buf == NULL) {
114238c8a9a5SSteve French rc = -ENOMEM;
114338c8a9a5SSteve French goto rddir2_exit;
114438c8a9a5SSteve French }
114538c8a9a5SSteve French
114638c8a9a5SSteve French for (i = 0; i < num_to_fill; i++) {
114738c8a9a5SSteve French if (current_entry == NULL) {
114838c8a9a5SSteve French /* evaluate whether this case is an error */
114938c8a9a5SSteve French cifs_dbg(VFS, "past SMB end, num to fill %d i %d\n",
115038c8a9a5SSteve French num_to_fill, i);
115138c8a9a5SSteve French break;
115238c8a9a5SSteve French }
115338c8a9a5SSteve French /*
115438c8a9a5SSteve French * if buggy server returns . and .. late do we want to
115538c8a9a5SSteve French * check for that here?
115638c8a9a5SSteve French */
115738c8a9a5SSteve French *tmp_buf = 0;
115838c8a9a5SSteve French rc = cifs_filldir(current_entry, file, ctx,
115938c8a9a5SSteve French tmp_buf, max_len, cfid);
116038c8a9a5SSteve French if (rc) {
116138c8a9a5SSteve French if (rc > 0)
116238c8a9a5SSteve French rc = 0;
116338c8a9a5SSteve French break;
116438c8a9a5SSteve French }
116538c8a9a5SSteve French
116638c8a9a5SSteve French ctx->pos++;
116738c8a9a5SSteve French if (cfid) {
116838c8a9a5SSteve French mutex_lock(&cfid->dirents.de_mutex);
116938c8a9a5SSteve French update_cached_dirents_count(&cfid->dirents, ctx);
117038c8a9a5SSteve French mutex_unlock(&cfid->dirents.de_mutex);
117138c8a9a5SSteve French }
117238c8a9a5SSteve French
117338c8a9a5SSteve French if (ctx->pos ==
117438c8a9a5SSteve French cifsFile->srch_inf.index_of_last_entry) {
117538c8a9a5SSteve French cifs_dbg(FYI, "last entry in buf at pos %lld %s\n",
117638c8a9a5SSteve French ctx->pos, tmp_buf);
117738c8a9a5SSteve French cifs_save_resume_key(current_entry, cifsFile);
117838c8a9a5SSteve French break;
117938c8a9a5SSteve French }
118038c8a9a5SSteve French current_entry =
118138c8a9a5SSteve French nxt_dir_entry(current_entry, end_of_smb,
118238c8a9a5SSteve French cifsFile->srch_inf.info_level);
118338c8a9a5SSteve French }
118438c8a9a5SSteve French kfree(tmp_buf);
118538c8a9a5SSteve French
118638c8a9a5SSteve French rddir2_exit:
118738c8a9a5SSteve French if (cfid)
118838c8a9a5SSteve French close_cached_dir(cfid);
118938c8a9a5SSteve French free_dentry_path(page);
119038c8a9a5SSteve French free_xid(xid);
119138c8a9a5SSteve French return rc;
119238c8a9a5SSteve French }
1193