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 cFYI(1, "empty cifs private file data");
54 if (cf
->invalidHandle
)
55 cFYI(1, "invalid handle");
56 if (cf
->srch_inf
.endOfSearch
)
57 cFYI(1, "end of search");
58 if (cf
->srch_inf
.emptyDir
)
63 static inline void dump_cifs_file_struct(struct file
*file
, char *label
)
69 * Find the dentry that matches "name". If there isn't one, create one. If it's
70 * a negative dentry or the uniqueid changed, then drop it and recreate it.
72 static struct dentry
*
73 cifs_readdir_lookup(struct dentry
*parent
, struct qstr
*name
,
74 struct cifs_fattr
*fattr
)
76 struct dentry
*dentry
, *alias
;
78 struct super_block
*sb
= parent
->d_inode
->i_sb
;
80 cFYI(1, "For %s", name
->name
);
82 if (parent
->d_op
&& parent
->d_op
->d_hash
)
83 parent
->d_op
->d_hash(parent
, parent
->d_inode
, name
);
85 name
->hash
= full_name_hash(name
->name
, name
->len
);
87 dentry
= d_lookup(parent
, name
);
89 /* FIXME: check for inode number changes? */
90 if (dentry
->d_inode
!= NULL
)
96 dentry
= d_alloc(parent
, name
);
100 inode
= cifs_iget(sb
, fattr
);
106 alias
= d_materialise_unique(dentry
, inode
);
118 cifs_fill_common_info(struct cifs_fattr
*fattr
, struct cifs_sb_info
*cifs_sb
)
120 fattr
->cf_uid
= cifs_sb
->mnt_uid
;
121 fattr
->cf_gid
= cifs_sb
->mnt_gid
;
123 if (fattr
->cf_cifsattrs
& ATTR_DIRECTORY
) {
124 fattr
->cf_mode
= S_IFDIR
| cifs_sb
->mnt_dir_mode
;
125 fattr
->cf_dtype
= DT_DIR
;
127 fattr
->cf_mode
= S_IFREG
| cifs_sb
->mnt_file_mode
;
128 fattr
->cf_dtype
= DT_REG
;
131 if (fattr
->cf_cifsattrs
& ATTR_READONLY
)
132 fattr
->cf_mode
&= ~S_IWUGO
;
134 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
&&
135 fattr
->cf_cifsattrs
& ATTR_SYSTEM
) {
136 if (fattr
->cf_eof
== 0) {
137 fattr
->cf_mode
&= ~S_IFMT
;
138 fattr
->cf_mode
|= S_IFIFO
;
139 fattr
->cf_dtype
= DT_FIFO
;
142 * trying to get the type and mode via SFU can be slow,
143 * so just call those regular files for now, and mark
146 fattr
->cf_flags
|= CIFS_FATTR_NEED_REVAL
;
152 cifs_dir_info_to_fattr(struct cifs_fattr
*fattr
, FILE_DIRECTORY_INFO
*info
,
153 struct cifs_sb_info
*cifs_sb
)
155 memset(fattr
, 0, sizeof(*fattr
));
156 fattr
->cf_cifsattrs
= le32_to_cpu(info
->ExtFileAttributes
);
157 fattr
->cf_eof
= le64_to_cpu(info
->EndOfFile
);
158 fattr
->cf_bytes
= le64_to_cpu(info
->AllocationSize
);
159 fattr
->cf_createtime
= le64_to_cpu(info
->CreationTime
);
160 fattr
->cf_atime
= cifs_NTtimeToUnix(info
->LastAccessTime
);
161 fattr
->cf_ctime
= cifs_NTtimeToUnix(info
->ChangeTime
);
162 fattr
->cf_mtime
= cifs_NTtimeToUnix(info
->LastWriteTime
);
164 cifs_fill_common_info(fattr
, cifs_sb
);
168 cifs_std_info_to_fattr(struct cifs_fattr
*fattr
, FIND_FILE_STANDARD_INFO
*info
,
169 struct cifs_sb_info
*cifs_sb
)
171 int offset
= cifs_sb_master_tcon(cifs_sb
)->ses
->server
->timeAdj
;
173 memset(fattr
, 0, sizeof(*fattr
));
174 fattr
->cf_atime
= cnvrtDosUnixTm(info
->LastAccessDate
,
175 info
->LastAccessTime
, offset
);
176 fattr
->cf_ctime
= cnvrtDosUnixTm(info
->LastWriteDate
,
177 info
->LastWriteTime
, offset
);
178 fattr
->cf_mtime
= cnvrtDosUnixTm(info
->LastWriteDate
,
179 info
->LastWriteTime
, offset
);
181 fattr
->cf_cifsattrs
= le16_to_cpu(info
->Attributes
);
182 fattr
->cf_bytes
= le32_to_cpu(info
->AllocationSize
);
183 fattr
->cf_eof
= le32_to_cpu(info
->DataSize
);
185 cifs_fill_common_info(fattr
, cifs_sb
);
188 /* BB eventually need to add the following helper function to
189 resolve NT_STATUS_STOPPED_ON_SYMLINK return code when
190 we try to do FindFirst on (NTFS) directory symlinks */
192 int get_symlink_reparse_path(char *full_path, struct cifs_sb_info *cifs_sb,
199 struct cifs_tcon *ptcon = cifs_sb_tcon(cifs_sb);
202 rc = CIFSSMBOpen(xid, ptcon, full_path, FILE_OPEN, GENERIC_READ,
203 OPEN_REPARSE_POINT, &fid, &oplock, NULL,
205 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
207 tmpbuffer = kmalloc(maxpath);
208 rc = CIFSSMBQueryReparseLinkInfo(xid, ptcon, full_path,
213 if (CIFSSMBClose(xid, ptcon, fid)) {
214 cFYI(1, "Error closing temporary reparsepoint open");
220 static int initiate_cifs_search(const int xid
, struct file
*file
)
224 char *full_path
= NULL
;
225 struct cifsFileInfo
*cifsFile
;
226 struct cifs_sb_info
*cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
227 struct tcon_link
*tlink
= NULL
;
228 struct cifs_tcon
*pTcon
;
230 if (file
->private_data
== NULL
) {
231 tlink
= cifs_sb_tlink(cifs_sb
);
233 return PTR_ERR(tlink
);
235 cifsFile
= kzalloc(sizeof(struct cifsFileInfo
), GFP_KERNEL
);
236 if (cifsFile
== NULL
) {
240 file
->private_data
= cifsFile
;
241 cifsFile
->tlink
= cifs_get_tlink(tlink
);
242 pTcon
= tlink_tcon(tlink
);
244 cifsFile
= file
->private_data
;
245 pTcon
= tlink_tcon(cifsFile
->tlink
);
248 cifsFile
->invalidHandle
= true;
249 cifsFile
->srch_inf
.endOfSearch
= false;
251 full_path
= build_path_from_dentry(file
->f_path
.dentry
);
252 if (full_path
== NULL
) {
257 cFYI(1, "Full path: %s start at: %lld", full_path
, file
->f_pos
);
260 /* test for Unix extensions */
261 /* but now check for them on the share/mount not on the SMB session */
262 /* if (pTcon->ses->capabilities & CAP_UNIX) { */
264 cifsFile
->srch_inf
.info_level
= SMB_FIND_FILE_UNIX
;
265 else if ((pTcon
->ses
->capabilities
&
266 (CAP_NT_SMBS
| CAP_NT_FIND
)) == 0) {
267 cifsFile
->srch_inf
.info_level
= SMB_FIND_FILE_INFO_STANDARD
;
268 } else if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
) {
269 cifsFile
->srch_inf
.info_level
= SMB_FIND_FILE_ID_FULL_DIR_INFO
;
270 } else /* not srvinos - BB fixme add check for backlevel? */ {
271 cifsFile
->srch_inf
.info_level
= SMB_FIND_FILE_DIRECTORY_INFO
;
274 search_flags
= CIFS_SEARCH_CLOSE_AT_END
| CIFS_SEARCH_RETURN_RESUME
;
275 if (backup_cred(cifs_sb
))
276 search_flags
|= CIFS_SEARCH_BACKUP_SEARCH
;
278 rc
= CIFSFindFirst(xid
, pTcon
, full_path
, cifs_sb
->local_nls
,
279 &cifsFile
->netfid
, search_flags
, &cifsFile
->srch_inf
,
280 cifs_sb
->mnt_cifs_flags
&
281 CIFS_MOUNT_MAP_SPECIAL_CHR
, CIFS_DIR_SEP(cifs_sb
));
283 cifsFile
->invalidHandle
= false;
284 /* BB add following call to handle readdir on new NTFS symlink errors
285 else if STATUS_STOPPED_ON_SYMLINK
286 call get_symlink_reparse_path and retry with new path */
287 else if ((rc
== -EOPNOTSUPP
) &&
288 (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
)) {
289 cifs_sb
->mnt_cifs_flags
&= ~CIFS_MOUNT_SERVER_INUM
;
294 cifs_put_tlink(tlink
);
298 /* return length of unicode string in bytes */
299 static int cifs_unicode_bytelen(const char *str
)
302 const __le16
*ustr
= (const __le16
*)str
;
304 for (len
= 0; len
<= PATH_MAX
; len
++) {
308 cFYI(1, "Unicode string longer than PATH_MAX found");
312 static char *nxt_dir_entry(char *old_entry
, char *end_of_smb
, int level
)
315 FILE_DIRECTORY_INFO
*pDirInfo
= (FILE_DIRECTORY_INFO
*)old_entry
;
317 if (level
== SMB_FIND_FILE_INFO_STANDARD
) {
318 FIND_FILE_STANDARD_INFO
*pfData
;
319 pfData
= (FIND_FILE_STANDARD_INFO
*)pDirInfo
;
321 new_entry
= old_entry
+ sizeof(FIND_FILE_STANDARD_INFO
) +
322 pfData
->FileNameLength
;
324 new_entry
= old_entry
+ le32_to_cpu(pDirInfo
->NextEntryOffset
);
325 cFYI(1, "new entry %p old entry %p", new_entry
, old_entry
);
326 /* validate that new_entry is not past end of SMB */
327 if (new_entry
>= end_of_smb
) {
328 cERROR(1, "search entry %p began after end of SMB %p old entry %p",
329 new_entry
, end_of_smb
, old_entry
);
331 } else if (((level
== SMB_FIND_FILE_INFO_STANDARD
) &&
332 (new_entry
+ sizeof(FIND_FILE_STANDARD_INFO
) > end_of_smb
))
333 || ((level
!= SMB_FIND_FILE_INFO_STANDARD
) &&
334 (new_entry
+ sizeof(FILE_DIRECTORY_INFO
) > end_of_smb
))) {
335 cERROR(1, "search entry %p extends after end of SMB %p",
336 new_entry
, end_of_smb
);
350 static void cifs_fill_dirent_unix(struct cifs_dirent
*de
,
351 const FILE_UNIX_INFO
*info
, bool is_unicode
)
353 de
->name
= &info
->FileName
[0];
355 de
->namelen
= cifs_unicode_bytelen(de
->name
);
357 de
->namelen
= strnlen(de
->name
, PATH_MAX
);
358 de
->resume_key
= info
->ResumeKey
;
359 de
->ino
= le64_to_cpu(info
->basic
.UniqueId
);
362 static void cifs_fill_dirent_dir(struct cifs_dirent
*de
,
363 const FILE_DIRECTORY_INFO
*info
)
365 de
->name
= &info
->FileName
[0];
366 de
->namelen
= le32_to_cpu(info
->FileNameLength
);
367 de
->resume_key
= info
->FileIndex
;
370 static void cifs_fill_dirent_full(struct cifs_dirent
*de
,
371 const FILE_FULL_DIRECTORY_INFO
*info
)
373 de
->name
= &info
->FileName
[0];
374 de
->namelen
= le32_to_cpu(info
->FileNameLength
);
375 de
->resume_key
= info
->FileIndex
;
378 static void cifs_fill_dirent_search(struct cifs_dirent
*de
,
379 const SEARCH_ID_FULL_DIR_INFO
*info
)
381 de
->name
= &info
->FileName
[0];
382 de
->namelen
= le32_to_cpu(info
->FileNameLength
);
383 de
->resume_key
= info
->FileIndex
;
384 de
->ino
= le64_to_cpu(info
->UniqueId
);
387 static void cifs_fill_dirent_both(struct cifs_dirent
*de
,
388 const FILE_BOTH_DIRECTORY_INFO
*info
)
390 de
->name
= &info
->FileName
[0];
391 de
->namelen
= le32_to_cpu(info
->FileNameLength
);
392 de
->resume_key
= info
->FileIndex
;
395 static void cifs_fill_dirent_std(struct cifs_dirent
*de
,
396 const FIND_FILE_STANDARD_INFO
*info
)
398 de
->name
= &info
->FileName
[0];
399 /* one byte length, no endianess conversion */
400 de
->namelen
= info
->FileNameLength
;
401 de
->resume_key
= info
->ResumeKey
;
404 static int cifs_fill_dirent(struct cifs_dirent
*de
, const void *info
,
405 u16 level
, bool is_unicode
)
407 memset(de
, 0, sizeof(*de
));
410 case SMB_FIND_FILE_UNIX
:
411 cifs_fill_dirent_unix(de
, info
, is_unicode
);
413 case SMB_FIND_FILE_DIRECTORY_INFO
:
414 cifs_fill_dirent_dir(de
, info
);
416 case SMB_FIND_FILE_FULL_DIRECTORY_INFO
:
417 cifs_fill_dirent_full(de
, info
);
419 case SMB_FIND_FILE_ID_FULL_DIR_INFO
:
420 cifs_fill_dirent_search(de
, info
);
422 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO
:
423 cifs_fill_dirent_both(de
, info
);
425 case SMB_FIND_FILE_INFO_STANDARD
:
426 cifs_fill_dirent_std(de
, info
);
429 cFYI(1, "Unknown findfirst level %d", level
);
436 #define UNICODE_DOT cpu_to_le16(0x2e)
438 /* return 0 if no match and 1 for . (current directory) and 2 for .. (parent) */
439 static int cifs_entry_is_dot(struct cifs_dirent
*de
, bool is_unicode
)
447 __le16
*ufilename
= (__le16
*)de
->name
;
448 if (de
->namelen
== 2) {
450 if (ufilename
[0] == UNICODE_DOT
)
452 } else if (de
->namelen
== 4) {
454 if (ufilename
[0] == UNICODE_DOT
&&
455 ufilename
[1] == UNICODE_DOT
)
459 if (de
->namelen
== 1) {
460 if (de
->name
[0] == '.')
462 } else if (de
->namelen
== 2) {
463 if (de
->name
[0] == '.' && de
->name
[1] == '.')
471 /* Check if directory that we are searching has changed so we can decide
472 whether we can use the cached search results from the previous search */
473 static int is_dir_changed(struct file
*file
)
475 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
476 struct cifsInodeInfo
*cifsInfo
= CIFS_I(inode
);
478 if (cifsInfo
->time
== 0)
479 return 1; /* directory was changed, perhaps due to unlink */
485 static int cifs_save_resume_key(const char *current_entry
,
486 struct cifsFileInfo
*file_info
)
488 struct cifs_dirent de
;
491 rc
= cifs_fill_dirent(&de
, current_entry
, file_info
->srch_inf
.info_level
,
492 file_info
->srch_inf
.unicode
);
494 file_info
->srch_inf
.presume_name
= de
.name
;
495 file_info
->srch_inf
.resume_name_len
= de
.namelen
;
496 file_info
->srch_inf
.resume_key
= de
.resume_key
;
501 /* find the corresponding entry in the search */
502 /* Note that the SMB server returns search entries for . and .. which
503 complicates logic here if we choose to parse for them and we do not
504 assume that they are located in the findfirst return buffer.*/
505 /* We start counting in the buffer with entry 2 and increment for every
506 entry (do not increment for . or .. entry) */
507 static int find_cifs_entry(const int xid
, struct cifs_tcon
*pTcon
,
508 struct file
*file
, char **ppCurrentEntry
, int *num_to_ret
)
513 loff_t first_entry_in_buffer
;
514 loff_t index_to_find
= file
->f_pos
;
515 struct cifsFileInfo
*cifsFile
= file
->private_data
;
516 struct cifs_sb_info
*cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
517 /* check if index in the buffer */
519 if ((cifsFile
== NULL
) || (ppCurrentEntry
== NULL
) ||
520 (num_to_ret
== NULL
))
523 *ppCurrentEntry
= NULL
;
524 first_entry_in_buffer
=
525 cifsFile
->srch_inf
.index_of_last_entry
-
526 cifsFile
->srch_inf
.entries_in_buffer
;
528 /* if first entry in buf is zero then is first buffer
529 in search response data which means it is likely . and ..
530 will be in this buffer, although some servers do not return
531 . and .. for the root of a drive and for those we need
532 to start two entries earlier */
534 dump_cifs_file_struct(file
, "In fce ");
535 if (((index_to_find
< cifsFile
->srch_inf
.index_of_last_entry
) &&
536 is_dir_changed(file
)) ||
537 (index_to_find
< first_entry_in_buffer
)) {
538 /* close and restart search */
539 cFYI(1, "search backing up - close and restart search");
540 spin_lock(&cifs_file_list_lock
);
541 if (!cifsFile
->srch_inf
.endOfSearch
&&
542 !cifsFile
->invalidHandle
) {
543 cifsFile
->invalidHandle
= true;
544 spin_unlock(&cifs_file_list_lock
);
545 CIFSFindClose(xid
, pTcon
, cifsFile
->netfid
);
547 spin_unlock(&cifs_file_list_lock
);
548 if (cifsFile
->srch_inf
.ntwrk_buf_start
) {
549 cFYI(1, "freeing SMB ff cache buf on search rewind");
550 if (cifsFile
->srch_inf
.smallBuf
)
551 cifs_small_buf_release(cifsFile
->srch_inf
.
554 cifs_buf_release(cifsFile
->srch_inf
.
556 cifsFile
->srch_inf
.ntwrk_buf_start
= NULL
;
558 rc
= initiate_cifs_search(xid
, file
);
560 cFYI(1, "error %d reinitiating a search on rewind",
564 /* FindFirst/Next set last_entry to NULL on malformed reply */
565 if (cifsFile
->srch_inf
.last_entry
)
566 cifs_save_resume_key(cifsFile
->srch_inf
.last_entry
,
570 search_flags
= CIFS_SEARCH_CLOSE_AT_END
| CIFS_SEARCH_RETURN_RESUME
;
571 if (backup_cred(cifs_sb
))
572 search_flags
|= CIFS_SEARCH_BACKUP_SEARCH
;
574 while ((index_to_find
>= cifsFile
->srch_inf
.index_of_last_entry
) &&
575 (rc
== 0) && !cifsFile
->srch_inf
.endOfSearch
) {
576 cFYI(1, "calling findnext2");
577 rc
= CIFSFindNext(xid
, pTcon
, cifsFile
->netfid
, search_flags
,
578 &cifsFile
->srch_inf
);
579 /* FindFirst/Next set last_entry to NULL on malformed reply */
580 if (cifsFile
->srch_inf
.last_entry
)
581 cifs_save_resume_key(cifsFile
->srch_inf
.last_entry
,
586 if (index_to_find
< cifsFile
->srch_inf
.index_of_last_entry
) {
587 /* we found the buffer that contains the entry */
588 /* scan and find it */
591 char *end_of_smb
= cifsFile
->srch_inf
.ntwrk_buf_start
+
592 smbCalcSize((struct smb_hdr
*)
593 cifsFile
->srch_inf
.ntwrk_buf_start
);
595 current_entry
= cifsFile
->srch_inf
.srch_entries_start
;
596 first_entry_in_buffer
= cifsFile
->srch_inf
.index_of_last_entry
597 - cifsFile
->srch_inf
.entries_in_buffer
;
598 pos_in_buf
= index_to_find
- first_entry_in_buffer
;
599 cFYI(1, "found entry - pos_in_buf %d", pos_in_buf
);
601 for (i
= 0; (i
< (pos_in_buf
)) && (current_entry
!= NULL
); i
++) {
602 /* go entry by entry figuring out which is first */
603 current_entry
= nxt_dir_entry(current_entry
, end_of_smb
,
604 cifsFile
->srch_inf
.info_level
);
606 if ((current_entry
== NULL
) && (i
< pos_in_buf
)) {
607 /* BB fixme - check if we should flag this error */
608 cERROR(1, "reached end of buf searching for pos in buf"
609 " %d index to find %lld rc %d",
610 pos_in_buf
, index_to_find
, rc
);
613 *ppCurrentEntry
= current_entry
;
615 cFYI(1, "index not in buffer - could not findnext into it");
619 if (pos_in_buf
>= cifsFile
->srch_inf
.entries_in_buffer
) {
620 cFYI(1, "can not return entries pos_in_buf beyond last");
623 *num_to_ret
= cifsFile
->srch_inf
.entries_in_buffer
- pos_in_buf
;
628 static int cifs_filldir(char *find_entry
, struct file
*file
, filldir_t filldir
,
629 void *dirent
, char *scratch_buf
, unsigned int max_len
)
631 struct cifsFileInfo
*file_info
= file
->private_data
;
632 struct super_block
*sb
= file
->f_path
.dentry
->d_sb
;
633 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
634 struct cifs_dirent de
= { NULL
, };
635 struct cifs_fattr fattr
;
636 struct dentry
*dentry
;
641 rc
= cifs_fill_dirent(&de
, find_entry
, file_info
->srch_inf
.info_level
,
642 file_info
->srch_inf
.unicode
);
646 if (de
.namelen
> max_len
) {
647 cERROR(1, "bad search response length %zd past smb end",
652 /* skip . and .. since we added them first */
653 if (cifs_entry_is_dot(&de
, file_info
->srch_inf
.unicode
))
656 if (file_info
->srch_inf
.unicode
) {
657 struct nls_table
*nlt
= cifs_sb
->local_nls
;
659 name
.name
= scratch_buf
;
661 cifs_from_utf16((char *)name
.name
, (__le16
*)de
.name
,
663 min_t(size_t, de
.namelen
,
664 (size_t)max_len
), nlt
,
665 cifs_sb
->mnt_cifs_flags
&
666 CIFS_MOUNT_MAP_SPECIAL_CHR
);
667 name
.len
-= nls_nullsize(nlt
);
670 name
.len
= de
.namelen
;
673 switch (file_info
->srch_inf
.info_level
) {
674 case SMB_FIND_FILE_UNIX
:
675 cifs_unix_basic_to_fattr(&fattr
,
676 &((FILE_UNIX_INFO
*)find_entry
)->basic
,
679 case SMB_FIND_FILE_INFO_STANDARD
:
680 cifs_std_info_to_fattr(&fattr
,
681 (FIND_FILE_STANDARD_INFO
*)find_entry
,
685 cifs_dir_info_to_fattr(&fattr
,
686 (FILE_DIRECTORY_INFO
*)find_entry
,
691 if (de
.ino
&& (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
)) {
692 fattr
.cf_uniqueid
= de
.ino
;
694 fattr
.cf_uniqueid
= iunique(sb
, ROOT_I
);
695 cifs_autodisable_serverino(cifs_sb
);
698 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MF_SYMLINKS
) &&
699 CIFSCouldBeMFSymlink(&fattr
))
701 * trying to get the type and mode can be slow,
702 * so just call those regular files for now, and mark
705 fattr
.cf_flags
|= CIFS_FATTR_NEED_REVAL
;
707 ino
= cifs_uniqueid_to_ino_t(fattr
.cf_uniqueid
);
708 dentry
= cifs_readdir_lookup(file
->f_dentry
, &name
, &fattr
);
710 rc
= filldir(dirent
, name
.name
, name
.len
, file
->f_pos
, ino
,
718 int cifs_readdir(struct file
*file
, void *direntry
, filldir_t filldir
)
722 struct cifs_tcon
*pTcon
;
723 struct cifsFileInfo
*cifsFile
= NULL
;
726 char *tmp_buf
= NULL
;
728 unsigned int max_len
;
733 * Ensure FindFirst doesn't fail before doing filldir() for '.' and
734 * '..'. Otherwise we won't be able to notify VFS in case of failure.
736 if (file
->private_data
== NULL
) {
737 rc
= initiate_cifs_search(xid
, file
);
738 cFYI(1, "initiate cifs search rc %d", rc
);
743 switch ((int) file
->f_pos
) {
745 if (filldir(direntry
, ".", 1, file
->f_pos
,
746 file
->f_path
.dentry
->d_inode
->i_ino
, DT_DIR
) < 0) {
747 cERROR(1, "Filldir for current dir failed");
753 if (filldir(direntry
, "..", 2, file
->f_pos
,
754 parent_ino(file
->f_path
.dentry
), DT_DIR
) < 0) {
755 cERROR(1, "Filldir for parent dir failed");
761 /* 1) If search is active,
762 is in current search buffer?
763 if it before then restart search
764 if after then keep searching till find it */
766 if (file
->private_data
== NULL
) {
771 cifsFile
= file
->private_data
;
772 if (cifsFile
->srch_inf
.endOfSearch
) {
773 if (cifsFile
->srch_inf
.emptyDir
) {
774 cFYI(1, "End of search, empty dir");
779 cifsFile->invalidHandle = true;
780 CIFSFindClose(xid, pTcon, cifsFile->netfid);
783 pTcon
= tlink_tcon(cifsFile
->tlink
);
784 rc
= find_cifs_entry(xid
, pTcon
, file
,
785 ¤t_entry
, &num_to_fill
);
787 cFYI(1, "fce error %d", rc
);
789 } else if (current_entry
!= NULL
) {
790 cFYI(1, "entry %lld found", file
->f_pos
);
792 cFYI(1, "could not find entry");
795 cFYI(1, "loop through %d times filling dir for net buf %p",
796 num_to_fill
, cifsFile
->srch_inf
.ntwrk_buf_start
);
797 max_len
= smbCalcSize((struct smb_hdr
*)
798 cifsFile
->srch_inf
.ntwrk_buf_start
);
799 end_of_smb
= cifsFile
->srch_inf
.ntwrk_buf_start
+ max_len
;
801 tmp_buf
= kmalloc(UNICODE_NAME_MAX
, GFP_KERNEL
);
802 if (tmp_buf
== NULL
) {
807 for (i
= 0; (i
< num_to_fill
) && (rc
== 0); i
++) {
808 if (current_entry
== NULL
) {
809 /* evaluate whether this case is an error */
810 cERROR(1, "past SMB end, num to fill %d i %d",
814 /* if buggy server returns . and .. late do
815 we want to check for that here? */
816 rc
= cifs_filldir(current_entry
, file
,
817 filldir
, direntry
, tmp_buf
, max_len
);
818 if (rc
== -EOVERFLOW
) {
825 cifsFile
->srch_inf
.index_of_last_entry
) {
826 cFYI(1, "last entry in buf at pos %lld %s",
827 file
->f_pos
, tmp_buf
);
828 cifs_save_resume_key(current_entry
, cifsFile
);
832 nxt_dir_entry(current_entry
, end_of_smb
,
833 cifsFile
->srch_inf
.info_level
);