1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C) 2012-2013 Samsung Electronics Co., Ltd. 4 */ 5 6 #include <linux/slab.h> 7 #include <linux/bio.h> 8 #include <linux/buffer_head.h> 9 10 #include "exfat_raw.h" 11 #include "exfat_fs.h" 12 13 static int exfat_extract_uni_name(struct exfat_dentry *ep, 14 unsigned short *uniname) 15 { 16 int i, len = 0; 17 18 for (i = 0; i < EXFAT_FILE_NAME_LEN; i++) { 19 *uniname = le16_to_cpu(ep->dentry.name.unicode_0_14[i]); 20 if (*uniname == 0x0) 21 return len; 22 uniname++; 23 len++; 24 } 25 26 *uniname = 0x0; 27 return len; 28 29 } 30 31 static void exfat_get_uniname_from_ext_entry(struct super_block *sb, 32 struct exfat_chain *p_dir, int entry, unsigned short *uniname) 33 { 34 int i; 35 struct exfat_dentry *ep; 36 struct exfat_entry_set_cache *es; 37 38 es = exfat_get_dentry_set(sb, p_dir, entry, ES_ALL_ENTRIES, &ep); 39 if (!es) 40 return; 41 42 if (es->num_entries < 3) 43 goto free_es; 44 45 ep += 2; 46 47 /* 48 * First entry : file entry 49 * Second entry : stream-extension entry 50 * Third entry : first file-name entry 51 * So, the index of first file-name dentry should start from 2. 52 */ 53 for (i = 2; i < es->num_entries; i++, ep++) { 54 /* end of name entry */ 55 if (exfat_get_entry_type(ep) != TYPE_EXTEND) 56 goto free_es; 57 58 exfat_extract_uni_name(ep, uniname); 59 uniname += EXFAT_FILE_NAME_LEN; 60 } 61 62 free_es: 63 kfree(es); 64 } 65 66 /* read a directory entry from the opened directory */ 67 static int exfat_readdir(struct inode *inode, struct exfat_dir_entry *dir_entry) 68 { 69 int i, dentries_per_clu, dentries_per_clu_bits = 0; 70 unsigned int type, clu_offset; 71 sector_t sector; 72 struct exfat_chain dir, clu; 73 struct exfat_uni_name uni_name; 74 struct exfat_dentry *ep; 75 struct super_block *sb = inode->i_sb; 76 struct exfat_sb_info *sbi = EXFAT_SB(sb); 77 struct exfat_inode_info *ei = EXFAT_I(inode); 78 unsigned int dentry = ei->rwoffset & 0xFFFFFFFF; 79 struct buffer_head *bh; 80 81 /* check if the given file ID is opened */ 82 if (ei->type != TYPE_DIR) 83 return -EPERM; 84 85 if (ei->entry == -1) 86 exfat_chain_set(&dir, sbi->root_dir, 0, ALLOC_FAT_CHAIN); 87 else 88 exfat_chain_set(&dir, ei->start_clu, 89 EXFAT_B_TO_CLU(i_size_read(inode), sbi), ei->flags); 90 91 dentries_per_clu = sbi->dentries_per_clu; 92 dentries_per_clu_bits = ilog2(dentries_per_clu); 93 94 clu_offset = dentry >> dentries_per_clu_bits; 95 exfat_chain_dup(&clu, &dir); 96 97 if (clu.flags == ALLOC_NO_FAT_CHAIN) { 98 clu.dir += clu_offset; 99 clu.size -= clu_offset; 100 } else { 101 /* hint_information */ 102 if (clu_offset > 0 && ei->hint_bmap.off != EXFAT_EOF_CLUSTER && 103 ei->hint_bmap.off > 0 && clu_offset >= ei->hint_bmap.off) { 104 clu_offset -= ei->hint_bmap.off; 105 clu.dir = ei->hint_bmap.clu; 106 } 107 108 while (clu_offset > 0) { 109 if (exfat_get_next_cluster(sb, &(clu.dir))) 110 return -EIO; 111 112 clu_offset--; 113 } 114 } 115 116 while (clu.dir != EXFAT_EOF_CLUSTER) { 117 i = dentry & (dentries_per_clu - 1); 118 119 for ( ; i < dentries_per_clu; i++, dentry++) { 120 ep = exfat_get_dentry(sb, &clu, i, &bh, §or); 121 if (!ep) 122 return -EIO; 123 124 type = exfat_get_entry_type(ep); 125 if (type == TYPE_UNUSED) { 126 brelse(bh); 127 break; 128 } 129 130 if (type != TYPE_FILE && type != TYPE_DIR) { 131 brelse(bh); 132 continue; 133 } 134 135 dir_entry->attr = le16_to_cpu(ep->dentry.file.attr); 136 exfat_get_entry_time(sbi, &dir_entry->crtime, 137 ep->dentry.file.create_tz, 138 ep->dentry.file.create_time, 139 ep->dentry.file.create_date, 140 ep->dentry.file.create_time_ms); 141 exfat_get_entry_time(sbi, &dir_entry->mtime, 142 ep->dentry.file.modify_tz, 143 ep->dentry.file.modify_time, 144 ep->dentry.file.modify_date, 145 ep->dentry.file.modify_time_ms); 146 exfat_get_entry_time(sbi, &dir_entry->atime, 147 ep->dentry.file.access_tz, 148 ep->dentry.file.access_time, 149 ep->dentry.file.access_date, 150 0); 151 152 *uni_name.name = 0x0; 153 exfat_get_uniname_from_ext_entry(sb, &dir, dentry, 154 uni_name.name); 155 exfat_utf16_to_nls(sb, &uni_name, 156 dir_entry->namebuf.lfn, 157 dir_entry->namebuf.lfnbuf_len); 158 brelse(bh); 159 160 ep = exfat_get_dentry(sb, &clu, i + 1, &bh, NULL); 161 if (!ep) 162 return -EIO; 163 dir_entry->size = 164 le64_to_cpu(ep->dentry.stream.valid_size); 165 brelse(bh); 166 167 ei->hint_bmap.off = dentry >> dentries_per_clu_bits; 168 ei->hint_bmap.clu = clu.dir; 169 170 ei->rwoffset = ++dentry; 171 return 0; 172 } 173 174 if (clu.flags == ALLOC_NO_FAT_CHAIN) { 175 if (--clu.size > 0) 176 clu.dir++; 177 else 178 clu.dir = EXFAT_EOF_CLUSTER; 179 } else { 180 if (exfat_get_next_cluster(sb, &(clu.dir))) 181 return -EIO; 182 } 183 } 184 185 dir_entry->namebuf.lfn[0] = '\0'; 186 ei->rwoffset = dentry; 187 return 0; 188 } 189 190 static void exfat_init_namebuf(struct exfat_dentry_namebuf *nb) 191 { 192 nb->lfn = NULL; 193 nb->lfnbuf_len = 0; 194 } 195 196 static int exfat_alloc_namebuf(struct exfat_dentry_namebuf *nb) 197 { 198 nb->lfn = __getname(); 199 if (!nb->lfn) 200 return -ENOMEM; 201 nb->lfnbuf_len = MAX_VFSNAME_BUF_SIZE; 202 return 0; 203 } 204 205 static void exfat_free_namebuf(struct exfat_dentry_namebuf *nb) 206 { 207 if (!nb->lfn) 208 return; 209 210 __putname(nb->lfn); 211 exfat_init_namebuf(nb); 212 } 213 214 /* skip iterating emit_dots when dir is empty */ 215 #define ITER_POS_FILLED_DOTS (2) 216 static int exfat_iterate(struct file *filp, struct dir_context *ctx) 217 { 218 struct inode *inode = filp->f_path.dentry->d_inode; 219 struct super_block *sb = inode->i_sb; 220 struct inode *tmp; 221 struct exfat_dir_entry de; 222 struct exfat_dentry_namebuf *nb = &(de.namebuf); 223 struct exfat_inode_info *ei = EXFAT_I(inode); 224 unsigned long inum; 225 loff_t cpos, i_pos; 226 int err = 0, fake_offset = 0; 227 228 exfat_init_namebuf(nb); 229 mutex_lock(&EXFAT_SB(sb)->s_lock); 230 231 cpos = ctx->pos; 232 if (!dir_emit_dots(filp, ctx)) 233 goto unlock; 234 235 if (ctx->pos == ITER_POS_FILLED_DOTS) { 236 cpos = 0; 237 fake_offset = 1; 238 } 239 240 if (cpos & (DENTRY_SIZE - 1)) { 241 err = -ENOENT; 242 goto unlock; 243 } 244 245 /* name buffer should be allocated before use */ 246 err = exfat_alloc_namebuf(nb); 247 if (err) 248 goto unlock; 249 get_new: 250 ei->rwoffset = EXFAT_B_TO_DEN(cpos); 251 252 if (cpos >= i_size_read(inode)) 253 goto end_of_dir; 254 255 err = exfat_readdir(inode, &de); 256 if (err) { 257 /* 258 * At least we tried to read a sector. Move cpos to next sector 259 * position (should be aligned). 260 */ 261 if (err == -EIO) { 262 cpos += 1 << (sb->s_blocksize_bits); 263 cpos &= ~(sb->s_blocksize - 1); 264 } 265 266 err = -EIO; 267 goto end_of_dir; 268 } 269 270 cpos = EXFAT_DEN_TO_B(ei->rwoffset); 271 272 if (!nb->lfn[0]) 273 goto end_of_dir; 274 275 i_pos = ((loff_t)ei->start_clu << 32) | 276 ((ei->rwoffset - 1) & 0xffffffff); 277 tmp = exfat_iget(sb, i_pos); 278 if (tmp) { 279 inum = tmp->i_ino; 280 iput(tmp); 281 } else { 282 inum = iunique(sb, EXFAT_ROOT_INO); 283 } 284 285 /* 286 * Before calling dir_emit(), sb_lock should be released. 287 * Because page fault can occur in dir_emit() when the size 288 * of buffer given from user is larger than one page size. 289 */ 290 mutex_unlock(&EXFAT_SB(sb)->s_lock); 291 if (!dir_emit(ctx, nb->lfn, strlen(nb->lfn), inum, 292 (de.attr & ATTR_SUBDIR) ? DT_DIR : DT_REG)) 293 goto out_unlocked; 294 mutex_lock(&EXFAT_SB(sb)->s_lock); 295 ctx->pos = cpos; 296 goto get_new; 297 298 end_of_dir: 299 if (!cpos && fake_offset) 300 cpos = ITER_POS_FILLED_DOTS; 301 ctx->pos = cpos; 302 unlock: 303 mutex_unlock(&EXFAT_SB(sb)->s_lock); 304 out_unlocked: 305 /* 306 * To improve performance, free namebuf after unlock sb_lock. 307 * If namebuf is not allocated, this function do nothing 308 */ 309 exfat_free_namebuf(nb); 310 return err; 311 } 312 313 const struct file_operations exfat_dir_operations = { 314 .llseek = generic_file_llseek, 315 .read = generic_read_dir, 316 .iterate = exfat_iterate, 317 .fsync = generic_file_fsync, 318 }; 319 320 int exfat_alloc_new_dir(struct inode *inode, struct exfat_chain *clu) 321 { 322 int ret; 323 324 exfat_chain_set(clu, EXFAT_EOF_CLUSTER, 0, ALLOC_NO_FAT_CHAIN); 325 326 ret = exfat_alloc_cluster(inode, 1, clu); 327 if (ret) 328 return ret; 329 330 return exfat_zeroed_cluster(inode, clu->dir); 331 } 332 333 int exfat_calc_num_entries(struct exfat_uni_name *p_uniname) 334 { 335 int len; 336 337 len = p_uniname->name_len; 338 if (len == 0) 339 return -EINVAL; 340 341 /* 1 file entry + 1 stream entry + name entries */ 342 return ((len - 1) / EXFAT_FILE_NAME_LEN + 3); 343 } 344 345 unsigned int exfat_get_entry_type(struct exfat_dentry *ep) 346 { 347 if (ep->type == EXFAT_UNUSED) 348 return TYPE_UNUSED; 349 if (IS_EXFAT_DELETED(ep->type)) 350 return TYPE_DELETED; 351 if (ep->type == EXFAT_INVAL) 352 return TYPE_INVALID; 353 if (IS_EXFAT_CRITICAL_PRI(ep->type)) { 354 if (ep->type == EXFAT_BITMAP) 355 return TYPE_BITMAP; 356 if (ep->type == EXFAT_UPCASE) 357 return TYPE_UPCASE; 358 if (ep->type == EXFAT_VOLUME) 359 return TYPE_VOLUME; 360 if (ep->type == EXFAT_FILE) { 361 if (le16_to_cpu(ep->dentry.file.attr) & ATTR_SUBDIR) 362 return TYPE_DIR; 363 return TYPE_FILE; 364 } 365 return TYPE_CRITICAL_PRI; 366 } 367 if (IS_EXFAT_BENIGN_PRI(ep->type)) { 368 if (ep->type == EXFAT_GUID) 369 return TYPE_GUID; 370 if (ep->type == EXFAT_PADDING) 371 return TYPE_PADDING; 372 if (ep->type == EXFAT_ACLTAB) 373 return TYPE_ACLTAB; 374 return TYPE_BENIGN_PRI; 375 } 376 if (IS_EXFAT_CRITICAL_SEC(ep->type)) { 377 if (ep->type == EXFAT_STREAM) 378 return TYPE_STREAM; 379 if (ep->type == EXFAT_NAME) 380 return TYPE_EXTEND; 381 if (ep->type == EXFAT_ACL) 382 return TYPE_ACL; 383 return TYPE_CRITICAL_SEC; 384 } 385 return TYPE_BENIGN_SEC; 386 } 387 388 static void exfat_set_entry_type(struct exfat_dentry *ep, unsigned int type) 389 { 390 if (type == TYPE_UNUSED) { 391 ep->type = EXFAT_UNUSED; 392 } else if (type == TYPE_DELETED) { 393 ep->type &= EXFAT_DELETE; 394 } else if (type == TYPE_STREAM) { 395 ep->type = EXFAT_STREAM; 396 } else if (type == TYPE_EXTEND) { 397 ep->type = EXFAT_NAME; 398 } else if (type == TYPE_BITMAP) { 399 ep->type = EXFAT_BITMAP; 400 } else if (type == TYPE_UPCASE) { 401 ep->type = EXFAT_UPCASE; 402 } else if (type == TYPE_VOLUME) { 403 ep->type = EXFAT_VOLUME; 404 } else if (type == TYPE_DIR) { 405 ep->type = EXFAT_FILE; 406 ep->dentry.file.attr = cpu_to_le16(ATTR_SUBDIR); 407 } else if (type == TYPE_FILE) { 408 ep->type = EXFAT_FILE; 409 ep->dentry.file.attr = cpu_to_le16(ATTR_ARCHIVE); 410 } 411 } 412 413 static void exfat_init_stream_entry(struct exfat_dentry *ep, 414 unsigned char flags, unsigned int start_clu, 415 unsigned long long size) 416 { 417 exfat_set_entry_type(ep, TYPE_STREAM); 418 ep->dentry.stream.flags = flags; 419 ep->dentry.stream.start_clu = cpu_to_le32(start_clu); 420 ep->dentry.stream.valid_size = cpu_to_le64(size); 421 ep->dentry.stream.size = cpu_to_le64(size); 422 } 423 424 static void exfat_init_name_entry(struct exfat_dentry *ep, 425 unsigned short *uniname) 426 { 427 int i; 428 429 exfat_set_entry_type(ep, TYPE_EXTEND); 430 ep->dentry.name.flags = 0x0; 431 432 for (i = 0; i < EXFAT_FILE_NAME_LEN; i++) { 433 ep->dentry.name.unicode_0_14[i] = cpu_to_le16(*uniname); 434 if (*uniname == 0x0) 435 break; 436 uniname++; 437 } 438 } 439 440 int exfat_init_dir_entry(struct inode *inode, struct exfat_chain *p_dir, 441 int entry, unsigned int type, unsigned int start_clu, 442 unsigned long long size) 443 { 444 struct super_block *sb = inode->i_sb; 445 struct exfat_sb_info *sbi = EXFAT_SB(sb); 446 struct timespec64 ts = current_time(inode); 447 sector_t sector; 448 struct exfat_dentry *ep; 449 struct buffer_head *bh; 450 451 /* 452 * We cannot use exfat_get_dentry_set here because file ep is not 453 * initialized yet. 454 */ 455 ep = exfat_get_dentry(sb, p_dir, entry, &bh, §or); 456 if (!ep) 457 return -EIO; 458 459 exfat_set_entry_type(ep, type); 460 exfat_set_entry_time(sbi, &ts, 461 &ep->dentry.file.create_tz, 462 &ep->dentry.file.create_time, 463 &ep->dentry.file.create_date, 464 &ep->dentry.file.create_time_ms); 465 exfat_set_entry_time(sbi, &ts, 466 &ep->dentry.file.modify_tz, 467 &ep->dentry.file.modify_time, 468 &ep->dentry.file.modify_date, 469 &ep->dentry.file.modify_time_ms); 470 exfat_set_entry_time(sbi, &ts, 471 &ep->dentry.file.access_tz, 472 &ep->dentry.file.access_time, 473 &ep->dentry.file.access_date, 474 NULL); 475 476 exfat_update_bh(sb, bh, IS_DIRSYNC(inode)); 477 brelse(bh); 478 479 ep = exfat_get_dentry(sb, p_dir, entry + 1, &bh, §or); 480 if (!ep) 481 return -EIO; 482 483 exfat_init_stream_entry(ep, 484 (type == TYPE_FILE) ? ALLOC_FAT_CHAIN : ALLOC_NO_FAT_CHAIN, 485 start_clu, size); 486 exfat_update_bh(sb, bh, IS_DIRSYNC(inode)); 487 brelse(bh); 488 489 return 0; 490 } 491 492 int exfat_update_dir_chksum(struct inode *inode, struct exfat_chain *p_dir, 493 int entry) 494 { 495 struct super_block *sb = inode->i_sb; 496 int ret = 0; 497 int i, num_entries; 498 sector_t sector; 499 unsigned short chksum; 500 struct exfat_dentry *ep, *fep; 501 struct buffer_head *fbh, *bh; 502 503 fep = exfat_get_dentry(sb, p_dir, entry, &fbh, §or); 504 if (!fep) 505 return -EIO; 506 507 num_entries = fep->dentry.file.num_ext + 1; 508 chksum = exfat_calc_chksum_2byte(fep, DENTRY_SIZE, 0, CS_DIR_ENTRY); 509 510 for (i = 1; i < num_entries; i++) { 511 ep = exfat_get_dentry(sb, p_dir, entry + i, &bh, NULL); 512 if (!ep) { 513 ret = -EIO; 514 goto release_fbh; 515 } 516 chksum = exfat_calc_chksum_2byte(ep, DENTRY_SIZE, chksum, 517 CS_DEFAULT); 518 brelse(bh); 519 } 520 521 fep->dentry.file.checksum = cpu_to_le16(chksum); 522 exfat_update_bh(sb, fbh, IS_DIRSYNC(inode)); 523 release_fbh: 524 brelse(fbh); 525 return ret; 526 } 527 528 int exfat_init_ext_entry(struct inode *inode, struct exfat_chain *p_dir, 529 int entry, int num_entries, struct exfat_uni_name *p_uniname) 530 { 531 struct super_block *sb = inode->i_sb; 532 int i; 533 sector_t sector; 534 unsigned short *uniname = p_uniname->name; 535 struct exfat_dentry *ep; 536 struct buffer_head *bh; 537 int sync = IS_DIRSYNC(inode); 538 539 ep = exfat_get_dentry(sb, p_dir, entry, &bh, §or); 540 if (!ep) 541 return -EIO; 542 543 ep->dentry.file.num_ext = (unsigned char)(num_entries - 1); 544 exfat_update_bh(sb, bh, sync); 545 brelse(bh); 546 547 ep = exfat_get_dentry(sb, p_dir, entry + 1, &bh, §or); 548 if (!ep) 549 return -EIO; 550 551 ep->dentry.stream.name_len = p_uniname->name_len; 552 ep->dentry.stream.name_hash = cpu_to_le16(p_uniname->name_hash); 553 exfat_update_bh(sb, bh, sync); 554 brelse(bh); 555 556 for (i = EXFAT_FIRST_CLUSTER; i < num_entries; i++) { 557 ep = exfat_get_dentry(sb, p_dir, entry + i, &bh, §or); 558 if (!ep) 559 return -EIO; 560 561 exfat_init_name_entry(ep, uniname); 562 exfat_update_bh(sb, bh, sync); 563 brelse(bh); 564 uniname += EXFAT_FILE_NAME_LEN; 565 } 566 567 exfat_update_dir_chksum(inode, p_dir, entry); 568 return 0; 569 } 570 571 int exfat_remove_entries(struct inode *inode, struct exfat_chain *p_dir, 572 int entry, int order, int num_entries) 573 { 574 struct super_block *sb = inode->i_sb; 575 int i; 576 sector_t sector; 577 struct exfat_dentry *ep; 578 struct buffer_head *bh; 579 580 for (i = order; i < num_entries; i++) { 581 ep = exfat_get_dentry(sb, p_dir, entry + i, &bh, §or); 582 if (!ep) 583 return -EIO; 584 585 exfat_set_entry_type(ep, TYPE_DELETED); 586 exfat_update_bh(sb, bh, IS_DIRSYNC(inode)); 587 brelse(bh); 588 } 589 590 return 0; 591 } 592 593 int exfat_update_dir_chksum_with_entry_set(struct super_block *sb, 594 struct exfat_entry_set_cache *es, int sync) 595 { 596 struct exfat_sb_info *sbi = EXFAT_SB(sb); 597 struct buffer_head *bh; 598 sector_t sec = es->sector; 599 unsigned int off = es->offset; 600 int chksum_type = CS_DIR_ENTRY, i, num_entries = es->num_entries; 601 unsigned int buf_off = (off - es->offset); 602 unsigned int remaining_byte_in_sector, copy_entries, clu; 603 unsigned short chksum = 0; 604 605 for (i = 0; i < num_entries; i++) { 606 chksum = exfat_calc_chksum_2byte(&es->entries[i], DENTRY_SIZE, 607 chksum, chksum_type); 608 chksum_type = CS_DEFAULT; 609 } 610 611 es->entries[0].dentry.file.checksum = cpu_to_le16(chksum); 612 613 while (num_entries) { 614 /* write per sector base */ 615 remaining_byte_in_sector = (1 << sb->s_blocksize_bits) - off; 616 copy_entries = min_t(int, 617 EXFAT_B_TO_DEN(remaining_byte_in_sector), 618 num_entries); 619 bh = sb_bread(sb, sec); 620 if (!bh) 621 goto err_out; 622 memcpy(bh->b_data + off, 623 (unsigned char *)&es->entries[0] + buf_off, 624 EXFAT_DEN_TO_B(copy_entries)); 625 exfat_update_bh(sb, bh, sync); 626 brelse(bh); 627 num_entries -= copy_entries; 628 629 if (num_entries) { 630 /* get next sector */ 631 if (exfat_is_last_sector_in_cluster(sbi, sec)) { 632 clu = exfat_sector_to_cluster(sbi, sec); 633 if (es->alloc_flag == ALLOC_NO_FAT_CHAIN) 634 clu++; 635 else if (exfat_get_next_cluster(sb, &clu)) 636 goto err_out; 637 sec = exfat_cluster_to_sector(sbi, clu); 638 } else { 639 sec++; 640 } 641 off = 0; 642 buf_off += EXFAT_DEN_TO_B(copy_entries); 643 } 644 } 645 646 return 0; 647 err_out: 648 return -EIO; 649 } 650 651 static int exfat_walk_fat_chain(struct super_block *sb, 652 struct exfat_chain *p_dir, unsigned int byte_offset, 653 unsigned int *clu) 654 { 655 struct exfat_sb_info *sbi = EXFAT_SB(sb); 656 unsigned int clu_offset; 657 unsigned int cur_clu; 658 659 clu_offset = EXFAT_B_TO_CLU(byte_offset, sbi); 660 cur_clu = p_dir->dir; 661 662 if (p_dir->flags == ALLOC_NO_FAT_CHAIN) { 663 cur_clu += clu_offset; 664 } else { 665 while (clu_offset > 0) { 666 if (exfat_get_next_cluster(sb, &cur_clu)) 667 return -EIO; 668 if (cur_clu == EXFAT_EOF_CLUSTER) { 669 exfat_fs_error(sb, 670 "invalid dentry access beyond EOF (clu : %u, eidx : %d)", 671 p_dir->dir, 672 EXFAT_B_TO_DEN(byte_offset)); 673 return -EIO; 674 } 675 clu_offset--; 676 } 677 } 678 679 *clu = cur_clu; 680 return 0; 681 } 682 683 int exfat_find_location(struct super_block *sb, struct exfat_chain *p_dir, 684 int entry, sector_t *sector, int *offset) 685 { 686 int ret; 687 unsigned int off, clu = 0; 688 struct exfat_sb_info *sbi = EXFAT_SB(sb); 689 690 off = EXFAT_DEN_TO_B(entry); 691 692 ret = exfat_walk_fat_chain(sb, p_dir, off, &clu); 693 if (ret) 694 return ret; 695 696 /* byte offset in cluster */ 697 off = EXFAT_CLU_OFFSET(off, sbi); 698 699 /* byte offset in sector */ 700 *offset = EXFAT_BLK_OFFSET(off, sb); 701 702 /* sector offset in cluster */ 703 *sector = EXFAT_B_TO_BLK(off, sb); 704 *sector += exfat_cluster_to_sector(sbi, clu); 705 return 0; 706 } 707 708 #define EXFAT_MAX_RA_SIZE (128*1024) 709 static int exfat_dir_readahead(struct super_block *sb, sector_t sec) 710 { 711 struct exfat_sb_info *sbi = EXFAT_SB(sb); 712 struct buffer_head *bh; 713 unsigned int max_ra_count = EXFAT_MAX_RA_SIZE >> sb->s_blocksize_bits; 714 unsigned int page_ra_count = PAGE_SIZE >> sb->s_blocksize_bits; 715 unsigned int adj_ra_count = max(sbi->sect_per_clus, page_ra_count); 716 unsigned int ra_count = min(adj_ra_count, max_ra_count); 717 718 /* Read-ahead is not required */ 719 if (sbi->sect_per_clus == 1) 720 return 0; 721 722 if (sec < sbi->data_start_sector) { 723 exfat_msg(sb, KERN_ERR, 724 "requested sector is invalid(sect:%llu, root:%llu)", 725 (unsigned long long)sec, sbi->data_start_sector); 726 return -EIO; 727 } 728 729 /* Not sector aligned with ra_count, resize ra_count to page size */ 730 if ((sec - sbi->data_start_sector) & (ra_count - 1)) 731 ra_count = page_ra_count; 732 733 bh = sb_find_get_block(sb, sec); 734 if (!bh || !buffer_uptodate(bh)) { 735 unsigned int i; 736 737 for (i = 0; i < ra_count; i++) 738 sb_breadahead(sb, (sector_t)(sec + i)); 739 } 740 brelse(bh); 741 return 0; 742 } 743 744 struct exfat_dentry *exfat_get_dentry(struct super_block *sb, 745 struct exfat_chain *p_dir, int entry, struct buffer_head **bh, 746 sector_t *sector) 747 { 748 unsigned int dentries_per_page = EXFAT_B_TO_DEN(PAGE_SIZE); 749 int off; 750 sector_t sec; 751 752 if (p_dir->dir == DIR_DELETED) { 753 exfat_msg(sb, KERN_ERR, "abnormal access to deleted dentry\n"); 754 return NULL; 755 } 756 757 if (exfat_find_location(sb, p_dir, entry, &sec, &off)) 758 return NULL; 759 760 if (p_dir->dir != EXFAT_FREE_CLUSTER && 761 !(entry & (dentries_per_page - 1))) 762 exfat_dir_readahead(sb, sec); 763 764 *bh = sb_bread(sb, sec); 765 if (!*bh) 766 return NULL; 767 768 if (sector) 769 *sector = sec; 770 return (struct exfat_dentry *)((*bh)->b_data + off); 771 } 772 773 enum exfat_validate_dentry_mode { 774 ES_MODE_STARTED, 775 ES_MODE_GET_FILE_ENTRY, 776 ES_MODE_GET_STRM_ENTRY, 777 ES_MODE_GET_NAME_ENTRY, 778 ES_MODE_GET_CRITICAL_SEC_ENTRY, 779 }; 780 781 static bool exfat_validate_entry(unsigned int type, 782 enum exfat_validate_dentry_mode *mode) 783 { 784 if (type == TYPE_UNUSED || type == TYPE_DELETED) 785 return false; 786 787 switch (*mode) { 788 case ES_MODE_STARTED: 789 if (type != TYPE_FILE && type != TYPE_DIR) 790 return false; 791 *mode = ES_MODE_GET_FILE_ENTRY; 792 return true; 793 case ES_MODE_GET_FILE_ENTRY: 794 if (type != TYPE_STREAM) 795 return false; 796 *mode = ES_MODE_GET_STRM_ENTRY; 797 return true; 798 case ES_MODE_GET_STRM_ENTRY: 799 if (type != TYPE_EXTEND) 800 return false; 801 *mode = ES_MODE_GET_NAME_ENTRY; 802 return true; 803 case ES_MODE_GET_NAME_ENTRY: 804 if (type == TYPE_STREAM) 805 return false; 806 if (type != TYPE_EXTEND) { 807 if (!(type & TYPE_CRITICAL_SEC)) 808 return false; 809 *mode = ES_MODE_GET_CRITICAL_SEC_ENTRY; 810 } 811 return true; 812 case ES_MODE_GET_CRITICAL_SEC_ENTRY: 813 if (type == TYPE_EXTEND || type == TYPE_STREAM) 814 return false; 815 if ((type & TYPE_CRITICAL_SEC) != TYPE_CRITICAL_SEC) 816 return false; 817 return true; 818 default: 819 WARN_ON_ONCE(1); 820 return false; 821 } 822 } 823 824 /* 825 * Returns a set of dentries for a file or dir. 826 * 827 * Note that this is a copy (dump) of dentries so that user should 828 * call write_entry_set() to apply changes made in this entry set 829 * to the real device. 830 * 831 * in: 832 * sb+p_dir+entry: indicates a file/dir 833 * type: specifies how many dentries should be included. 834 * out: 835 * file_ep: will point the first dentry(= file dentry) on success 836 * return: 837 * pointer of entry set on success, 838 * NULL on failure. 839 */ 840 struct exfat_entry_set_cache *exfat_get_dentry_set(struct super_block *sb, 841 struct exfat_chain *p_dir, int entry, unsigned int type, 842 struct exfat_dentry **file_ep) 843 { 844 int ret; 845 unsigned int off, byte_offset, clu = 0; 846 unsigned int entry_type; 847 sector_t sec; 848 struct exfat_sb_info *sbi = EXFAT_SB(sb); 849 struct exfat_entry_set_cache *es; 850 struct exfat_dentry *ep, *pos; 851 unsigned char num_entries; 852 enum exfat_validate_dentry_mode mode = ES_MODE_STARTED; 853 struct buffer_head *bh; 854 855 if (p_dir->dir == DIR_DELETED) { 856 exfat_msg(sb, KERN_ERR, "access to deleted dentry\n"); 857 return NULL; 858 } 859 860 byte_offset = EXFAT_DEN_TO_B(entry); 861 ret = exfat_walk_fat_chain(sb, p_dir, byte_offset, &clu); 862 if (ret) 863 return NULL; 864 865 /* byte offset in cluster */ 866 byte_offset = EXFAT_CLU_OFFSET(byte_offset, sbi); 867 868 /* byte offset in sector */ 869 off = EXFAT_BLK_OFFSET(byte_offset, sb); 870 871 /* sector offset in cluster */ 872 sec = EXFAT_B_TO_BLK(byte_offset, sb); 873 sec += exfat_cluster_to_sector(sbi, clu); 874 875 bh = sb_bread(sb, sec); 876 if (!bh) 877 return NULL; 878 879 ep = (struct exfat_dentry *)(bh->b_data + off); 880 entry_type = exfat_get_entry_type(ep); 881 882 if (entry_type != TYPE_FILE && entry_type != TYPE_DIR) 883 goto release_bh; 884 885 num_entries = type == ES_ALL_ENTRIES ? 886 ep->dentry.file.num_ext + 1 : type; 887 es = kmalloc(struct_size(es, entries, num_entries), GFP_KERNEL); 888 if (!es) 889 goto release_bh; 890 891 es->num_entries = num_entries; 892 es->sector = sec; 893 es->offset = off; 894 es->alloc_flag = p_dir->flags; 895 896 pos = &es->entries[0]; 897 898 while (num_entries) { 899 if (!exfat_validate_entry(exfat_get_entry_type(ep), &mode)) 900 goto free_es; 901 902 /* copy dentry */ 903 memcpy(pos, ep, sizeof(struct exfat_dentry)); 904 905 if (--num_entries == 0) 906 break; 907 908 if (((off + DENTRY_SIZE) & (sb->s_blocksize - 1)) < 909 (off & (sb->s_blocksize - 1))) { 910 /* get the next sector */ 911 if (exfat_is_last_sector_in_cluster(sbi, sec)) { 912 if (es->alloc_flag == ALLOC_NO_FAT_CHAIN) 913 clu++; 914 else if (exfat_get_next_cluster(sb, &clu)) 915 goto free_es; 916 sec = exfat_cluster_to_sector(sbi, clu); 917 } else { 918 sec++; 919 } 920 921 brelse(bh); 922 bh = sb_bread(sb, sec); 923 if (!bh) 924 goto free_es; 925 off = 0; 926 ep = (struct exfat_dentry *)bh->b_data; 927 } else { 928 ep++; 929 off += DENTRY_SIZE; 930 } 931 pos++; 932 } 933 934 if (file_ep) 935 *file_ep = &es->entries[0]; 936 brelse(bh); 937 return es; 938 939 free_es: 940 kfree(es); 941 release_bh: 942 brelse(bh); 943 return NULL; 944 } 945 946 enum { 947 DIRENT_STEP_FILE, 948 DIRENT_STEP_STRM, 949 DIRENT_STEP_NAME, 950 DIRENT_STEP_SECD, 951 }; 952 953 /* 954 * return values: 955 * >= 0 : return dir entiry position with the name in dir 956 * -EEXIST : (root dir, ".") it is the root dir itself 957 * -ENOENT : entry with the name does not exist 958 * -EIO : I/O error 959 */ 960 int exfat_find_dir_entry(struct super_block *sb, struct exfat_inode_info *ei, 961 struct exfat_chain *p_dir, struct exfat_uni_name *p_uniname, 962 int num_entries, unsigned int type) 963 { 964 int i, rewind = 0, dentry = 0, end_eidx = 0, num_ext = 0, len; 965 int order, step, name_len = 0; 966 int dentries_per_clu, num_empty = 0; 967 unsigned int entry_type; 968 unsigned short *uniname = NULL; 969 struct exfat_chain clu; 970 struct exfat_hint *hint_stat = &ei->hint_stat; 971 struct exfat_hint_femp candi_empty; 972 struct exfat_sb_info *sbi = EXFAT_SB(sb); 973 974 dentries_per_clu = sbi->dentries_per_clu; 975 976 exfat_chain_dup(&clu, p_dir); 977 978 if (hint_stat->eidx) { 979 clu.dir = hint_stat->clu; 980 dentry = hint_stat->eidx; 981 end_eidx = dentry; 982 } 983 984 candi_empty.eidx = EXFAT_HINT_NONE; 985 rewind: 986 order = 0; 987 step = DIRENT_STEP_FILE; 988 while (clu.dir != EXFAT_EOF_CLUSTER) { 989 i = dentry & (dentries_per_clu - 1); 990 for (; i < dentries_per_clu; i++, dentry++) { 991 struct exfat_dentry *ep; 992 struct buffer_head *bh; 993 994 if (rewind && dentry == end_eidx) 995 goto not_found; 996 997 ep = exfat_get_dentry(sb, &clu, i, &bh, NULL); 998 if (!ep) 999 return -EIO; 1000 1001 entry_type = exfat_get_entry_type(ep); 1002 1003 if (entry_type == TYPE_UNUSED || 1004 entry_type == TYPE_DELETED) { 1005 step = DIRENT_STEP_FILE; 1006 1007 num_empty++; 1008 if (candi_empty.eidx == EXFAT_HINT_NONE && 1009 num_empty == 1) { 1010 exfat_chain_set(&candi_empty.cur, 1011 clu.dir, clu.size, clu.flags); 1012 } 1013 1014 if (candi_empty.eidx == EXFAT_HINT_NONE && 1015 num_empty >= num_entries) { 1016 candi_empty.eidx = 1017 dentry - (num_empty - 1); 1018 WARN_ON(candi_empty.eidx < 0); 1019 candi_empty.count = num_empty; 1020 1021 if (ei->hint_femp.eidx == 1022 EXFAT_HINT_NONE || 1023 candi_empty.eidx <= 1024 ei->hint_femp.eidx) { 1025 memcpy(&ei->hint_femp, 1026 &candi_empty, 1027 sizeof(candi_empty)); 1028 } 1029 } 1030 1031 brelse(bh); 1032 if (entry_type == TYPE_UNUSED) 1033 goto not_found; 1034 continue; 1035 } 1036 1037 num_empty = 0; 1038 candi_empty.eidx = EXFAT_HINT_NONE; 1039 1040 if (entry_type == TYPE_FILE || entry_type == TYPE_DIR) { 1041 step = DIRENT_STEP_FILE; 1042 if (type == TYPE_ALL || type == entry_type) { 1043 num_ext = ep->dentry.file.num_ext; 1044 step = DIRENT_STEP_STRM; 1045 } 1046 brelse(bh); 1047 continue; 1048 } 1049 1050 if (entry_type == TYPE_STREAM) { 1051 unsigned short name_hash; 1052 1053 if (step != DIRENT_STEP_STRM) { 1054 step = DIRENT_STEP_FILE; 1055 brelse(bh); 1056 continue; 1057 } 1058 step = DIRENT_STEP_FILE; 1059 name_hash = le16_to_cpu( 1060 ep->dentry.stream.name_hash); 1061 if (p_uniname->name_hash == name_hash && 1062 p_uniname->name_len == 1063 ep->dentry.stream.name_len) { 1064 step = DIRENT_STEP_NAME; 1065 order = 1; 1066 name_len = 0; 1067 } 1068 brelse(bh); 1069 continue; 1070 } 1071 1072 brelse(bh); 1073 if (entry_type == TYPE_EXTEND) { 1074 unsigned short entry_uniname[16], unichar; 1075 1076 if (step != DIRENT_STEP_NAME) { 1077 step = DIRENT_STEP_FILE; 1078 continue; 1079 } 1080 1081 if (++order == 2) 1082 uniname = p_uniname->name; 1083 else 1084 uniname += EXFAT_FILE_NAME_LEN; 1085 1086 len = exfat_extract_uni_name(ep, entry_uniname); 1087 name_len += len; 1088 1089 unichar = *(uniname+len); 1090 *(uniname+len) = 0x0; 1091 1092 if (exfat_uniname_ncmp(sb, uniname, 1093 entry_uniname, len)) { 1094 step = DIRENT_STEP_FILE; 1095 } else if (p_uniname->name_len == name_len) { 1096 if (order == num_ext) 1097 goto found; 1098 step = DIRENT_STEP_SECD; 1099 } 1100 1101 *(uniname+len) = unichar; 1102 continue; 1103 } 1104 1105 if (entry_type & 1106 (TYPE_CRITICAL_SEC | TYPE_BENIGN_SEC)) { 1107 if (step == DIRENT_STEP_SECD) { 1108 if (++order == num_ext) 1109 goto found; 1110 continue; 1111 } 1112 } 1113 step = DIRENT_STEP_FILE; 1114 } 1115 1116 if (clu.flags == ALLOC_NO_FAT_CHAIN) { 1117 if (--clu.size > 0) 1118 clu.dir++; 1119 else 1120 clu.dir = EXFAT_EOF_CLUSTER; 1121 } else { 1122 if (exfat_get_next_cluster(sb, &clu.dir)) 1123 return -EIO; 1124 } 1125 } 1126 1127 not_found: 1128 /* 1129 * We started at not 0 index,so we should try to find target 1130 * from 0 index to the index we started at. 1131 */ 1132 if (!rewind && end_eidx) { 1133 rewind = 1; 1134 dentry = 0; 1135 clu.dir = p_dir->dir; 1136 /* reset empty hint */ 1137 num_empty = 0; 1138 candi_empty.eidx = EXFAT_HINT_NONE; 1139 goto rewind; 1140 } 1141 1142 /* initialized hint_stat */ 1143 hint_stat->clu = p_dir->dir; 1144 hint_stat->eidx = 0; 1145 return -ENOENT; 1146 1147 found: 1148 /* next dentry we'll find is out of this cluster */ 1149 if (!((dentry + 1) & (dentries_per_clu - 1))) { 1150 int ret = 0; 1151 1152 if (clu.flags == ALLOC_NO_FAT_CHAIN) { 1153 if (--clu.size > 0) 1154 clu.dir++; 1155 else 1156 clu.dir = EXFAT_EOF_CLUSTER; 1157 } else { 1158 ret = exfat_get_next_cluster(sb, &clu.dir); 1159 } 1160 1161 if (ret || clu.dir != EXFAT_EOF_CLUSTER) { 1162 /* just initialized hint_stat */ 1163 hint_stat->clu = p_dir->dir; 1164 hint_stat->eidx = 0; 1165 return (dentry - num_ext); 1166 } 1167 } 1168 1169 hint_stat->clu = clu.dir; 1170 hint_stat->eidx = dentry + 1; 1171 return dentry - num_ext; 1172 } 1173 1174 int exfat_count_ext_entries(struct super_block *sb, struct exfat_chain *p_dir, 1175 int entry, struct exfat_dentry *ep) 1176 { 1177 int i, count = 0; 1178 unsigned int type; 1179 struct exfat_dentry *ext_ep; 1180 struct buffer_head *bh; 1181 1182 for (i = 0, entry++; i < ep->dentry.file.num_ext; i++, entry++) { 1183 ext_ep = exfat_get_dentry(sb, p_dir, entry, &bh, NULL); 1184 if (!ext_ep) 1185 return -EIO; 1186 1187 type = exfat_get_entry_type(ext_ep); 1188 brelse(bh); 1189 if (type == TYPE_EXTEND || type == TYPE_STREAM) 1190 count++; 1191 else 1192 break; 1193 } 1194 return count; 1195 } 1196 1197 int exfat_count_dir_entries(struct super_block *sb, struct exfat_chain *p_dir) 1198 { 1199 int i, count = 0; 1200 int dentries_per_clu; 1201 unsigned int entry_type; 1202 struct exfat_chain clu; 1203 struct exfat_dentry *ep; 1204 struct exfat_sb_info *sbi = EXFAT_SB(sb); 1205 struct buffer_head *bh; 1206 1207 dentries_per_clu = sbi->dentries_per_clu; 1208 1209 exfat_chain_dup(&clu, p_dir); 1210 1211 while (clu.dir != EXFAT_EOF_CLUSTER) { 1212 for (i = 0; i < dentries_per_clu; i++) { 1213 ep = exfat_get_dentry(sb, &clu, i, &bh, NULL); 1214 if (!ep) 1215 return -EIO; 1216 entry_type = exfat_get_entry_type(ep); 1217 brelse(bh); 1218 1219 if (entry_type == TYPE_UNUSED) 1220 return count; 1221 if (entry_type != TYPE_DIR) 1222 continue; 1223 count++; 1224 } 1225 1226 if (clu.flags == ALLOC_NO_FAT_CHAIN) { 1227 if (--clu.size > 0) 1228 clu.dir++; 1229 else 1230 clu.dir = EXFAT_EOF_CLUSTER; 1231 } else { 1232 if (exfat_get_next_cluster(sb, &(clu.dir))) 1233 return -EIO; 1234 } 1235 } 1236 1237 return count; 1238 } 1239