Commit | Line | Data |
---|---|---|
929be906 | 1 | // SPDX-License-Identifier: LGPL-2.1 |
1da177e4 | 2 | /* |
1da177e4 LT |
3 | * |
4 | * Directory search handling | |
6dc0f87e | 5 | * |
ad7a2926 | 6 | * Copyright (C) International Business Machines Corp., 2004, 2008 |
cda0ec6a | 7 | * Copyright (C) Red Hat, Inc., 2011 |
1da177e4 LT |
8 | * Author(s): Steve French (sfrench@us.ibm.com) |
9 | * | |
1da177e4 LT |
10 | */ |
11 | #include <linux/fs.h> | |
273d81d6 | 12 | #include <linux/pagemap.h> |
5a0e3ad6 | 13 | #include <linux/slab.h> |
1da177e4 | 14 | #include <linux/stat.h> |
1da177e4 LT |
15 | #include "cifspdu.h" |
16 | #include "cifsglob.h" | |
17 | #include "cifsproto.h" | |
18 | #include "cifs_unicode.h" | |
19 | #include "cifs_debug.h" | |
20 | #include "cifs_fs_sb.h" | |
21 | #include "cifsfs.h" | |
3d519bd1 | 22 | #include "smb2proto.h" |
8401e936 | 23 | #include "fs_context.h" |
05b98fd2 | 24 | #include "cached_dir.h" |
1da177e4 | 25 | |
f5884166 JL |
26 | /* |
27 | * To be safe - for UCS to UTF-8 with strings loaded with the rare long | |
28 | * characters alloc more to account for such multibyte target UTF-8 | |
29 | * characters. | |
30 | */ | |
31 | #define UNICODE_NAME_MAX ((4 * NAME_MAX) + 2) | |
32 | ||
3979877e SF |
33 | #ifdef CONFIG_CIFS_DEBUG2 |
34 | static void dump_cifs_file_struct(struct file *file, char *label) | |
1da177e4 | 35 | { |
6dc0f87e | 36 | struct cifsFileInfo *cf; |
1da177e4 | 37 | |
4523cc30 | 38 | if (file) { |
1da177e4 | 39 | cf = file->private_data; |
4523cc30 | 40 | if (cf == NULL) { |
f96637be | 41 | cifs_dbg(FYI, "empty cifs private file data\n"); |
1da177e4 LT |
42 | return; |
43 | } | |
ad7a2926 | 44 | if (cf->invalidHandle) |
a0a3036b | 45 | cifs_dbg(FYI, "Invalid handle\n"); |
ad7a2926 | 46 | if (cf->srch_inf.endOfSearch) |
f96637be | 47 | cifs_dbg(FYI, "end of search\n"); |
ad7a2926 | 48 | if (cf->srch_inf.emptyDir) |
f96637be | 49 | cifs_dbg(FYI, "empty dir\n"); |
1da177e4 | 50 | } |
3979877e | 51 | } |
90c81e0b SF |
52 | #else |
53 | static inline void dump_cifs_file_struct(struct file *file, char *label) | |
54 | { | |
55 | } | |
3979877e | 56 | #endif /* DEBUG2 */ |
1da177e4 | 57 | |
cc0bad75 | 58 | /* |
eb1b3fa5 JL |
59 | * Attempt to preload the dcache with the results from the FIND_FIRST/NEXT |
60 | * | |
cc0bad75 | 61 | * Find the dentry that matches "name". If there isn't one, create one. If it's |
9e6d722f NA |
62 | * a negative dentry or the uniqueid or filetype(mode) changed, |
63 | * then drop it and recreate it. | |
cc0bad75 | 64 | */ |
eb1b3fa5 JL |
65 | static void |
66 | cifs_prime_dcache(struct dentry *parent, struct qstr *name, | |
cc0bad75 JL |
67 | struct cifs_fattr *fattr) |
68 | { | |
69 | struct dentry *dentry, *alias; | |
70 | struct inode *inode; | |
fc64005c | 71 | struct super_block *sb = parent->d_sb; |
2f2591a3 | 72 | struct cifs_sb_info *cifs_sb = CIFS_SB(sb); |
3125d265 | 73 | DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq); |
cc0bad75 | 74 | |
f96637be | 75 | cifs_dbg(FYI, "%s: for %s\n", __func__, name->name); |
cc0bad75 | 76 | |
4f522a24 | 77 | dentry = d_hash_and_lookup(parent, name); |
3125d265 AV |
78 | if (!dentry) { |
79 | /* | |
80 | * If we know that the inode will need to be revalidated | |
81 | * immediately, then don't create a new dentry for it. | |
82 | * We'll end up doing an on the wire call either way and | |
83 | * this spares us an invalidation. | |
84 | */ | |
85 | if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL) | |
86 | return; | |
87 | retry: | |
88 | dentry = d_alloc_parallel(parent, name, &wq); | |
89 | } | |
a1c83681 | 90 | if (IS_ERR(dentry)) |
4f522a24 | 91 | return; |
3125d265 | 92 | if (!d_in_lookup(dentry)) { |
2b0143b5 | 93 | inode = d_inode(dentry); |
2f2591a3 | 94 | if (inode) { |
3125d265 AV |
95 | if (d_mountpoint(dentry)) { |
96 | dput(dentry); | |
97 | return; | |
98 | } | |
2f2591a3 JL |
99 | /* |
100 | * If we're generating inode numbers, then we don't | |
101 | * want to clobber the existing one with the one that | |
102 | * the readdir code created. | |
103 | */ | |
104 | if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) | |
105 | fattr->cf_uniqueid = CIFS_I(inode)->uniqueid; | |
106 | ||
9e6d722f NA |
107 | /* update inode in place |
108 | * if both i_ino and i_mode didn't change */ | |
109 | if (CIFS_I(inode)->uniqueid == fattr->cf_uniqueid && | |
4d66952a | 110 | cifs_fattr_to_inode(inode, fattr) == 0) { |
3125d265 AV |
111 | dput(dentry); |
112 | return; | |
2f2591a3 | 113 | } |
cd60042c | 114 | } |
5542aa2f | 115 | d_invalidate(dentry); |
cc0bad75 | 116 | dput(dentry); |
3125d265 AV |
117 | goto retry; |
118 | } else { | |
119 | inode = cifs_iget(sb, fattr); | |
120 | if (!inode) | |
121 | inode = ERR_PTR(-ENOMEM); | |
122 | alias = d_splice_alias(inode, dentry); | |
123 | d_lookup_done(dentry); | |
124 | if (alias && !IS_ERR(alias)) | |
125 | dput(alias); | |
cc0bad75 | 126 | } |
eb1b3fa5 | 127 | dput(dentry); |
cc0bad75 JL |
128 | } |
129 | ||
046aca3c PAS |
130 | static bool reparse_file_needs_reval(const struct cifs_fattr *fattr) |
131 | { | |
132 | if (!(fattr->cf_cifsattrs & ATTR_REPARSE)) | |
133 | return false; | |
134 | /* | |
135 | * The DFS tags should be only intepreted by server side as per | |
136 | * MS-FSCC 2.1.2.1, but let's include them anyway. | |
137 | * | |
138 | * Besides, if cf_cifstag is unset (0), then we still need it to be | |
139 | * revalidated to know exactly what reparse point it is. | |
140 | */ | |
141 | switch (fattr->cf_cifstag) { | |
142 | case IO_REPARSE_TAG_DFS: | |
143 | case IO_REPARSE_TAG_DFSR: | |
144 | case IO_REPARSE_TAG_SYMLINK: | |
145 | case IO_REPARSE_TAG_NFS: | |
146 | case 0: | |
147 | return true; | |
148 | } | |
149 | return false; | |
150 | } | |
151 | ||
0b8f18e3 JL |
152 | static void |
153 | cifs_fill_common_info(struct cifs_fattr *fattr, struct cifs_sb_info *cifs_sb) | |
1da177e4 | 154 | { |
8401e936 RS |
155 | fattr->cf_uid = cifs_sb->ctx->linux_uid; |
156 | fattr->cf_gid = cifs_sb->ctx->linux_gid; | |
1da177e4 | 157 | |
13909d96 SF |
158 | /* |
159 | * The IO_REPARSE_TAG_LX_ tags originally were used by WSL but they | |
160 | * are preferred by the Linux client in some cases since, unlike | |
161 | * the NFS reparse tag (or EAs), they don't require an extra query | |
162 | * to determine which type of special file they represent. | |
163 | * TODO: go through all documented reparse tags to see if we can | |
164 | * reasonably map some of them to directories vs. files vs. symlinks | |
165 | */ | |
0b8f18e3 | 166 | if (fattr->cf_cifsattrs & ATTR_DIRECTORY) { |
8401e936 | 167 | fattr->cf_mode = S_IFDIR | cifs_sb->ctx->dir_mode; |
0b8f18e3 | 168 | fattr->cf_dtype = DT_DIR; |
13909d96 | 169 | } else if (fattr->cf_cifstag == IO_REPARSE_TAG_LX_SYMLINK) { |
8401e936 | 170 | fattr->cf_mode |= S_IFLNK | cifs_sb->ctx->file_mode; |
13909d96 SF |
171 | fattr->cf_dtype = DT_LNK; |
172 | } else if (fattr->cf_cifstag == IO_REPARSE_TAG_LX_FIFO) { | |
8401e936 | 173 | fattr->cf_mode |= S_IFIFO | cifs_sb->ctx->file_mode; |
13909d96 SF |
174 | fattr->cf_dtype = DT_FIFO; |
175 | } else if (fattr->cf_cifstag == IO_REPARSE_TAG_AF_UNIX) { | |
8401e936 | 176 | fattr->cf_mode |= S_IFSOCK | cifs_sb->ctx->file_mode; |
13909d96 SF |
177 | fattr->cf_dtype = DT_SOCK; |
178 | } else if (fattr->cf_cifstag == IO_REPARSE_TAG_LX_CHR) { | |
8401e936 | 179 | fattr->cf_mode |= S_IFCHR | cifs_sb->ctx->file_mode; |
13909d96 SF |
180 | fattr->cf_dtype = DT_CHR; |
181 | } else if (fattr->cf_cifstag == IO_REPARSE_TAG_LX_BLK) { | |
8401e936 | 182 | fattr->cf_mode |= S_IFBLK | cifs_sb->ctx->file_mode; |
13909d96 SF |
183 | fattr->cf_dtype = DT_BLK; |
184 | } else { /* TODO: should we mark some other reparse points (like DFSR) as directories? */ | |
8401e936 | 185 | fattr->cf_mode = S_IFREG | cifs_sb->ctx->file_mode; |
0b8f18e3 | 186 | fattr->cf_dtype = DT_REG; |
1da177e4 LT |
187 | } |
188 | ||
eb85d94b PS |
189 | /* |
190 | * We need to revalidate it further to make a decision about whether it | |
191 | * is a symbolic link, DFS referral or a reparse point with a direct | |
192 | * access like junctions, deduplicated files, NFS symlinks. | |
193 | */ | |
046aca3c | 194 | if (reparse_file_needs_reval(fattr)) |
eb85d94b PS |
195 | fattr->cf_flags |= CIFS_FATTR_NEED_REVAL; |
196 | ||
74d290da JM |
197 | /* non-unix readdir doesn't provide nlink */ |
198 | fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK; | |
199 | ||
0b8f18e3 JL |
200 | if (fattr->cf_cifsattrs & ATTR_READONLY) |
201 | fattr->cf_mode &= ~S_IWUGO; | |
5bafd765 | 202 | |
ccb5c001 JL |
203 | /* |
204 | * We of course don't get ACL info in FIND_FIRST/NEXT results, so | |
205 | * mark it for revalidation so that "ls -l" will look right. It might | |
206 | * be super-slow, but if we don't do this then the ownership of files | |
207 | * may look wrong since the inodes may not have timed out by the time | |
208 | * "ls" does a stat() call on them. | |
209 | */ | |
e3e056c3 AA |
210 | if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) || |
211 | (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) | |
ccb5c001 JL |
212 | fattr->cf_flags |= CIFS_FATTR_NEED_REVAL; |
213 | ||
0b8f18e3 JL |
214 | if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL && |
215 | fattr->cf_cifsattrs & ATTR_SYSTEM) { | |
216 | if (fattr->cf_eof == 0) { | |
217 | fattr->cf_mode &= ~S_IFMT; | |
218 | fattr->cf_mode |= S_IFIFO; | |
219 | fattr->cf_dtype = DT_FIFO; | |
3020a1f5 | 220 | } else { |
4468eb3f | 221 | /* |
0b8f18e3 JL |
222 | * trying to get the type and mode via SFU can be slow, |
223 | * so just call those regular files for now, and mark | |
224 | * for reval | |
4468eb3f | 225 | */ |
0b8f18e3 | 226 | fattr->cf_flags |= CIFS_FATTR_NEED_REVAL; |
4468eb3f JL |
227 | } |
228 | } | |
0b8f18e3 | 229 | } |
1da177e4 | 230 | |
3d519bd1 AA |
231 | /* Fill a cifs_fattr struct with info from SMB_FIND_FILE_POSIX_INFO. */ |
232 | static void | |
233 | cifs_posix_to_fattr(struct cifs_fattr *fattr, struct smb2_posix_info *info, | |
234 | struct cifs_sb_info *cifs_sb) | |
235 | { | |
236 | struct smb2_posix_info_parsed parsed; | |
237 | ||
238 | posix_info_parse(info, NULL, &parsed); | |
239 | ||
240 | memset(fattr, 0, sizeof(*fattr)); | |
241 | fattr->cf_uniqueid = le64_to_cpu(info->Inode); | |
242 | fattr->cf_bytes = le64_to_cpu(info->AllocationSize); | |
243 | fattr->cf_eof = le64_to_cpu(info->EndOfFile); | |
244 | ||
245 | fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime); | |
246 | fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime); | |
247 | fattr->cf_ctime = cifs_NTtimeToUnix(info->CreationTime); | |
248 | ||
249 | fattr->cf_nlink = le32_to_cpu(info->HardLinks); | |
250 | fattr->cf_cifsattrs = le32_to_cpu(info->DosAttributes); | |
251 | ||
252 | /* | |
253 | * Since we set the inode type below we need to mask off | |
254 | * to avoid strange results if bits set above. | |
255 | * XXX: why not make server&client use the type bits? | |
256 | */ | |
257 | fattr->cf_mode = le32_to_cpu(info->Mode) & ~S_IFMT; | |
258 | ||
a0a3036b | 259 | cifs_dbg(FYI, "posix fattr: dev %d, reparse %d, mode %o\n", |
3d519bd1 AA |
260 | le32_to_cpu(info->DeviceId), |
261 | le32_to_cpu(info->ReparseTag), | |
262 | le32_to_cpu(info->Mode)); | |
263 | ||
264 | if (fattr->cf_cifsattrs & ATTR_DIRECTORY) { | |
265 | fattr->cf_mode |= S_IFDIR; | |
266 | fattr->cf_dtype = DT_DIR; | |
267 | } else { | |
268 | /* | |
269 | * mark anything that is not a dir as regular | |
270 | * file. special files should have the REPARSE | |
271 | * attribute and will be marked as needing revaluation | |
272 | */ | |
273 | fattr->cf_mode |= S_IFREG; | |
274 | fattr->cf_dtype = DT_REG; | |
275 | } | |
276 | ||
277 | if (reparse_file_needs_reval(fattr)) | |
278 | fattr->cf_flags |= CIFS_FATTR_NEED_REVAL; | |
279 | ||
9934430e SF |
280 | sid_to_id(cifs_sb, &parsed.owner, fattr, SIDOWNER); |
281 | sid_to_id(cifs_sb, &parsed.group, fattr, SIDGROUP); | |
3d519bd1 AA |
282 | } |
283 | ||
046aca3c PAS |
284 | static void __dir_info_to_fattr(struct cifs_fattr *fattr, const void *info) |
285 | { | |
286 | const FILE_DIRECTORY_INFO *fi = info; | |
287 | ||
288 | memset(fattr, 0, sizeof(*fattr)); | |
289 | fattr->cf_cifsattrs = le32_to_cpu(fi->ExtFileAttributes); | |
290 | fattr->cf_eof = le64_to_cpu(fi->EndOfFile); | |
291 | fattr->cf_bytes = le64_to_cpu(fi->AllocationSize); | |
292 | fattr->cf_createtime = le64_to_cpu(fi->CreationTime); | |
293 | fattr->cf_atime = cifs_NTtimeToUnix(fi->LastAccessTime); | |
294 | fattr->cf_ctime = cifs_NTtimeToUnix(fi->ChangeTime); | |
295 | fattr->cf_mtime = cifs_NTtimeToUnix(fi->LastWriteTime); | |
296 | } | |
297 | ||
c052e2b4 | 298 | void |
0b8f18e3 JL |
299 | cifs_dir_info_to_fattr(struct cifs_fattr *fattr, FILE_DIRECTORY_INFO *info, |
300 | struct cifs_sb_info *cifs_sb) | |
301 | { | |
046aca3c PAS |
302 | __dir_info_to_fattr(fattr, info); |
303 | cifs_fill_common_info(fattr, cifs_sb); | |
304 | } | |
0b8f18e3 | 305 | |
046aca3c PAS |
306 | static void cifs_fulldir_info_to_fattr(struct cifs_fattr *fattr, |
307 | SEARCH_ID_FULL_DIR_INFO *info, | |
308 | struct cifs_sb_info *cifs_sb) | |
309 | { | |
310 | __dir_info_to_fattr(fattr, info); | |
311 | ||
2438c0bd | 312 | /* See MS-FSCC 2.4.19 FileIdFullDirectoryInformation */ |
046aca3c PAS |
313 | if (fattr->cf_cifsattrs & ATTR_REPARSE) |
314 | fattr->cf_cifstag = le32_to_cpu(info->EaSize); | |
0b8f18e3 JL |
315 | cifs_fill_common_info(fattr, cifs_sb); |
316 | } | |
1da177e4 | 317 | |
15dd4781 | 318 | static void |
0b8f18e3 JL |
319 | cifs_std_info_to_fattr(struct cifs_fattr *fattr, FIND_FILE_STANDARD_INFO *info, |
320 | struct cifs_sb_info *cifs_sb) | |
321 | { | |
0d424ad0 | 322 | int offset = cifs_sb_master_tcon(cifs_sb)->ses->server->timeAdj; |
1da177e4 | 323 | |
0b8f18e3 JL |
324 | memset(fattr, 0, sizeof(*fattr)); |
325 | fattr->cf_atime = cnvrtDosUnixTm(info->LastAccessDate, | |
326 | info->LastAccessTime, offset); | |
327 | fattr->cf_ctime = cnvrtDosUnixTm(info->LastWriteDate, | |
328 | info->LastWriteTime, offset); | |
329 | fattr->cf_mtime = cnvrtDosUnixTm(info->LastWriteDate, | |
330 | info->LastWriteTime, offset); | |
331 | ||
332 | fattr->cf_cifsattrs = le16_to_cpu(info->Attributes); | |
333 | fattr->cf_bytes = le32_to_cpu(info->AllocationSize); | |
334 | fattr->cf_eof = le32_to_cpu(info->DataSize); | |
335 | ||
336 | cifs_fill_common_info(fattr, cifs_sb); | |
1da177e4 LT |
337 | } |
338 | ||
0e0d2cf3 SF |
339 | /* BB eventually need to add the following helper function to |
340 | resolve NT_STATUS_STOPPED_ON_SYMLINK return code when | |
341 | we try to do FindFirst on (NTFS) directory symlinks */ | |
342 | /* | |
343 | int get_symlink_reparse_path(char *full_path, struct cifs_sb_info *cifs_sb, | |
6d5786a3 | 344 | unsigned int xid) |
0e0d2cf3 SF |
345 | { |
346 | __u16 fid; | |
347 | int len; | |
348 | int oplock = 0; | |
349 | int rc; | |
96daf2b0 | 350 | struct cifs_tcon *ptcon = cifs_sb_tcon(cifs_sb); |
0e0d2cf3 SF |
351 | char *tmpbuffer; |
352 | ||
353 | rc = CIFSSMBOpen(xid, ptcon, full_path, FILE_OPEN, GENERIC_READ, | |
354 | OPEN_REPARSE_POINT, &fid, &oplock, NULL, | |
355 | cifs_sb->local_nls, | |
2baa2682 | 356 | cifs_remap(cifs_sb); |
0e0d2cf3 SF |
357 | if (!rc) { |
358 | tmpbuffer = kmalloc(maxpath); | |
359 | rc = CIFSSMBQueryReparseLinkInfo(xid, ptcon, full_path, | |
360 | tmpbuffer, | |
361 | maxpath -1, | |
362 | fid, | |
363 | cifs_sb->local_nls); | |
364 | if (CIFSSMBClose(xid, ptcon, fid)) { | |
f96637be | 365 | cifs_dbg(FYI, "Error closing temporary reparsepoint open\n"); |
0e0d2cf3 SF |
366 | } |
367 | } | |
368 | } | |
369 | */ | |
370 | ||
92fc65a7 | 371 | static int |
3998f0b8 | 372 | _initiate_cifs_search(const unsigned int xid, struct file *file, |
f6f1f179 | 373 | const char *full_path) |
1da177e4 | 374 | { |
2608bee7 | 375 | __u16 search_flags; |
1da177e4 | 376 | int rc = 0; |
3870253e | 377 | struct cifsFileInfo *cifsFile; |
7119e220 | 378 | struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file); |
59c55ba1 | 379 | struct tcon_link *tlink = NULL; |
29e20f9c | 380 | struct cifs_tcon *tcon; |
92fc65a7 | 381 | struct TCP_Server_Info *server; |
1da177e4 | 382 | |
7ffec372 | 383 | if (file->private_data == NULL) { |
59c55ba1 JL |
384 | tlink = cifs_sb_tlink(cifs_sb); |
385 | if (IS_ERR(tlink)) | |
386 | return PTR_ERR(tlink); | |
387 | ||
388 | cifsFile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL); | |
389 | if (cifsFile == NULL) { | |
390 | rc = -ENOMEM; | |
391 | goto error_exit; | |
392 | } | |
81ddd8c0 | 393 | spin_lock_init(&cifsFile->file_info_lock); |
59c55ba1 JL |
394 | file->private_data = cifsFile; |
395 | cifsFile->tlink = cifs_get_tlink(tlink); | |
29e20f9c | 396 | tcon = tlink_tcon(tlink); |
59c55ba1 JL |
397 | } else { |
398 | cifsFile = file->private_data; | |
29e20f9c | 399 | tcon = tlink_tcon(cifsFile->tlink); |
7ffec372 | 400 | } |
1da177e4 | 401 | |
92fc65a7 PS |
402 | server = tcon->ses->server; |
403 | ||
404 | if (!server->ops->query_dir_first) { | |
405 | rc = -ENOSYS; | |
406 | goto error_exit; | |
407 | } | |
408 | ||
4b18f2a9 SF |
409 | cifsFile->invalidHandle = true; |
410 | cifsFile->srch_inf.endOfSearch = false; | |
1da177e4 | 411 | |
f96637be | 412 | cifs_dbg(FYI, "Full path: %s start at: %lld\n", full_path, file->f_pos); |
1da177e4 | 413 | |
75cf6bdc | 414 | ffirst_retry: |
1da177e4 | 415 | /* test for Unix extensions */ |
c18c842b | 416 | /* but now check for them on the share/mount not on the SMB session */ |
29e20f9c PS |
417 | /* if (cap_unix(tcon->ses) { */ |
418 | if (tcon->unix_ext) | |
5bafd765 | 419 | cifsFile->srch_inf.info_level = SMB_FIND_FILE_UNIX; |
3d519bd1 AA |
420 | else if (tcon->posix_extensions) |
421 | cifsFile->srch_inf.info_level = SMB_FIND_FILE_POSIX_INFO; | |
29e20f9c PS |
422 | else if ((tcon->ses->capabilities & |
423 | tcon->ses->server->vals->cap_nt_find) == 0) { | |
5bafd765 | 424 | cifsFile->srch_inf.info_level = SMB_FIND_FILE_INFO_STANDARD; |
1da177e4 LT |
425 | } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) { |
426 | cifsFile->srch_inf.info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO; | |
427 | } else /* not srvinos - BB fixme add check for backlevel? */ { | |
428 | cifsFile->srch_inf.info_level = SMB_FIND_FILE_DIRECTORY_INFO; | |
429 | } | |
430 | ||
2608bee7 SP |
431 | search_flags = CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME; |
432 | if (backup_cred(cifs_sb)) | |
433 | search_flags |= CIFS_SEARCH_BACKUP_SEARCH; | |
434 | ||
92fc65a7 PS |
435 | rc = server->ops->query_dir_first(xid, tcon, full_path, cifs_sb, |
436 | &cifsFile->fid, search_flags, | |
437 | &cifsFile->srch_inf); | |
438 | ||
4523cc30 | 439 | if (rc == 0) |
4b18f2a9 | 440 | cifsFile->invalidHandle = false; |
e836f015 | 441 | /* BB add following call to handle readdir on new NTFS symlink errors |
0e0d2cf3 SF |
442 | else if STATUS_STOPPED_ON_SYMLINK |
443 | call get_symlink_reparse_path and retry with new path */ | |
444 | else if ((rc == -EOPNOTSUPP) && | |
75cf6bdc SF |
445 | (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) { |
446 | cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM; | |
447 | goto ffirst_retry; | |
448 | } | |
7ffec372 | 449 | error_exit: |
7ffec372 | 450 | cifs_put_tlink(tlink); |
1da177e4 LT |
451 | return rc; |
452 | } | |
453 | ||
3998f0b8 RS |
454 | static int |
455 | initiate_cifs_search(const unsigned int xid, struct file *file, | |
456 | const char *full_path) | |
457 | { | |
458 | int rc, retry_count = 0; | |
459 | ||
460 | do { | |
461 | rc = _initiate_cifs_search(xid, file, full_path); | |
462 | /* | |
463 | * If we don't have enough credits to start reading the | |
464 | * directory just try again after short wait. | |
465 | */ | |
466 | if (rc != -EDEADLK) | |
467 | break; | |
468 | ||
469 | usleep_range(512, 2048); | |
470 | } while (retry_count++ < 5); | |
471 | ||
472 | return rc; | |
473 | } | |
474 | ||
1da177e4 | 475 | /* return length of unicode string in bytes */ |
cda0ec6a | 476 | static int cifs_unicode_bytelen(const char *str) |
1da177e4 LT |
477 | { |
478 | int len; | |
cda0ec6a | 479 | const __le16 *ustr = (const __le16 *)str; |
1da177e4 | 480 | |
3870253e | 481 | for (len = 0; len <= PATH_MAX; len++) { |
4523cc30 | 482 | if (ustr[len] == 0) |
1da177e4 LT |
483 | return len << 1; |
484 | } | |
f96637be | 485 | cifs_dbg(FYI, "Unicode string longer than PATH_MAX found\n"); |
1da177e4 LT |
486 | return len << 1; |
487 | } | |
488 | ||
5bafd765 | 489 | static char *nxt_dir_entry(char *old_entry, char *end_of_smb, int level) |
1da177e4 | 490 | { |
3870253e | 491 | char *new_entry; |
ad7a2926 | 492 | FILE_DIRECTORY_INFO *pDirInfo = (FILE_DIRECTORY_INFO *)old_entry; |
1da177e4 | 493 | |
4523cc30 | 494 | if (level == SMB_FIND_FILE_INFO_STANDARD) { |
ad7a2926 | 495 | FIND_FILE_STANDARD_INFO *pfData; |
5bafd765 SF |
496 | pfData = (FIND_FILE_STANDARD_INFO *)pDirInfo; |
497 | ||
35235e19 | 498 | new_entry = old_entry + sizeof(FIND_FILE_STANDARD_INFO) + 1 + |
5bafd765 | 499 | pfData->FileNameLength; |
8ad8aa35 DC |
500 | } else { |
501 | u32 next_offset = le32_to_cpu(pDirInfo->NextEntryOffset); | |
502 | ||
503 | if (old_entry + next_offset < old_entry) { | |
a0a3036b | 504 | cifs_dbg(VFS, "Invalid offset %u\n", next_offset); |
8ad8aa35 DC |
505 | return NULL; |
506 | } | |
507 | new_entry = old_entry + next_offset; | |
508 | } | |
f96637be | 509 | cifs_dbg(FYI, "new entry %p old entry %p\n", new_entry, old_entry); |
1da177e4 | 510 | /* validate that new_entry is not past end of SMB */ |
4523cc30 | 511 | if (new_entry >= end_of_smb) { |
f96637be JP |
512 | cifs_dbg(VFS, "search entry %p began after end of SMB %p old entry %p\n", |
513 | new_entry, end_of_smb, old_entry); | |
1da177e4 | 514 | return NULL; |
4523cc30 | 515 | } else if (((level == SMB_FIND_FILE_INFO_STANDARD) && |
35235e19 | 516 | (new_entry + sizeof(FIND_FILE_STANDARD_INFO) + 1 > end_of_smb)) |
3870253e | 517 | || ((level != SMB_FIND_FILE_INFO_STANDARD) && |
35235e19 | 518 | (new_entry + sizeof(FILE_DIRECTORY_INFO) + 1 > end_of_smb))) { |
f96637be JP |
519 | cifs_dbg(VFS, "search entry %p extends after end of SMB %p\n", |
520 | new_entry, end_of_smb); | |
09d1db5c | 521 | return NULL; |
3870253e | 522 | } else |
1da177e4 LT |
523 | return new_entry; |
524 | ||
525 | } | |
526 | ||
cda0ec6a CH |
527 | struct cifs_dirent { |
528 | const char *name; | |
529 | size_t namelen; | |
530 | u32 resume_key; | |
531 | u64 ino; | |
532 | }; | |
533 | ||
3d519bd1 AA |
534 | static void cifs_fill_dirent_posix(struct cifs_dirent *de, |
535 | const struct smb2_posix_info *info) | |
536 | { | |
537 | struct smb2_posix_info_parsed parsed; | |
538 | ||
539 | /* payload should have already been checked at this point */ | |
540 | if (posix_info_parse(info, NULL, &parsed) < 0) { | |
a0a3036b | 541 | cifs_dbg(VFS, "Invalid POSIX info payload\n"); |
3d519bd1 AA |
542 | return; |
543 | } | |
544 | ||
545 | de->name = parsed.name; | |
546 | de->namelen = parsed.name_len; | |
547 | de->resume_key = info->Ignored; | |
548 | de->ino = le64_to_cpu(info->Inode); | |
549 | } | |
550 | ||
cda0ec6a CH |
551 | static void cifs_fill_dirent_unix(struct cifs_dirent *de, |
552 | const FILE_UNIX_INFO *info, bool is_unicode) | |
553 | { | |
554 | de->name = &info->FileName[0]; | |
555 | if (is_unicode) | |
556 | de->namelen = cifs_unicode_bytelen(de->name); | |
557 | else | |
558 | de->namelen = strnlen(de->name, PATH_MAX); | |
559 | de->resume_key = info->ResumeKey; | |
560 | de->ino = le64_to_cpu(info->basic.UniqueId); | |
561 | } | |
562 | ||
563 | static void cifs_fill_dirent_dir(struct cifs_dirent *de, | |
564 | const FILE_DIRECTORY_INFO *info) | |
565 | { | |
566 | de->name = &info->FileName[0]; | |
567 | de->namelen = le32_to_cpu(info->FileNameLength); | |
568 | de->resume_key = info->FileIndex; | |
569 | } | |
570 | ||
571 | static void cifs_fill_dirent_full(struct cifs_dirent *de, | |
572 | const FILE_FULL_DIRECTORY_INFO *info) | |
573 | { | |
574 | de->name = &info->FileName[0]; | |
575 | de->namelen = le32_to_cpu(info->FileNameLength); | |
576 | de->resume_key = info->FileIndex; | |
577 | } | |
578 | ||
579 | static void cifs_fill_dirent_search(struct cifs_dirent *de, | |
580 | const SEARCH_ID_FULL_DIR_INFO *info) | |
581 | { | |
582 | de->name = &info->FileName[0]; | |
583 | de->namelen = le32_to_cpu(info->FileNameLength); | |
584 | de->resume_key = info->FileIndex; | |
585 | de->ino = le64_to_cpu(info->UniqueId); | |
586 | } | |
587 | ||
588 | static void cifs_fill_dirent_both(struct cifs_dirent *de, | |
589 | const FILE_BOTH_DIRECTORY_INFO *info) | |
590 | { | |
591 | de->name = &info->FileName[0]; | |
592 | de->namelen = le32_to_cpu(info->FileNameLength); | |
593 | de->resume_key = info->FileIndex; | |
594 | } | |
595 | ||
596 | static void cifs_fill_dirent_std(struct cifs_dirent *de, | |
597 | const FIND_FILE_STANDARD_INFO *info) | |
598 | { | |
599 | de->name = &info->FileName[0]; | |
600 | /* one byte length, no endianess conversion */ | |
601 | de->namelen = info->FileNameLength; | |
602 | de->resume_key = info->ResumeKey; | |
603 | } | |
604 | ||
605 | static int cifs_fill_dirent(struct cifs_dirent *de, const void *info, | |
606 | u16 level, bool is_unicode) | |
607 | { | |
608 | memset(de, 0, sizeof(*de)); | |
609 | ||
610 | switch (level) { | |
3d519bd1 AA |
611 | case SMB_FIND_FILE_POSIX_INFO: |
612 | cifs_fill_dirent_posix(de, info); | |
613 | break; | |
cda0ec6a CH |
614 | case SMB_FIND_FILE_UNIX: |
615 | cifs_fill_dirent_unix(de, info, is_unicode); | |
616 | break; | |
617 | case SMB_FIND_FILE_DIRECTORY_INFO: | |
618 | cifs_fill_dirent_dir(de, info); | |
619 | break; | |
620 | case SMB_FIND_FILE_FULL_DIRECTORY_INFO: | |
621 | cifs_fill_dirent_full(de, info); | |
622 | break; | |
623 | case SMB_FIND_FILE_ID_FULL_DIR_INFO: | |
624 | cifs_fill_dirent_search(de, info); | |
625 | break; | |
626 | case SMB_FIND_FILE_BOTH_DIRECTORY_INFO: | |
627 | cifs_fill_dirent_both(de, info); | |
628 | break; | |
629 | case SMB_FIND_FILE_INFO_STANDARD: | |
630 | cifs_fill_dirent_std(de, info); | |
631 | break; | |
632 | default: | |
f96637be | 633 | cifs_dbg(FYI, "Unknown findfirst level %d\n", level); |
cda0ec6a CH |
634 | return -EINVAL; |
635 | } | |
636 | ||
637 | return 0; | |
638 | } | |
639 | ||
1da177e4 LT |
640 | #define UNICODE_DOT cpu_to_le16(0x2e) |
641 | ||
642 | /* return 0 if no match and 1 for . (current directory) and 2 for .. (parent) */ | |
cda0ec6a | 643 | static int cifs_entry_is_dot(struct cifs_dirent *de, bool is_unicode) |
1da177e4 LT |
644 | { |
645 | int rc = 0; | |
1da177e4 | 646 | |
cda0ec6a CH |
647 | if (!de->name) |
648 | return 0; | |
1da177e4 | 649 | |
cda0ec6a CH |
650 | if (is_unicode) { |
651 | __le16 *ufilename = (__le16 *)de->name; | |
652 | if (de->namelen == 2) { | |
653 | /* check for . */ | |
654 | if (ufilename[0] == UNICODE_DOT) | |
655 | rc = 1; | |
656 | } else if (de->namelen == 4) { | |
657 | /* check for .. */ | |
658 | if (ufilename[0] == UNICODE_DOT && | |
659 | ufilename[1] == UNICODE_DOT) | |
660 | rc = 2; | |
661 | } | |
662 | } else /* ASCII */ { | |
663 | if (de->namelen == 1) { | |
664 | if (de->name[0] == '.') | |
665 | rc = 1; | |
666 | } else if (de->namelen == 2) { | |
667 | if (de->name[0] == '.' && de->name[1] == '.') | |
668 | rc = 2; | |
1da177e4 LT |
669 | } |
670 | } | |
671 | ||
672 | return rc; | |
673 | } | |
674 | ||
eafe8701 SF |
675 | /* Check if directory that we are searching has changed so we can decide |
676 | whether we can use the cached search results from the previous search */ | |
3870253e | 677 | static int is_dir_changed(struct file *file) |
eafe8701 | 678 | { |
496ad9aa | 679 | struct inode *inode = file_inode(file); |
c33f8d32 | 680 | struct cifsInodeInfo *cifsInfo = CIFS_I(inode); |
eafe8701 | 681 | |
c33f8d32 | 682 | if (cifsInfo->time == 0) |
eafe8701 SF |
683 | return 1; /* directory was changed, perhaps due to unlink */ |
684 | else | |
685 | return 0; | |
686 | ||
687 | } | |
688 | ||
0752f152 | 689 | static int cifs_save_resume_key(const char *current_entry, |
eaf35b1e | 690 | struct cifsFileInfo *file_info) |
0752f152 | 691 | { |
eaf35b1e CH |
692 | struct cifs_dirent de; |
693 | int rc; | |
0752f152 | 694 | |
eaf35b1e CH |
695 | rc = cifs_fill_dirent(&de, current_entry, file_info->srch_inf.info_level, |
696 | file_info->srch_inf.unicode); | |
697 | if (!rc) { | |
698 | file_info->srch_inf.presume_name = de.name; | |
699 | file_info->srch_inf.resume_name_len = de.namelen; | |
700 | file_info->srch_inf.resume_key = de.resume_key; | |
0752f152 | 701 | } |
0752f152 SF |
702 | return rc; |
703 | } | |
704 | ||
92fc65a7 PS |
705 | /* |
706 | * Find the corresponding entry in the search. Note that the SMB server returns | |
707 | * search entries for . and .. which complicates logic here if we choose to | |
708 | * parse for them and we do not assume that they are located in the findfirst | |
709 | * return buffer. We start counting in the buffer with entry 2 and increment for | |
710 | * every entry (do not increment for . or .. entry). | |
711 | */ | |
712 | static int | |
be4ccdcc | 713 | find_cifs_entry(const unsigned int xid, struct cifs_tcon *tcon, loff_t pos, |
f6f1f179 | 714 | struct file *file, const char *full_path, |
d1542cf6 | 715 | char **current_entry, int *num_to_ret) |
1da177e4 | 716 | { |
2608bee7 | 717 | __u16 search_flags; |
1da177e4 LT |
718 | int rc = 0; |
719 | int pos_in_buf = 0; | |
720 | loff_t first_entry_in_buffer; | |
be4ccdcc | 721 | loff_t index_to_find = pos; |
92fc65a7 | 722 | struct cifsFileInfo *cfile = file->private_data; |
7119e220 | 723 | struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file); |
92fc65a7 | 724 | struct TCP_Server_Info *server = tcon->ses->server; |
1da177e4 | 725 | /* check if index in the buffer */ |
50c2f753 | 726 | |
92fc65a7 PS |
727 | if (!server->ops->query_dir_first || !server->ops->query_dir_next) |
728 | return -ENOSYS; | |
729 | ||
730 | if ((cfile == NULL) || (current_entry == NULL) || (num_to_ret == NULL)) | |
1da177e4 | 731 | return -ENOENT; |
50c2f753 | 732 | |
92fc65a7 PS |
733 | *current_entry = NULL; |
734 | first_entry_in_buffer = cfile->srch_inf.index_of_last_entry - | |
735 | cfile->srch_inf.entries_in_buffer; | |
60808233 | 736 | |
92fc65a7 PS |
737 | /* |
738 | * If first entry in buf is zero then is first buffer | |
739 | * in search response data which means it is likely . and .. | |
740 | * will be in this buffer, although some servers do not return | |
741 | * . and .. for the root of a drive and for those we need | |
742 | * to start two entries earlier. | |
743 | */ | |
60808233 | 744 | |
3979877e | 745 | dump_cifs_file_struct(file, "In fce "); |
92fc65a7 PS |
746 | if (((index_to_find < cfile->srch_inf.index_of_last_entry) && |
747 | is_dir_changed(file)) || (index_to_find < first_entry_in_buffer)) { | |
1da177e4 | 748 | /* close and restart search */ |
f96637be | 749 | cifs_dbg(FYI, "search backing up - close and restart search\n"); |
3afca265 | 750 | spin_lock(&cfile->file_info_lock); |
52755808 | 751 | if (server->ops->dir_needs_close(cfile)) { |
92fc65a7 | 752 | cfile->invalidHandle = true; |
3afca265 | 753 | spin_unlock(&cfile->file_info_lock); |
f736906a PS |
754 | if (server->ops->close_dir) |
755 | server->ops->close_dir(xid, tcon, &cfile->fid); | |
ddb4cbfc | 756 | } else |
3afca265 | 757 | spin_unlock(&cfile->file_info_lock); |
92fc65a7 | 758 | if (cfile->srch_inf.ntwrk_buf_start) { |
f96637be | 759 | cifs_dbg(FYI, "freeing SMB ff cache buf on search rewind\n"); |
92fc65a7 PS |
760 | if (cfile->srch_inf.smallBuf) |
761 | cifs_small_buf_release(cfile->srch_inf. | |
d47d7c1a SF |
762 | ntwrk_buf_start); |
763 | else | |
92fc65a7 | 764 | cifs_buf_release(cfile->srch_inf. |
d47d7c1a | 765 | ntwrk_buf_start); |
92fc65a7 | 766 | cfile->srch_inf.ntwrk_buf_start = NULL; |
1da177e4 | 767 | } |
d1542cf6 | 768 | rc = initiate_cifs_search(xid, file, full_path); |
4523cc30 | 769 | if (rc) { |
f96637be | 770 | cifs_dbg(FYI, "error %d reinitiating a search on rewind\n", |
b6b38f70 | 771 | rc); |
1da177e4 LT |
772 | return rc; |
773 | } | |
7023676f | 774 | /* FindFirst/Next set last_entry to NULL on malformed reply */ |
92fc65a7 PS |
775 | if (cfile->srch_inf.last_entry) |
776 | cifs_save_resume_key(cfile->srch_inf.last_entry, cfile); | |
1da177e4 LT |
777 | } |
778 | ||
2608bee7 SP |
779 | search_flags = CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME; |
780 | if (backup_cred(cifs_sb)) | |
781 | search_flags |= CIFS_SEARCH_BACKUP_SEARCH; | |
782 | ||
92fc65a7 PS |
783 | while ((index_to_find >= cfile->srch_inf.index_of_last_entry) && |
784 | (rc == 0) && !cfile->srch_inf.endOfSearch) { | |
f96637be | 785 | cifs_dbg(FYI, "calling findnext2\n"); |
92fc65a7 PS |
786 | rc = server->ops->query_dir_next(xid, tcon, &cfile->fid, |
787 | search_flags, | |
788 | &cfile->srch_inf); | |
7023676f | 789 | /* FindFirst/Next set last_entry to NULL on malformed reply */ |
92fc65a7 PS |
790 | if (cfile->srch_inf.last_entry) |
791 | cifs_save_resume_key(cfile->srch_inf.last_entry, cfile); | |
4523cc30 | 792 | if (rc) |
1da177e4 LT |
793 | return -ENOENT; |
794 | } | |
92fc65a7 | 795 | if (index_to_find < cfile->srch_inf.index_of_last_entry) { |
1da177e4 LT |
796 | /* we found the buffer that contains the entry */ |
797 | /* scan and find it */ | |
798 | int i; | |
92fc65a7 | 799 | char *cur_ent; |
59a63e47 RS |
800 | char *end_of_smb; |
801 | ||
802 | if (cfile->srch_inf.ntwrk_buf_start == NULL) { | |
803 | cifs_dbg(VFS, "ntwrk_buf_start is NULL during readdir\n"); | |
804 | return -EIO; | |
805 | } | |
806 | ||
807 | end_of_smb = cfile->srch_inf.ntwrk_buf_start + | |
92fc65a7 | 808 | server->ops->calc_smb_size( |
68ed1449 | 809 | cfile->srch_inf.ntwrk_buf_start); |
92fc65a7 PS |
810 | |
811 | cur_ent = cfile->srch_inf.srch_entries_start; | |
812 | first_entry_in_buffer = cfile->srch_inf.index_of_last_entry | |
813 | - cfile->srch_inf.entries_in_buffer; | |
1da177e4 | 814 | pos_in_buf = index_to_find - first_entry_in_buffer; |
f96637be | 815 | cifs_dbg(FYI, "found entry - pos_in_buf %d\n", pos_in_buf); |
5bafd765 | 816 | |
92fc65a7 | 817 | for (i = 0; (i < (pos_in_buf)) && (cur_ent != NULL); i++) { |
dfb7533b | 818 | /* go entry by entry figuring out which is first */ |
92fc65a7 PS |
819 | cur_ent = nxt_dir_entry(cur_ent, end_of_smb, |
820 | cfile->srch_inf.info_level); | |
1da177e4 | 821 | } |
92fc65a7 | 822 | if ((cur_ent == NULL) && (i < pos_in_buf)) { |
1da177e4 | 823 | /* BB fixme - check if we should flag this error */ |
f96637be JP |
824 | cifs_dbg(VFS, "reached end of buf searching for pos in buf %d index to find %lld rc %d\n", |
825 | pos_in_buf, index_to_find, rc); | |
1da177e4 LT |
826 | } |
827 | rc = 0; | |
92fc65a7 | 828 | *current_entry = cur_ent; |
1da177e4 | 829 | } else { |
f96637be | 830 | cifs_dbg(FYI, "index not in buffer - could not findnext into it\n"); |
1da177e4 LT |
831 | return 0; |
832 | } | |
833 | ||
92fc65a7 | 834 | if (pos_in_buf >= cfile->srch_inf.entries_in_buffer) { |
f96637be | 835 | cifs_dbg(FYI, "can not return entries pos_in_buf beyond last\n"); |
1da177e4 LT |
836 | *num_to_ret = 0; |
837 | } else | |
92fc65a7 | 838 | *num_to_ret = cfile->srch_inf.entries_in_buffer - pos_in_buf; |
1da177e4 LT |
839 | |
840 | return rc; | |
841 | } | |
842 | ||
d87c48ce RS |
843 | static bool emit_cached_dirents(struct cached_dirents *cde, |
844 | struct dir_context *ctx) | |
845 | { | |
846 | struct cached_dirent *dirent; | |
780614ce | 847 | bool rc; |
d87c48ce RS |
848 | |
849 | list_for_each_entry(dirent, &cde->entries, entry) { | |
780614ce RS |
850 | /* |
851 | * Skip all early entries prior to the current lseek() | |
852 | * position. | |
853 | */ | |
854 | if (ctx->pos > dirent->pos) | |
d87c48ce | 855 | continue; |
780614ce RS |
856 | /* |
857 | * We recorded the current ->pos value for the dirent | |
858 | * when we stored it in the cache. | |
859 | * However, this sequence of ->pos values may have holes | |
860 | * in it, for example dot-dirs returned from the server | |
861 | * are suppressed. | |
862 | * Handle this bu forcing ctx->pos to be the same as the | |
863 | * ->pos of the current dirent we emit from the cache. | |
864 | * This means that when we emit these entries from the cache | |
865 | * we now emit them with the same ->pos value as in the | |
866 | * initial scan. | |
867 | */ | |
d87c48ce RS |
868 | ctx->pos = dirent->pos; |
869 | rc = dir_emit(ctx, dirent->name, dirent->namelen, | |
870 | dirent->fattr.cf_uniqueid, | |
871 | dirent->fattr.cf_dtype); | |
872 | if (!rc) | |
873 | return rc; | |
780614ce | 874 | ctx->pos++; |
d87c48ce RS |
875 | } |
876 | return true; | |
877 | } | |
878 | ||
879 | static void update_cached_dirents_count(struct cached_dirents *cde, | |
880 | struct dir_context *ctx) | |
881 | { | |
882 | if (cde->ctx != ctx) | |
883 | return; | |
884 | if (cde->is_valid || cde->is_failed) | |
885 | return; | |
886 | ||
887 | cde->pos++; | |
888 | } | |
889 | ||
890 | static void finished_cached_dirents_count(struct cached_dirents *cde, | |
891 | struct dir_context *ctx) | |
892 | { | |
893 | if (cde->ctx != ctx) | |
894 | return; | |
895 | if (cde->is_valid || cde->is_failed) | |
896 | return; | |
897 | if (ctx->pos != cde->pos) | |
898 | return; | |
899 | ||
900 | cde->is_valid = 1; | |
901 | } | |
902 | ||
903 | static void add_cached_dirent(struct cached_dirents *cde, | |
904 | struct dir_context *ctx, | |
905 | const char *name, int namelen, | |
906 | struct cifs_fattr *fattr) | |
907 | { | |
908 | struct cached_dirent *de; | |
909 | ||
910 | if (cde->ctx != ctx) | |
911 | return; | |
912 | if (cde->is_valid || cde->is_failed) | |
913 | return; | |
914 | if (ctx->pos != cde->pos) { | |
915 | cde->is_failed = 1; | |
916 | return; | |
917 | } | |
918 | de = kzalloc(sizeof(*de), GFP_ATOMIC); | |
919 | if (de == NULL) { | |
920 | cde->is_failed = 1; | |
921 | return; | |
922 | } | |
923 | de->namelen = namelen; | |
924 | de->name = kstrndup(name, namelen, GFP_ATOMIC); | |
925 | if (de->name == NULL) { | |
926 | kfree(de); | |
927 | cde->is_failed = 1; | |
928 | return; | |
929 | } | |
930 | de->pos = ctx->pos; | |
931 | ||
932 | memcpy(&de->fattr, fattr, sizeof(struct cifs_fattr)); | |
933 | ||
934 | list_add_tail(&de->entry, &cde->entries); | |
935 | } | |
936 | ||
937 | static bool cifs_dir_emit(struct dir_context *ctx, | |
938 | const char *name, int namelen, | |
939 | struct cifs_fattr *fattr, | |
940 | struct cached_fid *cfid) | |
941 | { | |
942 | bool rc; | |
943 | ino_t ino = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid); | |
944 | ||
945 | rc = dir_emit(ctx, name, namelen, ino, fattr->cf_dtype); | |
946 | if (!rc) | |
947 | return rc; | |
948 | ||
949 | if (cfid) { | |
950 | mutex_lock(&cfid->dirents.de_mutex); | |
951 | add_cached_dirent(&cfid->dirents, ctx, name, namelen, | |
952 | fattr); | |
953 | mutex_unlock(&cfid->dirents.de_mutex); | |
954 | } | |
955 | ||
956 | return rc; | |
957 | } | |
958 | ||
be4ccdcc | 959 | static int cifs_filldir(char *find_entry, struct file *file, |
d87c48ce RS |
960 | struct dir_context *ctx, |
961 | char *scratch_buf, unsigned int max_len, | |
962 | struct cached_fid *cfid) | |
1da177e4 | 963 | { |
9feed6f8 | 964 | struct cifsFileInfo *file_info = file->private_data; |
7119e220 | 965 | struct super_block *sb = file_inode(file)->i_sb; |
9feed6f8 | 966 | struct cifs_sb_info *cifs_sb = CIFS_SB(sb); |
cda0ec6a | 967 | struct cifs_dirent de = { NULL, }; |
cc0bad75 | 968 | struct cifs_fattr fattr; |
9feed6f8 | 969 | struct qstr name; |
1da177e4 | 970 | int rc = 0; |
1da177e4 | 971 | |
cda0ec6a CH |
972 | rc = cifs_fill_dirent(&de, find_entry, file_info->srch_inf.info_level, |
973 | file_info->srch_inf.unicode); | |
974 | if (rc) | |
975 | return rc; | |
5bafd765 | 976 | |
f16d59b4 | 977 | if (de.namelen > max_len) { |
f96637be JP |
978 | cifs_dbg(VFS, "bad search response length %zd past smb end\n", |
979 | de.namelen); | |
5bafd765 SF |
980 | return -EINVAL; |
981 | } | |
982 | ||
60808233 | 983 | /* skip . and .. since we added them first */ |
cda0ec6a | 984 | if (cifs_entry_is_dot(&de, file_info->srch_inf.unicode)) |
60808233 SF |
985 | return 0; |
986 | ||
f16d59b4 CH |
987 | if (file_info->srch_inf.unicode) { |
988 | struct nls_table *nlt = cifs_sb->local_nls; | |
b693855f SF |
989 | int map_type; |
990 | ||
2baa2682 | 991 | map_type = cifs_remap(cifs_sb); |
f16d59b4 CH |
992 | name.name = scratch_buf; |
993 | name.len = | |
acbbb76a SF |
994 | cifs_from_utf16((char *)name.name, (__le16 *)de.name, |
995 | UNICODE_NAME_MAX, | |
996 | min_t(size_t, de.namelen, | |
b693855f | 997 | (size_t)max_len), nlt, map_type); |
f16d59b4 CH |
998 | name.len -= nls_nullsize(nlt); |
999 | } else { | |
1000 | name.name = de.name; | |
1001 | name.len = de.namelen; | |
1002 | } | |
1da177e4 | 1003 | |
9feed6f8 | 1004 | switch (file_info->srch_inf.info_level) { |
3d519bd1 AA |
1005 | case SMB_FIND_FILE_POSIX_INFO: |
1006 | cifs_posix_to_fattr(&fattr, | |
1007 | (struct smb2_posix_info *)find_entry, | |
1008 | cifs_sb); | |
1009 | break; | |
9feed6f8 | 1010 | case SMB_FIND_FILE_UNIX: |
cc0bad75 | 1011 | cifs_unix_basic_to_fattr(&fattr, |
9feed6f8 CH |
1012 | &((FILE_UNIX_INFO *)find_entry)->basic, |
1013 | cifs_sb); | |
76894f3e PA |
1014 | if (S_ISLNK(fattr.cf_mode)) |
1015 | fattr.cf_flags |= CIFS_FATTR_NEED_REVAL; | |
9feed6f8 CH |
1016 | break; |
1017 | case SMB_FIND_FILE_INFO_STANDARD: | |
1018 | cifs_std_info_to_fattr(&fattr, | |
1019 | (FIND_FILE_STANDARD_INFO *)find_entry, | |
1020 | cifs_sb); | |
1021 | break; | |
046aca3c PAS |
1022 | case SMB_FIND_FILE_ID_FULL_DIR_INFO: |
1023 | cifs_fulldir_info_to_fattr(&fattr, | |
1024 | (SEARCH_ID_FULL_DIR_INFO *)find_entry, | |
1025 | cifs_sb); | |
1026 | break; | |
9feed6f8 CH |
1027 | default: |
1028 | cifs_dir_info_to_fattr(&fattr, | |
1029 | (FILE_DIRECTORY_INFO *)find_entry, | |
1030 | cifs_sb); | |
1031 | break; | |
1032 | } | |
b835bebe | 1033 | |
f16d59b4 CH |
1034 | if (de.ino && (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) { |
1035 | fattr.cf_uniqueid = de.ino; | |
ec06aedd | 1036 | } else { |
0b8f18e3 | 1037 | fattr.cf_uniqueid = iunique(sb, ROOT_I); |
ec06aedd JL |
1038 | cifs_autodisable_serverino(cifs_sb); |
1039 | } | |
50c2f753 | 1040 | |
1b12b9c1 | 1041 | if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) && |
cb084b1a | 1042 | couldbe_mf_symlink(&fattr)) |
1b12b9c1 SM |
1043 | /* |
1044 | * trying to get the type and mode can be slow, | |
1045 | * so just call those regular files for now, and mark | |
1046 | * for reval | |
1047 | */ | |
1048 | fattr.cf_flags |= CIFS_FATTR_NEED_REVAL; | |
1049 | ||
1f1735cb | 1050 | cifs_prime_dcache(file_dentry(file), &name, &fattr); |
3870253e | 1051 | |
d87c48ce RS |
1052 | return !cifs_dir_emit(ctx, name.name, name.len, |
1053 | &fattr, cfid); | |
1da177e4 LT |
1054 | } |
1055 | ||
1da177e4 | 1056 | |
be4ccdcc | 1057 | int cifs_readdir(struct file *file, struct dir_context *ctx) |
1da177e4 LT |
1058 | { |
1059 | int rc = 0; | |
6d5786a3 PS |
1060 | unsigned int xid; |
1061 | int i; | |
d87c48ce | 1062 | struct tcon_link *tlink = NULL; |
92fc65a7 | 1063 | struct cifs_tcon *tcon; |
d87c48ce | 1064 | struct cifsFileInfo *cifsFile; |
3870253e | 1065 | char *current_entry; |
1da177e4 | 1066 | int num_to_fill = 0; |
3870253e | 1067 | char *tmp_buf = NULL; |
50c2f753 | 1068 | char *end_of_smb; |
18295796 | 1069 | unsigned int max_len; |
f6a9bc33 AV |
1070 | const char *full_path; |
1071 | void *page = alloc_dentry_path(); | |
d87c48ce RS |
1072 | struct cached_fid *cfid = NULL; |
1073 | struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file); | |
1da177e4 | 1074 | |
6d5786a3 | 1075 | xid = get_xid(); |
1da177e4 | 1076 | |
f6a9bc33 AV |
1077 | full_path = build_path_from_dentry(file_dentry(file), page); |
1078 | if (IS_ERR(full_path)) { | |
1079 | rc = PTR_ERR(full_path); | |
d1542cf6 RS |
1080 | goto rddir2_exit; |
1081 | } | |
1082 | ||
d87c48ce RS |
1083 | if (file->private_data == NULL) { |
1084 | tlink = cifs_sb_tlink(cifs_sb); | |
1085 | if (IS_ERR(tlink)) | |
1086 | goto cache_not_found; | |
1087 | tcon = tlink_tcon(tlink); | |
1088 | } else { | |
1089 | cifsFile = file->private_data; | |
1090 | tcon = tlink_tcon(cifsFile->tlink); | |
1091 | } | |
1092 | ||
7eb59a98 | 1093 | rc = open_cached_dir(xid, tcon, full_path, cifs_sb, false, &cfid); |
d87c48ce RS |
1094 | cifs_put_tlink(tlink); |
1095 | if (rc) | |
1096 | goto cache_not_found; | |
1097 | ||
1098 | mutex_lock(&cfid->dirents.de_mutex); | |
1099 | /* | |
1100 | * If this was reading from the start of the directory | |
1101 | * we need to initialize scanning and storing the | |
1102 | * directory content. | |
1103 | */ | |
1104 | if (ctx->pos == 0 && cfid->dirents.ctx == NULL) { | |
1105 | cfid->dirents.ctx = ctx; | |
1106 | cfid->dirents.pos = 2; | |
1107 | } | |
1108 | /* | |
1109 | * If we already have the entire directory cached then | |
1110 | * we can just serve the cache. | |
1111 | */ | |
1112 | if (cfid->dirents.is_valid) { | |
1113 | if (!dir_emit_dots(file, ctx)) { | |
1114 | mutex_unlock(&cfid->dirents.de_mutex); | |
1115 | goto rddir2_exit; | |
1116 | } | |
1117 | emit_cached_dirents(&cfid->dirents, ctx); | |
1118 | mutex_unlock(&cfid->dirents.de_mutex); | |
1119 | goto rddir2_exit; | |
1120 | } | |
1121 | mutex_unlock(&cfid->dirents.de_mutex); | |
1122 | ||
1123 | /* Drop the cache while calling initiate_cifs_search and | |
1124 | * find_cifs_entry in case there will be reconnects during | |
1125 | * query_directory. | |
1126 | */ | |
44a48081 SF |
1127 | close_cached_dir(cfid); |
1128 | cfid = NULL; | |
d87c48ce RS |
1129 | |
1130 | cache_not_found: | |
6221ddd0 SJ |
1131 | /* |
1132 | * Ensure FindFirst doesn't fail before doing filldir() for '.' and | |
1133 | * '..'. Otherwise we won't be able to notify VFS in case of failure. | |
1134 | */ | |
1135 | if (file->private_data == NULL) { | |
d1542cf6 | 1136 | rc = initiate_cifs_search(xid, file, full_path); |
f96637be | 1137 | cifs_dbg(FYI, "initiate cifs search rc %d\n", rc); |
6221ddd0 SJ |
1138 | if (rc) |
1139 | goto rddir2_exit; | |
1140 | } | |
1141 | ||
be4ccdcc AV |
1142 | if (!dir_emit_dots(file, ctx)) |
1143 | goto rddir2_exit; | |
1da177e4 | 1144 | |
be4ccdcc AV |
1145 | /* 1) If search is active, |
1146 | is in current search buffer? | |
1147 | if it before then restart search | |
1148 | if after then keep searching till find it */ | |
be4ccdcc AV |
1149 | cifsFile = file->private_data; |
1150 | if (cifsFile->srch_inf.endOfSearch) { | |
1151 | if (cifsFile->srch_inf.emptyDir) { | |
1152 | cifs_dbg(FYI, "End of search, empty dir\n"); | |
1153 | rc = 0; | |
1da177e4 LT |
1154 | goto rddir2_exit; |
1155 | } | |
be4ccdcc AV |
1156 | } /* else { |
1157 | cifsFile->invalidHandle = true; | |
1158 | tcon->ses->server->close(xid, tcon, &cifsFile->fid); | |
1159 | } */ | |
1160 | ||
1161 | tcon = tlink_tcon(cifsFile->tlink); | |
d1542cf6 RS |
1162 | rc = find_cifs_entry(xid, tcon, ctx->pos, file, full_path, |
1163 | ¤t_entry, &num_to_fill); | |
7eb59a98 | 1164 | open_cached_dir(xid, tcon, full_path, cifs_sb, false, &cfid); |
be4ccdcc AV |
1165 | if (rc) { |
1166 | cifs_dbg(FYI, "fce error %d\n", rc); | |
1167 | goto rddir2_exit; | |
1168 | } else if (current_entry != NULL) { | |
1169 | cifs_dbg(FYI, "entry %lld found\n", ctx->pos); | |
1170 | } else { | |
d87c48ce RS |
1171 | if (cfid) { |
1172 | mutex_lock(&cfid->dirents.de_mutex); | |
1173 | finished_cached_dirents_count(&cfid->dirents, ctx); | |
1174 | mutex_unlock(&cfid->dirents.de_mutex); | |
1175 | } | |
a0a3036b | 1176 | cifs_dbg(FYI, "Could not find entry\n"); |
be4ccdcc AV |
1177 | goto rddir2_exit; |
1178 | } | |
1179 | cifs_dbg(FYI, "loop through %d times filling dir for net buf %p\n", | |
1180 | num_to_fill, cifsFile->srch_inf.ntwrk_buf_start); | |
1181 | max_len = tcon->ses->server->ops->calc_smb_size( | |
68ed1449 | 1182 | cifsFile->srch_inf.ntwrk_buf_start); |
be4ccdcc AV |
1183 | end_of_smb = cifsFile->srch_inf.ntwrk_buf_start + max_len; |
1184 | ||
1185 | tmp_buf = kmalloc(UNICODE_NAME_MAX, GFP_KERNEL); | |
1186 | if (tmp_buf == NULL) { | |
1187 | rc = -ENOMEM; | |
1188 | goto rddir2_exit; | |
1189 | } | |
1190 | ||
1191 | for (i = 0; i < num_to_fill; i++) { | |
1192 | if (current_entry == NULL) { | |
1193 | /* evaluate whether this case is an error */ | |
1194 | cifs_dbg(VFS, "past SMB end, num to fill %d i %d\n", | |
1195 | num_to_fill, i); | |
f55fdcca KV |
1196 | break; |
1197 | } | |
be4ccdcc AV |
1198 | /* |
1199 | * if buggy server returns . and .. late do we want to | |
1200 | * check for that here? | |
1201 | */ | |
01b9b0b2 | 1202 | *tmp_buf = 0; |
be4ccdcc | 1203 | rc = cifs_filldir(current_entry, file, ctx, |
d87c48ce | 1204 | tmp_buf, max_len, cfid); |
be4ccdcc AV |
1205 | if (rc) { |
1206 | if (rc > 0) | |
7ca85ba7 | 1207 | rc = 0; |
be4ccdcc | 1208 | break; |
1da177e4 | 1209 | } |
be4ccdcc AV |
1210 | |
1211 | ctx->pos++; | |
d87c48ce RS |
1212 | if (cfid) { |
1213 | mutex_lock(&cfid->dirents.de_mutex); | |
1214 | update_cached_dirents_count(&cfid->dirents, ctx); | |
1215 | mutex_unlock(&cfid->dirents.de_mutex); | |
1216 | } | |
1217 | ||
be4ccdcc AV |
1218 | if (ctx->pos == |
1219 | cifsFile->srch_inf.index_of_last_entry) { | |
1220 | cifs_dbg(FYI, "last entry in buf at pos %lld %s\n", | |
1221 | ctx->pos, tmp_buf); | |
1222 | cifs_save_resume_key(current_entry, cifsFile); | |
1223 | break; | |
780614ce RS |
1224 | } |
1225 | current_entry = | |
1226 | nxt_dir_entry(current_entry, end_of_smb, | |
1227 | cifsFile->srch_inf.info_level); | |
be4ccdcc AV |
1228 | } |
1229 | kfree(tmp_buf); | |
1da177e4 LT |
1230 | |
1231 | rddir2_exit: | |
d87c48ce RS |
1232 | if (cfid) |
1233 | close_cached_dir(cfid); | |
f6a9bc33 | 1234 | free_dentry_path(page); |
6d5786a3 | 1235 | free_xid(xid); |
1da177e4 LT |
1236 | return rc; |
1237 | } |