[CIFS] Fix readdir caching when unlink removes file in current search
[linux-2.6] / fs / cifs / readdir.c
1 /*
2  *   fs/cifs/readdir.c
3  *
4  *   Directory search handling
5  * 
6  *   Copyright (C) International Business Machines  Corp., 2004, 2005
7  *   Author(s): Steve French (sfrench@us.ibm.com)
8  *
9  *   This library is free software; you can redistribute it and/or modify
10  *   it under the terms of the GNU Lesser General Public License as published
11  *   by the Free Software Foundation; either version 2.1 of the License, or
12  *   (at your option) any later version.
13  *
14  *   This library is distributed in the hope that it will be useful,
15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
17  *   the GNU Lesser General Public License for more details.
18  *
19  *   You should have received a copy of the GNU Lesser General Public License
20  *   along with this library; if not, write to the Free Software
21  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22  */
23 #include <linux/fs.h>
24 #include <linux/stat.h>
25 #include <linux/smp_lock.h>
26 #include "cifspdu.h"
27 #include "cifsglob.h"
28 #include "cifsproto.h"
29 #include "cifs_unicode.h"
30 #include "cifs_debug.h"
31 #include "cifs_fs_sb.h"
32 #include "cifsfs.h"
33
34 /* BB fixme - add debug wrappers around this function to disable it fixme BB */
35 /* static void dump_cifs_file_struct(struct file *file, char *label)
36 {
37         struct cifsFileInfo * cf;
38
39         if(file) {
40                 cf = file->private_data;
41                 if(cf == NULL) {
42                         cFYI(1,("empty cifs private file data"));
43                         return;
44                 }
45                 if(cf->invalidHandle) {
46                         cFYI(1,("invalid handle"));
47                 }
48                 if(cf->srch_inf.endOfSearch) {
49                         cFYI(1,("end of search"));
50                 }
51                 if(cf->srch_inf.emptyDir) {
52                         cFYI(1,("empty dir"));
53                 }
54                 
55         }
56 } */
57
58 /* Returns one if new inode created (which therefore needs to be hashed) */
59 /* Might check in the future if inode number changed so we can rehash inode */
60 static int construct_dentry(struct qstr *qstring, struct file *file,
61         struct inode **ptmp_inode, struct dentry **pnew_dentry)
62 {
63         struct dentry *tmp_dentry;
64         struct cifs_sb_info *cifs_sb;
65         struct cifsTconInfo *pTcon;
66         int rc = 0;
67
68         cFYI(1, ("For %s", qstring->name));
69         cifs_sb = CIFS_SB(file->f_dentry->d_sb);
70         pTcon = cifs_sb->tcon;
71
72         qstring->hash = full_name_hash(qstring->name, qstring->len);
73         tmp_dentry = d_lookup(file->f_dentry, qstring);
74         if (tmp_dentry) {
75                 cFYI(0, ("existing dentry with inode 0x%p", tmp_dentry->d_inode));
76                 *ptmp_inode = tmp_dentry->d_inode;
77 /* BB overwrite old name? i.e. tmp_dentry->d_name and tmp_dentry->d_name.len??*/
78                 if(*ptmp_inode == NULL) {
79                         *ptmp_inode = new_inode(file->f_dentry->d_sb);
80                         if(*ptmp_inode == NULL)
81                                 return rc;
82                         rc = 1;
83                         d_instantiate(tmp_dentry, *ptmp_inode);
84                 }
85         } else {
86                 tmp_dentry = d_alloc(file->f_dentry, qstring);
87                 if(tmp_dentry == NULL) {
88                         cERROR(1,("Failed allocating dentry"));
89                         *ptmp_inode = NULL;
90                         return rc;
91                 }
92
93                 *ptmp_inode = new_inode(file->f_dentry->d_sb);
94                 if (pTcon->nocase)
95                         tmp_dentry->d_op = &cifs_ci_dentry_ops;
96                 else
97                         tmp_dentry->d_op = &cifs_dentry_ops;
98                 if(*ptmp_inode == NULL)
99                         return rc;
100                 rc = 1;
101                 d_instantiate(tmp_dentry, *ptmp_inode);
102                 d_rehash(tmp_dentry);
103         }
104
105         tmp_dentry->d_time = jiffies;
106         *pnew_dentry = tmp_dentry;
107         return rc;
108 }
109
110 static void fill_in_inode(struct inode *tmp_inode,
111         FILE_DIRECTORY_INFO *pfindData, int *pobject_type, int isNewInode)
112 {
113         loff_t local_size;
114         struct timespec local_mtime;
115
116         struct cifsInodeInfo *cifsInfo = CIFS_I(tmp_inode);
117         struct cifs_sb_info *cifs_sb = CIFS_SB(tmp_inode->i_sb);
118         __u32 attr = le32_to_cpu(pfindData->ExtFileAttributes);
119         __u64 allocation_size = le64_to_cpu(pfindData->AllocationSize);
120         __u64 end_of_file = le64_to_cpu(pfindData->EndOfFile);
121
122         cifsInfo->cifsAttrs = attr;
123         cifsInfo->time = jiffies;
124
125         /* save mtime and size */
126         local_mtime = tmp_inode->i_mtime;
127         local_size  = tmp_inode->i_size;
128
129         /* Linux can not store file creation time unfortunately so ignore it */
130         tmp_inode->i_atime =
131             cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastAccessTime));
132         tmp_inode->i_mtime =
133             cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastWriteTime));
134         tmp_inode->i_ctime =
135             cifs_NTtimeToUnix(le64_to_cpu(pfindData->ChangeTime));
136         /* treat dos attribute of read-only as read-only mode bit e.g. 555? */
137         /* 2767 perms - indicate mandatory locking */
138                 /* BB fill in uid and gid here? with help from winbind? 
139                    or retrieve from NTFS stream extended attribute */
140         if (atomic_read(&cifsInfo->inUse) == 0) {
141                 tmp_inode->i_uid = cifs_sb->mnt_uid;
142                 tmp_inode->i_gid = cifs_sb->mnt_gid;
143                 /* set default mode. will override for dirs below */
144                 tmp_inode->i_mode = cifs_sb->mnt_file_mode;
145         }
146
147         if (attr & ATTR_DIRECTORY) {
148                 *pobject_type = DT_DIR;
149                 /* override default perms since we do not lock dirs */
150                 if(atomic_read(&cifsInfo->inUse) == 0) {
151                         tmp_inode->i_mode = cifs_sb->mnt_dir_mode;
152                 }
153                 tmp_inode->i_mode |= S_IFDIR;
154         } else if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) && 
155                    (attr & ATTR_SYSTEM) && (end_of_file == 0)) {
156                 *pobject_type = DT_FIFO;
157                 tmp_inode->i_mode |= S_IFIFO;
158 /* BB Finish for SFU style symlinks and devies */
159 /*      } else if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) &&
160                 (attr & ATTR_SYSTEM) && ) { */
161 /* we no longer mark these because we could not follow them */
162 /*        } else if (attr & ATTR_REPARSE) {
163                 *pobject_type = DT_LNK;
164                 tmp_inode->i_mode |= S_IFLNK; */
165         } else {
166                 *pobject_type = DT_REG;
167                 tmp_inode->i_mode |= S_IFREG;
168                 if (attr & ATTR_READONLY)
169                         tmp_inode->i_mode &= ~(S_IWUGO);
170         } /* could add code here - to validate if device or weird share type? */
171
172         /* can not fill in nlink here as in qpathinfo version and Unx search */
173         if (atomic_read(&cifsInfo->inUse) == 0) {
174                 atomic_set(&cifsInfo->inUse, 1);
175         }
176
177         if (is_size_safe_to_change(cifsInfo)) {
178                 /* can not safely change the file size here if the 
179                 client is writing to it due to potential races */
180                 i_size_write(tmp_inode, end_of_file);
181
182         /* 512 bytes (2**9) is the fake blocksize that must be used */
183         /* for this calculation, even though the reported blocksize is larger */
184                 tmp_inode->i_blocks = (512 - 1 + allocation_size) >> 9;
185         }
186
187         if (allocation_size < end_of_file)
188                 cFYI(1, ("May be sparse file, allocation less than file size"));
189         cFYI(1,
190              ("File Size %ld and blocks %ld and blocksize %ld",
191               (unsigned long)tmp_inode->i_size, tmp_inode->i_blocks,
192               tmp_inode->i_blksize));
193         if (S_ISREG(tmp_inode->i_mode)) {
194                 cFYI(1, ("File inode"));
195                 tmp_inode->i_op = &cifs_file_inode_ops;
196                 if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
197                         tmp_inode->i_fop = &cifs_file_direct_ops;
198                 else
199                         tmp_inode->i_fop = &cifs_file_ops;
200                 if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
201                         tmp_inode->i_fop->lock = NULL;
202                 tmp_inode->i_data.a_ops = &cifs_addr_ops;
203                 if((cifs_sb->tcon) && (cifs_sb->tcon->ses) &&
204                    (cifs_sb->tcon->ses->server->maxBuf <
205                         4096 + MAX_CIFS_HDR_SIZE))
206                         tmp_inode->i_data.a_ops->readpages = NULL;
207                 if(isNewInode)
208                         return; /* No sense invalidating pages for new inode
209                                    since have not started caching readahead file
210                                    data yet */
211
212                 if (timespec_equal(&tmp_inode->i_mtime, &local_mtime) &&
213                         (local_size == tmp_inode->i_size)) {
214                         cFYI(1, ("inode exists but unchanged"));
215                 } else {
216                         /* file may have changed on server */
217                         cFYI(1, ("invalidate inode, readdir detected change"));
218                         invalidate_remote_inode(tmp_inode);
219                 }
220         } else if (S_ISDIR(tmp_inode->i_mode)) {
221                 cFYI(1, ("Directory inode"));
222                 tmp_inode->i_op = &cifs_dir_inode_ops;
223                 tmp_inode->i_fop = &cifs_dir_ops;
224         } else if (S_ISLNK(tmp_inode->i_mode)) {
225                 cFYI(1, ("Symbolic Link inode"));
226                 tmp_inode->i_op = &cifs_symlink_inode_ops;
227         } else {
228                 cFYI(1, ("Init special inode"));
229                 init_special_inode(tmp_inode, tmp_inode->i_mode,
230                                    tmp_inode->i_rdev);
231         }
232 }
233
234 static void unix_fill_in_inode(struct inode *tmp_inode,
235         FILE_UNIX_INFO *pfindData, int *pobject_type, int isNewInode)
236 {
237         loff_t local_size;
238         struct timespec local_mtime;
239
240         struct cifsInodeInfo *cifsInfo = CIFS_I(tmp_inode);
241         struct cifs_sb_info *cifs_sb = CIFS_SB(tmp_inode->i_sb);
242
243         __u32 type = le32_to_cpu(pfindData->Type);
244         __u64 num_of_bytes = le64_to_cpu(pfindData->NumOfBytes);
245         __u64 end_of_file = le64_to_cpu(pfindData->EndOfFile);
246         cifsInfo->time = jiffies;
247         atomic_inc(&cifsInfo->inUse);
248
249         /* save mtime and size */
250         local_mtime = tmp_inode->i_mtime;
251         local_size  = tmp_inode->i_size;
252
253         tmp_inode->i_atime =
254             cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastAccessTime));
255         tmp_inode->i_mtime =
256             cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastModificationTime));
257         tmp_inode->i_ctime =
258             cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastStatusChange));
259
260         tmp_inode->i_mode = le64_to_cpu(pfindData->Permissions);
261         if (type == UNIX_FILE) {
262                 *pobject_type = DT_REG;
263                 tmp_inode->i_mode |= S_IFREG;
264         } else if (type == UNIX_SYMLINK) {
265                 *pobject_type = DT_LNK;
266                 tmp_inode->i_mode |= S_IFLNK;
267         } else if (type == UNIX_DIR) {
268                 *pobject_type = DT_DIR;
269                 tmp_inode->i_mode |= S_IFDIR;
270         } else if (type == UNIX_CHARDEV) {
271                 *pobject_type = DT_CHR;
272                 tmp_inode->i_mode |= S_IFCHR;
273                 tmp_inode->i_rdev = MKDEV(le64_to_cpu(pfindData->DevMajor),
274                                 le64_to_cpu(pfindData->DevMinor) & MINORMASK);
275         } else if (type == UNIX_BLOCKDEV) {
276                 *pobject_type = DT_BLK;
277                 tmp_inode->i_mode |= S_IFBLK;
278                 tmp_inode->i_rdev = MKDEV(le64_to_cpu(pfindData->DevMajor),
279                                 le64_to_cpu(pfindData->DevMinor) & MINORMASK);
280         } else if (type == UNIX_FIFO) {
281                 *pobject_type = DT_FIFO;
282                 tmp_inode->i_mode |= S_IFIFO;
283         } else if (type == UNIX_SOCKET) {
284                 *pobject_type = DT_SOCK;
285                 tmp_inode->i_mode |= S_IFSOCK;
286         }
287
288         tmp_inode->i_uid = le64_to_cpu(pfindData->Uid);
289         tmp_inode->i_gid = le64_to_cpu(pfindData->Gid);
290         tmp_inode->i_nlink = le64_to_cpu(pfindData->Nlinks);
291
292         if (is_size_safe_to_change(cifsInfo)) {
293                 /* can not safely change the file size here if the 
294                 client is writing to it due to potential races */
295                 i_size_write(tmp_inode,end_of_file);
296
297         /* 512 bytes (2**9) is the fake blocksize that must be used */
298         /* for this calculation, not the real blocksize */
299                 tmp_inode->i_blocks = (512 - 1 + num_of_bytes) >> 9;
300         }
301
302         if (S_ISREG(tmp_inode->i_mode)) {
303                 cFYI(1, ("File inode"));
304                 tmp_inode->i_op = &cifs_file_inode_ops;
305                 if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
306                         tmp_inode->i_fop = &cifs_file_direct_ops;
307                 else
308                         tmp_inode->i_fop = &cifs_file_ops;
309                 if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
310                         tmp_inode->i_fop->lock = NULL;
311                 tmp_inode->i_data.a_ops = &cifs_addr_ops;
312                 if((cifs_sb->tcon) && (cifs_sb->tcon->ses) &&
313                    (cifs_sb->tcon->ses->server->maxBuf < 
314                         4096 + MAX_CIFS_HDR_SIZE))
315                         tmp_inode->i_data.a_ops->readpages = NULL;
316
317                 if(isNewInode)
318                         return; /* No sense invalidating pages for new inode since we
319                                            have not started caching readahead file data yet */
320
321                 if (timespec_equal(&tmp_inode->i_mtime, &local_mtime) &&
322                         (local_size == tmp_inode->i_size)) {
323                         cFYI(1, ("inode exists but unchanged"));
324                 } else {
325                         /* file may have changed on server */
326                         cFYI(1, ("invalidate inode, readdir detected change"));
327                         invalidate_remote_inode(tmp_inode);
328                 }
329         } else if (S_ISDIR(tmp_inode->i_mode)) {
330                 cFYI(1, ("Directory inode"));
331                 tmp_inode->i_op = &cifs_dir_inode_ops;
332                 tmp_inode->i_fop = &cifs_dir_ops;
333         } else if (S_ISLNK(tmp_inode->i_mode)) {
334                 cFYI(1, ("Symbolic Link inode"));
335                 tmp_inode->i_op = &cifs_symlink_inode_ops;
336 /* tmp_inode->i_fop = *//* do not need to set to anything */
337         } else {
338                 cFYI(1, ("Special inode")); 
339                 init_special_inode(tmp_inode, tmp_inode->i_mode,
340                                    tmp_inode->i_rdev);
341         }
342 }
343
344 static int initiate_cifs_search(const int xid, struct file *file)
345 {
346         int rc = 0;
347         char * full_path;
348         struct cifsFileInfo * cifsFile;
349         struct cifs_sb_info *cifs_sb;
350         struct cifsTconInfo *pTcon;
351
352         if(file->private_data == NULL) {
353                 file->private_data = 
354                         kmalloc(sizeof(struct cifsFileInfo),GFP_KERNEL);
355         }
356
357         if(file->private_data == NULL) {
358                 return -ENOMEM;
359         } else {
360                 memset(file->private_data,0,sizeof(struct cifsFileInfo));
361         }
362         cifsFile = file->private_data;
363         cifsFile->invalidHandle = TRUE;
364         cifsFile->srch_inf.endOfSearch = FALSE;
365
366         if(file->f_dentry == NULL)
367                 return -ENOENT;
368
369         cifs_sb = CIFS_SB(file->f_dentry->d_sb);
370         if(cifs_sb == NULL)
371                 return -EINVAL;
372
373         pTcon = cifs_sb->tcon;
374         if(pTcon == NULL)
375                 return -EINVAL;
376
377         down(&file->f_dentry->d_sb->s_vfs_rename_sem);
378         full_path = build_path_from_dentry(file->f_dentry);
379         up(&file->f_dentry->d_sb->s_vfs_rename_sem);
380
381         if(full_path == NULL) {
382                 return -ENOMEM;
383         }
384
385         cFYI(1, ("Full path: %s start at: %lld", full_path, file->f_pos));
386
387 ffirst_retry:
388         /* test for Unix extensions */
389         if (pTcon->ses->capabilities & CAP_UNIX) {
390                 cifsFile->srch_inf.info_level = SMB_FIND_FILE_UNIX; 
391         } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
392                 cifsFile->srch_inf.info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
393         } else /* not srvinos - BB fixme add check for backlevel? */ {
394                 cifsFile->srch_inf.info_level = SMB_FIND_FILE_DIRECTORY_INFO;
395         }
396
397         rc = CIFSFindFirst(xid, pTcon,full_path,cifs_sb->local_nls,
398                 &cifsFile->netfid, &cifsFile->srch_inf,
399                 cifs_sb->mnt_cifs_flags & 
400                         CIFS_MOUNT_MAP_SPECIAL_CHR, CIFS_DIR_SEP(cifs_sb));
401         if(rc == 0)
402                 cifsFile->invalidHandle = FALSE;
403         if((rc == -EOPNOTSUPP) && 
404                 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
405                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM;
406                 goto ffirst_retry;
407         }
408         kfree(full_path);
409         return rc;
410 }
411
412 /* return length of unicode string in bytes */
413 static int cifs_unicode_bytelen(char *str)
414 {
415         int len;
416         __le16 * ustr = (__le16 *)str;
417
418         for(len=0;len <= PATH_MAX;len++) {
419                 if(ustr[len] == 0)
420                         return len << 1;
421         }
422         cFYI(1,("Unicode string longer than PATH_MAX found"));
423         return len << 1;
424 }
425
426 static char *nxt_dir_entry(char *old_entry, char *end_of_smb)
427 {
428         char * new_entry;
429         FILE_DIRECTORY_INFO * pDirInfo = (FILE_DIRECTORY_INFO *)old_entry;
430
431         new_entry = old_entry + le32_to_cpu(pDirInfo->NextEntryOffset);
432         cFYI(1,("new entry %p old entry %p",new_entry,old_entry));
433         /* validate that new_entry is not past end of SMB */
434         if(new_entry >= end_of_smb) {
435                 cERROR(1,
436                       ("search entry %p began after end of SMB %p old entry %p",
437                         new_entry, end_of_smb, old_entry)); 
438                 return NULL;
439         } else if (new_entry + sizeof(FILE_DIRECTORY_INFO) > end_of_smb) {
440                 cERROR(1,("search entry %p extends after end of SMB %p",
441                         new_entry, end_of_smb));
442                 return NULL;
443         } else 
444                 return new_entry;
445
446 }
447
448 #define UNICODE_DOT cpu_to_le16(0x2e)
449
450 /* return 0 if no match and 1 for . (current directory) and 2 for .. (parent) */
451 static int cifs_entry_is_dot(char *current_entry, struct cifsFileInfo *cfile)
452 {
453         int rc = 0;
454         char * filename = NULL;
455         int len = 0; 
456
457         if(cfile->srch_inf.info_level == 0x202) {
458                 FILE_UNIX_INFO * pFindData = (FILE_UNIX_INFO *)current_entry;
459                 filename = &pFindData->FileName[0];
460                 if(cfile->srch_inf.unicode) {
461                         len = cifs_unicode_bytelen(filename);
462                 } else {
463                         /* BB should we make this strnlen of PATH_MAX? */
464                         len = strnlen(filename, 5);
465                 }
466         } else if(cfile->srch_inf.info_level == 0x101) {
467                 FILE_DIRECTORY_INFO * pFindData = 
468                         (FILE_DIRECTORY_INFO *)current_entry;
469                 filename = &pFindData->FileName[0];
470                 len = le32_to_cpu(pFindData->FileNameLength);
471         } else if(cfile->srch_inf.info_level == 0x102) {
472                 FILE_FULL_DIRECTORY_INFO * pFindData = 
473                         (FILE_FULL_DIRECTORY_INFO *)current_entry;
474                 filename = &pFindData->FileName[0];
475                 len = le32_to_cpu(pFindData->FileNameLength);
476         } else if(cfile->srch_inf.info_level == 0x105) {
477                 SEARCH_ID_FULL_DIR_INFO * pFindData = 
478                         (SEARCH_ID_FULL_DIR_INFO *)current_entry;
479                 filename = &pFindData->FileName[0];
480                 len = le32_to_cpu(pFindData->FileNameLength);
481         } else if(cfile->srch_inf.info_level == 0x104) {
482                 FILE_BOTH_DIRECTORY_INFO * pFindData = 
483                         (FILE_BOTH_DIRECTORY_INFO *)current_entry;
484                 filename = &pFindData->FileName[0];
485                 len = le32_to_cpu(pFindData->FileNameLength);
486         } else {
487                 cFYI(1,("Unknown findfirst level %d",cfile->srch_inf.info_level));
488         }
489
490         if(filename) {
491                 if(cfile->srch_inf.unicode) {
492                         __le16 *ufilename = (__le16 *)filename;
493                         if(len == 2) {
494                                 /* check for . */
495                                 if(ufilename[0] == UNICODE_DOT)
496                                         rc = 1;
497                         } else if(len == 4) {
498                                 /* check for .. */
499                                 if((ufilename[0] == UNICODE_DOT)
500                                    &&(ufilename[1] == UNICODE_DOT))
501                                         rc = 2;
502                         }
503                 } else /* ASCII */ {
504                         if(len == 1) {
505                                 if(filename[0] == '.') 
506                                         rc = 1;
507                         } else if(len == 2) {
508                                 if((filename[0] == '.') && (filename[1] == '.')) 
509                                         rc = 2;
510                         }
511                 }
512         }
513
514         return rc;
515 }
516
517 /* Check if directory that we are searching has changed so we can decide
518    whether we can use the cached search results from the previous search */
519 static int is_dir_changed(struct file * file)
520 {
521         struct inode * inode;
522         struct cifsInodeInfo *cifsInfo;
523
524         if(file->f_dentry == NULL)
525                 return 0;
526
527         inode = file->f_dentry->d_inode;
528
529         if(inode == NULL)
530                 return 0;
531
532         cifsInfo = CIFS_I(inode);
533
534         if(cifsInfo->time == 0)
535                 return 1; /* directory was changed, perhaps due to unlink */
536         else
537                 return 0;
538
539 }
540
541 /* find the corresponding entry in the search */
542 /* Note that the SMB server returns search entries for . and .. which
543    complicates logic here if we choose to parse for them and we do not
544    assume that they are located in the findfirst return buffer.*/
545 /* We start counting in the buffer with entry 2 and increment for every
546    entry (do not increment for . or .. entry) */
547 static int find_cifs_entry(const int xid, struct cifsTconInfo *pTcon,
548         struct file *file, char **ppCurrentEntry, int *num_to_ret) 
549 {
550         int rc = 0;
551         int pos_in_buf = 0;
552         loff_t first_entry_in_buffer;
553         loff_t index_to_find = file->f_pos;
554         struct cifsFileInfo * cifsFile = file->private_data;
555         /* check if index in the buffer */
556         
557         if((cifsFile == NULL) || (ppCurrentEntry == NULL) || 
558            (num_to_ret == NULL))
559                 return -ENOENT;
560         
561         *ppCurrentEntry = NULL;
562         first_entry_in_buffer = 
563                 cifsFile->srch_inf.index_of_last_entry - 
564                         cifsFile->srch_inf.entries_in_buffer;
565 /*      dump_cifs_file_struct(file, "In fce ");*/
566         if(((index_to_find < cifsFile->srch_inf.index_of_last_entry) && 
567              is_dir_changed(file)) || 
568            (index_to_find < first_entry_in_buffer)) {
569                 /* close and restart search */
570                 cFYI(1,("search backing up - close and restart search"));
571                 cifsFile->invalidHandle = TRUE;
572                 CIFSFindClose(xid, pTcon, cifsFile->netfid);
573                 kfree(cifsFile->search_resume_name);
574                 cifsFile->search_resume_name = NULL;
575                 if(cifsFile->srch_inf.ntwrk_buf_start) {
576                         cFYI(1,("freeing SMB ff cache buf on search rewind"));
577                         cifs_buf_release(cifsFile->srch_inf.ntwrk_buf_start);
578                 }
579                 rc = initiate_cifs_search(xid,file);
580                 if(rc) {
581                         cFYI(1,("error %d reinitiating a search on rewind",rc));
582                         return rc;
583                 }
584         }
585
586         while((index_to_find >= cifsFile->srch_inf.index_of_last_entry) && 
587               (rc == 0) && (cifsFile->srch_inf.endOfSearch == FALSE)){
588                 cFYI(1,("calling findnext2"));
589                 rc = CIFSFindNext(xid,pTcon,cifsFile->netfid, 
590                                   &cifsFile->srch_inf);
591                 if(rc)
592                         return -ENOENT;
593         }
594         if(index_to_find < cifsFile->srch_inf.index_of_last_entry) {
595                 /* we found the buffer that contains the entry */
596                 /* scan and find it */
597                 int i;
598                 char * current_entry;
599                 char * end_of_smb = cifsFile->srch_inf.ntwrk_buf_start + 
600                         smbCalcSize((struct smb_hdr *)
601                                 cifsFile->srch_inf.ntwrk_buf_start);
602                 first_entry_in_buffer = cifsFile->srch_inf.index_of_last_entry
603                                         - cifsFile->srch_inf.entries_in_buffer;
604                 pos_in_buf = index_to_find - first_entry_in_buffer;
605                 cFYI(1,("found entry - pos_in_buf %d",pos_in_buf)); 
606                 current_entry = cifsFile->srch_inf.srch_entries_start;
607                 for(i=0;(i<(pos_in_buf)) && (current_entry != NULL);i++) {
608                         /* go entry by entry figuring out which is first */
609                         /* if( . or ..)
610                                 skip */
611                         rc = cifs_entry_is_dot(current_entry,cifsFile);
612                         if(rc == 1) /* is . or .. so skip */ {
613                                 cFYI(1,("Entry is .")); /* BB removeme BB */
614                                 /* continue; */
615                         } else if (rc == 2 ) {
616                                 cFYI(1,("Entry is ..")); /* BB removeme BB */
617                                 /* continue; */
618                         }
619                         current_entry = nxt_dir_entry(current_entry,end_of_smb);
620                 }
621                 if((current_entry == NULL) && (i < pos_in_buf)) {
622                         /* BB fixme - check if we should flag this error */
623                         cERROR(1,("reached end of buf searching for pos in buf"
624                           " %d index to find %lld rc %d",
625                           pos_in_buf,index_to_find,rc));
626                 }
627                 rc = 0;
628                 *ppCurrentEntry = current_entry;
629         } else {
630                 cFYI(1,("index not in buffer - could not findnext into it"));
631                 return 0;
632         }
633
634         if(pos_in_buf >= cifsFile->srch_inf.entries_in_buffer) {
635                 cFYI(1,("can not return entries pos_in_buf beyond last entry"));
636                 *num_to_ret = 0;
637         } else
638                 *num_to_ret = cifsFile->srch_inf.entries_in_buffer - pos_in_buf;
639
640         return rc;
641 }
642
643 /* inode num, inode type and filename returned */
644 static int cifs_get_name_from_search_buf(struct qstr *pqst,
645         char *current_entry, __u16 level, unsigned int unicode,
646         struct cifs_sb_info * cifs_sb, ino_t *pinum)
647 {
648         int rc = 0;
649         unsigned int len = 0;
650         char * filename;
651         struct nls_table * nlt = cifs_sb->local_nls;
652
653         *pinum = 0;
654
655         if(level == SMB_FIND_FILE_UNIX) {
656                 FILE_UNIX_INFO * pFindData = (FILE_UNIX_INFO *)current_entry;
657
658                 filename = &pFindData->FileName[0];
659                 if(unicode) {
660                         len = cifs_unicode_bytelen(filename);
661                 } else {
662                         /* BB should we make this strnlen of PATH_MAX? */
663                         len = strnlen(filename, PATH_MAX);
664                 }
665
666                 /* BB fixme - hash low and high 32 bits if not 64 bit arch BB fixme */
667                 if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
668                         *pinum = pFindData->UniqueId;
669         } else if(level == SMB_FIND_FILE_DIRECTORY_INFO) {
670                 FILE_DIRECTORY_INFO * pFindData = 
671                         (FILE_DIRECTORY_INFO *)current_entry;
672                 filename = &pFindData->FileName[0];
673                 len = le32_to_cpu(pFindData->FileNameLength);
674         } else if(level == SMB_FIND_FILE_FULL_DIRECTORY_INFO) {
675                 FILE_FULL_DIRECTORY_INFO * pFindData = 
676                         (FILE_FULL_DIRECTORY_INFO *)current_entry;
677                 filename = &pFindData->FileName[0];
678                 len = le32_to_cpu(pFindData->FileNameLength);
679         } else if(level == SMB_FIND_FILE_ID_FULL_DIR_INFO) {
680                 SEARCH_ID_FULL_DIR_INFO * pFindData = 
681                         (SEARCH_ID_FULL_DIR_INFO *)current_entry;
682                 filename = &pFindData->FileName[0];
683                 len = le32_to_cpu(pFindData->FileNameLength);
684                 *pinum = pFindData->UniqueId;
685         } else if(level == SMB_FIND_FILE_BOTH_DIRECTORY_INFO) {
686                 FILE_BOTH_DIRECTORY_INFO * pFindData = 
687                         (FILE_BOTH_DIRECTORY_INFO *)current_entry;
688                 filename = &pFindData->FileName[0];
689                 len = le32_to_cpu(pFindData->FileNameLength);
690         } else {
691                 cFYI(1,("Unknown findfirst level %d",level));
692                 return -EINVAL;
693         }
694         if(unicode) {
695                 /* BB fixme - test with long names */
696                 /* Note converted filename can be longer than in unicode */
697                 if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
698                         pqst->len = cifs_convertUCSpath((char *)pqst->name,
699                                         (__le16 *)filename, len/2, nlt);
700                 else
701                         pqst->len = cifs_strfromUCS_le((char *)pqst->name,
702                                         (wchar_t *)filename,len/2,nlt);
703         } else {
704                 pqst->name = filename;
705                 pqst->len = len;
706         }
707         pqst->hash = full_name_hash(pqst->name,pqst->len);
708 /*      cFYI(1,("filldir on %s",pqst->name));  */
709         return rc;
710 }
711
712 static int cifs_filldir(char *pfindEntry, struct file *file,
713         filldir_t filldir, void *direntry, char *scratch_buf)
714 {
715         int rc = 0;
716         struct qstr qstring;
717         struct cifsFileInfo * pCifsF;
718         unsigned obj_type;
719         ino_t  inum;
720         struct cifs_sb_info * cifs_sb;
721         struct inode *tmp_inode;
722         struct dentry *tmp_dentry;
723
724         /* get filename and len into qstring */
725         /* get dentry */
726         /* decide whether to create and populate ionde */
727         if((direntry == NULL) || (file == NULL))
728                 return -EINVAL;
729
730         pCifsF = file->private_data;
731         
732         if((scratch_buf == NULL) || (pfindEntry == NULL) || (pCifsF == NULL))
733                 return -ENOENT;
734
735         if(file->f_dentry == NULL)
736                 return -ENOENT;
737
738         cifs_sb = CIFS_SB(file->f_dentry->d_sb);
739
740         qstring.name = scratch_buf;
741         rc = cifs_get_name_from_search_buf(&qstring,pfindEntry,
742                         pCifsF->srch_inf.info_level,
743                         pCifsF->srch_inf.unicode,cifs_sb,
744                         &inum /* returned */);
745
746         if(rc)
747                 return rc;
748
749         rc = construct_dentry(&qstring,file,&tmp_inode, &tmp_dentry);
750         if((tmp_inode == NULL) || (tmp_dentry == NULL))
751                 return -ENOMEM;
752
753         if(rc) {
754                 /* inode created, we need to hash it with right inode number */
755                 if(inum != 0) {
756                         /* BB fixme - hash the 2 32 quantities bits together if necessary BB */
757                         tmp_inode->i_ino = inum;
758                 }
759                 insert_inode_hash(tmp_inode);
760         }
761
762         /* we pass in rc below, indicating whether it is a new inode,
763            so we can figure out whether to invalidate the inode cached
764            data if the file has changed */
765         if(pCifsF->srch_inf.info_level == SMB_FIND_FILE_UNIX) {
766                 unix_fill_in_inode(tmp_inode,
767                                    (FILE_UNIX_INFO *)pfindEntry,&obj_type, rc);
768         } else {
769                 fill_in_inode(tmp_inode,
770                               (FILE_DIRECTORY_INFO *)pfindEntry,&obj_type, rc);
771         }
772         
773         rc = filldir(direntry,qstring.name,qstring.len,file->f_pos,
774                      tmp_inode->i_ino,obj_type);
775         if(rc) {
776                 cFYI(1,("filldir rc = %d",rc));
777         }
778
779         dput(tmp_dentry);
780         return rc;
781 }
782
783 static int cifs_save_resume_key(const char *current_entry,
784         struct cifsFileInfo *cifsFile)
785 {
786         int rc = 0;
787         unsigned int len = 0;
788         __u16 level;
789         char * filename;
790
791         if((cifsFile == NULL) || (current_entry == NULL))
792                 return -EINVAL;
793
794         level = cifsFile->srch_inf.info_level;
795
796         if(level == SMB_FIND_FILE_UNIX) {
797                 FILE_UNIX_INFO * pFindData = (FILE_UNIX_INFO *)current_entry;
798
799                 filename = &pFindData->FileName[0];
800                 if(cifsFile->srch_inf.unicode) {
801                         len = cifs_unicode_bytelen(filename);
802                 } else {
803                         /* BB should we make this strnlen of PATH_MAX? */
804                         len = strnlen(filename, PATH_MAX);
805                 }
806                 cifsFile->srch_inf.resume_key = pFindData->ResumeKey;
807         } else if(level == SMB_FIND_FILE_DIRECTORY_INFO) {
808                 FILE_DIRECTORY_INFO * pFindData = 
809                         (FILE_DIRECTORY_INFO *)current_entry;
810                 filename = &pFindData->FileName[0];
811                 len = le32_to_cpu(pFindData->FileNameLength);
812                 cifsFile->srch_inf.resume_key = pFindData->FileIndex;
813         } else if(level == SMB_FIND_FILE_FULL_DIRECTORY_INFO) {
814                 FILE_FULL_DIRECTORY_INFO * pFindData = 
815                         (FILE_FULL_DIRECTORY_INFO *)current_entry;
816                 filename = &pFindData->FileName[0];
817                 len = le32_to_cpu(pFindData->FileNameLength);
818                 cifsFile->srch_inf.resume_key = pFindData->FileIndex;
819         } else if(level == SMB_FIND_FILE_ID_FULL_DIR_INFO) {
820                 SEARCH_ID_FULL_DIR_INFO * pFindData = 
821                         (SEARCH_ID_FULL_DIR_INFO *)current_entry;
822                 filename = &pFindData->FileName[0];
823                 len = le32_to_cpu(pFindData->FileNameLength);
824                 cifsFile->srch_inf.resume_key = pFindData->FileIndex;
825         } else if(level == SMB_FIND_FILE_BOTH_DIRECTORY_INFO) {
826                 FILE_BOTH_DIRECTORY_INFO * pFindData = 
827                         (FILE_BOTH_DIRECTORY_INFO *)current_entry;
828                 filename = &pFindData->FileName[0];
829                 len = le32_to_cpu(pFindData->FileNameLength);
830                 cifsFile->srch_inf.resume_key = pFindData->FileIndex;
831         } else {
832                 cFYI(1,("Unknown findfirst level %d",level));
833                 return -EINVAL;
834         }
835         cifsFile->srch_inf.resume_name_len = len;
836         cifsFile->srch_inf.presume_name = filename;
837         return rc;
838 }
839
840 int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
841 {
842         int rc = 0;
843         int xid,i;
844         struct cifs_sb_info *cifs_sb;
845         struct cifsTconInfo *pTcon;
846         struct cifsFileInfo *cifsFile = NULL;
847         char * current_entry;
848         int num_to_fill = 0;
849         char * tmp_buf = NULL;
850         char * end_of_smb;
851
852         xid = GetXid();
853
854         if(file->f_dentry == NULL) {
855                 FreeXid(xid);
856                 return -EIO;
857         }
858
859         cifs_sb = CIFS_SB(file->f_dentry->d_sb);
860         pTcon = cifs_sb->tcon;
861         if(pTcon == NULL)
862                 return -EINVAL;
863
864         switch ((int) file->f_pos) {
865         case 0:
866                 /*if (filldir(direntry, ".", 1, file->f_pos,
867                      file->f_dentry->d_inode->i_ino, DT_DIR) < 0) {
868                         cERROR(1, ("Filldir for current dir failed "));
869                         rc = -ENOMEM;
870                         break;
871                 }
872                 file->f_pos++; */
873         case 1:
874                 /* if (filldir(direntry, "..", 2, file->f_pos,
875                      file->f_dentry->d_parent->d_inode->i_ino, DT_DIR) < 0) {
876                         cERROR(1, ("Filldir for parent dir failed "));
877                         rc = -ENOMEM;
878                         break;
879                 }
880                 file->f_pos++; */
881         case 2:
882                 /* 1) If search is active, 
883                         is in current search buffer? 
884                         if it before then restart search
885                         if after then keep searching till find it */
886
887                 if(file->private_data == NULL) {
888                         rc = initiate_cifs_search(xid,file);
889                         cFYI(1,("initiate cifs search rc %d",rc));
890                         if(rc) {
891                                 FreeXid(xid);
892                                 return rc;
893                         }
894                 }
895         default:
896                 if(file->private_data == NULL) {
897                         rc = -EINVAL;
898                         FreeXid(xid);
899                         return rc;
900                 }
901                 cifsFile = file->private_data;
902                 if (cifsFile->srch_inf.endOfSearch) {
903                         if(cifsFile->srch_inf.emptyDir) {
904                                 cFYI(1, ("End of search, empty dir"));
905                                 rc = 0;
906                                 break;
907                         }
908                 } /* else {
909                         cifsFile->invalidHandle = TRUE;
910                         CIFSFindClose(xid, pTcon, cifsFile->netfid);
911                 } 
912                 kfree(cifsFile->search_resume_name);
913                 cifsFile->search_resume_name = NULL; */
914
915                 /* BB account for . and .. in f_pos as special case */
916
917                 rc = find_cifs_entry(xid,pTcon, file,
918                                 &current_entry,&num_to_fill);
919                 if(rc) {
920                         cFYI(1,("fce error %d",rc)); 
921                         goto rddir2_exit;
922                 } else if (current_entry != NULL) {
923                         cFYI(1,("entry %lld found",file->f_pos));
924                 } else {
925                         cFYI(1,("could not find entry"));
926                         goto rddir2_exit;
927                 }
928                 cFYI(1,("loop through %d times filling dir for net buf %p",
929                         num_to_fill,cifsFile->srch_inf.ntwrk_buf_start)); 
930                 end_of_smb = cifsFile->srch_inf.ntwrk_buf_start +
931                         smbCalcSize((struct smb_hdr *)
932                                     cifsFile->srch_inf.ntwrk_buf_start);
933                 /* To be safe - for UCS to UTF-8 with strings loaded
934                 with the rare long characters alloc more to account for
935                 such multibyte target UTF-8 characters. cifs_unicode.c,
936                 which actually does the conversion, has the same limit */
937                 tmp_buf = kmalloc((2 * NAME_MAX) + 4, GFP_KERNEL);
938                 for(i=0;(i<num_to_fill) && (rc == 0);i++) {
939                         if(current_entry == NULL) {
940                                 /* evaluate whether this case is an error */
941                                 cERROR(1,("past end of SMB num to fill %d i %d",
942                                           num_to_fill, i));
943                                 break;
944                         }
945
946                         rc = cifs_filldir(current_entry, file, 
947                                         filldir, direntry,tmp_buf);
948                         file->f_pos++;
949                         if(file->f_pos == cifsFile->srch_inf.index_of_last_entry) {
950                                 cFYI(1,("last entry in buf at pos %lld %s",
951                                         file->f_pos,tmp_buf)); /* BB removeme BB */
952                                 cifs_save_resume_key(current_entry,cifsFile);
953                                 break;
954                         } else 
955                                 current_entry = nxt_dir_entry(current_entry,
956                                                               end_of_smb);
957                 }
958                 kfree(tmp_buf);
959                 break;
960         } /* end switch */
961
962 rddir2_exit:
963         FreeXid(xid);
964         return rc;
965 }