Merge tag 'exfat-for-6.13-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/linkinjeon/exfat

+5 -24

fs/exfat/dir.c

··· 82 82 if (ei->type != TYPE_DIR) 83 83 return -EPERM; 84 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); 85 + exfat_chain_set(&dir, ei->start_clu, 86 + EXFAT_B_TO_CLU(i_size_read(inode), sbi), ei->flags); 90 87 91 88 dentries_per_clu = sbi->dentries_per_clu; 92 89 max_dentries = (unsigned int)min_t(u64, MAX_EXFAT_DENTRIES, ··· 132 135 133 136 num_ext = ep->dentry.file.num_ext; 134 137 dir_entry->attr = le16_to_cpu(ep->dentry.file.attr); 135 - exfat_get_entry_time(sbi, &dir_entry->crtime, 136 - ep->dentry.file.create_tz, 137 - ep->dentry.file.create_time, 138 - ep->dentry.file.create_date, 139 - ep->dentry.file.create_time_cs); 140 - exfat_get_entry_time(sbi, &dir_entry->mtime, 141 - ep->dentry.file.modify_tz, 142 - ep->dentry.file.modify_time, 143 - ep->dentry.file.modify_date, 144 - ep->dentry.file.modify_time_cs); 145 - exfat_get_entry_time(sbi, &dir_entry->atime, 146 - ep->dentry.file.access_tz, 147 - ep->dentry.file.access_time, 148 - ep->dentry.file.access_date, 149 - 0); 150 138 151 139 *uni_name.name = 0x0; 152 140 err = exfat_get_uniname_from_ext_entry(sb, &clu, i, ··· 148 166 ep = exfat_get_dentry(sb, &clu, i + 1, &bh); 149 167 if (!ep) 150 168 return -EIO; 151 - dir_entry->size = 152 - le64_to_cpu(ep->dentry.stream.valid_size); 153 - dir_entry->entry = dentry; 169 + dir_entry->entry = i; 170 + dir_entry->dir = clu; 154 171 brelse(bh); 155 172 156 173 ei->hint_bmap.off = EXFAT_DEN_TO_CLU(dentry, sbi); ··· 257 276 if (!nb->lfn[0]) 258 277 goto end_of_dir; 259 278 260 - i_pos = ((loff_t)ei->start_clu << 32) | (de.entry & 0xffffffff); 279 + i_pos = ((loff_t)de.dir.dir << 32) | (de.entry & 0xffffffff); 261 280 tmp = exfat_iget(sb, i_pos); 262 281 if (tmp) { 263 282 inum = tmp->i_ino;

+6

fs/exfat/exfat_fs.h

··· 204 204 #define IS_DYNAMIC_ES(es) ((es)->__bh != (es)->bh) 205 205 206 206 struct exfat_dir_entry { 207 + /* the cluster where file dentry is located */ 207 208 struct exfat_chain dir; 209 + /* the index of file dentry in ->dir */ 208 210 int entry; 209 211 unsigned int type; 210 212 unsigned int start_clu; ··· 292 290 * EXFAT file system inode in-memory data 293 291 */ 294 292 struct exfat_inode_info { 293 + /* the cluster where file dentry is located */ 295 294 struct exfat_chain dir; 295 + /* the index of file dentry in ->dir */ 296 296 int entry; 297 297 unsigned int type; 298 298 unsigned short attr; ··· 512 508 int exfat_get_dentry_set(struct exfat_entry_set_cache *es, 513 509 struct super_block *sb, struct exfat_chain *p_dir, int entry, 514 510 unsigned int num_entries); 511 + #define exfat_get_dentry_set_by_ei(es, sb, ei) \ 512 + exfat_get_dentry_set(es, sb, &(ei)->dir, (ei)->entry, ES_ALL_ENTRIES) 515 513 int exfat_get_empty_dentry_set(struct exfat_entry_set_cache *es, 516 514 struct super_block *sb, struct exfat_chain *p_dir, int entry, 517 515 unsigned int num_entries);

+10

fs/exfat/file.c

··· 584 584 if (ret < 0) 585 585 goto unlock; 586 586 587 + if (iocb->ki_flags & IOCB_DIRECT) { 588 + unsigned long align = pos | iov_iter_alignment(iter); 589 + 590 + if (!IS_ALIGNED(align, i_blocksize(inode)) && 591 + !IS_ALIGNED(align, bdev_logical_block_size(inode->i_sb->s_bdev))) { 592 + ret = -EINVAL; 593 + goto unlock; 594 + } 595 + } 596 + 587 597 if (pos > valid_size) { 588 598 ret = exfat_extend_valid_size(file, pos); 589 599 if (ret < 0 && ret != -ENOSPC) {

+1 -1

fs/exfat/inode.c

··· 43 43 exfat_set_volume_dirty(sb); 44 44 45 45 /* get the directory entry of given file or directory */ 46 - if (exfat_get_dentry_set(&es, sb, &(ei->dir), ei->entry, ES_ALL_ENTRIES)) 46 + if (exfat_get_dentry_set_by_ei(&es, sb, ei)) 47 47 return -EIO; 48 48 ep = exfat_get_dentry_cached(&es, ES_IDX_FILE); 49 49 ep2 = exfat_get_dentry_cached(&es, ES_IDX_STREAM);

+91 -103

fs/exfat/namei.c

··· 288 288 return 0; 289 289 } 290 290 291 - /* find empty directory entry. 292 - * if there isn't any empty slot, expand cluster chain. 291 + /* 292 + * Find an empty directory entry set. 293 + * 294 + * If there isn't any empty slot, expand cluster chain. 295 + * 296 + * in: 297 + * inode: inode of the parent directory 298 + * num_entries: specifies how many dentries in the empty directory entry set 299 + * 300 + * out: 301 + * p_dir: the cluster where the empty directory entry set is located 302 + * es: The found empty directory entry set 303 + * 304 + * return: 305 + * the directory entry index in p_dir is returned on succeeds 306 + * -error code is returned on failure 293 307 */ 294 308 static int exfat_find_empty_entry(struct inode *inode, 295 309 struct exfat_chain *p_dir, int num_entries, ··· 324 310 hint_femp = ei->hint_femp; 325 311 ei->hint_femp.eidx = EXFAT_HINT_NONE; 326 312 } 313 + 314 + exfat_chain_set(p_dir, ei->start_clu, 315 + EXFAT_B_TO_CLU(i_size_read(inode), sbi), ei->flags); 327 316 328 317 while ((dentry = exfat_search_empty_slot(sb, &hint_femp, p_dir, 329 318 num_entries, es)) < 0) { ··· 362 345 if (ei->start_clu == EXFAT_EOF_CLUSTER) { 363 346 ei->start_clu = clu.dir; 364 347 p_dir->dir = clu.dir; 348 + hint_femp.eidx = 0; 365 349 } 366 350 367 351 /* append to the FAT chain */ ··· 395 377 inode->i_blocks += sbi->cluster_size >> 9; 396 378 } 397 379 398 - return dentry; 380 + p_dir->dir = exfat_sector_to_cluster(sbi, es->bh[0]->b_blocknr); 381 + p_dir->size -= dentry / sbi->dentries_per_clu; 382 + 383 + return dentry & (sbi->dentries_per_clu - 1); 399 384 } 400 385 401 386 /* ··· 406 385 * Zero if it was successful; otherwise nonzero. 407 386 */ 408 387 static int __exfat_resolve_path(struct inode *inode, const unsigned char *path, 409 - struct exfat_chain *p_dir, struct exfat_uni_name *p_uniname, 410 - int lookup) 388 + struct exfat_uni_name *p_uniname, int lookup) 411 389 { 412 390 int namelen; 413 391 int lossy = NLS_NAME_NO_LOSSY; 414 392 struct super_block *sb = inode->i_sb; 415 - struct exfat_sb_info *sbi = EXFAT_SB(sb); 416 - struct exfat_inode_info *ei = EXFAT_I(inode); 417 393 int pathlen = strlen(path); 418 394 419 395 /* ··· 449 431 if ((lossy && !lookup) || !namelen) 450 432 return (lossy & NLS_NAME_OVERLEN) ? -ENAMETOOLONG : -EINVAL; 451 433 452 - exfat_chain_set(p_dir, ei->start_clu, 453 - EXFAT_B_TO_CLU(i_size_read(inode), sbi), ei->flags); 454 - 455 434 return 0; 456 435 } 457 436 458 437 static inline int exfat_resolve_path(struct inode *inode, 459 - const unsigned char *path, struct exfat_chain *dir, 460 - struct exfat_uni_name *uni) 438 + const unsigned char *path, struct exfat_uni_name *uni) 461 439 { 462 - return __exfat_resolve_path(inode, path, dir, uni, 0); 440 + return __exfat_resolve_path(inode, path, uni, 0); 463 441 } 464 442 465 443 static inline int exfat_resolve_path_for_lookup(struct inode *inode, 466 - const unsigned char *path, struct exfat_chain *dir, 467 - struct exfat_uni_name *uni) 444 + const unsigned char *path, struct exfat_uni_name *uni) 468 445 { 469 - return __exfat_resolve_path(inode, path, dir, uni, 1); 446 + return __exfat_resolve_path(inode, path, uni, 1); 470 447 } 471 448 472 449 static inline loff_t exfat_make_i_pos(struct exfat_dir_entry *info) ··· 470 457 } 471 458 472 459 static int exfat_add_entry(struct inode *inode, const char *path, 473 - struct exfat_chain *p_dir, unsigned int type, 474 - struct exfat_dir_entry *info) 460 + unsigned int type, struct exfat_dir_entry *info) 475 461 { 476 462 int ret, dentry, num_entries; 477 463 struct super_block *sb = inode->i_sb; ··· 482 470 int clu_size = 0; 483 471 unsigned int start_clu = EXFAT_FREE_CLUSTER; 484 472 485 - ret = exfat_resolve_path(inode, path, p_dir, &uniname); 473 + ret = exfat_resolve_path(inode, path, &uniname); 486 474 if (ret) 487 475 goto out; 488 476 ··· 493 481 } 494 482 495 483 /* exfat_find_empty_entry must be called before alloc_cluster() */ 496 - dentry = exfat_find_empty_entry(inode, p_dir, num_entries, &es); 484 + dentry = exfat_find_empty_entry(inode, &info->dir, num_entries, &es); 497 485 if (dentry < 0) { 498 486 ret = dentry; /* -EIO or -ENOSPC */ 499 487 goto out; ··· 520 508 if (ret) 521 509 goto out; 522 510 523 - info->dir = *p_dir; 524 511 info->entry = dentry; 525 512 info->flags = ALLOC_NO_FAT_CHAIN; 526 513 info->type = type; ··· 552 541 { 553 542 struct super_block *sb = dir->i_sb; 554 543 struct inode *inode; 555 - struct exfat_chain cdir; 556 544 struct exfat_dir_entry info; 557 545 loff_t i_pos; 558 546 int err; ··· 562 552 563 553 mutex_lock(&EXFAT_SB(sb)->s_lock); 564 554 exfat_set_volume_dirty(sb); 565 - err = exfat_add_entry(dir, dentry->d_name.name, &cdir, TYPE_FILE, 566 - &info); 555 + err = exfat_add_entry(dir, dentry->d_name.name, TYPE_FILE, &info); 567 556 if (err) 568 557 goto unlock; 569 558 ··· 610 601 return -ENOENT; 611 602 612 603 /* check the validity of directory name in the given pathname */ 613 - ret = exfat_resolve_path_for_lookup(dir, qname->name, &cdir, &uni_name); 604 + ret = exfat_resolve_path_for_lookup(dir, qname->name, &uni_name); 614 605 if (ret) 615 606 return ret; 607 + 608 + exfat_chain_set(&cdir, ei->start_clu, 609 + EXFAT_B_TO_CLU(i_size_read(dir), sbi), ei->flags); 616 610 617 611 /* check the validation of hint_stat and initialize it if required */ 618 612 if (ei->version != (inode_peek_iversion_raw(dir) & 0xffffffff)) { ··· 630 618 if (dentry < 0) 631 619 return dentry; /* -error value */ 632 620 633 - info->dir = cdir; 634 - info->entry = dentry; 635 - info->num_subdirs = 0; 636 - 637 621 /* adjust cdir to the optimized value */ 638 622 cdir.dir = hint_opt.clu; 639 623 if (cdir.flags & ALLOC_NO_FAT_CHAIN) 640 624 cdir.size -= dentry / sbi->dentries_per_clu; 641 625 dentry = hint_opt.eidx; 626 + 627 + info->dir = cdir; 628 + info->entry = dentry; 629 + info->num_subdirs = 0; 630 + 642 631 if (exfat_get_dentry_set(&es, sb, &cdir, dentry, ES_2_ENTRIES)) 643 632 return -EIO; 644 633 ep = exfat_get_dentry_cached(&es, ES_IDX_FILE); ··· 650 637 info->size = le64_to_cpu(ep2->dentry.stream.valid_size); 651 638 info->valid_size = le64_to_cpu(ep2->dentry.stream.valid_size); 652 639 info->size = le64_to_cpu(ep2->dentry.stream.size); 640 + 641 + info->start_clu = le32_to_cpu(ep2->dentry.stream.start_clu); 642 + if (!is_valid_cluster(sbi, info->start_clu) && info->size) { 643 + exfat_warn(sb, "start_clu is invalid cluster(0x%x)", 644 + info->start_clu); 645 + info->size = 0; 646 + info->valid_size = 0; 647 + } 648 + 649 + if (info->valid_size > info->size) { 650 + exfat_warn(sb, "valid_size(%lld) is greater than size(%lld)", 651 + info->valid_size, info->size); 652 + info->valid_size = info->size; 653 + } 654 + 653 655 if (info->size == 0) { 654 656 info->flags = ALLOC_NO_FAT_CHAIN; 655 657 info->start_clu = EXFAT_EOF_CLUSTER; 656 - } else { 658 + } else 657 659 info->flags = ep2->dentry.stream.flags; 658 - info->start_clu = 659 - le32_to_cpu(ep2->dentry.stream.start_clu); 660 - } 661 660 662 661 exfat_get_entry_time(sbi, &info->crtime, 663 662 ep->dentry.file.create_tz, ··· 791 766 /* remove an entry, BUT don't truncate */ 792 767 static int exfat_unlink(struct inode *dir, struct dentry *dentry) 793 768 { 794 - struct exfat_chain cdir; 795 769 struct super_block *sb = dir->i_sb; 796 770 struct inode *inode = dentry->d_inode; 797 771 struct exfat_inode_info *ei = EXFAT_I(inode); 798 772 struct exfat_entry_set_cache es; 799 - int entry, err = 0; 773 + int err = 0; 800 774 801 775 if (unlikely(exfat_forced_shutdown(sb))) 802 776 return -EIO; 803 777 804 778 mutex_lock(&EXFAT_SB(sb)->s_lock); 805 - exfat_chain_dup(&cdir, &ei->dir); 806 - entry = ei->entry; 807 779 if (ei->dir.dir == DIR_DELETED) { 808 780 exfat_err(sb, "abnormal access to deleted dentry"); 809 781 err = -ENOENT; 810 782 goto unlock; 811 783 } 812 784 813 - err = exfat_get_dentry_set(&es, sb, &cdir, entry, ES_ALL_ENTRIES); 785 + err = exfat_get_dentry_set_by_ei(&es, sb, ei); 814 786 if (err) { 815 787 err = -EIO; 816 788 goto unlock; ··· 846 824 struct super_block *sb = dir->i_sb; 847 825 struct inode *inode; 848 826 struct exfat_dir_entry info; 849 - struct exfat_chain cdir; 850 827 loff_t i_pos; 851 828 int err; 852 829 loff_t size = i_size_read(dir); ··· 855 834 856 835 mutex_lock(&EXFAT_SB(sb)->s_lock); 857 836 exfat_set_volume_dirty(sb); 858 - err = exfat_add_entry(dir, dentry->d_name.name, &cdir, TYPE_DIR, 859 - &info); 837 + err = exfat_add_entry(dir, dentry->d_name.name, TYPE_DIR, &info); 860 838 if (err) 861 839 goto unlock; 862 840 ··· 935 915 static int exfat_rmdir(struct inode *dir, struct dentry *dentry) 936 916 { 937 917 struct inode *inode = dentry->d_inode; 938 - struct exfat_chain cdir, clu_to_free; 918 + struct exfat_chain clu_to_free; 939 919 struct super_block *sb = inode->i_sb; 940 920 struct exfat_sb_info *sbi = EXFAT_SB(sb); 941 921 struct exfat_inode_info *ei = EXFAT_I(inode); 942 922 struct exfat_entry_set_cache es; 943 - int entry, err; 923 + int err; 944 924 945 925 if (unlikely(exfat_forced_shutdown(sb))) 946 926 return -EIO; 947 927 948 928 mutex_lock(&EXFAT_SB(inode->i_sb)->s_lock); 949 - 950 - exfat_chain_dup(&cdir, &ei->dir); 951 - entry = ei->entry; 952 929 953 930 if (ei->dir.dir == DIR_DELETED) { 954 931 exfat_err(sb, "abnormal access to deleted dentry"); ··· 964 947 goto unlock; 965 948 } 966 949 967 - err = exfat_get_dentry_set(&es, sb, &cdir, entry, ES_ALL_ENTRIES); 950 + err = exfat_get_dentry_set_by_ei(&es, sb, ei); 968 951 if (err) { 969 952 err = -EIO; 970 953 goto unlock; ··· 999 982 return err; 1000 983 } 1001 984 1002 - static int exfat_rename_file(struct inode *inode, struct exfat_chain *p_dir, 1003 - int oldentry, struct exfat_uni_name *p_uniname, 1004 - struct exfat_inode_info *ei) 985 + static int exfat_rename_file(struct inode *parent_inode, 986 + struct exfat_uni_name *p_uniname, struct exfat_inode_info *ei) 1005 987 { 1006 988 int ret, num_new_entries; 1007 989 struct exfat_dentry *epold, *epnew; 1008 - struct super_block *sb = inode->i_sb; 990 + struct super_block *sb = parent_inode->i_sb; 1009 991 struct exfat_entry_set_cache old_es, new_es; 1010 - int sync = IS_DIRSYNC(inode); 992 + int sync = IS_DIRSYNC(parent_inode); 1011 993 1012 994 if (unlikely(exfat_forced_shutdown(sb))) 1013 995 return -EIO; ··· 1015 999 if (num_new_entries < 0) 1016 1000 return num_new_entries; 1017 1001 1018 - ret = exfat_get_dentry_set(&old_es, sb, p_dir, oldentry, ES_ALL_ENTRIES); 1002 + ret = exfat_get_dentry_set_by_ei(&old_es, sb, ei); 1019 1003 if (ret) { 1020 1004 ret = -EIO; 1021 1005 return ret; ··· 1025 1009 1026 1010 if (old_es.num_entries < num_new_entries) { 1027 1011 int newentry; 1012 + struct exfat_chain dir; 1028 1013 1029 - newentry = exfat_find_empty_entry(inode, p_dir, num_new_entries, 1030 - &new_es); 1014 + newentry = exfat_find_empty_entry(parent_inode, &dir, 1015 + num_new_entries, &new_es); 1031 1016 if (newentry < 0) { 1032 1017 ret = newentry; /* -EIO or -ENOSPC */ 1033 1018 goto put_old_es; ··· 1051 1034 if (ret) 1052 1035 goto put_old_es; 1053 1036 1054 - exfat_remove_entries(inode, &old_es, ES_IDX_FILE); 1055 - ei->dir = *p_dir; 1037 + exfat_remove_entries(parent_inode, &old_es, ES_IDX_FILE); 1038 + ei->dir = dir; 1056 1039 ei->entry = newentry; 1057 1040 } else { 1058 1041 if (exfat_get_entry_type(epold) == TYPE_FILE) { ··· 1060 1043 ei->attr |= EXFAT_ATTR_ARCHIVE; 1061 1044 } 1062 1045 1063 - exfat_remove_entries(inode, &old_es, ES_IDX_FIRST_FILENAME + 1); 1046 + exfat_remove_entries(parent_inode, &old_es, ES_IDX_FIRST_FILENAME + 1); 1064 1047 exfat_init_ext_entry(&old_es, num_new_entries, p_uniname); 1065 1048 } 1066 1049 return exfat_put_dentry_set(&old_es, sync); ··· 1070 1053 return ret; 1071 1054 } 1072 1055 1073 - static int exfat_move_file(struct inode *inode, struct exfat_chain *p_olddir, 1074 - int oldentry, struct exfat_chain *p_newdir, 1056 + static int exfat_move_file(struct inode *parent_inode, 1075 1057 struct exfat_uni_name *p_uniname, struct exfat_inode_info *ei) 1076 1058 { 1077 1059 int ret, newentry, num_new_entries; 1078 1060 struct exfat_dentry *epmov, *epnew; 1079 - struct super_block *sb = inode->i_sb; 1080 1061 struct exfat_entry_set_cache mov_es, new_es; 1062 + struct exfat_chain newdir; 1081 1063 1082 1064 num_new_entries = exfat_calc_num_entries(p_uniname); 1083 1065 if (num_new_entries < 0) 1084 1066 return num_new_entries; 1085 1067 1086 - ret = exfat_get_dentry_set(&mov_es, sb, p_olddir, oldentry, 1087 - ES_ALL_ENTRIES); 1068 + ret = exfat_get_dentry_set_by_ei(&mov_es, parent_inode->i_sb, ei); 1088 1069 if (ret) 1089 1070 return -EIO; 1090 1071 1091 - newentry = exfat_find_empty_entry(inode, p_newdir, num_new_entries, 1092 - &new_es); 1072 + newentry = exfat_find_empty_entry(parent_inode, &newdir, 1073 + num_new_entries, &new_es); 1093 1074 if (newentry < 0) { 1094 1075 ret = newentry; /* -EIO or -ENOSPC */ 1095 1076 goto put_mov_es; ··· 1106 1091 *epnew = *epmov; 1107 1092 1108 1093 exfat_init_ext_entry(&new_es, num_new_entries, p_uniname); 1109 - exfat_remove_entries(inode, &mov_es, ES_IDX_FILE); 1094 + exfat_remove_entries(parent_inode, &mov_es, ES_IDX_FILE); 1110 1095 1111 - exfat_chain_set(&ei->dir, p_newdir->dir, p_newdir->size, 1112 - p_newdir->flags); 1113 - 1096 + ei->dir = newdir; 1114 1097 ei->entry = newentry; 1115 1098 1116 - ret = exfat_put_dentry_set(&new_es, IS_DIRSYNC(inode)); 1099 + ret = exfat_put_dentry_set(&new_es, IS_DIRSYNC(parent_inode)); 1117 1100 if (ret) 1118 1101 goto put_mov_es; 1119 1102 1120 - return exfat_put_dentry_set(&mov_es, IS_DIRSYNC(inode)); 1103 + return exfat_put_dentry_set(&mov_es, IS_DIRSYNC(parent_inode)); 1121 1104 1122 1105 put_mov_es: 1123 1106 exfat_put_dentry_set(&mov_es, false); ··· 1129 1116 struct dentry *new_dentry) 1130 1117 { 1131 1118 int ret; 1132 - int dentry; 1133 - struct exfat_chain olddir, newdir; 1134 - struct exfat_chain *p_dir = NULL; 1135 1119 struct exfat_uni_name uni_name; 1136 - struct exfat_dentry *ep; 1137 1120 struct super_block *sb = old_parent_inode->i_sb; 1138 1121 struct exfat_sb_info *sbi = EXFAT_SB(sb); 1139 1122 const unsigned char *new_path = new_dentry->d_name.name; 1140 1123 struct inode *new_inode = new_dentry->d_inode; 1141 1124 struct exfat_inode_info *new_ei = NULL; 1142 - unsigned int new_entry_type = TYPE_UNUSED; 1143 - int new_entry = 0; 1144 - struct buffer_head *new_bh = NULL; 1145 1125 1146 1126 /* check the validity of pointer parameters */ 1147 1127 if (new_path == NULL || strlen(new_path) == 0) ··· 1144 1138 exfat_err(sb, "abnormal access to deleted source dentry"); 1145 1139 return -ENOENT; 1146 1140 } 1147 - 1148 - exfat_chain_set(&olddir, EXFAT_I(old_parent_inode)->start_clu, 1149 - EXFAT_B_TO_CLU_ROUND_UP(i_size_read(old_parent_inode), sbi), 1150 - EXFAT_I(old_parent_inode)->flags); 1151 - dentry = ei->entry; 1152 1141 1153 1142 /* check whether new dir is existing directory and empty */ 1154 1143 if (new_inode) { ··· 1155 1154 goto out; 1156 1155 } 1157 1156 1158 - p_dir = &(new_ei->dir); 1159 - new_entry = new_ei->entry; 1160 - ep = exfat_get_dentry(sb, p_dir, new_entry, &new_bh); 1161 - if (!ep) 1162 - goto out; 1163 - 1164 - new_entry_type = exfat_get_entry_type(ep); 1165 - brelse(new_bh); 1166 - 1167 1157 /* if new_inode exists, update ei */ 1168 - if (new_entry_type == TYPE_DIR) { 1158 + if (S_ISDIR(new_inode->i_mode)) { 1169 1159 struct exfat_chain new_clu; 1170 1160 1171 1161 new_clu.dir = new_ei->start_clu; ··· 1172 1180 } 1173 1181 1174 1182 /* check the validity of directory name in the given new pathname */ 1175 - ret = exfat_resolve_path(new_parent_inode, new_path, &newdir, 1176 - &uni_name); 1183 + ret = exfat_resolve_path(new_parent_inode, new_path, &uni_name); 1177 1184 if (ret) 1178 1185 goto out; 1179 1186 1180 1187 exfat_set_volume_dirty(sb); 1181 1188 1182 - if (olddir.dir == newdir.dir) 1183 - ret = exfat_rename_file(new_parent_inode, &olddir, dentry, 1184 - &uni_name, ei); 1189 + if (new_parent_inode == old_parent_inode) 1190 + ret = exfat_rename_file(new_parent_inode, &uni_name, ei); 1185 1191 else 1186 - ret = exfat_move_file(new_parent_inode, &olddir, dentry, 1187 - &newdir, &uni_name, ei); 1192 + ret = exfat_move_file(new_parent_inode, &uni_name, ei); 1188 1193 1189 1194 if (!ret && new_inode) { 1190 1195 struct exfat_entry_set_cache es; 1191 1196 1192 1197 /* delete entries of new_dir */ 1193 - ret = exfat_get_dentry_set(&es, sb, p_dir, new_entry, 1194 - ES_ALL_ENTRIES); 1198 + ret = exfat_get_dentry_set_by_ei(&es, sb, new_ei); 1195 1199 if (ret) { 1196 1200 ret = -EIO; 1197 1201 goto del_out; ··· 1200 1212 goto del_out; 1201 1213 1202 1214 /* Free the clusters if new_inode is a dir(as if exfat_rmdir) */ 1203 - if (new_entry_type == TYPE_DIR && 1215 + if (S_ISDIR(new_inode->i_mode) && 1204 1216 new_ei->start_clu != EXFAT_EOF_CLUSTER) { 1205 1217 /* new_ei, new_clu_to_free */ 1206 1218 struct exfat_chain new_clu_to_free;

Configure Feed

Configure Feed