readdir.c 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877
  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 (sfrench@us.ibm.com)
  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. * To be safe - for UCS to UTF-8 with strings loaded with the rare long
  37. * characters alloc more to account for such multibyte target UTF-8
  38. * characters.
  39. */
  40. #define UNICODE_NAME_MAX ((4 * NAME_MAX) + 2)
  41. #ifdef CONFIG_CIFS_DEBUG2
  42. static void dump_cifs_file_struct(struct file *file, char *label)
  43. {
  44. struct cifsFileInfo *cf;
  45. if (file) {
  46. cf = file->private_data;
  47. if (cf == NULL) {
  48. cifs_dbg(FYI, "empty cifs private file data\n");
  49. return;
  50. }
  51. if (cf->invalidHandle)
  52. cifs_dbg(FYI, "invalid handle\n");
  53. if (cf->srch_inf.endOfSearch)
  54. cifs_dbg(FYI, "end of search\n");
  55. if (cf->srch_inf.emptyDir)
  56. cifs_dbg(FYI, "empty dir\n");
  57. }
  58. }
  59. #else
  60. static inline void dump_cifs_file_struct(struct file *file, char *label)
  61. {
  62. }
  63. #endif /* DEBUG2 */
  64. /*
  65. * Attempt to preload the dcache with the results from the FIND_FIRST/NEXT
  66. *
  67. * Find the dentry that matches "name". If there isn't one, create one. If it's
  68. * a negative dentry or the uniqueid changed, then drop it and recreate it.
  69. */
  70. static void
  71. cifs_prime_dcache(struct dentry *parent, struct qstr *name,
  72. struct cifs_fattr *fattr)
  73. {
  74. struct dentry *dentry, *alias;
  75. struct inode *inode;
  76. struct super_block *sb = parent->d_inode->i_sb;
  77. struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
  78. cifs_dbg(FYI, "%s: for %s\n", __func__, name->name);
  79. dentry = d_hash_and_lookup(parent, name);
  80. if (unlikely(IS_ERR(dentry)))
  81. return;
  82. if (dentry) {
  83. int err;
  84. inode = dentry->d_inode;
  85. if (inode) {
  86. /*
  87. * If we're generating inode numbers, then we don't
  88. * want to clobber the existing one with the one that
  89. * the readdir code created.
  90. */
  91. if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM))
  92. fattr->cf_uniqueid = CIFS_I(inode)->uniqueid;
  93. /* update inode in place if i_ino didn't change */
  94. if (CIFS_I(inode)->uniqueid == fattr->cf_uniqueid) {
  95. cifs_fattr_to_inode(inode, fattr);
  96. goto out;
  97. }
  98. }
  99. err = d_invalidate(dentry);
  100. dput(dentry);
  101. if (err)
  102. return;
  103. }
  104. /*
  105. * If we know that the inode will need to be revalidated immediately,
  106. * then don't create a new dentry for it. We'll end up doing an on
  107. * the wire call either way and this spares us an invalidation.
  108. */
  109. if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
  110. return;
  111. dentry = d_alloc(parent, name);
  112. if (!dentry)
  113. return;
  114. inode = cifs_iget(sb, fattr);
  115. if (!inode)
  116. goto out;
  117. alias = d_materialise_unique(dentry, inode);
  118. if (alias && !IS_ERR(alias))
  119. dput(alias);
  120. out:
  121. dput(dentry);
  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. if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
  129. fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
  130. fattr->cf_dtype = DT_DIR;
  131. } else {
  132. fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
  133. fattr->cf_dtype = DT_REG;
  134. }
  135. /*
  136. * We need to revalidate it further to make a decision about whether it
  137. * is a symbolic link, DFS referral or a reparse point with a direct
  138. * access like junctions, deduplicated files, NFS symlinks.
  139. */
  140. if (fattr->cf_cifsattrs & ATTR_REPARSE)
  141. fattr->cf_flags |= CIFS_FATTR_NEED_REVAL;
  142. /* non-unix readdir doesn't provide nlink */
  143. fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
  144. if (fattr->cf_cifsattrs & ATTR_READONLY)
  145. fattr->cf_mode &= ~S_IWUGO;
  146. /*
  147. * We of course don't get ACL info in FIND_FIRST/NEXT results, so
  148. * mark it for revalidation so that "ls -l" will look right. It might
  149. * be super-slow, but if we don't do this then the ownership of files
  150. * may look wrong since the inodes may not have timed out by the time
  151. * "ls" does a stat() call on them.
  152. */
  153. if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
  154. fattr->cf_flags |= CIFS_FATTR_NEED_REVAL;
  155. if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL &&
  156. fattr->cf_cifsattrs & ATTR_SYSTEM) {
  157. if (fattr->cf_eof == 0) {
  158. fattr->cf_mode &= ~S_IFMT;
  159. fattr->cf_mode |= S_IFIFO;
  160. fattr->cf_dtype = DT_FIFO;
  161. } else {
  162. /*
  163. * trying to get the type and mode via SFU can be slow,
  164. * so just call those regular files for now, and mark
  165. * for reval
  166. */
  167. fattr->cf_flags |= CIFS_FATTR_NEED_REVAL;
  168. }
  169. }
  170. }
  171. void
  172. cifs_dir_info_to_fattr(struct cifs_fattr *fattr, FILE_DIRECTORY_INFO *info,
  173. struct cifs_sb_info *cifs_sb)
  174. {
  175. memset(fattr, 0, sizeof(*fattr));
  176. fattr->cf_cifsattrs = le32_to_cpu(info->ExtFileAttributes);
  177. fattr->cf_eof = le64_to_cpu(info->EndOfFile);
  178. fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
  179. fattr->cf_createtime = le64_to_cpu(info->CreationTime);
  180. fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
  181. fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
  182. fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
  183. cifs_fill_common_info(fattr, cifs_sb);
  184. }
  185. static void
  186. cifs_std_info_to_fattr(struct cifs_fattr *fattr, FIND_FILE_STANDARD_INFO *info,
  187. struct cifs_sb_info *cifs_sb)
  188. {
  189. int offset = cifs_sb_master_tcon(cifs_sb)->ses->server->timeAdj;
  190. memset(fattr, 0, sizeof(*fattr));
  191. fattr->cf_atime = cnvrtDosUnixTm(info->LastAccessDate,
  192. info->LastAccessTime, offset);
  193. fattr->cf_ctime = cnvrtDosUnixTm(info->LastWriteDate,
  194. info->LastWriteTime, offset);
  195. fattr->cf_mtime = cnvrtDosUnixTm(info->LastWriteDate,
  196. info->LastWriteTime, offset);
  197. fattr->cf_cifsattrs = le16_to_cpu(info->Attributes);
  198. fattr->cf_bytes = le32_to_cpu(info->AllocationSize);
  199. fattr->cf_eof = le32_to_cpu(info->DataSize);
  200. cifs_fill_common_info(fattr, cifs_sb);
  201. }
  202. /* BB eventually need to add the following helper function to
  203. resolve NT_STATUS_STOPPED_ON_SYMLINK return code when
  204. we try to do FindFirst on (NTFS) directory symlinks */
  205. /*
  206. int get_symlink_reparse_path(char *full_path, struct cifs_sb_info *cifs_sb,
  207. unsigned int xid)
  208. {
  209. __u16 fid;
  210. int len;
  211. int oplock = 0;
  212. int rc;
  213. struct cifs_tcon *ptcon = cifs_sb_tcon(cifs_sb);
  214. char *tmpbuffer;
  215. rc = CIFSSMBOpen(xid, ptcon, full_path, FILE_OPEN, GENERIC_READ,
  216. OPEN_REPARSE_POINT, &fid, &oplock, NULL,
  217. cifs_sb->local_nls,
  218. cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
  219. if (!rc) {
  220. tmpbuffer = kmalloc(maxpath);
  221. rc = CIFSSMBQueryReparseLinkInfo(xid, ptcon, full_path,
  222. tmpbuffer,
  223. maxpath -1,
  224. fid,
  225. cifs_sb->local_nls);
  226. if (CIFSSMBClose(xid, ptcon, fid)) {
  227. cifs_dbg(FYI, "Error closing temporary reparsepoint open\n");
  228. }
  229. }
  230. }
  231. */
  232. static int
  233. initiate_cifs_search(const unsigned int xid, struct file *file)
  234. {
  235. __u16 search_flags;
  236. int rc = 0;
  237. char *full_path = NULL;
  238. struct cifsFileInfo *cifsFile;
  239. struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
  240. struct tcon_link *tlink = NULL;
  241. struct cifs_tcon *tcon;
  242. struct TCP_Server_Info *server;
  243. if (file->private_data == NULL) {
  244. tlink = cifs_sb_tlink(cifs_sb);
  245. if (IS_ERR(tlink))
  246. return PTR_ERR(tlink);
  247. cifsFile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
  248. if (cifsFile == NULL) {
  249. rc = -ENOMEM;
  250. goto error_exit;
  251. }
  252. file->private_data = cifsFile;
  253. cifsFile->tlink = cifs_get_tlink(tlink);
  254. tcon = tlink_tcon(tlink);
  255. } else {
  256. cifsFile = file->private_data;
  257. tcon = tlink_tcon(cifsFile->tlink);
  258. }
  259. server = tcon->ses->server;
  260. if (!server->ops->query_dir_first) {
  261. rc = -ENOSYS;
  262. goto error_exit;
  263. }
  264. cifsFile->invalidHandle = true;
  265. cifsFile->srch_inf.endOfSearch = false;
  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. cifs_dbg(FYI, "Full path: %s start at: %lld\n", full_path, file->f_pos);
  272. ffirst_retry:
  273. /* test for Unix extensions */
  274. /* but now check for them on the share/mount not on the SMB session */
  275. /* if (cap_unix(tcon->ses) { */
  276. if (tcon->unix_ext)
  277. cifsFile->srch_inf.info_level = SMB_FIND_FILE_UNIX;
  278. else if ((tcon->ses->capabilities &
  279. tcon->ses->server->vals->cap_nt_find) == 0) {
  280. cifsFile->srch_inf.info_level = SMB_FIND_FILE_INFO_STANDARD;
  281. } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
  282. cifsFile->srch_inf.info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
  283. } else /* not srvinos - BB fixme add check for backlevel? */ {
  284. cifsFile->srch_inf.info_level = SMB_FIND_FILE_DIRECTORY_INFO;
  285. }
  286. search_flags = CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME;
  287. if (backup_cred(cifs_sb))
  288. search_flags |= CIFS_SEARCH_BACKUP_SEARCH;
  289. rc = server->ops->query_dir_first(xid, tcon, full_path, cifs_sb,
  290. &cifsFile->fid, search_flags,
  291. &cifsFile->srch_inf);
  292. if (rc == 0)
  293. cifsFile->invalidHandle = false;
  294. /* BB add following call to handle readdir on new NTFS symlink errors
  295. else if STATUS_STOPPED_ON_SYMLINK
  296. call get_symlink_reparse_path and retry with new path */
  297. else if ((rc == -EOPNOTSUPP) &&
  298. (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
  299. cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM;
  300. goto ffirst_retry;
  301. }
  302. error_exit:
  303. kfree(full_path);
  304. cifs_put_tlink(tlink);
  305. return rc;
  306. }
  307. /* return length of unicode string in bytes */
  308. static int cifs_unicode_bytelen(const char *str)
  309. {
  310. int len;
  311. const __le16 *ustr = (const __le16 *)str;
  312. for (len = 0; len <= PATH_MAX; len++) {
  313. if (ustr[len] == 0)
  314. return len << 1;
  315. }
  316. cifs_dbg(FYI, "Unicode string longer than PATH_MAX found\n");
  317. return len << 1;
  318. }
  319. static char *nxt_dir_entry(char *old_entry, char *end_of_smb, int level)
  320. {
  321. char *new_entry;
  322. FILE_DIRECTORY_INFO *pDirInfo = (FILE_DIRECTORY_INFO *)old_entry;
  323. if (level == SMB_FIND_FILE_INFO_STANDARD) {
  324. FIND_FILE_STANDARD_INFO *pfData;
  325. pfData = (FIND_FILE_STANDARD_INFO *)pDirInfo;
  326. new_entry = old_entry + sizeof(FIND_FILE_STANDARD_INFO) +
  327. pfData->FileNameLength;
  328. } else
  329. new_entry = old_entry + le32_to_cpu(pDirInfo->NextEntryOffset);
  330. cifs_dbg(FYI, "new entry %p old entry %p\n", new_entry, old_entry);
  331. /* validate that new_entry is not past end of SMB */
  332. if (new_entry >= end_of_smb) {
  333. cifs_dbg(VFS, "search entry %p began after end of SMB %p old entry %p\n",
  334. new_entry, end_of_smb, old_entry);
  335. return NULL;
  336. } else if (((level == SMB_FIND_FILE_INFO_STANDARD) &&
  337. (new_entry + sizeof(FIND_FILE_STANDARD_INFO) > end_of_smb))
  338. || ((level != SMB_FIND_FILE_INFO_STANDARD) &&
  339. (new_entry + sizeof(FILE_DIRECTORY_INFO) > end_of_smb))) {
  340. cifs_dbg(VFS, "search entry %p extends after end of SMB %p\n",
  341. new_entry, end_of_smb);
  342. return NULL;
  343. } else
  344. return new_entry;
  345. }
  346. struct cifs_dirent {
  347. const char *name;
  348. size_t namelen;
  349. u32 resume_key;
  350. u64 ino;
  351. };
  352. static void cifs_fill_dirent_unix(struct cifs_dirent *de,
  353. const FILE_UNIX_INFO *info, bool is_unicode)
  354. {
  355. de->name = &info->FileName[0];
  356. if (is_unicode)
  357. de->namelen = cifs_unicode_bytelen(de->name);
  358. else
  359. de->namelen = strnlen(de->name, PATH_MAX);
  360. de->resume_key = info->ResumeKey;
  361. de->ino = le64_to_cpu(info->basic.UniqueId);
  362. }
  363. static void cifs_fill_dirent_dir(struct cifs_dirent *de,
  364. const FILE_DIRECTORY_INFO *info)
  365. {
  366. de->name = &info->FileName[0];
  367. de->namelen = le32_to_cpu(info->FileNameLength);
  368. de->resume_key = info->FileIndex;
  369. }
  370. static void cifs_fill_dirent_full(struct cifs_dirent *de,
  371. const FILE_FULL_DIRECTORY_INFO *info)
  372. {
  373. de->name = &info->FileName[0];
  374. de->namelen = le32_to_cpu(info->FileNameLength);
  375. de->resume_key = info->FileIndex;
  376. }
  377. static void cifs_fill_dirent_search(struct cifs_dirent *de,
  378. const SEARCH_ID_FULL_DIR_INFO *info)
  379. {
  380. de->name = &info->FileName[0];
  381. de->namelen = le32_to_cpu(info->FileNameLength);
  382. de->resume_key = info->FileIndex;
  383. de->ino = le64_to_cpu(info->UniqueId);
  384. }
  385. static void cifs_fill_dirent_both(struct cifs_dirent *de,
  386. const FILE_BOTH_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. static void cifs_fill_dirent_std(struct cifs_dirent *de,
  393. const FIND_FILE_STANDARD_INFO *info)
  394. {
  395. de->name = &info->FileName[0];
  396. /* one byte length, no endianess conversion */
  397. de->namelen = info->FileNameLength;
  398. de->resume_key = info->ResumeKey;
  399. }
  400. static int cifs_fill_dirent(struct cifs_dirent *de, const void *info,
  401. u16 level, bool is_unicode)
  402. {
  403. memset(de, 0, sizeof(*de));
  404. switch (level) {
  405. case SMB_FIND_FILE_UNIX:
  406. cifs_fill_dirent_unix(de, info, is_unicode);
  407. break;
  408. case SMB_FIND_FILE_DIRECTORY_INFO:
  409. cifs_fill_dirent_dir(de, info);
  410. break;
  411. case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
  412. cifs_fill_dirent_full(de, info);
  413. break;
  414. case SMB_FIND_FILE_ID_FULL_DIR_INFO:
  415. cifs_fill_dirent_search(de, info);
  416. break;
  417. case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
  418. cifs_fill_dirent_both(de, info);
  419. break;
  420. case SMB_FIND_FILE_INFO_STANDARD:
  421. cifs_fill_dirent_std(de, info);
  422. break;
  423. default:
  424. cifs_dbg(FYI, "Unknown findfirst level %d\n", level);
  425. return -EINVAL;
  426. }
  427. return 0;
  428. }
  429. #define UNICODE_DOT cpu_to_le16(0x2e)
  430. /* return 0 if no match and 1 for . (current directory) and 2 for .. (parent) */
  431. static int cifs_entry_is_dot(struct cifs_dirent *de, bool is_unicode)
  432. {
  433. int rc = 0;
  434. if (!de->name)
  435. return 0;
  436. if (is_unicode) {
  437. __le16 *ufilename = (__le16 *)de->name;
  438. if (de->namelen == 2) {
  439. /* check for . */
  440. if (ufilename[0] == UNICODE_DOT)
  441. rc = 1;
  442. } else if (de->namelen == 4) {
  443. /* check for .. */
  444. if (ufilename[0] == UNICODE_DOT &&
  445. ufilename[1] == UNICODE_DOT)
  446. rc = 2;
  447. }
  448. } else /* ASCII */ {
  449. if (de->namelen == 1) {
  450. if (de->name[0] == '.')
  451. rc = 1;
  452. } else if (de->namelen == 2) {
  453. if (de->name[0] == '.' && de->name[1] == '.')
  454. rc = 2;
  455. }
  456. }
  457. return rc;
  458. }
  459. /* Check if directory that we are searching has changed so we can decide
  460. whether we can use the cached search results from the previous search */
  461. static int is_dir_changed(struct file *file)
  462. {
  463. struct inode *inode = file_inode(file);
  464. struct cifsInodeInfo *cifsInfo = CIFS_I(inode);
  465. if (cifsInfo->time == 0)
  466. return 1; /* directory was changed, perhaps due to unlink */
  467. else
  468. return 0;
  469. }
  470. static int cifs_save_resume_key(const char *current_entry,
  471. struct cifsFileInfo *file_info)
  472. {
  473. struct cifs_dirent de;
  474. int rc;
  475. rc = cifs_fill_dirent(&de, current_entry, file_info->srch_inf.info_level,
  476. file_info->srch_inf.unicode);
  477. if (!rc) {
  478. file_info->srch_inf.presume_name = de.name;
  479. file_info->srch_inf.resume_name_len = de.namelen;
  480. file_info->srch_inf.resume_key = de.resume_key;
  481. }
  482. return rc;
  483. }
  484. /*
  485. * Find the corresponding entry in the search. Note that the SMB server returns
  486. * search entries for . and .. which complicates logic here if we choose to
  487. * parse for them and we do not assume that they are located in the findfirst
  488. * return buffer. We start counting in the buffer with entry 2 and increment for
  489. * every entry (do not increment for . or .. entry).
  490. */
  491. static int
  492. find_cifs_entry(const unsigned int xid, struct cifs_tcon *tcon, loff_t pos,
  493. struct file *file, char **current_entry, int *num_to_ret)
  494. {
  495. __u16 search_flags;
  496. int rc = 0;
  497. int pos_in_buf = 0;
  498. loff_t first_entry_in_buffer;
  499. loff_t index_to_find = pos;
  500. struct cifsFileInfo *cfile = file->private_data;
  501. struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
  502. struct TCP_Server_Info *server = tcon->ses->server;
  503. /* check if index in the buffer */
  504. if (!server->ops->query_dir_first || !server->ops->query_dir_next)
  505. return -ENOSYS;
  506. if ((cfile == NULL) || (current_entry == NULL) || (num_to_ret == NULL))
  507. return -ENOENT;
  508. *current_entry = NULL;
  509. first_entry_in_buffer = cfile->srch_inf.index_of_last_entry -
  510. cfile->srch_inf.entries_in_buffer;
  511. /*
  512. * If first entry in buf is zero then is first buffer
  513. * in search response data which means it is likely . and ..
  514. * will be in this buffer, although some servers do not return
  515. * . and .. for the root of a drive and for those we need
  516. * to start two entries earlier.
  517. */
  518. dump_cifs_file_struct(file, "In fce ");
  519. if (((index_to_find < cfile->srch_inf.index_of_last_entry) &&
  520. is_dir_changed(file)) || (index_to_find < first_entry_in_buffer)) {
  521. /* close and restart search */
  522. cifs_dbg(FYI, "search backing up - close and restart search\n");
  523. spin_lock(&cifs_file_list_lock);
  524. if (!cfile->srch_inf.endOfSearch && !cfile->invalidHandle) {
  525. cfile->invalidHandle = true;
  526. spin_unlock(&cifs_file_list_lock);
  527. if (server->ops->close)
  528. server->ops->close(xid, tcon, &cfile->fid);
  529. } else
  530. spin_unlock(&cifs_file_list_lock);
  531. if (cfile->srch_inf.ntwrk_buf_start) {
  532. cifs_dbg(FYI, "freeing SMB ff cache buf on search rewind\n");
  533. if (cfile->srch_inf.smallBuf)
  534. cifs_small_buf_release(cfile->srch_inf.
  535. ntwrk_buf_start);
  536. else
  537. cifs_buf_release(cfile->srch_inf.
  538. ntwrk_buf_start);
  539. cfile->srch_inf.ntwrk_buf_start = NULL;
  540. }
  541. rc = initiate_cifs_search(xid, file);
  542. if (rc) {
  543. cifs_dbg(FYI, "error %d reinitiating a search on rewind\n",
  544. rc);
  545. return rc;
  546. }
  547. /* FindFirst/Next set last_entry to NULL on malformed reply */
  548. if (cfile->srch_inf.last_entry)
  549. cifs_save_resume_key(cfile->srch_inf.last_entry, cfile);
  550. }
  551. search_flags = CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME;
  552. if (backup_cred(cifs_sb))
  553. search_flags |= CIFS_SEARCH_BACKUP_SEARCH;
  554. while ((index_to_find >= cfile->srch_inf.index_of_last_entry) &&
  555. (rc == 0) && !cfile->srch_inf.endOfSearch) {
  556. cifs_dbg(FYI, "calling findnext2\n");
  557. rc = server->ops->query_dir_next(xid, tcon, &cfile->fid,
  558. search_flags,
  559. &cfile->srch_inf);
  560. /* FindFirst/Next set last_entry to NULL on malformed reply */
  561. if (cfile->srch_inf.last_entry)
  562. cifs_save_resume_key(cfile->srch_inf.last_entry, cfile);
  563. if (rc)
  564. return -ENOENT;
  565. }
  566. if (index_to_find < cfile->srch_inf.index_of_last_entry) {
  567. /* we found the buffer that contains the entry */
  568. /* scan and find it */
  569. int i;
  570. char *cur_ent;
  571. char *end_of_smb = cfile->srch_inf.ntwrk_buf_start +
  572. server->ops->calc_smb_size(
  573. cfile->srch_inf.ntwrk_buf_start);
  574. cur_ent = cfile->srch_inf.srch_entries_start;
  575. first_entry_in_buffer = cfile->srch_inf.index_of_last_entry
  576. - cfile->srch_inf.entries_in_buffer;
  577. pos_in_buf = index_to_find - first_entry_in_buffer;
  578. cifs_dbg(FYI, "found entry - pos_in_buf %d\n", pos_in_buf);
  579. for (i = 0; (i < (pos_in_buf)) && (cur_ent != NULL); i++) {
  580. /* go entry by entry figuring out which is first */
  581. cur_ent = nxt_dir_entry(cur_ent, end_of_smb,
  582. cfile->srch_inf.info_level);
  583. }
  584. if ((cur_ent == NULL) && (i < pos_in_buf)) {
  585. /* BB fixme - check if we should flag this error */
  586. cifs_dbg(VFS, "reached end of buf searching for pos in buf %d index to find %lld rc %d\n",
  587. pos_in_buf, index_to_find, rc);
  588. }
  589. rc = 0;
  590. *current_entry = cur_ent;
  591. } else {
  592. cifs_dbg(FYI, "index not in buffer - could not findnext into it\n");
  593. return 0;
  594. }
  595. if (pos_in_buf >= cfile->srch_inf.entries_in_buffer) {
  596. cifs_dbg(FYI, "can not return entries pos_in_buf beyond last\n");
  597. *num_to_ret = 0;
  598. } else
  599. *num_to_ret = cfile->srch_inf.entries_in_buffer - pos_in_buf;
  600. return rc;
  601. }
  602. static int cifs_filldir(char *find_entry, struct file *file,
  603. struct dir_context *ctx,
  604. char *scratch_buf, unsigned int max_len)
  605. {
  606. struct cifsFileInfo *file_info = file->private_data;
  607. struct super_block *sb = file->f_path.dentry->d_sb;
  608. struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
  609. struct cifs_dirent de = { NULL, };
  610. struct cifs_fattr fattr;
  611. struct qstr name;
  612. int rc = 0;
  613. ino_t ino;
  614. rc = cifs_fill_dirent(&de, find_entry, file_info->srch_inf.info_level,
  615. file_info->srch_inf.unicode);
  616. if (rc)
  617. return rc;
  618. if (de.namelen > max_len) {
  619. cifs_dbg(VFS, "bad search response length %zd past smb end\n",
  620. de.namelen);
  621. return -EINVAL;
  622. }
  623. /* skip . and .. since we added them first */
  624. if (cifs_entry_is_dot(&de, file_info->srch_inf.unicode))
  625. return 0;
  626. if (file_info->srch_inf.unicode) {
  627. struct nls_table *nlt = cifs_sb->local_nls;
  628. name.name = scratch_buf;
  629. name.len =
  630. cifs_from_utf16((char *)name.name, (__le16 *)de.name,
  631. UNICODE_NAME_MAX,
  632. min_t(size_t, de.namelen,
  633. (size_t)max_len), nlt,
  634. cifs_sb->mnt_cifs_flags &
  635. CIFS_MOUNT_MAP_SPECIAL_CHR);
  636. name.len -= nls_nullsize(nlt);
  637. } else {
  638. name.name = de.name;
  639. name.len = de.namelen;
  640. }
  641. switch (file_info->srch_inf.info_level) {
  642. case SMB_FIND_FILE_UNIX:
  643. cifs_unix_basic_to_fattr(&fattr,
  644. &((FILE_UNIX_INFO *)find_entry)->basic,
  645. cifs_sb);
  646. break;
  647. case SMB_FIND_FILE_INFO_STANDARD:
  648. cifs_std_info_to_fattr(&fattr,
  649. (FIND_FILE_STANDARD_INFO *)find_entry,
  650. cifs_sb);
  651. break;
  652. default:
  653. cifs_dir_info_to_fattr(&fattr,
  654. (FILE_DIRECTORY_INFO *)find_entry,
  655. cifs_sb);
  656. break;
  657. }
  658. if (de.ino && (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
  659. fattr.cf_uniqueid = de.ino;
  660. } else {
  661. fattr.cf_uniqueid = iunique(sb, ROOT_I);
  662. cifs_autodisable_serverino(cifs_sb);
  663. }
  664. if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) &&
  665. CIFSCouldBeMFSymlink(&fattr))
  666. /*
  667. * trying to get the type and mode can be slow,
  668. * so just call those regular files for now, and mark
  669. * for reval
  670. */
  671. fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
  672. cifs_prime_dcache(file->f_dentry, &name, &fattr);
  673. ino = cifs_uniqueid_to_ino_t(fattr.cf_uniqueid);
  674. return !dir_emit(ctx, name.name, name.len, ino, fattr.cf_dtype);
  675. }
  676. int cifs_readdir(struct file *file, struct dir_context *ctx)
  677. {
  678. int rc = 0;
  679. unsigned int xid;
  680. int i;
  681. struct cifs_tcon *tcon;
  682. struct cifsFileInfo *cifsFile = NULL;
  683. char *current_entry;
  684. int num_to_fill = 0;
  685. char *tmp_buf = NULL;
  686. char *end_of_smb;
  687. unsigned int max_len;
  688. xid = get_xid();
  689. /*
  690. * Ensure FindFirst doesn't fail before doing filldir() for '.' and
  691. * '..'. Otherwise we won't be able to notify VFS in case of failure.
  692. */
  693. if (file->private_data == NULL) {
  694. rc = initiate_cifs_search(xid, file);
  695. cifs_dbg(FYI, "initiate cifs search rc %d\n", rc);
  696. if (rc)
  697. goto rddir2_exit;
  698. }
  699. if (!dir_emit_dots(file, ctx))
  700. goto rddir2_exit;
  701. /* 1) If search is active,
  702. is in current search buffer?
  703. if it before then restart search
  704. if after then keep searching till find it */
  705. if (file->private_data == NULL) {
  706. rc = -EINVAL;
  707. goto rddir2_exit;
  708. }
  709. cifsFile = file->private_data;
  710. if (cifsFile->srch_inf.endOfSearch) {
  711. if (cifsFile->srch_inf.emptyDir) {
  712. cifs_dbg(FYI, "End of search, empty dir\n");
  713. rc = 0;
  714. goto rddir2_exit;
  715. }
  716. } /* else {
  717. cifsFile->invalidHandle = true;
  718. tcon->ses->server->close(xid, tcon, &cifsFile->fid);
  719. } */
  720. tcon = tlink_tcon(cifsFile->tlink);
  721. rc = find_cifs_entry(xid, tcon, ctx->pos, file, &current_entry,
  722. &num_to_fill);
  723. if (rc) {
  724. cifs_dbg(FYI, "fce error %d\n", rc);
  725. goto rddir2_exit;
  726. } else if (current_entry != NULL) {
  727. cifs_dbg(FYI, "entry %lld found\n", ctx->pos);
  728. } else {
  729. cifs_dbg(FYI, "could not find entry\n");
  730. goto rddir2_exit;
  731. }
  732. cifs_dbg(FYI, "loop through %d times filling dir for net buf %p\n",
  733. num_to_fill, cifsFile->srch_inf.ntwrk_buf_start);
  734. max_len = tcon->ses->server->ops->calc_smb_size(
  735. cifsFile->srch_inf.ntwrk_buf_start);
  736. end_of_smb = cifsFile->srch_inf.ntwrk_buf_start + max_len;
  737. tmp_buf = kmalloc(UNICODE_NAME_MAX, GFP_KERNEL);
  738. if (tmp_buf == NULL) {
  739. rc = -ENOMEM;
  740. goto rddir2_exit;
  741. }
  742. for (i = 0; i < num_to_fill; i++) {
  743. if (current_entry == NULL) {
  744. /* evaluate whether this case is an error */
  745. cifs_dbg(VFS, "past SMB end, num to fill %d i %d\n",
  746. num_to_fill, i);
  747. break;
  748. }
  749. /*
  750. * if buggy server returns . and .. late do we want to
  751. * check for that here?
  752. */
  753. rc = cifs_filldir(current_entry, file, ctx,
  754. tmp_buf, max_len);
  755. if (rc) {
  756. if (rc > 0)
  757. rc = 0;
  758. break;
  759. }
  760. ctx->pos++;
  761. if (ctx->pos ==
  762. cifsFile->srch_inf.index_of_last_entry) {
  763. cifs_dbg(FYI, "last entry in buf at pos %lld %s\n",
  764. ctx->pos, tmp_buf);
  765. cifs_save_resume_key(current_entry, cifsFile);
  766. break;
  767. } else
  768. current_entry =
  769. nxt_dir_entry(current_entry, end_of_smb,
  770. cifsFile->srch_inf.info_level);
  771. }
  772. kfree(tmp_buf);
  773. rddir2_exit:
  774. free_xid(xid);
  775. return rc;
  776. }