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