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 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq); 77 int rc; 78 79 cifs_dbg(FYI, "%s: for %s\n", __func__, name->name); 80 81 dentry = try_lookup_noperm(name, parent); 82 if (!dentry) { 83 /* 84 * If we know that the inode will need to be revalidated 85 * immediately, then don't create a new dentry for it. 86 * We'll end up doing an on the wire call either way and 87 * this spares us an invalidation. 88 */ 89 retry: 90 if (posix) { 91 switch (fattr->cf_mode & S_IFMT) { 92 case S_IFLNK: 93 case S_IFBLK: 94 case S_IFCHR: 95 reparse_need_reval = true; 96 break; 97 default: 98 break; 99 } 100 } else if (fattr->cf_cifsattrs & ATTR_REPARSE_POINT) { 101 reparse_need_reval = true; 102 } 103 104 if (reparse_need_reval || 105 (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)) 106 return; 107 108 dentry = d_alloc_parallel(parent, name, &wq); 109 } 110 if (IS_ERR(dentry)) 111 return; 112 if (!d_in_lookup(dentry)) { 113 inode = d_inode(dentry); 114 if (inode) { 115 if (d_mountpoint(dentry)) { 116 dput(dentry); 117 return; 118 } 119 /* 120 * If we're generating inode numbers, then we don't 121 * want to clobber the existing one with the one that 122 * the readdir code created. 123 */ 124 if (!(cifs_sb_flags(cifs_sb) & CIFS_MOUNT_SERVER_INUM)) 125 fattr->cf_uniqueid = CIFS_I(inode)->uniqueid; 126 127 /* 128 * Update inode in place if both i_ino and i_mode didn't 129 * change. 130 */ 131 if (CIFS_I(inode)->uniqueid == fattr->cf_uniqueid) { 132 /* 133 * Query dir responses don't provide enough 134 * information about reparse points other than 135 * their reparse tags. Save an invalidation by 136 * not clobbering some existing attributes when 137 * reparse tag and ctime haven't changed. 138 */ 139 rc = 0; 140 if (fattr->cf_cifsattrs & ATTR_REPARSE_POINT) { 141 if (likely(reparse_inode_match(inode, fattr))) { 142 fattr->cf_mode = inode->i_mode; 143 fattr->cf_rdev = inode->i_rdev; 144 fattr->cf_uid = inode->i_uid; 145 fattr->cf_gid = inode->i_gid; 146 fattr->cf_eof = CIFS_I(inode)->netfs.remote_i_size; 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 736 cifs_buf_release(cfile->srch_inf. 737 ntwrk_buf_start); 738 /* Reset all pointers to the network buffer to prevent stale references */ 739 cfile->srch_inf.ntwrk_buf_start = NULL; 740 cfile->srch_inf.srch_entries_start = NULL; 741 cfile->srch_inf.last_entry = NULL; 742 } 743 rc = initiate_cifs_search(xid, file, full_path); 744 if (rc) { 745 cifs_dbg(FYI, "error %d reinitiating a search on rewind\n", 746 rc); 747 return rc; 748 } 749 /* FindFirst/Next set last_entry to NULL on malformed reply */ 750 if (cfile->srch_inf.last_entry) 751 cifs_save_resume_key(cfile->srch_inf.last_entry, cfile); 752 } 753 754 search_flags = CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME; 755 if (backup_cred(cifs_sb)) 756 search_flags |= CIFS_SEARCH_BACKUP_SEARCH; 757 758 while ((index_to_find >= cfile->srch_inf.index_of_last_entry) && 759 (rc == 0) && !cfile->srch_inf.endOfSearch) { 760 cifs_dbg(FYI, "calling findnext2\n"); 761 rc = server->ops->query_dir_next(xid, tcon, &cfile->fid, 762 search_flags, 763 &cfile->srch_inf); 764 if (rc) 765 return -ENOENT; 766 /* FindFirst/Next set last_entry to NULL on malformed reply */ 767 if (cfile->srch_inf.last_entry) 768 cifs_save_resume_key(cfile->srch_inf.last_entry, cfile); 769 } 770 if (index_to_find < cfile->srch_inf.index_of_last_entry) { 771 /* we found the buffer that contains the entry */ 772 /* scan and find it */ 773 int i; 774 char *cur_ent; 775 char *end_of_smb; 776 777 if (cfile->srch_inf.ntwrk_buf_start == NULL) { 778 cifs_dbg(VFS, "ntwrk_buf_start is NULL during readdir\n"); 779 return smb_EIO(smb_eio_trace_null_pointers); 780 } 781 782 end_of_smb = cfile->srch_inf.ntwrk_buf_start + 783 server->ops->calc_smb_size( 784 cfile->srch_inf.ntwrk_buf_start); 785 786 cur_ent = cfile->srch_inf.srch_entries_start; 787 first_entry_in_buffer = cfile->srch_inf.index_of_last_entry 788 - cfile->srch_inf.entries_in_buffer; 789 pos_in_buf = index_to_find - first_entry_in_buffer; 790 cifs_dbg(FYI, "found entry - pos_in_buf %d\n", pos_in_buf); 791 792 for (i = 0; (i < (pos_in_buf)) && (cur_ent != NULL); i++) { 793 /* go entry by entry figuring out which is first */ 794 cur_ent = nxt_dir_entry(cur_ent, end_of_smb, 795 cfile->srch_inf.info_level); 796 } 797 if ((cur_ent == NULL) && (i < pos_in_buf)) { 798 /* BB fixme - check if we should flag this error */ 799 cifs_dbg(VFS, "reached end of buf searching for pos in buf %d index to find %lld rc %d\n", 800 pos_in_buf, index_to_find, rc); 801 } 802 rc = 0; 803 *current_entry = cur_ent; 804 } else { 805 cifs_dbg(FYI, "index not in buffer - could not findnext into it\n"); 806 return 0; 807 } 808 809 if (pos_in_buf >= cfile->srch_inf.entries_in_buffer) { 810 cifs_dbg(FYI, "can not return entries pos_in_buf beyond last\n"); 811 *num_to_ret = 0; 812 } else 813 *num_to_ret = cfile->srch_inf.entries_in_buffer - pos_in_buf; 814 815 return rc; 816 } 817 818 static bool emit_cached_dirents(struct cached_dirents *cde, 819 struct dir_context *ctx) 820 { 821 struct cached_dirent *dirent; 822 bool rc; 823 824 list_for_each_entry(dirent, &cde->entries, entry) { 825 /* 826 * Skip all early entries prior to the current lseek() 827 * position. 828 */ 829 if (ctx->pos > dirent->pos) 830 continue; 831 /* 832 * We recorded the current ->pos value for the dirent 833 * when we stored it in the cache. 834 * However, this sequence of ->pos values may have holes 835 * in it, for example dot-dirs returned from the server 836 * are suppressed. 837 * Handle this by forcing ctx->pos to be the same as the 838 * ->pos of the current dirent we emit from the cache. 839 * This means that when we emit these entries from the cache 840 * we now emit them with the same ->pos value as in the 841 * initial scan. 842 */ 843 ctx->pos = dirent->pos; 844 rc = dir_emit(ctx, dirent->name, dirent->namelen, 845 dirent->fattr.cf_uniqueid, 846 dirent->fattr.cf_dtype); 847 if (!rc) 848 return rc; 849 ctx->pos++; 850 } 851 return true; 852 } 853 854 static void update_cached_dirents_count(struct cached_dirents *cde, 855 struct file *file) 856 { 857 if (cde->file != file) 858 return; 859 if (cde->is_valid || cde->is_failed) 860 return; 861 862 cde->pos++; 863 } 864 865 static void finished_cached_dirents_count(struct cached_dirents *cde, 866 struct dir_context *ctx, struct file *file) 867 { 868 if (cde->file != file) 869 return; 870 if (cde->is_valid || cde->is_failed) 871 return; 872 if (ctx->pos != cde->pos) 873 return; 874 875 cde->is_valid = 1; 876 } 877 878 static bool add_cached_dirent(struct cached_dirents *cde, 879 struct dir_context *ctx, const char *name, 880 int namelen, struct cifs_fattr *fattr, 881 struct file *file) 882 { 883 struct cached_dirent *de; 884 885 if (cde->file != file) 886 return false; 887 if (cde->is_valid || cde->is_failed) 888 return false; 889 if (ctx->pos != cde->pos) { 890 cde->is_failed = 1; 891 return false; 892 } 893 de = kzalloc_obj(*de, GFP_ATOMIC); 894 if (de == NULL) { 895 cde->is_failed = 1; 896 return false; 897 } 898 de->namelen = namelen; 899 de->name = kstrndup(name, namelen, GFP_ATOMIC); 900 if (de->name == NULL) { 901 kfree(de); 902 cde->is_failed = 1; 903 return false; 904 } 905 de->pos = ctx->pos; 906 907 memcpy(&de->fattr, fattr, sizeof(struct cifs_fattr)); 908 909 list_add_tail(&de->entry, &cde->entries); 910 /* update accounting */ 911 cde->entries_count++; 912 cde->bytes_used += sizeof(*de) + (size_t)namelen + 1; 913 return true; 914 } 915 916 static bool cifs_dir_emit(struct dir_context *ctx, 917 const char *name, int namelen, 918 struct cifs_fattr *fattr, 919 struct cached_fid *cfid, 920 struct file *file) 921 { 922 size_t delta_bytes = 0; 923 bool rc, added = false; 924 ino_t ino = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid); 925 926 rc = dir_emit(ctx, name, namelen, ino, fattr->cf_dtype); 927 if (!rc) 928 return rc; 929 930 if (cfid) { 931 /* Cost of this entry */ 932 delta_bytes = sizeof(struct cached_dirent) + (size_t)namelen + 1; 933 934 mutex_lock(&cfid->dirents.de_mutex); 935 added = add_cached_dirent(&cfid->dirents, ctx, name, namelen, 936 fattr, file); 937 mutex_unlock(&cfid->dirents.de_mutex); 938 939 if (added) { 940 /* per-tcon then global for consistency with free path */ 941 atomic64_add((long long)delta_bytes, &cfid->cfids->total_dirents_bytes); 942 atomic_long_inc(&cfid->cfids->total_dirents_entries); 943 atomic64_add((long long)delta_bytes, &cifs_dircache_bytes_used); 944 } 945 } 946 947 return rc; 948 } 949 950 static int cifs_filldir(char *find_entry, struct file *file, 951 struct dir_context *ctx, 952 char *scratch_buf, unsigned int max_len, 953 struct cached_fid *cfid) 954 { 955 struct cifsFileInfo *file_info = file->private_data; 956 struct super_block *sb = file_inode(file)->i_sb; 957 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 958 struct cifs_dirent de = { NULL, }; 959 struct cifs_fattr fattr; 960 unsigned int sbflags; 961 struct qstr name; 962 int rc = 0; 963 964 rc = cifs_fill_dirent(&de, find_entry, file_info->srch_inf.info_level, 965 file_info->srch_inf.unicode); 966 if (rc) 967 return rc; 968 969 if (de.namelen > max_len) { 970 cifs_dbg(VFS, "bad search response length %zd past smb end\n", 971 de.namelen); 972 return -EINVAL; 973 } 974 975 /* skip . and .. since we added them first */ 976 if (cifs_entry_is_dot(&de, file_info->srch_inf.unicode)) 977 return 0; 978 979 if (file_info->srch_inf.unicode) { 980 struct nls_table *nlt = cifs_sb->local_nls; 981 int map_type; 982 983 map_type = cifs_remap(cifs_sb); 984 name.name = scratch_buf; 985 name.len = 986 cifs_from_utf16((char *)name.name, (__le16 *)de.name, 987 UNICODE_NAME_MAX, 988 min_t(size_t, de.namelen, 989 (size_t)max_len), nlt, map_type); 990 name.len -= nls_nullsize(nlt); 991 } else { 992 name.name = de.name; 993 name.len = de.namelen; 994 } 995 996 switch (file_info->srch_inf.info_level) { 997 case SMB_FIND_FILE_POSIX_INFO: 998 cifs_posix_to_fattr(&fattr, 999 (struct smb2_posix_info *)find_entry, 1000 cifs_sb); 1001 break; 1002 case SMB_FIND_FILE_UNIX: 1003 cifs_unix_basic_to_fattr(&fattr, 1004 &((FILE_UNIX_INFO *)find_entry)->basic, 1005 cifs_sb); 1006 if (S_ISLNK(fattr.cf_mode)) 1007 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL; 1008 break; 1009 case SMB_FIND_FILE_INFO_STANDARD: 1010 cifs_std_info_to_fattr(&fattr, 1011 (FIND_FILE_STANDARD_INFO *)find_entry, 1012 cifs_sb); 1013 break; 1014 case SMB_FIND_FILE_FULL_DIRECTORY_INFO: 1015 case SMB_FIND_FILE_ID_FULL_DIR_INFO: 1016 cifs_fulldir_info_to_fattr(&fattr, find_entry, cifs_sb); 1017 break; 1018 default: 1019 cifs_dir_info_to_fattr(&fattr, 1020 (FILE_DIRECTORY_INFO *)find_entry, 1021 cifs_sb); 1022 break; 1023 } 1024 1025 sbflags = cifs_sb_flags(cifs_sb); 1026 if (de.ino && (sbflags & CIFS_MOUNT_SERVER_INUM)) { 1027 fattr.cf_uniqueid = de.ino; 1028 } else { 1029 fattr.cf_uniqueid = iunique(sb, ROOT_I); 1030 cifs_autodisable_serverino(cifs_sb); 1031 } 1032 1033 if ((sbflags & CIFS_MOUNT_MF_SYMLINKS) && couldbe_mf_symlink(&fattr)) 1034 /* 1035 * trying to get the type and mode can be slow, 1036 * so just call those regular files for now, and mark 1037 * for reval 1038 */ 1039 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL; 1040 1041 cifs_prime_dcache(file_dentry(file), &name, &fattr); 1042 1043 return !cifs_dir_emit(ctx, name.name, name.len, 1044 &fattr, cfid, file); 1045 } 1046 1047 1048 int cifs_readdir(struct file *file, struct dir_context *ctx) 1049 { 1050 int rc = 0; 1051 unsigned int xid; 1052 int i; 1053 struct tcon_link *tlink = NULL; 1054 struct cifs_tcon *tcon; 1055 struct cifsFileInfo *cifsFile; 1056 char *current_entry; 1057 int num_to_fill = 0; 1058 char *tmp_buf = NULL; 1059 char *end_of_smb; 1060 unsigned int max_len; 1061 const char *full_path; 1062 void *page = alloc_dentry_path(); 1063 struct cached_fid *cfid = NULL; 1064 struct cifs_sb_info *cifs_sb = CIFS_SB(file); 1065 1066 xid = get_xid(); 1067 1068 full_path = build_path_from_dentry(file_dentry(file), page); 1069 if (IS_ERR(full_path)) { 1070 rc = PTR_ERR(full_path); 1071 goto rddir2_exit; 1072 } 1073 1074 if (file->private_data == NULL) { 1075 tlink = cifs_sb_tlink(cifs_sb); 1076 if (IS_ERR(tlink)) 1077 goto cache_not_found; 1078 tcon = tlink_tcon(tlink); 1079 } else { 1080 cifsFile = file->private_data; 1081 tcon = tlink_tcon(cifsFile->tlink); 1082 } 1083 1084 rc = open_cached_dir(xid, tcon, full_path, cifs_sb, false, &cfid); 1085 cifs_put_tlink(tlink); 1086 if (rc) 1087 goto cache_not_found; 1088 1089 mutex_lock(&cfid->dirents.de_mutex); 1090 /* 1091 * If this was reading from the start of the directory 1092 * we need to initialize scanning and storing the 1093 * directory content. 1094 */ 1095 if (ctx->pos == 0 && cfid->dirents.file == NULL) { 1096 cfid->dirents.file = file; 1097 cfid->dirents.pos = 2; 1098 } 1099 /* 1100 * If we already have the entire directory cached then 1101 * we can just serve the cache. 1102 */ 1103 if (cfid->dirents.is_valid) { 1104 if (!dir_emit_dots(file, ctx)) { 1105 mutex_unlock(&cfid->dirents.de_mutex); 1106 goto rddir2_exit; 1107 } 1108 emit_cached_dirents(&cfid->dirents, ctx); 1109 mutex_unlock(&cfid->dirents.de_mutex); 1110 goto rddir2_exit; 1111 } 1112 mutex_unlock(&cfid->dirents.de_mutex); 1113 1114 /* Drop the cache while calling initiate_cifs_search and 1115 * find_cifs_entry in case there will be reconnects during 1116 * query_directory. 1117 */ 1118 close_cached_dir(cfid); 1119 cfid = NULL; 1120 1121 cache_not_found: 1122 /* 1123 * Ensure FindFirst doesn't fail before doing filldir() for '.' and 1124 * '..'. Otherwise we won't be able to notify VFS in case of failure. 1125 */ 1126 if (file->private_data == NULL) { 1127 rc = initiate_cifs_search(xid, file, full_path); 1128 cifs_dbg(FYI, "initiate cifs search rc %d\n", rc); 1129 if (rc) 1130 goto rddir2_exit; 1131 } 1132 1133 if (!dir_emit_dots(file, ctx)) 1134 goto rddir2_exit; 1135 1136 /* 1) If search is active, 1137 is in current search buffer? 1138 if it before then restart search 1139 if after then keep searching till find it */ 1140 cifsFile = file->private_data; 1141 if (cifsFile->srch_inf.endOfSearch) { 1142 if (cifsFile->srch_inf.emptyDir) { 1143 cifs_dbg(FYI, "End of search, empty dir\n"); 1144 rc = 0; 1145 goto rddir2_exit; 1146 } 1147 } /* else { 1148 cifsFile->invalidHandle = true; 1149 tcon->ses->server->close(xid, tcon, &cifsFile->fid); 1150 } */ 1151 1152 tcon = tlink_tcon(cifsFile->tlink); 1153 rc = find_cifs_entry(xid, tcon, ctx->pos, file, full_path, 1154 ¤t_entry, &num_to_fill); 1155 open_cached_dir(xid, tcon, full_path, cifs_sb, false, &cfid); 1156 if (rc) { 1157 cifs_dbg(FYI, "fce error %d\n", rc); 1158 goto rddir2_exit; 1159 } else if (current_entry != NULL) { 1160 cifs_dbg(FYI, "entry %lld found\n", ctx->pos); 1161 } else { 1162 if (cfid) { 1163 mutex_lock(&cfid->dirents.de_mutex); 1164 finished_cached_dirents_count(&cfid->dirents, ctx, file); 1165 mutex_unlock(&cfid->dirents.de_mutex); 1166 } 1167 cifs_dbg(FYI, "Could not find entry\n"); 1168 goto rddir2_exit; 1169 } 1170 cifs_dbg(FYI, "loop through %d times filling dir for net buf %p\n", 1171 num_to_fill, cifsFile->srch_inf.ntwrk_buf_start); 1172 max_len = tcon->ses->server->ops->calc_smb_size( 1173 cifsFile->srch_inf.ntwrk_buf_start); 1174 end_of_smb = cifsFile->srch_inf.ntwrk_buf_start + max_len; 1175 1176 tmp_buf = kmalloc(UNICODE_NAME_MAX, GFP_KERNEL); 1177 if (tmp_buf == NULL) { 1178 rc = -ENOMEM; 1179 goto rddir2_exit; 1180 } 1181 1182 for (i = 0; i < num_to_fill; i++) { 1183 if (current_entry == NULL) { 1184 /* evaluate whether this case is an error */ 1185 cifs_dbg(VFS, "past SMB end, num to fill %d i %d\n", 1186 num_to_fill, i); 1187 break; 1188 } 1189 /* 1190 * if buggy server returns . and .. late do we want to 1191 * check for that here? 1192 */ 1193 *tmp_buf = 0; 1194 rc = cifs_filldir(current_entry, file, ctx, 1195 tmp_buf, max_len, cfid); 1196 if (rc) { 1197 if (rc > 0) 1198 rc = 0; 1199 break; 1200 } 1201 1202 ctx->pos++; 1203 if (cfid) { 1204 mutex_lock(&cfid->dirents.de_mutex); 1205 update_cached_dirents_count(&cfid->dirents, file); 1206 mutex_unlock(&cfid->dirents.de_mutex); 1207 } 1208 1209 if (ctx->pos == 1210 cifsFile->srch_inf.index_of_last_entry) { 1211 cifs_dbg(FYI, "last entry in buf at pos %lld %s\n", 1212 ctx->pos, tmp_buf); 1213 cifs_save_resume_key(current_entry, cifsFile); 1214 break; 1215 } 1216 current_entry = 1217 nxt_dir_entry(current_entry, end_of_smb, 1218 cifsFile->srch_inf.info_level); 1219 } 1220 kfree(tmp_buf); 1221 1222 rddir2_exit: 1223 if (cfid) 1224 close_cached_dir(cfid); 1225 free_dentry_path(page); 1226 free_xid(xid); 1227 return rc; 1228 } 1229