Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
readdir.c
Go to the documentation of this file.
1 /*
2  * fs/cifs/readdir.c
3  *
4  * Directory search handling
5  *
6  * Copyright (C) International Business Machines Corp., 2004, 2008
7  * Copyright (C) Red Hat, Inc., 2011
8  * Author(s): Steve French ([email protected])
9  *
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.
14  *
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.
19  *
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
23  */
24 #include <linux/fs.h>
25 #include <linux/pagemap.h>
26 #include <linux/slab.h>
27 #include <linux/stat.h>
28 #include "cifspdu.h"
29 #include "cifsglob.h"
30 #include "cifsproto.h"
31 #include "cifs_unicode.h"
32 #include "cifs_debug.h"
33 #include "cifs_fs_sb.h"
34 #include "cifsfs.h"
35 
36 /*
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
39  * characters.
40  */
41 #define UNICODE_NAME_MAX ((4 * NAME_MAX) + 2)
42 
43 #ifdef CONFIG_CIFS_DEBUG2
44 static void dump_cifs_file_struct(struct file *file, char *label)
45 {
46  struct cifsFileInfo *cf;
47 
48  if (file) {
49  cf = file->private_data;
50  if (cf == NULL) {
51  cFYI(1, "empty cifs private file data");
52  return;
53  }
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)
59  cFYI(1, "empty dir");
60  }
61 }
62 #else
63 static inline void dump_cifs_file_struct(struct file *file, char *label)
64 {
65 }
66 #endif /* DEBUG2 */
67 
68 /*
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.
71  */
72 static struct dentry *
73 cifs_readdir_lookup(struct dentry *parent, struct qstr *name,
74  struct cifs_fattr *fattr)
75 {
76  struct dentry *dentry, *alias;
77  struct inode *inode;
78  struct super_block *sb = parent->d_inode->i_sb;
79 
80  cFYI(1, "For %s", name->name);
81 
82  if (parent->d_op && parent->d_op->d_hash)
83  parent->d_op->d_hash(parent, parent->d_inode, name);
84  else
85  name->hash = full_name_hash(name->name, name->len);
86 
87  dentry = d_lookup(parent, name);
88  if (dentry) {
89  int err;
90  inode = dentry->d_inode;
91  /* update inode in place if i_ino didn't change */
92  if (inode && CIFS_I(inode)->uniqueid == fattr->cf_uniqueid) {
93  cifs_fattr_to_inode(inode, fattr);
94  return dentry;
95  }
96  err = d_invalidate(dentry);
97  dput(dentry);
98  if (err)
99  return NULL;
100  }
101 
102  dentry = d_alloc(parent, name);
103  if (dentry == NULL)
104  return NULL;
105 
106  inode = cifs_iget(sb, fattr);
107  if (!inode) {
108  dput(dentry);
109  return NULL;
110  }
111 
112  alias = d_materialise_unique(dentry, inode);
113  if (alias != NULL) {
114  dput(dentry);
115  if (IS_ERR(alias))
116  return NULL;
117  dentry = alias;
118  }
119 
120  return dentry;
121 }
122 
123 static void
124 cifs_fill_common_info(struct cifs_fattr *fattr, struct cifs_sb_info *cifs_sb)
125 {
126  fattr->cf_uid = cifs_sb->mnt_uid;
127  fattr->cf_gid = cifs_sb->mnt_gid;
128 
129  if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
130  fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
131  fattr->cf_dtype = DT_DIR;
132  } else {
133  fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
134  fattr->cf_dtype = DT_REG;
135  }
136 
137  if (fattr->cf_cifsattrs & ATTR_READONLY)
138  fattr->cf_mode &= ~S_IWUGO;
139 
140  if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL &&
141  fattr->cf_cifsattrs & ATTR_SYSTEM) {
142  if (fattr->cf_eof == 0) {
143  fattr->cf_mode &= ~S_IFMT;
144  fattr->cf_mode |= S_IFIFO;
145  fattr->cf_dtype = DT_FIFO;
146  } else {
147  /*
148  * trying to get the type and mode via SFU can be slow,
149  * so just call those regular files for now, and mark
150  * for reval
151  */
153  }
154  }
155 }
156 
157 void
158 cifs_dir_info_to_fattr(struct cifs_fattr *fattr, FILE_DIRECTORY_INFO *info,
159  struct cifs_sb_info *cifs_sb)
160 {
161  memset(fattr, 0, sizeof(*fattr));
162  fattr->cf_cifsattrs = le32_to_cpu(info->ExtFileAttributes);
163  fattr->cf_eof = le64_to_cpu(info->EndOfFile);
164  fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
165  fattr->cf_createtime = le64_to_cpu(info->CreationTime);
166  fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
167  fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
168  fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
169 
170  cifs_fill_common_info(fattr, cifs_sb);
171 }
172 
173 static void
174 cifs_std_info_to_fattr(struct cifs_fattr *fattr, FIND_FILE_STANDARD_INFO *info,
175  struct cifs_sb_info *cifs_sb)
176 {
177  int offset = cifs_sb_master_tcon(cifs_sb)->ses->server->timeAdj;
178 
179  memset(fattr, 0, sizeof(*fattr));
180  fattr->cf_atime = cnvrtDosUnixTm(info->LastAccessDate,
181  info->LastAccessTime, offset);
182  fattr->cf_ctime = cnvrtDosUnixTm(info->LastWriteDate,
183  info->LastWriteTime, offset);
184  fattr->cf_mtime = cnvrtDosUnixTm(info->LastWriteDate,
185  info->LastWriteTime, offset);
186 
187  fattr->cf_cifsattrs = le16_to_cpu(info->Attributes);
188  fattr->cf_bytes = le32_to_cpu(info->AllocationSize);
189  fattr->cf_eof = le32_to_cpu(info->DataSize);
190 
191  cifs_fill_common_info(fattr, cifs_sb);
192 }
193 
194 /* BB eventually need to add the following helper function to
195  resolve NT_STATUS_STOPPED_ON_SYMLINK return code when
196  we try to do FindFirst on (NTFS) directory symlinks */
197 /*
198 int get_symlink_reparse_path(char *full_path, struct cifs_sb_info *cifs_sb,
199  unsigned int xid)
200 {
201  __u16 fid;
202  int len;
203  int oplock = 0;
204  int rc;
205  struct cifs_tcon *ptcon = cifs_sb_tcon(cifs_sb);
206  char *tmpbuffer;
207 
208  rc = CIFSSMBOpen(xid, ptcon, full_path, FILE_OPEN, GENERIC_READ,
209  OPEN_REPARSE_POINT, &fid, &oplock, NULL,
210  cifs_sb->local_nls,
211  cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
212  if (!rc) {
213  tmpbuffer = kmalloc(maxpath);
214  rc = CIFSSMBQueryReparseLinkInfo(xid, ptcon, full_path,
215  tmpbuffer,
216  maxpath -1,
217  fid,
218  cifs_sb->local_nls);
219  if (CIFSSMBClose(xid, ptcon, fid)) {
220  cFYI(1, "Error closing temporary reparsepoint open");
221  }
222  }
223 }
224  */
225 
226 static int
227 initiate_cifs_search(const unsigned int xid, struct file *file)
228 {
229  __u16 search_flags;
230  int rc = 0;
231  char *full_path = NULL;
232  struct cifsFileInfo *cifsFile;
233  struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
234  struct tcon_link *tlink = NULL;
235  struct cifs_tcon *tcon;
236  struct TCP_Server_Info *server;
237 
238  if (file->private_data == NULL) {
239  tlink = cifs_sb_tlink(cifs_sb);
240  if (IS_ERR(tlink))
241  return PTR_ERR(tlink);
242 
243  cifsFile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
244  if (cifsFile == NULL) {
245  rc = -ENOMEM;
246  goto error_exit;
247  }
248  file->private_data = cifsFile;
249  cifsFile->tlink = cifs_get_tlink(tlink);
250  tcon = tlink_tcon(tlink);
251  } else {
252  cifsFile = file->private_data;
253  tcon = tlink_tcon(cifsFile->tlink);
254  }
255 
256  server = tcon->ses->server;
257 
258  if (!server->ops->query_dir_first) {
259  rc = -ENOSYS;
260  goto error_exit;
261  }
262 
263  cifsFile->invalidHandle = true;
264  cifsFile->srch_inf.endOfSearch = false;
265 
266  full_path = build_path_from_dentry(file->f_path.dentry);
267  if (full_path == NULL) {
268  rc = -ENOMEM;
269  goto error_exit;
270  }
271 
272  cFYI(1, "Full path: %s start at: %lld", full_path, file->f_pos);
273 
274 ffirst_retry:
275  /* test for Unix extensions */
276  /* but now check for them on the share/mount not on the SMB session */
277  /* if (cap_unix(tcon->ses) { */
278  if (tcon->unix_ext)
279  cifsFile->srch_inf.info_level = SMB_FIND_FILE_UNIX;
280  else if ((tcon->ses->capabilities &
281  tcon->ses->server->vals->cap_nt_find) == 0) {
282  cifsFile->srch_inf.info_level = SMB_FIND_FILE_INFO_STANDARD;
283  } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
284  cifsFile->srch_inf.info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
285  } else /* not srvinos - BB fixme add check for backlevel? */ {
286  cifsFile->srch_inf.info_level = SMB_FIND_FILE_DIRECTORY_INFO;
287  }
288 
290  if (backup_cred(cifs_sb))
291  search_flags |= CIFS_SEARCH_BACKUP_SEARCH;
292 
293  rc = server->ops->query_dir_first(xid, tcon, full_path, cifs_sb,
294  &cifsFile->fid, search_flags,
295  &cifsFile->srch_inf);
296 
297  if (rc == 0)
298  cifsFile->invalidHandle = false;
299  /* BB add following call to handle readdir on new NTFS symlink errors
300  else if STATUS_STOPPED_ON_SYMLINK
301  call get_symlink_reparse_path and retry with new path */
302  else if ((rc == -EOPNOTSUPP) &&
303  (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
305  goto ffirst_retry;
306  }
307 error_exit:
308  kfree(full_path);
309  cifs_put_tlink(tlink);
310  return rc;
311 }
312 
313 /* return length of unicode string in bytes */
314 static int cifs_unicode_bytelen(const char *str)
315 {
316  int len;
317  const __le16 *ustr = (const __le16 *)str;
318 
319  for (len = 0; len <= PATH_MAX; len++) {
320  if (ustr[len] == 0)
321  return len << 1;
322  }
323  cFYI(1, "Unicode string longer than PATH_MAX found");
324  return len << 1;
325 }
326 
327 static char *nxt_dir_entry(char *old_entry, char *end_of_smb, int level)
328 {
329  char *new_entry;
330  FILE_DIRECTORY_INFO *pDirInfo = (FILE_DIRECTORY_INFO *)old_entry;
331 
332  if (level == SMB_FIND_FILE_INFO_STANDARD) {
333  FIND_FILE_STANDARD_INFO *pfData;
334  pfData = (FIND_FILE_STANDARD_INFO *)pDirInfo;
335 
336  new_entry = old_entry + sizeof(FIND_FILE_STANDARD_INFO) +
337  pfData->FileNameLength;
338  } else
339  new_entry = old_entry + le32_to_cpu(pDirInfo->NextEntryOffset);
340  cFYI(1, "new entry %p old entry %p", new_entry, old_entry);
341  /* validate that new_entry is not past end of SMB */
342  if (new_entry >= end_of_smb) {
343  cERROR(1, "search entry %p began after end of SMB %p old entry %p",
344  new_entry, end_of_smb, old_entry);
345  return NULL;
346  } else if (((level == SMB_FIND_FILE_INFO_STANDARD) &&
347  (new_entry + sizeof(FIND_FILE_STANDARD_INFO) > end_of_smb))
348  || ((level != SMB_FIND_FILE_INFO_STANDARD) &&
349  (new_entry + sizeof(FILE_DIRECTORY_INFO) > end_of_smb))) {
350  cERROR(1, "search entry %p extends after end of SMB %p",
351  new_entry, end_of_smb);
352  return NULL;
353  } else
354  return new_entry;
355 
356 }
357 
358 struct cifs_dirent {
359  const char *name;
360  size_t namelen;
363 };
364 
365 static void cifs_fill_dirent_unix(struct cifs_dirent *de,
366  const FILE_UNIX_INFO *info, bool is_unicode)
367 {
368  de->name = &info->FileName[0];
369  if (is_unicode)
370  de->namelen = cifs_unicode_bytelen(de->name);
371  else
372  de->namelen = strnlen(de->name, PATH_MAX);
373  de->resume_key = info->ResumeKey;
374  de->ino = le64_to_cpu(info->basic.UniqueId);
375 }
376 
377 static void cifs_fill_dirent_dir(struct cifs_dirent *de,
378  const FILE_DIRECTORY_INFO *info)
379 {
380  de->name = &info->FileName[0];
381  de->namelen = le32_to_cpu(info->FileNameLength);
382  de->resume_key = info->FileIndex;
383 }
384 
385 static void cifs_fill_dirent_full(struct cifs_dirent *de,
386  const FILE_FULL_DIRECTORY_INFO *info)
387 {
388  de->name = &info->FileName[0];
389  de->namelen = le32_to_cpu(info->FileNameLength);
390  de->resume_key = info->FileIndex;
391 }
392 
393 static void cifs_fill_dirent_search(struct cifs_dirent *de,
394  const SEARCH_ID_FULL_DIR_INFO *info)
395 {
396  de->name = &info->FileName[0];
397  de->namelen = le32_to_cpu(info->FileNameLength);
398  de->resume_key = info->FileIndex;
399  de->ino = le64_to_cpu(info->UniqueId);
400 }
401 
402 static void cifs_fill_dirent_both(struct cifs_dirent *de,
403  const FILE_BOTH_DIRECTORY_INFO *info)
404 {
405  de->name = &info->FileName[0];
406  de->namelen = le32_to_cpu(info->FileNameLength);
407  de->resume_key = info->FileIndex;
408 }
409 
410 static void cifs_fill_dirent_std(struct cifs_dirent *de,
411  const FIND_FILE_STANDARD_INFO *info)
412 {
413  de->name = &info->FileName[0];
414  /* one byte length, no endianess conversion */
415  de->namelen = info->FileNameLength;
416  de->resume_key = info->ResumeKey;
417 }
418 
419 static int cifs_fill_dirent(struct cifs_dirent *de, const void *info,
420  u16 level, bool is_unicode)
421 {
422  memset(de, 0, sizeof(*de));
423 
424  switch (level) {
425  case SMB_FIND_FILE_UNIX:
426  cifs_fill_dirent_unix(de, info, is_unicode);
427  break;
429  cifs_fill_dirent_dir(de, info);
430  break;
432  cifs_fill_dirent_full(de, info);
433  break;
435  cifs_fill_dirent_search(de, info);
436  break;
438  cifs_fill_dirent_both(de, info);
439  break;
441  cifs_fill_dirent_std(de, info);
442  break;
443  default:
444  cFYI(1, "Unknown findfirst level %d", level);
445  return -EINVAL;
446  }
447 
448  return 0;
449 }
450 
451 #define UNICODE_DOT cpu_to_le16(0x2e)
452 
453 /* return 0 if no match and 1 for . (current directory) and 2 for .. (parent) */
454 static int cifs_entry_is_dot(struct cifs_dirent *de, bool is_unicode)
455 {
456  int rc = 0;
457 
458  if (!de->name)
459  return 0;
460 
461  if (is_unicode) {
462  __le16 *ufilename = (__le16 *)de->name;
463  if (de->namelen == 2) {
464  /* check for . */
465  if (ufilename[0] == UNICODE_DOT)
466  rc = 1;
467  } else if (de->namelen == 4) {
468  /* check for .. */
469  if (ufilename[0] == UNICODE_DOT &&
470  ufilename[1] == UNICODE_DOT)
471  rc = 2;
472  }
473  } else /* ASCII */ {
474  if (de->namelen == 1) {
475  if (de->name[0] == '.')
476  rc = 1;
477  } else if (de->namelen == 2) {
478  if (de->name[0] == '.' && de->name[1] == '.')
479  rc = 2;
480  }
481  }
482 
483  return rc;
484 }
485 
486 /* Check if directory that we are searching has changed so we can decide
487  whether we can use the cached search results from the previous search */
488 static int is_dir_changed(struct file *file)
489 {
490  struct inode *inode = file->f_path.dentry->d_inode;
491  struct cifsInodeInfo *cifsInfo = CIFS_I(inode);
492 
493  if (cifsInfo->time == 0)
494  return 1; /* directory was changed, perhaps due to unlink */
495  else
496  return 0;
497 
498 }
499 
500 static int cifs_save_resume_key(const char *current_entry,
501  struct cifsFileInfo *file_info)
502 {
503  struct cifs_dirent de;
504  int rc;
505 
506  rc = cifs_fill_dirent(&de, current_entry, file_info->srch_inf.info_level,
507  file_info->srch_inf.unicode);
508  if (!rc) {
509  file_info->srch_inf.presume_name = de.name;
510  file_info->srch_inf.resume_name_len = de.namelen;
511  file_info->srch_inf.resume_key = de.resume_key;
512  }
513  return rc;
514 }
515 
516 /*
517  * Find the corresponding entry in the search. Note that the SMB server returns
518  * search entries for . and .. which complicates logic here if we choose to
519  * parse for them and we do not assume that they are located in the findfirst
520  * return buffer. We start counting in the buffer with entry 2 and increment for
521  * every entry (do not increment for . or .. entry).
522  */
523 static int
524 find_cifs_entry(const unsigned int xid, struct cifs_tcon *tcon,
525  struct file *file, char **current_entry, int *num_to_ret)
526 {
527  __u16 search_flags;
528  int rc = 0;
529  int pos_in_buf = 0;
530  loff_t first_entry_in_buffer;
531  loff_t index_to_find = file->f_pos;
532  struct cifsFileInfo *cfile = file->private_data;
533  struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
534  struct TCP_Server_Info *server = tcon->ses->server;
535  /* check if index in the buffer */
536 
537  if (!server->ops->query_dir_first || !server->ops->query_dir_next)
538  return -ENOSYS;
539 
540  if ((cfile == NULL) || (current_entry == NULL) || (num_to_ret == NULL))
541  return -ENOENT;
542 
543  *current_entry = NULL;
544  first_entry_in_buffer = cfile->srch_inf.index_of_last_entry -
545  cfile->srch_inf.entries_in_buffer;
546 
547  /*
548  * If first entry in buf is zero then is first buffer
549  * in search response data which means it is likely . and ..
550  * will be in this buffer, although some servers do not return
551  * . and .. for the root of a drive and for those we need
552  * to start two entries earlier.
553  */
554 
555  dump_cifs_file_struct(file, "In fce ");
556  if (((index_to_find < cfile->srch_inf.index_of_last_entry) &&
557  is_dir_changed(file)) || (index_to_find < first_entry_in_buffer)) {
558  /* close and restart search */
559  cFYI(1, "search backing up - close and restart search");
560  spin_lock(&cifs_file_list_lock);
561  if (!cfile->srch_inf.endOfSearch && !cfile->invalidHandle) {
562  cfile->invalidHandle = true;
563  spin_unlock(&cifs_file_list_lock);
564  if (server->ops->close)
565  server->ops->close(xid, tcon, &cfile->fid);
566  } else
567  spin_unlock(&cifs_file_list_lock);
568  if (cfile->srch_inf.ntwrk_buf_start) {
569  cFYI(1, "freeing SMB ff cache buf on search rewind");
570  if (cfile->srch_inf.smallBuf)
572  ntwrk_buf_start);
573  else
574  cifs_buf_release(cfile->srch_inf.
575  ntwrk_buf_start);
576  cfile->srch_inf.ntwrk_buf_start = NULL;
577  }
578  rc = initiate_cifs_search(xid, file);
579  if (rc) {
580  cFYI(1, "error %d reinitiating a search on rewind",
581  rc);
582  return rc;
583  }
584  /* FindFirst/Next set last_entry to NULL on malformed reply */
585  if (cfile->srch_inf.last_entry)
586  cifs_save_resume_key(cfile->srch_inf.last_entry, cfile);
587  }
588 
590  if (backup_cred(cifs_sb))
591  search_flags |= CIFS_SEARCH_BACKUP_SEARCH;
592 
593  while ((index_to_find >= cfile->srch_inf.index_of_last_entry) &&
594  (rc == 0) && !cfile->srch_inf.endOfSearch) {
595  cFYI(1, "calling findnext2");
596  rc = server->ops->query_dir_next(xid, tcon, &cfile->fid,
597  search_flags,
598  &cfile->srch_inf);
599  /* FindFirst/Next set last_entry to NULL on malformed reply */
600  if (cfile->srch_inf.last_entry)
601  cifs_save_resume_key(cfile->srch_inf.last_entry, cfile);
602  if (rc)
603  return -ENOENT;
604  }
605  if (index_to_find < cfile->srch_inf.index_of_last_entry) {
606  /* we found the buffer that contains the entry */
607  /* scan and find it */
608  int i;
609  char *cur_ent;
610  char *end_of_smb = cfile->srch_inf.ntwrk_buf_start +
611  server->ops->calc_smb_size(
612  cfile->srch_inf.ntwrk_buf_start);
613 
614  cur_ent = cfile->srch_inf.srch_entries_start;
615  first_entry_in_buffer = cfile->srch_inf.index_of_last_entry
616  - cfile->srch_inf.entries_in_buffer;
617  pos_in_buf = index_to_find - first_entry_in_buffer;
618  cFYI(1, "found entry - pos_in_buf %d", pos_in_buf);
619 
620  for (i = 0; (i < (pos_in_buf)) && (cur_ent != NULL); i++) {
621  /* go entry by entry figuring out which is first */
622  cur_ent = nxt_dir_entry(cur_ent, end_of_smb,
623  cfile->srch_inf.info_level);
624  }
625  if ((cur_ent == NULL) && (i < pos_in_buf)) {
626  /* BB fixme - check if we should flag this error */
627  cERROR(1, "reached end of buf searching for pos in buf"
628  " %d index to find %lld rc %d", pos_in_buf,
629  index_to_find, rc);
630  }
631  rc = 0;
632  *current_entry = cur_ent;
633  } else {
634  cFYI(1, "index not in buffer - could not findnext into it");
635  return 0;
636  }
637 
638  if (pos_in_buf >= cfile->srch_inf.entries_in_buffer) {
639  cFYI(1, "can not return entries pos_in_buf beyond last");
640  *num_to_ret = 0;
641  } else
642  *num_to_ret = cfile->srch_inf.entries_in_buffer - pos_in_buf;
643 
644  return rc;
645 }
646 
647 static int cifs_filldir(char *find_entry, struct file *file, filldir_t filldir,
648  void *dirent, char *scratch_buf, unsigned int max_len)
649 {
650  struct cifsFileInfo *file_info = file->private_data;
651  struct super_block *sb = file->f_path.dentry->d_sb;
652  struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
653  struct cifs_dirent de = { NULL, };
654  struct cifs_fattr fattr;
655  struct dentry *dentry;
656  struct qstr name;
657  int rc = 0;
658  ino_t ino;
659 
660  rc = cifs_fill_dirent(&de, find_entry, file_info->srch_inf.info_level,
661  file_info->srch_inf.unicode);
662  if (rc)
663  return rc;
664 
665  if (de.namelen > max_len) {
666  cERROR(1, "bad search response length %zd past smb end",
667  de.namelen);
668  return -EINVAL;
669  }
670 
671  /* skip . and .. since we added them first */
672  if (cifs_entry_is_dot(&de, file_info->srch_inf.unicode))
673  return 0;
674 
675  if (file_info->srch_inf.unicode) {
676  struct nls_table *nlt = cifs_sb->local_nls;
677 
678  name.name = scratch_buf;
679  name.len =
680  cifs_from_utf16((char *)name.name, (__le16 *)de.name,
682  min_t(size_t, de.namelen,
683  (size_t)max_len), nlt,
684  cifs_sb->mnt_cifs_flags &
686  name.len -= nls_nullsize(nlt);
687  } else {
688  name.name = de.name;
689  name.len = de.namelen;
690  }
691 
692  switch (file_info->srch_inf.info_level) {
693  case SMB_FIND_FILE_UNIX:
695  &((FILE_UNIX_INFO *)find_entry)->basic,
696  cifs_sb);
697  break;
699  cifs_std_info_to_fattr(&fattr,
700  (FIND_FILE_STANDARD_INFO *)find_entry,
701  cifs_sb);
702  break;
703  default:
704  cifs_dir_info_to_fattr(&fattr,
705  (FILE_DIRECTORY_INFO *)find_entry,
706  cifs_sb);
707  break;
708  }
709 
710  if (de.ino && (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
711  fattr.cf_uniqueid = de.ino;
712  } else {
713  fattr.cf_uniqueid = iunique(sb, ROOT_I);
715  }
716 
717  if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) &&
718  CIFSCouldBeMFSymlink(&fattr))
719  /*
720  * trying to get the type and mode can be slow,
721  * so just call those regular files for now, and mark
722  * for reval
723  */
725 
726  ino = cifs_uniqueid_to_ino_t(fattr.cf_uniqueid);
727  dentry = cifs_readdir_lookup(file->f_dentry, &name, &fattr);
728 
729  rc = filldir(dirent, name.name, name.len, file->f_pos, ino,
730  fattr.cf_dtype);
731 
732  dput(dentry);
733  return rc;
734 }
735 
736 
737 int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
738 {
739  int rc = 0;
740  unsigned int xid;
741  int i;
742  struct cifs_tcon *tcon;
743  struct cifsFileInfo *cifsFile = NULL;
744  char *current_entry;
745  int num_to_fill = 0;
746  char *tmp_buf = NULL;
747  char *end_of_smb;
748  unsigned int max_len;
749 
750  xid = get_xid();
751 
752  /*
753  * Ensure FindFirst doesn't fail before doing filldir() for '.' and
754  * '..'. Otherwise we won't be able to notify VFS in case of failure.
755  */
756  if (file->private_data == NULL) {
757  rc = initiate_cifs_search(xid, file);
758  cFYI(1, "initiate cifs search rc %d", rc);
759  if (rc)
760  goto rddir2_exit;
761  }
762 
763  switch ((int) file->f_pos) {
764  case 0:
765  if (filldir(direntry, ".", 1, file->f_pos,
766  file->f_path.dentry->d_inode->i_ino, DT_DIR) < 0) {
767  cERROR(1, "Filldir for current dir failed");
768  rc = -ENOMEM;
769  break;
770  }
771  file->f_pos++;
772  case 1:
773  if (filldir(direntry, "..", 2, file->f_pos,
774  parent_ino(file->f_path.dentry), DT_DIR) < 0) {
775  cERROR(1, "Filldir for parent dir failed");
776  rc = -ENOMEM;
777  break;
778  }
779  file->f_pos++;
780  default:
781  /* 1) If search is active,
782  is in current search buffer?
783  if it before then restart search
784  if after then keep searching till find it */
785 
786  if (file->private_data == NULL) {
787  rc = -EINVAL;
788  free_xid(xid);
789  return rc;
790  }
791  cifsFile = file->private_data;
792  if (cifsFile->srch_inf.endOfSearch) {
793  if (cifsFile->srch_inf.emptyDir) {
794  cFYI(1, "End of search, empty dir");
795  rc = 0;
796  break;
797  }
798  } /* else {
799  cifsFile->invalidHandle = true;
800  tcon->ses->server->close(xid, tcon, &cifsFile->fid);
801  } */
802 
803  tcon = tlink_tcon(cifsFile->tlink);
804  rc = find_cifs_entry(xid, tcon, file, &current_entry,
805  &num_to_fill);
806  if (rc) {
807  cFYI(1, "fce error %d", rc);
808  goto rddir2_exit;
809  } else if (current_entry != NULL) {
810  cFYI(1, "entry %lld found", file->f_pos);
811  } else {
812  cFYI(1, "could not find entry");
813  goto rddir2_exit;
814  }
815  cFYI(1, "loop through %d times filling dir for net buf %p",
816  num_to_fill, cifsFile->srch_inf.ntwrk_buf_start);
817  max_len = tcon->ses->server->ops->calc_smb_size(
818  cifsFile->srch_inf.ntwrk_buf_start);
819  end_of_smb = cifsFile->srch_inf.ntwrk_buf_start + max_len;
820 
821  tmp_buf = kmalloc(UNICODE_NAME_MAX, GFP_KERNEL);
822  if (tmp_buf == NULL) {
823  rc = -ENOMEM;
824  break;
825  }
826 
827  for (i = 0; (i < num_to_fill) && (rc == 0); i++) {
828  if (current_entry == NULL) {
829  /* evaluate whether this case is an error */
830  cERROR(1, "past SMB end, num to fill %d i %d",
831  num_to_fill, i);
832  break;
833  }
834  /*
835  * if buggy server returns . and .. late do we want to
836  * check for that here?
837  */
838  rc = cifs_filldir(current_entry, file, filldir,
839  direntry, tmp_buf, max_len);
840  if (rc == -EOVERFLOW) {
841  rc = 0;
842  break;
843  }
844 
845  file->f_pos++;
846  if (file->f_pos ==
847  cifsFile->srch_inf.index_of_last_entry) {
848  cFYI(1, "last entry in buf at pos %lld %s",
849  file->f_pos, tmp_buf);
850  cifs_save_resume_key(current_entry, cifsFile);
851  break;
852  } else
853  current_entry =
854  nxt_dir_entry(current_entry, end_of_smb,
855  cifsFile->srch_inf.info_level);
856  }
857  kfree(tmp_buf);
858  break;
859  } /* end switch */
860 
861 rddir2_exit:
862  free_xid(xid);
863  return rc;
864 }