4 * Directory search handling
6 * Copyright (C) International Business Machines Corp., 2004, 2008
7 * Copyright (C) Red Hat, Inc., 2011
8 * Author(s): Steve French (sfrench@us.ibm.com)
10 * This library is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU Lesser General Public License as published
12 * by the Free Software Foundation; either version 2.1 of the License, or
13 * (at your option) any later version.
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
18 * the GNU Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public License
21 * along with this library; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 #include <linux/pagemap.h>
26 #include <linux/slab.h>
27 #include <linux/stat.h>
30 #include "cifsproto.h"
31 #include "cifs_unicode.h"
32 #include "cifs_debug.h"
33 #include "cifs_fs_sb.h"
37 * To be safe - for UCS to UTF-8 with strings loaded with the rare long
38 * characters alloc more to account for such multibyte target UTF-8
41 #define UNICODE_NAME_MAX ((4 * NAME_MAX) + 2)
43 #ifdef CONFIG_CIFS_DEBUG2
44 static void dump_cifs_file_struct(struct file
*file
, char *label
)
46 struct cifsFileInfo
*cf
;
49 cf
= file
->private_data
;
51 cifs_dbg(FYI
, "empty cifs private file data\n");
54 if (cf
->invalidHandle
)
55 cifs_dbg(FYI
, "invalid handle\n");
56 if (cf
->srch_inf
.endOfSearch
)
57 cifs_dbg(FYI
, "end of search\n");
58 if (cf
->srch_inf
.emptyDir
)
59 cifs_dbg(FYI
, "empty dir\n");
63 static inline void dump_cifs_file_struct(struct file
*file
, char *label
)
69 * Attempt to preload the dcache with the results from the FIND_FIRST/NEXT
71 * Find the dentry that matches "name". If there isn't one, create one. If it's
72 * a negative dentry or the uniqueid changed, then drop it and recreate it.
75 cifs_prime_dcache(struct dentry
*parent
, struct qstr
*name
,
76 struct cifs_fattr
*fattr
)
78 struct dentry
*dentry
, *alias
;
80 struct super_block
*sb
= parent
->d_inode
->i_sb
;
81 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
83 cifs_dbg(FYI
, "%s: for %s\n", __func__
, name
->name
);
85 dentry
= d_hash_and_lookup(parent
, name
);
86 if (unlikely(IS_ERR(dentry
)))
92 inode
= dentry
->d_inode
;
95 * If we're generating inode numbers, then we don't
96 * want to clobber the existing one with the one that
97 * the readdir code created.
99 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
))
100 fattr
->cf_uniqueid
= CIFS_I(inode
)->uniqueid
;
102 /* update inode in place if i_ino didn't change */
103 if (CIFS_I(inode
)->uniqueid
== fattr
->cf_uniqueid
) {
104 cifs_fattr_to_inode(inode
, fattr
);
108 err
= d_invalidate(dentry
);
115 * If we know that the inode will need to be revalidated immediately,
116 * then don't create a new dentry for it. We'll end up doing an on
117 * the wire call either way and this spares us an invalidation.
119 if (fattr
->cf_flags
& CIFS_FATTR_NEED_REVAL
)
122 dentry
= d_alloc(parent
, name
);
126 inode
= cifs_iget(sb
, fattr
);
130 alias
= d_materialise_unique(dentry
, inode
);
131 if (alias
&& !IS_ERR(alias
))
138 * Is it possible that this directory might turn out to be a DFS referral
139 * once we go to try and use it?
142 cifs_dfs_is_possible(struct cifs_sb_info
*cifs_sb
)
144 #ifdef CONFIG_CIFS_DFS_UPCALL
145 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
147 if (tcon
->Flags
& SMB_SHARE_IS_IN_DFS
)
154 cifs_fill_common_info(struct cifs_fattr
*fattr
, struct cifs_sb_info
*cifs_sb
)
156 fattr
->cf_uid
= cifs_sb
->mnt_uid
;
157 fattr
->cf_gid
= cifs_sb
->mnt_gid
;
159 if (fattr
->cf_cifsattrs
& ATTR_DIRECTORY
) {
160 fattr
->cf_mode
= S_IFDIR
| cifs_sb
->mnt_dir_mode
;
161 fattr
->cf_dtype
= DT_DIR
;
163 * Windows CIFS servers generally make DFS referrals look
164 * like directories in FIND_* responses with the reparse
165 * attribute flag also set (since DFS junctions are
166 * reparse points). We must revalidate at least these
167 * directory inodes before trying to use them (if
168 * they are DFS we will get PATH_NOT_COVERED back
169 * when queried directly and can then try to connect
172 if (cifs_dfs_is_possible(cifs_sb
) &&
173 (fattr
->cf_cifsattrs
& ATTR_REPARSE
))
174 fattr
->cf_flags
|= CIFS_FATTR_NEED_REVAL
;
175 } else if (fattr
->cf_cifsattrs
& ATTR_REPARSE
) {
176 fattr
->cf_mode
= S_IFLNK
;
177 fattr
->cf_dtype
= DT_LNK
;
179 fattr
->cf_mode
= S_IFREG
| cifs_sb
->mnt_file_mode
;
180 fattr
->cf_dtype
= DT_REG
;
183 /* non-unix readdir doesn't provide nlink */
184 fattr
->cf_flags
|= CIFS_FATTR_UNKNOWN_NLINK
;
186 if (fattr
->cf_cifsattrs
& ATTR_READONLY
)
187 fattr
->cf_mode
&= ~S_IWUGO
;
190 * We of course don't get ACL info in FIND_FIRST/NEXT results, so
191 * mark it for revalidation so that "ls -l" will look right. It might
192 * be super-slow, but if we don't do this then the ownership of files
193 * may look wrong since the inodes may not have timed out by the time
194 * "ls" does a stat() call on them.
196 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
)
197 fattr
->cf_flags
|= CIFS_FATTR_NEED_REVAL
;
199 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
&&
200 fattr
->cf_cifsattrs
& ATTR_SYSTEM
) {
201 if (fattr
->cf_eof
== 0) {
202 fattr
->cf_mode
&= ~S_IFMT
;
203 fattr
->cf_mode
|= S_IFIFO
;
204 fattr
->cf_dtype
= DT_FIFO
;
207 * trying to get the type and mode via SFU can be slow,
208 * so just call those regular files for now, and mark
211 fattr
->cf_flags
|= CIFS_FATTR_NEED_REVAL
;
217 cifs_dir_info_to_fattr(struct cifs_fattr
*fattr
, FILE_DIRECTORY_INFO
*info
,
218 struct cifs_sb_info
*cifs_sb
)
220 memset(fattr
, 0, sizeof(*fattr
));
221 fattr
->cf_cifsattrs
= le32_to_cpu(info
->ExtFileAttributes
);
222 fattr
->cf_eof
= le64_to_cpu(info
->EndOfFile
);
223 fattr
->cf_bytes
= le64_to_cpu(info
->AllocationSize
);
224 fattr
->cf_createtime
= le64_to_cpu(info
->CreationTime
);
225 fattr
->cf_atime
= cifs_NTtimeToUnix(info
->LastAccessTime
);
226 fattr
->cf_ctime
= cifs_NTtimeToUnix(info
->ChangeTime
);
227 fattr
->cf_mtime
= cifs_NTtimeToUnix(info
->LastWriteTime
);
229 cifs_fill_common_info(fattr
, cifs_sb
);
233 cifs_std_info_to_fattr(struct cifs_fattr
*fattr
, FIND_FILE_STANDARD_INFO
*info
,
234 struct cifs_sb_info
*cifs_sb
)
236 int offset
= cifs_sb_master_tcon(cifs_sb
)->ses
->server
->timeAdj
;
238 memset(fattr
, 0, sizeof(*fattr
));
239 fattr
->cf_atime
= cnvrtDosUnixTm(info
->LastAccessDate
,
240 info
->LastAccessTime
, offset
);
241 fattr
->cf_ctime
= cnvrtDosUnixTm(info
->LastWriteDate
,
242 info
->LastWriteTime
, offset
);
243 fattr
->cf_mtime
= cnvrtDosUnixTm(info
->LastWriteDate
,
244 info
->LastWriteTime
, offset
);
246 fattr
->cf_cifsattrs
= le16_to_cpu(info
->Attributes
);
247 fattr
->cf_bytes
= le32_to_cpu(info
->AllocationSize
);
248 fattr
->cf_eof
= le32_to_cpu(info
->DataSize
);
250 cifs_fill_common_info(fattr
, cifs_sb
);
253 /* BB eventually need to add the following helper function to
254 resolve NT_STATUS_STOPPED_ON_SYMLINK return code when
255 we try to do FindFirst on (NTFS) directory symlinks */
257 int get_symlink_reparse_path(char *full_path, struct cifs_sb_info *cifs_sb,
264 struct cifs_tcon *ptcon = cifs_sb_tcon(cifs_sb);
267 rc = CIFSSMBOpen(xid, ptcon, full_path, FILE_OPEN, GENERIC_READ,
268 OPEN_REPARSE_POINT, &fid, &oplock, NULL,
270 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
272 tmpbuffer = kmalloc(maxpath);
273 rc = CIFSSMBQueryReparseLinkInfo(xid, ptcon, full_path,
278 if (CIFSSMBClose(xid, ptcon, fid)) {
279 cifs_dbg(FYI, "Error closing temporary reparsepoint open\n");
286 initiate_cifs_search(const unsigned int xid
, struct file
*file
)
290 char *full_path
= NULL
;
291 struct cifsFileInfo
*cifsFile
;
292 struct cifs_sb_info
*cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
293 struct tcon_link
*tlink
= NULL
;
294 struct cifs_tcon
*tcon
;
295 struct TCP_Server_Info
*server
;
297 if (file
->private_data
== NULL
) {
298 tlink
= cifs_sb_tlink(cifs_sb
);
300 return PTR_ERR(tlink
);
302 cifsFile
= kzalloc(sizeof(struct cifsFileInfo
), GFP_KERNEL
);
303 if (cifsFile
== NULL
) {
307 file
->private_data
= cifsFile
;
308 cifsFile
->tlink
= cifs_get_tlink(tlink
);
309 tcon
= tlink_tcon(tlink
);
311 cifsFile
= file
->private_data
;
312 tcon
= tlink_tcon(cifsFile
->tlink
);
315 server
= tcon
->ses
->server
;
317 if (!server
->ops
->query_dir_first
) {
322 cifsFile
->invalidHandle
= true;
323 cifsFile
->srch_inf
.endOfSearch
= false;
325 full_path
= build_path_from_dentry(file
->f_path
.dentry
);
326 if (full_path
== NULL
) {
331 cifs_dbg(FYI
, "Full path: %s start at: %lld\n", full_path
, file
->f_pos
);
334 /* test for Unix extensions */
335 /* but now check for them on the share/mount not on the SMB session */
336 /* if (cap_unix(tcon->ses) { */
338 cifsFile
->srch_inf
.info_level
= SMB_FIND_FILE_UNIX
;
339 else if ((tcon
->ses
->capabilities
&
340 tcon
->ses
->server
->vals
->cap_nt_find
) == 0) {
341 cifsFile
->srch_inf
.info_level
= SMB_FIND_FILE_INFO_STANDARD
;
342 } else if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
) {
343 cifsFile
->srch_inf
.info_level
= SMB_FIND_FILE_ID_FULL_DIR_INFO
;
344 } else /* not srvinos - BB fixme add check for backlevel? */ {
345 cifsFile
->srch_inf
.info_level
= SMB_FIND_FILE_DIRECTORY_INFO
;
348 search_flags
= CIFS_SEARCH_CLOSE_AT_END
| CIFS_SEARCH_RETURN_RESUME
;
349 if (backup_cred(cifs_sb
))
350 search_flags
|= CIFS_SEARCH_BACKUP_SEARCH
;
352 rc
= server
->ops
->query_dir_first(xid
, tcon
, full_path
, cifs_sb
,
353 &cifsFile
->fid
, search_flags
,
354 &cifsFile
->srch_inf
);
357 cifsFile
->invalidHandle
= false;
358 /* BB add following call to handle readdir on new NTFS symlink errors
359 else if STATUS_STOPPED_ON_SYMLINK
360 call get_symlink_reparse_path and retry with new path */
361 else if ((rc
== -EOPNOTSUPP
) &&
362 (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
)) {
363 cifs_sb
->mnt_cifs_flags
&= ~CIFS_MOUNT_SERVER_INUM
;
368 cifs_put_tlink(tlink
);
372 /* return length of unicode string in bytes */
373 static int cifs_unicode_bytelen(const char *str
)
376 const __le16
*ustr
= (const __le16
*)str
;
378 for (len
= 0; len
<= PATH_MAX
; len
++) {
382 cifs_dbg(FYI
, "Unicode string longer than PATH_MAX found\n");
386 static char *nxt_dir_entry(char *old_entry
, char *end_of_smb
, int level
)
389 FILE_DIRECTORY_INFO
*pDirInfo
= (FILE_DIRECTORY_INFO
*)old_entry
;
391 if (level
== SMB_FIND_FILE_INFO_STANDARD
) {
392 FIND_FILE_STANDARD_INFO
*pfData
;
393 pfData
= (FIND_FILE_STANDARD_INFO
*)pDirInfo
;
395 new_entry
= old_entry
+ sizeof(FIND_FILE_STANDARD_INFO
) +
396 pfData
->FileNameLength
;
398 new_entry
= old_entry
+ le32_to_cpu(pDirInfo
->NextEntryOffset
);
399 cifs_dbg(FYI
, "new entry %p old entry %p\n", new_entry
, old_entry
);
400 /* validate that new_entry is not past end of SMB */
401 if (new_entry
>= end_of_smb
) {
402 cifs_dbg(VFS
, "search entry %p began after end of SMB %p old entry %p\n",
403 new_entry
, end_of_smb
, old_entry
);
405 } else if (((level
== SMB_FIND_FILE_INFO_STANDARD
) &&
406 (new_entry
+ sizeof(FIND_FILE_STANDARD_INFO
) > end_of_smb
))
407 || ((level
!= SMB_FIND_FILE_INFO_STANDARD
) &&
408 (new_entry
+ sizeof(FILE_DIRECTORY_INFO
) > end_of_smb
))) {
409 cifs_dbg(VFS
, "search entry %p extends after end of SMB %p\n",
410 new_entry
, end_of_smb
);
424 static void cifs_fill_dirent_unix(struct cifs_dirent
*de
,
425 const FILE_UNIX_INFO
*info
, bool is_unicode
)
427 de
->name
= &info
->FileName
[0];
429 de
->namelen
= cifs_unicode_bytelen(de
->name
);
431 de
->namelen
= strnlen(de
->name
, PATH_MAX
);
432 de
->resume_key
= info
->ResumeKey
;
433 de
->ino
= le64_to_cpu(info
->basic
.UniqueId
);
436 static void cifs_fill_dirent_dir(struct cifs_dirent
*de
,
437 const FILE_DIRECTORY_INFO
*info
)
439 de
->name
= &info
->FileName
[0];
440 de
->namelen
= le32_to_cpu(info
->FileNameLength
);
441 de
->resume_key
= info
->FileIndex
;
444 static void cifs_fill_dirent_full(struct cifs_dirent
*de
,
445 const FILE_FULL_DIRECTORY_INFO
*info
)
447 de
->name
= &info
->FileName
[0];
448 de
->namelen
= le32_to_cpu(info
->FileNameLength
);
449 de
->resume_key
= info
->FileIndex
;
452 static void cifs_fill_dirent_search(struct cifs_dirent
*de
,
453 const SEARCH_ID_FULL_DIR_INFO
*info
)
455 de
->name
= &info
->FileName
[0];
456 de
->namelen
= le32_to_cpu(info
->FileNameLength
);
457 de
->resume_key
= info
->FileIndex
;
458 de
->ino
= le64_to_cpu(info
->UniqueId
);
461 static void cifs_fill_dirent_both(struct cifs_dirent
*de
,
462 const FILE_BOTH_DIRECTORY_INFO
*info
)
464 de
->name
= &info
->FileName
[0];
465 de
->namelen
= le32_to_cpu(info
->FileNameLength
);
466 de
->resume_key
= info
->FileIndex
;
469 static void cifs_fill_dirent_std(struct cifs_dirent
*de
,
470 const FIND_FILE_STANDARD_INFO
*info
)
472 de
->name
= &info
->FileName
[0];
473 /* one byte length, no endianess conversion */
474 de
->namelen
= info
->FileNameLength
;
475 de
->resume_key
= info
->ResumeKey
;
478 static int cifs_fill_dirent(struct cifs_dirent
*de
, const void *info
,
479 u16 level
, bool is_unicode
)
481 memset(de
, 0, sizeof(*de
));
484 case SMB_FIND_FILE_UNIX
:
485 cifs_fill_dirent_unix(de
, info
, is_unicode
);
487 case SMB_FIND_FILE_DIRECTORY_INFO
:
488 cifs_fill_dirent_dir(de
, info
);
490 case SMB_FIND_FILE_FULL_DIRECTORY_INFO
:
491 cifs_fill_dirent_full(de
, info
);
493 case SMB_FIND_FILE_ID_FULL_DIR_INFO
:
494 cifs_fill_dirent_search(de
, info
);
496 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO
:
497 cifs_fill_dirent_both(de
, info
);
499 case SMB_FIND_FILE_INFO_STANDARD
:
500 cifs_fill_dirent_std(de
, info
);
503 cifs_dbg(FYI
, "Unknown findfirst level %d\n", level
);
510 #define UNICODE_DOT cpu_to_le16(0x2e)
512 /* return 0 if no match and 1 for . (current directory) and 2 for .. (parent) */
513 static int cifs_entry_is_dot(struct cifs_dirent
*de
, bool is_unicode
)
521 __le16
*ufilename
= (__le16
*)de
->name
;
522 if (de
->namelen
== 2) {
524 if (ufilename
[0] == UNICODE_DOT
)
526 } else if (de
->namelen
== 4) {
528 if (ufilename
[0] == UNICODE_DOT
&&
529 ufilename
[1] == UNICODE_DOT
)
533 if (de
->namelen
== 1) {
534 if (de
->name
[0] == '.')
536 } else if (de
->namelen
== 2) {
537 if (de
->name
[0] == '.' && de
->name
[1] == '.')
545 /* Check if directory that we are searching has changed so we can decide
546 whether we can use the cached search results from the previous search */
547 static int is_dir_changed(struct file
*file
)
549 struct inode
*inode
= file_inode(file
);
550 struct cifsInodeInfo
*cifsInfo
= CIFS_I(inode
);
552 if (cifsInfo
->time
== 0)
553 return 1; /* directory was changed, perhaps due to unlink */
559 static int cifs_save_resume_key(const char *current_entry
,
560 struct cifsFileInfo
*file_info
)
562 struct cifs_dirent de
;
565 rc
= cifs_fill_dirent(&de
, current_entry
, file_info
->srch_inf
.info_level
,
566 file_info
->srch_inf
.unicode
);
568 file_info
->srch_inf
.presume_name
= de
.name
;
569 file_info
->srch_inf
.resume_name_len
= de
.namelen
;
570 file_info
->srch_inf
.resume_key
= de
.resume_key
;
576 * Find the corresponding entry in the search. Note that the SMB server returns
577 * search entries for . and .. which complicates logic here if we choose to
578 * parse for them and we do not assume that they are located in the findfirst
579 * return buffer. We start counting in the buffer with entry 2 and increment for
580 * every entry (do not increment for . or .. entry).
583 find_cifs_entry(const unsigned int xid
, struct cifs_tcon
*tcon
, loff_t pos
,
584 struct file
*file
, char **current_entry
, int *num_to_ret
)
589 loff_t first_entry_in_buffer
;
590 loff_t index_to_find
= pos
;
591 struct cifsFileInfo
*cfile
= file
->private_data
;
592 struct cifs_sb_info
*cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
593 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
594 /* check if index in the buffer */
596 if (!server
->ops
->query_dir_first
|| !server
->ops
->query_dir_next
)
599 if ((cfile
== NULL
) || (current_entry
== NULL
) || (num_to_ret
== NULL
))
602 *current_entry
= NULL
;
603 first_entry_in_buffer
= cfile
->srch_inf
.index_of_last_entry
-
604 cfile
->srch_inf
.entries_in_buffer
;
607 * If first entry in buf is zero then is first buffer
608 * in search response data which means it is likely . and ..
609 * will be in this buffer, although some servers do not return
610 * . and .. for the root of a drive and for those we need
611 * to start two entries earlier.
614 dump_cifs_file_struct(file
, "In fce ");
615 if (((index_to_find
< cfile
->srch_inf
.index_of_last_entry
) &&
616 is_dir_changed(file
)) || (index_to_find
< first_entry_in_buffer
)) {
617 /* close and restart search */
618 cifs_dbg(FYI
, "search backing up - close and restart search\n");
619 spin_lock(&cifs_file_list_lock
);
620 if (!cfile
->srch_inf
.endOfSearch
&& !cfile
->invalidHandle
) {
621 cfile
->invalidHandle
= true;
622 spin_unlock(&cifs_file_list_lock
);
623 if (server
->ops
->close
)
624 server
->ops
->close(xid
, tcon
, &cfile
->fid
);
626 spin_unlock(&cifs_file_list_lock
);
627 if (cfile
->srch_inf
.ntwrk_buf_start
) {
628 cifs_dbg(FYI
, "freeing SMB ff cache buf on search rewind\n");
629 if (cfile
->srch_inf
.smallBuf
)
630 cifs_small_buf_release(cfile
->srch_inf
.
633 cifs_buf_release(cfile
->srch_inf
.
635 cfile
->srch_inf
.ntwrk_buf_start
= NULL
;
637 rc
= initiate_cifs_search(xid
, file
);
639 cifs_dbg(FYI
, "error %d reinitiating a search on rewind\n",
643 /* FindFirst/Next set last_entry to NULL on malformed reply */
644 if (cfile
->srch_inf
.last_entry
)
645 cifs_save_resume_key(cfile
->srch_inf
.last_entry
, cfile
);
648 search_flags
= CIFS_SEARCH_CLOSE_AT_END
| CIFS_SEARCH_RETURN_RESUME
;
649 if (backup_cred(cifs_sb
))
650 search_flags
|= CIFS_SEARCH_BACKUP_SEARCH
;
652 while ((index_to_find
>= cfile
->srch_inf
.index_of_last_entry
) &&
653 (rc
== 0) && !cfile
->srch_inf
.endOfSearch
) {
654 cifs_dbg(FYI
, "calling findnext2\n");
655 rc
= server
->ops
->query_dir_next(xid
, tcon
, &cfile
->fid
,
658 /* FindFirst/Next set last_entry to NULL on malformed reply */
659 if (cfile
->srch_inf
.last_entry
)
660 cifs_save_resume_key(cfile
->srch_inf
.last_entry
, cfile
);
664 if (index_to_find
< cfile
->srch_inf
.index_of_last_entry
) {
665 /* we found the buffer that contains the entry */
666 /* scan and find it */
669 char *end_of_smb
= cfile
->srch_inf
.ntwrk_buf_start
+
670 server
->ops
->calc_smb_size(
671 cfile
->srch_inf
.ntwrk_buf_start
);
673 cur_ent
= cfile
->srch_inf
.srch_entries_start
;
674 first_entry_in_buffer
= cfile
->srch_inf
.index_of_last_entry
675 - cfile
->srch_inf
.entries_in_buffer
;
676 pos_in_buf
= index_to_find
- first_entry_in_buffer
;
677 cifs_dbg(FYI
, "found entry - pos_in_buf %d\n", pos_in_buf
);
679 for (i
= 0; (i
< (pos_in_buf
)) && (cur_ent
!= NULL
); i
++) {
680 /* go entry by entry figuring out which is first */
681 cur_ent
= nxt_dir_entry(cur_ent
, end_of_smb
,
682 cfile
->srch_inf
.info_level
);
684 if ((cur_ent
== NULL
) && (i
< pos_in_buf
)) {
685 /* BB fixme - check if we should flag this error */
686 cifs_dbg(VFS
, "reached end of buf searching for pos in buf %d index to find %lld rc %d\n",
687 pos_in_buf
, index_to_find
, rc
);
690 *current_entry
= cur_ent
;
692 cifs_dbg(FYI
, "index not in buffer - could not findnext into it\n");
696 if (pos_in_buf
>= cfile
->srch_inf
.entries_in_buffer
) {
697 cifs_dbg(FYI
, "can not return entries pos_in_buf beyond last\n");
700 *num_to_ret
= cfile
->srch_inf
.entries_in_buffer
- pos_in_buf
;
705 static int cifs_filldir(char *find_entry
, struct file
*file
,
706 struct dir_context
*ctx
,
707 char *scratch_buf
, unsigned int max_len
)
709 struct cifsFileInfo
*file_info
= file
->private_data
;
710 struct super_block
*sb
= file
->f_path
.dentry
->d_sb
;
711 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
712 struct cifs_dirent de
= { NULL
, };
713 struct cifs_fattr fattr
;
718 rc
= cifs_fill_dirent(&de
, find_entry
, file_info
->srch_inf
.info_level
,
719 file_info
->srch_inf
.unicode
);
723 if (de
.namelen
> max_len
) {
724 cifs_dbg(VFS
, "bad search response length %zd past smb end\n",
729 /* skip . and .. since we added them first */
730 if (cifs_entry_is_dot(&de
, file_info
->srch_inf
.unicode
))
733 if (file_info
->srch_inf
.unicode
) {
734 struct nls_table
*nlt
= cifs_sb
->local_nls
;
736 name
.name
= scratch_buf
;
738 cifs_from_utf16((char *)name
.name
, (__le16
*)de
.name
,
740 min_t(size_t, de
.namelen
,
741 (size_t)max_len
), nlt
,
742 cifs_sb
->mnt_cifs_flags
&
743 CIFS_MOUNT_MAP_SPECIAL_CHR
);
744 name
.len
-= nls_nullsize(nlt
);
747 name
.len
= de
.namelen
;
750 switch (file_info
->srch_inf
.info_level
) {
751 case SMB_FIND_FILE_UNIX
:
752 cifs_unix_basic_to_fattr(&fattr
,
753 &((FILE_UNIX_INFO
*)find_entry
)->basic
,
756 case SMB_FIND_FILE_INFO_STANDARD
:
757 cifs_std_info_to_fattr(&fattr
,
758 (FIND_FILE_STANDARD_INFO
*)find_entry
,
762 cifs_dir_info_to_fattr(&fattr
,
763 (FILE_DIRECTORY_INFO
*)find_entry
,
768 if (de
.ino
&& (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
)) {
769 fattr
.cf_uniqueid
= de
.ino
;
771 fattr
.cf_uniqueid
= iunique(sb
, ROOT_I
);
772 cifs_autodisable_serverino(cifs_sb
);
775 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MF_SYMLINKS
) &&
776 CIFSCouldBeMFSymlink(&fattr
))
778 * trying to get the type and mode can be slow,
779 * so just call those regular files for now, and mark
782 fattr
.cf_flags
|= CIFS_FATTR_NEED_REVAL
;
784 cifs_prime_dcache(file
->f_dentry
, &name
, &fattr
);
786 ino
= cifs_uniqueid_to_ino_t(fattr
.cf_uniqueid
);
787 return !dir_emit(ctx
, name
.name
, name
.len
, ino
, fattr
.cf_dtype
);
791 int cifs_readdir(struct file
*file
, struct dir_context
*ctx
)
796 struct cifs_tcon
*tcon
;
797 struct cifsFileInfo
*cifsFile
= NULL
;
800 char *tmp_buf
= NULL
;
802 unsigned int max_len
;
807 * Ensure FindFirst doesn't fail before doing filldir() for '.' and
808 * '..'. Otherwise we won't be able to notify VFS in case of failure.
810 if (file
->private_data
== NULL
) {
811 rc
= initiate_cifs_search(xid
, file
);
812 cifs_dbg(FYI
, "initiate cifs search rc %d\n", rc
);
817 if (!dir_emit_dots(file
, ctx
))
820 /* 1) If search is active,
821 is in current search buffer?
822 if it before then restart search
823 if after then keep searching till find it */
825 if (file
->private_data
== NULL
) {
829 cifsFile
= file
->private_data
;
830 if (cifsFile
->srch_inf
.endOfSearch
) {
831 if (cifsFile
->srch_inf
.emptyDir
) {
832 cifs_dbg(FYI
, "End of search, empty dir\n");
837 cifsFile->invalidHandle = true;
838 tcon->ses->server->close(xid, tcon, &cifsFile->fid);
841 tcon
= tlink_tcon(cifsFile
->tlink
);
842 rc
= find_cifs_entry(xid
, tcon
, ctx
->pos
, file
, ¤t_entry
,
845 cifs_dbg(FYI
, "fce error %d\n", rc
);
847 } else if (current_entry
!= NULL
) {
848 cifs_dbg(FYI
, "entry %lld found\n", ctx
->pos
);
850 cifs_dbg(FYI
, "could not find entry\n");
853 cifs_dbg(FYI
, "loop through %d times filling dir for net buf %p\n",
854 num_to_fill
, cifsFile
->srch_inf
.ntwrk_buf_start
);
855 max_len
= tcon
->ses
->server
->ops
->calc_smb_size(
856 cifsFile
->srch_inf
.ntwrk_buf_start
);
857 end_of_smb
= cifsFile
->srch_inf
.ntwrk_buf_start
+ max_len
;
859 tmp_buf
= kmalloc(UNICODE_NAME_MAX
, GFP_KERNEL
);
860 if (tmp_buf
== NULL
) {
865 for (i
= 0; i
< num_to_fill
; i
++) {
866 if (current_entry
== NULL
) {
867 /* evaluate whether this case is an error */
868 cifs_dbg(VFS
, "past SMB end, num to fill %d i %d\n",
873 * if buggy server returns . and .. late do we want to
874 * check for that here?
876 rc
= cifs_filldir(current_entry
, file
, ctx
,
886 cifsFile
->srch_inf
.index_of_last_entry
) {
887 cifs_dbg(FYI
, "last entry in buf at pos %lld %s\n",
889 cifs_save_resume_key(current_entry
, cifsFile
);
893 nxt_dir_entry(current_entry
, end_of_smb
,
894 cifsFile
->srch_inf
.info_level
);