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 unsigned int sbflags = cifs_sb_flags(cifs_sb); 246 struct smb2_posix_info_parsed parsed; 247 int rc; 248 249 rc = posix_info_parse(info, NULL, &parsed); 250 251 memset(fattr, 0, sizeof(*fattr)); 252 fattr->cf_uniqueid = le64_to_cpu(info->Inode); 253 fattr->cf_bytes = le64_to_cpu(info->AllocationSize); 254 fattr->cf_eof = le64_to_cpu(info->EndOfFile); 255 256 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime); 257 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime); 258 fattr->cf_ctime = cifs_NTtimeToUnix(info->CreationTime); 259 260 fattr->cf_nlink = le32_to_cpu(info->HardLinks); 261 fattr->cf_cifsattrs = le32_to_cpu(info->DosAttributes); 262 263 if (fattr->cf_cifsattrs & ATTR_REPARSE_POINT) 264 fattr->cf_cifstag = le32_to_cpu(info->ReparseTag); 265 266 /* The Mode field in the response can now include the file type as well */ 267 fattr->cf_mode = wire_mode_to_posix(le32_to_cpu(info->Mode), 268 fattr->cf_cifsattrs & ATTR_DIRECTORY); 269 fattr->cf_dtype = S_DT(fattr->cf_mode); 270 271 switch (fattr->cf_mode & S_IFMT) { 272 case S_IFLNK: 273 case S_IFBLK: 274 case S_IFCHR: 275 fattr->cf_flags |= CIFS_FATTR_NEED_REVAL; 276 break; 277 default: 278 break; 279 } 280 281 cifs_dbg(FYI, "posix fattr: dev %d, reparse %d, mode %o\n", 282 le32_to_cpu(info->DeviceId), 283 le32_to_cpu(info->ReparseTag), 284 le32_to_cpu(info->Mode)); 285 286 fattr->cf_uid = cifs_sb->ctx->linux_uid; 287 fattr->cf_gid = cifs_sb->ctx->linux_gid; 288 if (rc < 0) { 289 cifs_dbg(VFS, "%s: failed to parse SIDs: %d\n", 290 __func__, rc); 291 } else { 292 if (!(sbflags & CIFS_MOUNT_OVERR_UID)) 293 sid_to_id(cifs_sb, &parsed.owner, fattr, SIDOWNER); 294 if (!(sbflags & CIFS_MOUNT_OVERR_GID)) 295 sid_to_id(cifs_sb, &parsed.group, fattr, SIDGROUP); 296 } 297 } 298 299 static void __dir_info_to_fattr(struct cifs_fattr *fattr, const void *info) 300 { 301 const FILE_DIRECTORY_INFO *fi = info; 302 303 memset(fattr, 0, sizeof(*fattr)); 304 fattr->cf_cifsattrs = le32_to_cpu(fi->ExtFileAttributes); 305 fattr->cf_eof = le64_to_cpu(fi->EndOfFile); 306 fattr->cf_bytes = le64_to_cpu(fi->AllocationSize); 307 fattr->cf_createtime = le64_to_cpu(fi->CreationTime); 308 fattr->cf_atime = cifs_NTtimeToUnix(fi->LastAccessTime); 309 fattr->cf_ctime = cifs_NTtimeToUnix(fi->ChangeTime); 310 fattr->cf_mtime = cifs_NTtimeToUnix(fi->LastWriteTime); 311 } 312 313 void 314 cifs_dir_info_to_fattr(struct cifs_fattr *fattr, FILE_DIRECTORY_INFO *info, 315 struct cifs_sb_info *cifs_sb) 316 { 317 __dir_info_to_fattr(fattr, info); 318 cifs_fill_common_info(fattr, cifs_sb); 319 } 320 321 static void cifs_fulldir_info_to_fattr(struct cifs_fattr *fattr, 322 const void *info, 323 struct cifs_sb_info *cifs_sb) 324 { 325 const FILE_FULL_DIRECTORY_INFO *di = info; 326 327 __dir_info_to_fattr(fattr, info); 328 329 /* See MS-FSCC 2.4.14, 2.4.19 */ 330 if (fattr->cf_cifsattrs & ATTR_REPARSE_POINT) 331 fattr->cf_cifstag = le32_to_cpu(di->EaSize); 332 cifs_fill_common_info(fattr, cifs_sb); 333 } 334 335 static void 336 cifs_std_info_to_fattr(struct cifs_fattr *fattr, FIND_FILE_STANDARD_INFO *info, 337 struct cifs_sb_info *cifs_sb) 338 { 339 int offset = cifs_sb_master_tcon(cifs_sb)->ses->server->timeAdj; 340 341 memset(fattr, 0, sizeof(*fattr)); 342 fattr->cf_atime = cnvrtDosUnixTm(info->LastAccessDate, 343 info->LastAccessTime, offset); 344 fattr->cf_ctime = cnvrtDosUnixTm(info->LastWriteDate, 345 info->LastWriteTime, offset); 346 fattr->cf_mtime = cnvrtDosUnixTm(info->LastWriteDate, 347 info->LastWriteTime, offset); 348 349 fattr->cf_cifsattrs = le16_to_cpu(info->Attributes); 350 fattr->cf_bytes = le32_to_cpu(info->AllocationSize); 351 fattr->cf_eof = le32_to_cpu(info->DataSize); 352 353 cifs_fill_common_info(fattr, cifs_sb); 354 } 355 356 static int 357 _initiate_cifs_search(const unsigned int xid, struct file *file, 358 const char *full_path) 359 { 360 struct cifs_sb_info *cifs_sb = CIFS_SB(file); 361 struct tcon_link *tlink = NULL; 362 struct TCP_Server_Info *server; 363 struct cifsFileInfo *cifsFile; 364 struct cifs_tcon *tcon; 365 unsigned int sbflags; 366 __u16 search_flags; 367 int rc = 0; 368 369 if (file->private_data == NULL) { 370 tlink = cifs_sb_tlink(cifs_sb); 371 if (IS_ERR(tlink)) 372 return PTR_ERR(tlink); 373 374 cifsFile = kzalloc_obj(struct cifsFileInfo); 375 if (cifsFile == NULL) { 376 rc = -ENOMEM; 377 goto error_exit; 378 } 379 spin_lock_init(&cifsFile->file_info_lock); 380 file->private_data = cifsFile; 381 cifsFile->tlink = cifs_get_tlink(tlink); 382 tcon = tlink_tcon(tlink); 383 } else { 384 cifsFile = file->private_data; 385 tcon = tlink_tcon(cifsFile->tlink); 386 } 387 388 server = tcon->ses->server; 389 390 if (!server->ops->query_dir_first) { 391 rc = -ENOSYS; 392 goto error_exit; 393 } 394 395 cifsFile->invalidHandle = true; 396 cifsFile->srch_inf.endOfSearch = false; 397 398 cifs_dbg(FYI, "Full path: %s start at: %lld\n", full_path, file->f_pos); 399 400 ffirst_retry: 401 sbflags = cifs_sb_flags(cifs_sb); 402 /* test for Unix extensions */ 403 /* but now check for them on the share/mount not on the SMB session */ 404 /* if (cap_unix(tcon->ses) { */ 405 if (tcon->unix_ext) 406 cifsFile->srch_inf.info_level = SMB_FIND_FILE_UNIX; 407 else if (tcon->posix_extensions) 408 cifsFile->srch_inf.info_level = SMB_FIND_FILE_POSIX_INFO; 409 else if ((tcon->ses->capabilities & 410 tcon->ses->server->vals->cap_nt_find) == 0) { 411 cifsFile->srch_inf.info_level = SMB_FIND_FILE_INFO_STANDARD; 412 } else if (sbflags & CIFS_MOUNT_SERVER_INUM) { 413 cifsFile->srch_inf.info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO; 414 } else /* not srvinos - BB fixme add check for backlevel? */ { 415 cifsFile->srch_inf.info_level = SMB_FIND_FILE_FULL_DIRECTORY_INFO; 416 } 417 418 search_flags = CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME; 419 if (backup_cred(cifs_sb)) 420 search_flags |= CIFS_SEARCH_BACKUP_SEARCH; 421 422 rc = server->ops->query_dir_first(xid, tcon, full_path, cifs_sb, 423 &cifsFile->fid, search_flags, 424 &cifsFile->srch_inf); 425 426 if (rc == 0) { 427 cifsFile->invalidHandle = false; 428 } else if (rc == -EOPNOTSUPP && (sbflags & CIFS_MOUNT_SERVER_INUM)) { 429 cifs_autodisable_serverino(cifs_sb, "Cannot retrieve inode number via query_dir_first", rc); 430 goto ffirst_retry; 431 } 432 error_exit: 433 cifs_put_tlink(tlink); 434 return rc; 435 } 436 437 static int 438 initiate_cifs_search(const unsigned int xid, struct file *file, 439 const char *full_path) 440 { 441 int rc, retry_count = 0; 442 443 do { 444 rc = _initiate_cifs_search(xid, file, full_path); 445 /* 446 * If we don't have enough credits to start reading the 447 * directory just try again after short wait. 448 */ 449 if (rc != -EDEADLK) 450 break; 451 452 usleep_range(512, 2048); 453 } while (retry_count++ < 5); 454 455 return rc; 456 } 457 458 /* return length of unicode string in bytes */ 459 static int cifs_unicode_bytelen(const char *str) 460 { 461 int len; 462 const __le16 *ustr = (const __le16 *)str; 463 464 for (len = 0; len <= PATH_MAX; len++) { 465 if (ustr[len] == 0) 466 return len << 1; 467 } 468 cifs_dbg(FYI, "Unicode string longer than PATH_MAX found\n"); 469 return len << 1; 470 } 471 472 static char *nxt_dir_entry(char *old_entry, char *end_of_smb, int level) 473 { 474 char *new_entry; 475 FILE_DIRECTORY_INFO *pDirInfo = (FILE_DIRECTORY_INFO *)old_entry; 476 477 if (level == SMB_FIND_FILE_INFO_STANDARD) { 478 FIND_FILE_STANDARD_INFO *pfData; 479 pfData = (FIND_FILE_STANDARD_INFO *)pDirInfo; 480 481 new_entry = old_entry + sizeof(FIND_FILE_STANDARD_INFO) + 1 + 482 pfData->FileNameLength; 483 } else { 484 u32 next_offset = le32_to_cpu(pDirInfo->NextEntryOffset); 485 486 if (old_entry + next_offset < old_entry) { 487 cifs_dbg(VFS, "Invalid offset %u\n", next_offset); 488 return NULL; 489 } 490 new_entry = old_entry + next_offset; 491 } 492 cifs_dbg(FYI, "new entry %p old entry %p\n", new_entry, old_entry); 493 /* validate that new_entry is not past end of SMB */ 494 if (new_entry >= end_of_smb) { 495 cifs_dbg(VFS, "search entry %p began after end of SMB %p old entry %p\n", 496 new_entry, end_of_smb, old_entry); 497 return NULL; 498 } else if (((level == SMB_FIND_FILE_INFO_STANDARD) && 499 (new_entry + sizeof(FIND_FILE_STANDARD_INFO) + 1 > end_of_smb)) 500 || ((level != SMB_FIND_FILE_INFO_STANDARD) && 501 (new_entry + sizeof(FILE_DIRECTORY_INFO) + 1 > end_of_smb))) { 502 cifs_dbg(VFS, "search entry %p extends after end of SMB %p\n", 503 new_entry, end_of_smb); 504 return NULL; 505 } else 506 return new_entry; 507 508 } 509 510 struct cifs_dirent { 511 const char *name; 512 size_t namelen; 513 u32 resume_key; 514 u64 ino; 515 }; 516 517 static void cifs_fill_dirent_posix(struct cifs_dirent *de, 518 const struct smb2_posix_info *info) 519 { 520 struct smb2_posix_info_parsed parsed; 521 522 /* payload should have already been checked at this point */ 523 if (posix_info_parse(info, NULL, &parsed) < 0) { 524 cifs_dbg(VFS, "Invalid POSIX info payload\n"); 525 return; 526 } 527 528 de->name = parsed.name; 529 de->namelen = parsed.name_len; 530 de->resume_key = info->Ignored; 531 de->ino = le64_to_cpu(info->Inode); 532 } 533 534 static void cifs_fill_dirent_unix(struct cifs_dirent *de, 535 const FILE_UNIX_INFO *info, bool is_unicode) 536 { 537 de->name = &info->FileName[0]; 538 if (is_unicode) 539 de->namelen = cifs_unicode_bytelen(de->name); 540 else 541 de->namelen = strnlen(de->name, PATH_MAX); 542 de->resume_key = info->ResumeKey; 543 de->ino = le64_to_cpu(info->basic.UniqueId); 544 } 545 546 static void cifs_fill_dirent_dir(struct cifs_dirent *de, 547 const FILE_DIRECTORY_INFO *info) 548 { 549 de->name = &info->FileName[0]; 550 de->namelen = le32_to_cpu(info->FileNameLength); 551 de->resume_key = info->FileIndex; 552 } 553 554 static void cifs_fill_dirent_full(struct cifs_dirent *de, 555 const FILE_FULL_DIRECTORY_INFO *info) 556 { 557 de->name = &info->FileName[0]; 558 de->namelen = le32_to_cpu(info->FileNameLength); 559 de->resume_key = info->FileIndex; 560 } 561 562 static void cifs_fill_dirent_search(struct cifs_dirent *de, 563 const FILE_ID_FULL_DIR_INFO *info) 564 { 565 de->name = &info->FileName[0]; 566 de->namelen = le32_to_cpu(info->FileNameLength); 567 de->resume_key = info->FileIndex; 568 de->ino = le64_to_cpu(info->UniqueId); 569 } 570 571 static void cifs_fill_dirent_both(struct cifs_dirent *de, 572 const FILE_BOTH_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_std(struct cifs_dirent *de, 580 const FIND_FILE_STANDARD_INFO *info) 581 { 582 de->name = &info->FileName[0]; 583 /* one byte length, no endianness conversion */ 584 de->namelen = info->FileNameLength; 585 de->resume_key = info->ResumeKey; 586 } 587 588 static int cifs_fill_dirent(struct cifs_dirent *de, const void *info, 589 u16 level, bool is_unicode) 590 { 591 memset(de, 0, sizeof(*de)); 592 593 switch (level) { 594 case SMB_FIND_FILE_POSIX_INFO: 595 cifs_fill_dirent_posix(de, info); 596 break; 597 case SMB_FIND_FILE_UNIX: 598 cifs_fill_dirent_unix(de, info, is_unicode); 599 break; 600 case SMB_FIND_FILE_DIRECTORY_INFO: 601 cifs_fill_dirent_dir(de, info); 602 break; 603 case SMB_FIND_FILE_FULL_DIRECTORY_INFO: 604 cifs_fill_dirent_full(de, info); 605 break; 606 case SMB_FIND_FILE_ID_FULL_DIR_INFO: 607 cifs_fill_dirent_search(de, info); 608 break; 609 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO: 610 cifs_fill_dirent_both(de, info); 611 break; 612 case SMB_FIND_FILE_INFO_STANDARD: 613 cifs_fill_dirent_std(de, info); 614 break; 615 default: 616 cifs_dbg(FYI, "Unknown findfirst level %d\n", level); 617 return -EINVAL; 618 } 619 620 return 0; 621 } 622 623 #define UNICODE_DOT cpu_to_le16(0x2e) 624 625 /* return 0 if no match and 1 for . (current directory) and 2 for .. (parent) */ 626 static int cifs_entry_is_dot(struct cifs_dirent *de, bool is_unicode) 627 { 628 int rc = 0; 629 630 if (!de->name) 631 return 0; 632 633 if (is_unicode) { 634 __le16 *ufilename = (__le16 *)de->name; 635 if (de->namelen == 2) { 636 /* check for . */ 637 if (ufilename[0] == UNICODE_DOT) 638 rc = 1; 639 } else if (de->namelen == 4) { 640 /* check for .. */ 641 if (ufilename[0] == UNICODE_DOT && 642 ufilename[1] == UNICODE_DOT) 643 rc = 2; 644 } 645 } else /* ASCII */ { 646 if (de->namelen == 1) { 647 if (de->name[0] == '.') 648 rc = 1; 649 } else if (de->namelen == 2) { 650 if (de->name[0] == '.' && de->name[1] == '.') 651 rc = 2; 652 } 653 } 654 655 return rc; 656 } 657 658 /* Check if directory that we are searching has changed so we can decide 659 whether we can use the cached search results from the previous search */ 660 static int is_dir_changed(struct file *file) 661 { 662 struct inode *inode = file_inode(file); 663 struct cifsInodeInfo *cifs_inode_info = CIFS_I(inode); 664 665 if (cifs_inode_info->time == 0) 666 return 1; /* directory was changed, e.g. unlink or new file */ 667 else 668 return 0; 669 670 } 671 672 static int cifs_save_resume_key(const char *current_entry, 673 struct cifsFileInfo *file_info) 674 { 675 struct cifs_dirent de; 676 int rc; 677 678 rc = cifs_fill_dirent(&de, current_entry, file_info->srch_inf.info_level, 679 file_info->srch_inf.unicode); 680 if (!rc) { 681 file_info->srch_inf.presume_name = de.name; 682 file_info->srch_inf.resume_name_len = de.namelen; 683 file_info->srch_inf.resume_key = de.resume_key; 684 } 685 return rc; 686 } 687 688 /* 689 * Find the corresponding entry in the search. Note that the SMB server returns 690 * search entries for . and .. which complicates logic here if we choose to 691 * parse for them and we do not assume that they are located in the findfirst 692 * return buffer. We start counting in the buffer with entry 2 and increment for 693 * every entry (do not increment for . or .. entry). 694 */ 695 static int 696 find_cifs_entry(const unsigned int xid, struct cifs_tcon *tcon, loff_t pos, 697 struct file *file, const char *full_path, 698 char **current_entry, int *num_to_ret) 699 { 700 __u16 search_flags; 701 int rc = 0; 702 int pos_in_buf = 0; 703 loff_t first_entry_in_buffer; 704 loff_t index_to_find = pos; 705 struct cifsFileInfo *cfile = file->private_data; 706 struct cifs_sb_info *cifs_sb = CIFS_SB(file); 707 struct TCP_Server_Info *server = tcon->ses->server; 708 /* check if index in the buffer */ 709 710 if (!server->ops->query_dir_first || !server->ops->query_dir_next) 711 return -ENOSYS; 712 713 if ((cfile == NULL) || (current_entry == NULL) || (num_to_ret == NULL)) 714 return -ENOENT; 715 716 *current_entry = NULL; 717 first_entry_in_buffer = cfile->srch_inf.index_of_last_entry - 718 cfile->srch_inf.entries_in_buffer; 719 720 /* 721 * If first entry in buf is zero then is first buffer 722 * in search response data which means it is likely . and .. 723 * will be in this buffer, although some servers do not return 724 * . and .. for the root of a drive and for those we need 725 * to start two entries earlier. 726 */ 727 728 dump_cifs_file_struct(file, "In fce "); 729 if (((index_to_find < cfile->srch_inf.index_of_last_entry) && 730 is_dir_changed(file)) || (index_to_find < first_entry_in_buffer)) { 731 /* close and restart search */ 732 cifs_dbg(FYI, "search backing up - close and restart search\n"); 733 spin_lock(&cfile->file_info_lock); 734 if (server->ops->dir_needs_close(cfile)) { 735 cfile->invalidHandle = true; 736 spin_unlock(&cfile->file_info_lock); 737 if (server->ops->close_dir) 738 server->ops->close_dir(xid, tcon, &cfile->fid); 739 } else 740 spin_unlock(&cfile->file_info_lock); 741 if (cfile->srch_inf.ntwrk_buf_start) { 742 cifs_dbg(FYI, "freeing SMB ff cache buf on search rewind\n"); 743 if (cfile->srch_inf.smallBuf) 744 cifs_small_buf_release(cfile->srch_inf. 745 ntwrk_buf_start); 746 else if (cfile->srch_inf.is_dynamic_buf) 747 kfree(cfile->srch_inf.ntwrk_buf_start); 748 else 749 cifs_buf_release(cfile->srch_inf. 750 ntwrk_buf_start); 751 /* Reset all pointers to the network buffer to prevent stale references */ 752 cfile->srch_inf.ntwrk_buf_start = NULL; 753 cfile->srch_inf.srch_entries_start = NULL; 754 cfile->srch_inf.last_entry = NULL; 755 } 756 rc = initiate_cifs_search(xid, file, full_path); 757 if (rc) { 758 cifs_dbg(FYI, "error %d reinitiating a search on rewind\n", 759 rc); 760 return rc; 761 } 762 /* FindFirst/Next set last_entry to NULL on malformed reply */ 763 if (cfile->srch_inf.last_entry) 764 cifs_save_resume_key(cfile->srch_inf.last_entry, cfile); 765 } 766 767 search_flags = CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME; 768 if (backup_cred(cifs_sb)) 769 search_flags |= CIFS_SEARCH_BACKUP_SEARCH; 770 771 while ((index_to_find >= cfile->srch_inf.index_of_last_entry) && 772 (rc == 0) && !cfile->srch_inf.endOfSearch) { 773 cifs_dbg(FYI, "calling findnext2\n"); 774 rc = server->ops->query_dir_next(xid, tcon, &cfile->fid, 775 search_flags, 776 &cfile->srch_inf); 777 if (rc) 778 return -ENOENT; 779 /* FindFirst/Next set last_entry to NULL on malformed reply */ 780 if (cfile->srch_inf.last_entry) 781 cifs_save_resume_key(cfile->srch_inf.last_entry, cfile); 782 } 783 if (index_to_find < cfile->srch_inf.index_of_last_entry) { 784 /* we found the buffer that contains the entry */ 785 /* scan and find it */ 786 int i; 787 char *cur_ent; 788 char *end_of_smb; 789 790 if (cfile->srch_inf.ntwrk_buf_start == NULL) { 791 cifs_dbg(VFS, "ntwrk_buf_start is NULL during readdir\n"); 792 return smb_EIO(smb_eio_trace_null_pointers); 793 } 794 795 end_of_smb = cfile->srch_inf.ntwrk_buf_start + 796 server->ops->calc_smb_size( 797 cfile->srch_inf.ntwrk_buf_start); 798 799 cur_ent = cfile->srch_inf.srch_entries_start; 800 first_entry_in_buffer = cfile->srch_inf.index_of_last_entry 801 - cfile->srch_inf.entries_in_buffer; 802 pos_in_buf = index_to_find - first_entry_in_buffer; 803 cifs_dbg(FYI, "found entry - pos_in_buf %d\n", pos_in_buf); 804 805 for (i = 0; (i < (pos_in_buf)) && (cur_ent != NULL); i++) { 806 /* go entry by entry figuring out which is first */ 807 cur_ent = nxt_dir_entry(cur_ent, end_of_smb, 808 cfile->srch_inf.info_level); 809 } 810 if ((cur_ent == NULL) && (i < pos_in_buf)) { 811 /* BB fixme - check if we should flag this error */ 812 cifs_dbg(VFS, "reached end of buf searching for pos in buf %d index to find %lld rc %d\n", 813 pos_in_buf, index_to_find, rc); 814 } 815 rc = 0; 816 *current_entry = cur_ent; 817 } else { 818 cifs_dbg(FYI, "index not in buffer - could not findnext into it\n"); 819 return 0; 820 } 821 822 if (pos_in_buf >= cfile->srch_inf.entries_in_buffer) { 823 cifs_dbg(FYI, "can not return entries pos_in_buf beyond last\n"); 824 *num_to_ret = 0; 825 } else 826 *num_to_ret = cfile->srch_inf.entries_in_buffer - pos_in_buf; 827 828 return rc; 829 } 830 831 static bool emit_cached_dirents(struct cached_dirents *cde, 832 struct dir_context *ctx) 833 { 834 struct cached_dirent *dirent; 835 bool rc; 836 837 list_for_each_entry(dirent, &cde->entries, entry) { 838 /* 839 * Skip all early entries prior to the current lseek() 840 * position. 841 */ 842 if (ctx->pos > dirent->pos) 843 continue; 844 /* 845 * We recorded the current ->pos value for the dirent 846 * when we stored it in the cache. 847 * However, this sequence of ->pos values may have holes 848 * in it, for example dot-dirs returned from the server 849 * are suppressed. 850 * Handle this by forcing ctx->pos to be the same as the 851 * ->pos of the current dirent we emit from the cache. 852 * This means that when we emit these entries from the cache 853 * we now emit them with the same ->pos value as in the 854 * initial scan. 855 */ 856 ctx->pos = dirent->pos; 857 rc = dir_emit(ctx, dirent->name, dirent->namelen, 858 dirent->fattr.cf_uniqueid, 859 dirent->fattr.cf_dtype); 860 if (!rc) 861 return rc; 862 ctx->pos++; 863 } 864 return true; 865 } 866 867 static void update_cached_dirents_count(struct cached_dirents *cde, 868 struct file *file) 869 { 870 if (cde->file != file) 871 return; 872 if (cde->is_valid || cde->is_failed) 873 return; 874 875 cde->pos++; 876 } 877 878 static void finished_cached_dirents_count(struct cached_dirents *cde, 879 struct dir_context *ctx, struct file *file) 880 { 881 if (cde->file != file) 882 return; 883 if (cde->is_valid || cde->is_failed) 884 return; 885 if (ctx->pos != cde->pos) 886 return; 887 888 cde->is_valid = 1; 889 } 890 891 static bool add_cached_dirent(struct cached_dirents *cde, 892 struct dir_context *ctx, const char *name, 893 int namelen, struct cifs_fattr *fattr, 894 struct file *file) 895 { 896 struct cached_dirent *de; 897 898 if (cde->file != file) 899 return false; 900 if (cde->is_valid || cde->is_failed) 901 return false; 902 if (ctx->pos != cde->pos) { 903 cde->is_failed = 1; 904 return false; 905 } 906 de = kzalloc_obj(*de, GFP_ATOMIC); 907 if (de == NULL) { 908 cde->is_failed = 1; 909 return false; 910 } 911 de->namelen = namelen; 912 de->name = kstrndup(name, namelen, GFP_ATOMIC); 913 if (de->name == NULL) { 914 kfree(de); 915 cde->is_failed = 1; 916 return false; 917 } 918 de->pos = ctx->pos; 919 920 memcpy(&de->fattr, fattr, sizeof(struct cifs_fattr)); 921 922 list_add_tail(&de->entry, &cde->entries); 923 /* update accounting */ 924 cde->entries_count++; 925 cde->bytes_used += sizeof(*de) + (size_t)namelen + 1; 926 return true; 927 } 928 929 static bool cifs_dir_emit(struct dir_context *ctx, 930 const char *name, int namelen, 931 struct cifs_fattr *fattr, 932 struct cached_fid *cfid, 933 struct file *file) 934 { 935 size_t delta_bytes = 0; 936 bool rc, added = false; 937 ino_t ino = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid); 938 939 rc = dir_emit(ctx, name, namelen, ino, fattr->cf_dtype); 940 if (!rc) 941 return rc; 942 943 if (cfid) { 944 /* Cost of this entry */ 945 delta_bytes = sizeof(struct cached_dirent) + (size_t)namelen + 1; 946 947 mutex_lock(&cfid->dirents.de_mutex); 948 added = add_cached_dirent(&cfid->dirents, ctx, name, namelen, 949 fattr, file); 950 mutex_unlock(&cfid->dirents.de_mutex); 951 952 if (added) { 953 /* per-tcon then global for consistency with free path */ 954 atomic64_add((long long)delta_bytes, &cfid->cfids->total_dirents_bytes); 955 atomic_long_inc(&cfid->cfids->total_dirents_entries); 956 atomic64_add((long long)delta_bytes, &cifs_dircache_bytes_used); 957 } 958 } 959 960 return rc; 961 } 962 963 static int cifs_filldir(char *find_entry, struct file *file, 964 struct dir_context *ctx, 965 char *scratch_buf, unsigned int max_len, 966 char *end_of_smb, struct cached_fid *cfid) 967 { 968 struct cifsFileInfo *file_info = file->private_data; 969 struct super_block *sb = file_inode(file)->i_sb; 970 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 971 struct cifs_dirent de = { NULL, }; 972 struct cifs_fattr fattr; 973 unsigned int sbflags; 974 struct qstr name; 975 int rc = 0; 976 977 rc = cifs_fill_dirent(&de, find_entry, file_info->srch_inf.info_level, 978 file_info->srch_inf.unicode); 979 if (rc) 980 return rc; 981 982 if (de.namelen > max_len) { 983 cifs_dbg(VFS, "bad search response length %zd past smb end\n", 984 de.namelen); 985 return -EINVAL; 986 } 987 988 if (de.name + de.namelen > end_of_smb) { 989 cifs_dbg(VFS, "search entry name extends past end of SMB\n"); 990 return -EINVAL; 991 } 992 993 /* skip . and .. since we added them first */ 994 if (cifs_entry_is_dot(&de, file_info->srch_inf.unicode)) 995 return 0; 996 997 if (file_info->srch_inf.unicode) { 998 struct nls_table *nlt = cifs_sb->local_nls; 999 int map_type; 1000 1001 map_type = cifs_remap(cifs_sb); 1002 name.name = scratch_buf; 1003 name.len = 1004 cifs_from_utf16((char *)name.name, (__le16 *)de.name, 1005 UNICODE_NAME_MAX, 1006 min_t(size_t, de.namelen, 1007 (size_t)max_len), nlt, map_type); 1008 name.len -= nls_nullsize(nlt); 1009 } else { 1010 name.name = de.name; 1011 name.len = de.namelen; 1012 } 1013 1014 switch (file_info->srch_inf.info_level) { 1015 case SMB_FIND_FILE_POSIX_INFO: 1016 cifs_posix_to_fattr(&fattr, 1017 (struct smb2_posix_info *)find_entry, 1018 cifs_sb); 1019 break; 1020 case SMB_FIND_FILE_UNIX: 1021 cifs_unix_basic_to_fattr(&fattr, 1022 &((FILE_UNIX_INFO *)find_entry)->basic, 1023 cifs_sb); 1024 if (S_ISLNK(fattr.cf_mode)) 1025 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL; 1026 break; 1027 case SMB_FIND_FILE_INFO_STANDARD: 1028 cifs_std_info_to_fattr(&fattr, 1029 (FIND_FILE_STANDARD_INFO *)find_entry, 1030 cifs_sb); 1031 break; 1032 case SMB_FIND_FILE_FULL_DIRECTORY_INFO: 1033 case SMB_FIND_FILE_ID_FULL_DIR_INFO: 1034 cifs_fulldir_info_to_fattr(&fattr, find_entry, cifs_sb); 1035 break; 1036 default: 1037 cifs_dir_info_to_fattr(&fattr, 1038 (FILE_DIRECTORY_INFO *)find_entry, 1039 cifs_sb); 1040 break; 1041 } 1042 1043 sbflags = cifs_sb_flags(cifs_sb); 1044 if (de.ino && (sbflags & CIFS_MOUNT_SERVER_INUM)) { 1045 fattr.cf_uniqueid = de.ino; 1046 } else { 1047 fattr.cf_uniqueid = iunique(sb, ROOT_I); 1048 cifs_autodisable_serverino(cifs_sb, "Cannot retrieve inode number from readdir", 0); 1049 } 1050 1051 if ((sbflags & CIFS_MOUNT_MF_SYMLINKS) && couldbe_mf_symlink(&fattr)) 1052 /* 1053 * trying to get the type and mode can be slow, 1054 * so just call those regular files for now, and mark 1055 * for reval 1056 */ 1057 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL; 1058 1059 cifs_prime_dcache(file_dentry(file), &name, &fattr); 1060 1061 return !cifs_dir_emit(ctx, name.name, name.len, 1062 &fattr, cfid, file); 1063 } 1064 1065 1066 int cifs_readdir(struct file *file, struct dir_context *ctx) 1067 { 1068 int rc = 0; 1069 unsigned int xid; 1070 int i; 1071 struct tcon_link *tlink = NULL; 1072 struct cifs_tcon *tcon; 1073 struct cifsFileInfo *cifsFile; 1074 char *current_entry; 1075 int num_to_fill = 0; 1076 char *tmp_buf = NULL; 1077 char *end_of_smb; 1078 unsigned int max_len; 1079 const char *full_path; 1080 void *page = alloc_dentry_path(); 1081 struct cached_fid *cfid = NULL; 1082 struct cifs_sb_info *cifs_sb = CIFS_SB(file); 1083 1084 xid = get_xid(); 1085 1086 full_path = build_path_from_dentry(file_dentry(file), page); 1087 if (IS_ERR(full_path)) { 1088 rc = PTR_ERR(full_path); 1089 goto rddir2_exit; 1090 } 1091 1092 if (file->private_data == NULL) { 1093 tlink = cifs_sb_tlink(cifs_sb); 1094 if (IS_ERR(tlink)) 1095 goto cache_not_found; 1096 tcon = tlink_tcon(tlink); 1097 } else { 1098 cifsFile = file->private_data; 1099 tcon = tlink_tcon(cifsFile->tlink); 1100 } 1101 1102 rc = open_cached_dir(xid, tcon, full_path, cifs_sb, false, &cfid); 1103 cifs_put_tlink(tlink); 1104 if (rc) 1105 goto cache_not_found; 1106 1107 mutex_lock(&cfid->dirents.de_mutex); 1108 /* 1109 * If this was reading from the start of the directory 1110 * we need to initialize scanning and storing the 1111 * directory content. 1112 */ 1113 if (ctx->pos == 0 && cfid->dirents.file == NULL) { 1114 cfid->dirents.file = file; 1115 cfid->dirents.pos = 2; 1116 } 1117 /* 1118 * If we already have the entire directory cached then 1119 * we can just serve the cache. 1120 */ 1121 if (cfid->dirents.is_valid) { 1122 if (!dir_emit_dots(file, ctx)) { 1123 mutex_unlock(&cfid->dirents.de_mutex); 1124 goto rddir2_exit; 1125 } 1126 emit_cached_dirents(&cfid->dirents, ctx); 1127 mutex_unlock(&cfid->dirents.de_mutex); 1128 goto rddir2_exit; 1129 } 1130 mutex_unlock(&cfid->dirents.de_mutex); 1131 1132 /* Drop the cache while calling initiate_cifs_search and 1133 * find_cifs_entry in case there will be reconnects during 1134 * query_directory. 1135 */ 1136 close_cached_dir(cfid); 1137 cfid = NULL; 1138 1139 cache_not_found: 1140 /* 1141 * Ensure FindFirst doesn't fail before doing filldir() for '.' and 1142 * '..'. Otherwise we won't be able to notify VFS in case of failure. 1143 */ 1144 if (file->private_data == NULL) { 1145 rc = initiate_cifs_search(xid, file, full_path); 1146 cifs_dbg(FYI, "initiate cifs search rc %d\n", rc); 1147 if (rc) 1148 goto rddir2_exit; 1149 } 1150 1151 if (!dir_emit_dots(file, ctx)) 1152 goto rddir2_exit; 1153 1154 /* 1) If search is active, 1155 is in current search buffer? 1156 if it before then restart search 1157 if after then keep searching till find it */ 1158 cifsFile = file->private_data; 1159 if (cifsFile->srch_inf.endOfSearch) { 1160 if (cifsFile->srch_inf.emptyDir) { 1161 cifs_dbg(FYI, "End of search, empty dir\n"); 1162 rc = 0; 1163 goto rddir2_exit; 1164 } 1165 } /* else { 1166 cifsFile->invalidHandle = true; 1167 tcon->ses->server->close(xid, tcon, &cifsFile->fid); 1168 } */ 1169 1170 tcon = tlink_tcon(cifsFile->tlink); 1171 rc = find_cifs_entry(xid, tcon, ctx->pos, file, full_path, 1172 ¤t_entry, &num_to_fill); 1173 open_cached_dir(xid, tcon, full_path, cifs_sb, false, &cfid); 1174 if (rc) { 1175 cifs_dbg(FYI, "fce error %d\n", rc); 1176 goto rddir2_exit; 1177 } else if (current_entry != NULL) { 1178 cifs_dbg(FYI, "entry %lld found\n", ctx->pos); 1179 } else { 1180 if (cfid) { 1181 mutex_lock(&cfid->dirents.de_mutex); 1182 finished_cached_dirents_count(&cfid->dirents, ctx, file); 1183 mutex_unlock(&cfid->dirents.de_mutex); 1184 } 1185 cifs_dbg(FYI, "Could not find entry\n"); 1186 goto rddir2_exit; 1187 } 1188 cifs_dbg(FYI, "loop through %d times filling dir for net buf %p\n", 1189 num_to_fill, cifsFile->srch_inf.ntwrk_buf_start); 1190 max_len = tcon->ses->server->ops->calc_smb_size( 1191 cifsFile->srch_inf.ntwrk_buf_start); 1192 end_of_smb = cifsFile->srch_inf.ntwrk_buf_start + max_len; 1193 1194 tmp_buf = kmalloc(UNICODE_NAME_MAX, GFP_KERNEL); 1195 if (tmp_buf == NULL) { 1196 rc = -ENOMEM; 1197 goto rddir2_exit; 1198 } 1199 1200 for (i = 0; i < num_to_fill; i++) { 1201 if (current_entry == NULL) { 1202 /* evaluate whether this case is an error */ 1203 cifs_dbg(VFS, "past SMB end, num to fill %d i %d\n", 1204 num_to_fill, i); 1205 break; 1206 } 1207 /* 1208 * if buggy server returns . and .. late do we want to 1209 * check for that here? 1210 */ 1211 *tmp_buf = 0; 1212 rc = cifs_filldir(current_entry, file, ctx, 1213 tmp_buf, max_len, end_of_smb, cfid); 1214 if (rc) { 1215 if (rc > 0) 1216 rc = 0; 1217 break; 1218 } 1219 1220 ctx->pos++; 1221 if (cfid) { 1222 mutex_lock(&cfid->dirents.de_mutex); 1223 update_cached_dirents_count(&cfid->dirents, file); 1224 mutex_unlock(&cfid->dirents.de_mutex); 1225 } 1226 1227 if (ctx->pos == 1228 cifsFile->srch_inf.index_of_last_entry) { 1229 cifs_dbg(FYI, "last entry in buf at pos %lld %s\n", 1230 ctx->pos, tmp_buf); 1231 cifs_save_resume_key(current_entry, cifsFile); 1232 break; 1233 } 1234 current_entry = 1235 nxt_dir_entry(current_entry, end_of_smb, 1236 cifsFile->srch_inf.info_level); 1237 } 1238 kfree(tmp_buf); 1239 1240 rddir2_exit: 1241 if (cfid) 1242 close_cached_dir(cfid); 1243 free_dentry_path(page); 1244 free_xid(xid); 1245 return rc; 1246 } 1247