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