fs/exfat/dir.c

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