fsck/fsck.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *   Copyright (C) 2019 Namjae Jeon <linkinjeon@kernel.org>
   4  *   Copyright (C) 2020 Hyunchul Lee <hyc.lee@gmail.com>
   5  */
   6
   7 #include <unistd.h>
   8 #include <stdlib.h>
   9 #include <stdio.h>
  10 #include <getopt.h>
  11 #include <inttypes.h>
  12 #include <string.h>
  13 #include <errno.h>
  14 #include <locale.h>
  15
  16 #include "exfat_ondisk.h"
  17 #include "libexfat.h"
  18 #include "repair.h"
  19 #include "exfat_fs.h"
  20 #include "exfat_dir.h"
  21 #include "fsck.h"
  22
  23 struct fsck_user_input {
  24         struct exfat_user_input         ei;
  25         enum fsck_ui_options            options;
  26 };
  27
  28 #define EXFAT_MAX_UPCASE_CHARS  0x10000
  29
  30 #define FSCK_EXIT_NO_ERRORS             0x00
  31 #define FSCK_EXIT_CORRECTED             0x01
  32 #define FSCK_EXIT_NEED_REBOOT           0x02
  33 #define FSCK_EXIT_ERRORS_LEFT           0x04
  34 #define FSCK_EXIT_OPERATION_ERROR       0x08
  35 #define FSCK_EXIT_SYNTAX_ERROR          0x10
  36 #define FSCK_EXIT_USER_CANCEL           0x20
  37 #define FSCK_EXIT_LIBRARY_ERROR         0x80
  38
  39 struct exfat_stat {
  40         long            dir_count;
  41         long            file_count;
  42         long            error_count;
  43         long            fixed_count;
  44 };
  45
  46 struct exfat_fsck exfat_fsck;
  47 struct exfat_stat exfat_stat;
  48 struct path_resolve_ctx path_resolve_ctx;
  49
  50 static struct option opts[] = {
  51         {"repair",      no_argument,    NULL,   'r' },
  52         {"repair-yes",  no_argument,    NULL,   'y' },
  53         {"repair-no",   no_argument,    NULL,   'n' },
  54         {"repair-auto", no_argument,    NULL,   'p' },
  55         {"rescue",      no_argument,    NULL,   's' },
  56         {"version",     no_argument,    NULL,   'V' },
  57         {"verbose",     no_argument,    NULL,   'v' },
  58         {"help",        no_argument,    NULL,   'h' },
  59         {"?",           no_argument,    NULL,   '?' },
  60         {"ignore-bad-fs",       no_argument,    NULL,   'b' },
  61         {NULL,          0,              NULL,    0  }
  62 };
  63
  64 static void usage(char *name)
  65 {
  66         fprintf(stderr, "Usage: %s\n", name);
  67         fprintf(stderr, "\t-r | --repair        Repair interactively\n");
  68         fprintf(stderr, "\t-y | --repair-yes    Repair without ask\n");
  69         fprintf(stderr, "\t-n | --repair-no     No repair\n");
  70         fprintf(stderr, "\t-p | --repair-auto   Repair automatically\n");
  71         fprintf(stderr, "\t-a                   Repair automatically\n");
  72         fprintf(stderr, "\t-b | --ignore-bad-fs Try to recover even if exfat is not found\n");
  73         fprintf(stderr, "\t-s | --rescue        Assign orphaned clusters to files\n");
  74         fprintf(stderr, "\t-V | --version       Show version\n");
  75         fprintf(stderr, "\t-v | --verbose       Print debug\n");
  76         fprintf(stderr, "\t-h | --help          Show help\n");
  77
  78         exit(FSCK_EXIT_SYNTAX_ERROR);
  79 }
  80
  81 #define fsck_err(parent, inode, fmt, ...)               \
  82 ({                                                      \
  83                 exfat_resolve_path_parent(&path_resolve_ctx,    \
  84                         parent, inode);                 \
  85                 exfat_err("ERROR: %s: " fmt,            \
  86                         path_resolve_ctx.local_path,    \
  87                         ##__VA_ARGS__);                 \
  88 })
  89
  90 #define repair_file_ask(iter, inode, code, fmt, ...)    \
  91 ({                                                      \
  92                 if (inode)                                              \
  93                         exfat_resolve_path_parent(&path_resolve_ctx,    \
  94                                             (iter)->parent, inode);     \
  95                 else                                                    \
  96                         exfat_resolve_path(&path_resolve_ctx,           \
  97                                      (iter)->parent);                   \
  98                 exfat_repair_ask(&exfat_fsck, code,                     \
  99                                  "ERROR: %s: " fmt " at %#" PRIx64,     \
 100                                  path_resolve_ctx.local_path,           \
 101                                  ##__VA_ARGS__,                         \
 102                                  exfat_de_iter_device_offset(iter));    \
 103 })
 104
 105 static int check_clus_chain(struct exfat_de_iter *de_iter,
 106                             struct exfat_inode *node)
 107 {
 108         struct exfat *exfat = de_iter->exfat;
 109         struct exfat_dentry *stream_de;
 110         clus_t clus, prev, next;
 111         uint64_t count, max_count;
 112
 113         clus = node->first_clus;
 114         prev = EXFAT_EOF_CLUSTER;
 115         count = 0;
 116         max_count = DIV_ROUND_UP(node->size, exfat->clus_size);
 117
 118         if (node->size == 0 && node->first_clus == EXFAT_FREE_CLUSTER)
 119                 return 0;
 120
 121         /* the first cluster is wrong */
 122         if ((node->size == 0 && node->first_clus != EXFAT_FREE_CLUSTER) ||
 123             (node->size > 0 && !exfat_heap_clus(exfat, node->first_clus))) {
 124                 if (repair_file_ask(de_iter, node,
 125                                     ER_FILE_FIRST_CLUS,
 126                                     "size %#" PRIx64 ", but the first cluster %#x",
 127                                     node->size, node->first_clus))
 128                         goto truncate_file;
 129                 else
 130                         return -EINVAL;
 131         }
 132
 133         while (clus != EXFAT_EOF_CLUSTER) {
 134                 if (count >= max_count) {
 135                         if (node->is_contiguous)
 136                                 break;
 137                         if (repair_file_ask(de_iter, node,
 138                                             ER_FILE_SMALLER_SIZE,
 139                                             "more clusters are allocated. truncate to %"
 140                                             PRIu64 " bytes",
 141                                             count * exfat->clus_size))
 142                                 goto truncate_file;
 143                         else
 144                                 return -EINVAL;
 145                 }
 146
 147                 /*
 148                  * This cluster is already allocated. it may be shared with
 149                  * the other file, or there is a loop in cluster chain.
 150                  */
 151                 if (exfat_bitmap_get(exfat->alloc_bitmap, clus)) {
 152                         if (repair_file_ask(de_iter, node,
 153                                             ER_FILE_DUPLICATED_CLUS,
 154                                             "cluster is already allocated for the other file. truncated to %"
 155                                             PRIu64 " bytes",
 156                                             count * exfat->clus_size))
 157                                 goto truncate_file;
 158                         else
 159                                 return -EINVAL;
 160                 }
 161
 162                 if (!exfat_bitmap_get(exfat->disk_bitmap, clus)) {
 163                         if (!repair_file_ask(de_iter, node,
 164                                              ER_FILE_INVALID_CLUS,
 165                                              "cluster %#x is marked as free",
 166                                              clus))
 167                                 return -EINVAL;
 168                 }
 169
 170                 /* This cluster is allocated or not */
 171                 if (exfat_get_inode_next_clus(exfat, node, clus, &next))
 172                         goto truncate_file;
 173                 if (next == EXFAT_BAD_CLUSTER) {
 174                         if (repair_file_ask(de_iter, node,
 175                                             ER_FILE_INVALID_CLUS,
 176                                             "BAD cluster. truncate to %"
 177                                             PRIu64 " bytes",
 178                                             count * exfat->clus_size))
 179                                 goto truncate_file;
 180                         else
 181                                 return -EINVAL;
 182                 } else if (!node->is_contiguous) {
 183                         if (next != EXFAT_EOF_CLUSTER &&
 184                             !exfat_heap_clus(exfat, next)) {
 185                                 if (repair_file_ask(de_iter, node,
 186                                                     ER_FILE_INVALID_CLUS,
 187                                                     "broken cluster chain. truncate to %"
 188                                                     PRIu64 " bytes",
 189                                                     (count + 1) * exfat->clus_size)) {
 190                                         count++;
 191                                         prev = clus;
 192                                         exfat_bitmap_set(exfat->alloc_bitmap,
 193                                                          clus);
 194                                         goto truncate_file;
 195                                 } else {
 196                                         return -EINVAL;
 197                                 }
 198                         }
 199                 }
 200
 201                 count++;
 202                 exfat_bitmap_set(exfat->alloc_bitmap, clus);
 203                 prev = clus;
 204                 clus = next;
 205         }
 206
 207         if (count < max_count) {
 208                 if (repair_file_ask(de_iter, node, ER_FILE_LARGER_SIZE,
 209                                     "less clusters are allocated. truncates to %"
 210                                     PRIu64 " bytes",
 211                                     count * exfat->clus_size))
 212                         goto truncate_file;
 213                 else
 214                         return -EINVAL;
 215         }
 216
 217         return 0;
 218 truncate_file:
 219         node->size = count * exfat->clus_size;
 220         if (!exfat_heap_clus(exfat, prev))
 221                 node->first_clus = EXFAT_FREE_CLUSTER;
 222
 223         exfat_de_iter_get_dirty(de_iter, 1, &stream_de);
 224         if (count * exfat->clus_size <
 225             le64_to_cpu(stream_de->stream_valid_size))
 226                 stream_de->stream_valid_size = cpu_to_le64(
 227                                                            count * exfat->clus_size);
 228         if (!exfat_heap_clus(exfat, prev))
 229                 stream_de->stream_start_clu = EXFAT_FREE_CLUSTER;
 230         stream_de->stream_size = cpu_to_le64(
 231                                              count * exfat->clus_size);
 232
 233         /* remaining clusters will be freed while FAT is compared with
 234          * alloc_bitmap.
 235          */
 236         if (!node->is_contiguous && exfat_heap_clus(exfat, prev)) {
 237                 if (exfat_set_fat(exfat, prev, EXFAT_EOF_CLUSTER))
 238                         return -EIO;
 239         }
 240         return 1;
 241 }
 242
 243 static int root_check_clus_chain(struct exfat *exfat,
 244                                  struct exfat_inode *node,
 245                                  clus_t *clus_count)
 246 {
 247         clus_t clus, next, prev = EXFAT_EOF_CLUSTER;
 248
 249         if (!exfat_heap_clus(exfat, node->first_clus))
 250                 goto out_trunc;
 251
 252         clus = node->first_clus;
 253         *clus_count = 0;
 254
 255         do {
 256                 if (exfat_bitmap_get(exfat->alloc_bitmap, clus)) {
 257                         if (exfat_repair_ask(&exfat_fsck,
 258                                              ER_FILE_DUPLICATED_CLUS,
 259                                              "ERROR: the cluster chain of root is cyclic"))
 260                                 goto out_trunc;
 261                         return -EINVAL;
 262                 }
 263
 264                 exfat_bitmap_set(exfat->alloc_bitmap, clus);
 265
 266                 if (exfat_get_inode_next_clus(exfat, node, clus, &next)) {
 267                         exfat_err("ERROR: failed to read the fat entry of root");
 268                         goto out_trunc;
 269                 }
 270
 271                 if (next != EXFAT_EOF_CLUSTER && !exfat_heap_clus(exfat, next)) {
 272                         if (exfat_repair_ask(&exfat_fsck,
 273                                              ER_FILE_INVALID_CLUS,
 274                                              "ERROR: the cluster chain of root is broken")) {
 275                                 if (next != EXFAT_BAD_CLUSTER) {
 276                                         prev = clus;
 277                                         (*clus_count)++;
 278                                 }
 279                                 goto out_trunc;
 280                         }
 281                         return -EINVAL;
 282                 }
 283
 284                 prev = clus;
 285                 clus = next;
 286                 (*clus_count)++;
 287         } while (clus != EXFAT_EOF_CLUSTER);
 288
 289         return 0;
 290 out_trunc:
 291         if (!exfat_heap_clus(exfat, prev)) {
 292                 exfat_err("ERROR: the start cluster of root is wrong\n");
 293                 return -EINVAL;
 294         }
 295         node->size = *clus_count * exfat->clus_size;
 296         return exfat_set_fat(exfat, prev, EXFAT_EOF_CLUSTER);
 297 }
 298
 299 static int boot_region_checksum(int dev_fd,
 300                                 int bs_offset, unsigned int sect_size)
 301 {
 302         void *sect;
 303         unsigned int i;
 304         uint32_t checksum;
 305         int ret = 0;
 306
 307         sect = malloc(sect_size);
 308         if (!sect)
 309                 return -ENOMEM;
 310
 311         checksum = 0;
 312         for (i = 0; i < 11; i++) {
 313                 if (exfat_read(dev_fd, sect, sect_size,
 314                                 bs_offset * sect_size + i * sect_size) !=
 315                                 (ssize_t)sect_size) {
 316                         exfat_err("failed to read boot region\n");
 317                         ret = -EIO;
 318                         goto out;
 319                 }
 320                 boot_calc_checksum(sect, sect_size, i == 0, &checksum);
 321         }
 322
 323         if (exfat_read(dev_fd, sect, sect_size,
 324                         bs_offset * sect_size + 11 * sect_size) !=
 325                         (ssize_t)sect_size) {
 326                 exfat_err("failed to read a boot checksum sector\n");
 327                 ret = -EIO;
 328                 goto out;
 329         }
 330
 331         for (i = 0; i < sect_size/sizeof(checksum); i++) {
 332                 if (le32_to_cpu(((__le32 *)sect)[i]) != checksum) {
 333                         exfat_err("checksum of boot region is not correct. %#x, but expected %#x\n",
 334                                 le32_to_cpu(((__le32 *)sect)[i]), checksum);
 335                         ret = -EINVAL;
 336                         goto out;
 337                 }
 338         }
 339 out:
 340         free(sect);
 341         return ret;
 342 }
 343
 344 static int exfat_mark_volume_dirty(struct exfat *exfat, bool dirty)
 345 {
 346         uint16_t flags;
 347
 348         flags = le16_to_cpu(exfat->bs->bsx.vol_flags);
 349         if (dirty)
 350                 flags |= 0x02;
 351         else
 352                 flags &= ~0x02;
 353
 354         exfat->bs->bsx.vol_flags = cpu_to_le16(flags);
 355         if (exfat_write(exfat->blk_dev->dev_fd, exfat->bs,
 356                         sizeof(struct pbr), 0) != (ssize_t)sizeof(struct pbr)) {
 357                 exfat_err("failed to set VolumeDirty\n");
 358                 return -EIO;
 359         }
 360
 361         if (fsync(exfat->blk_dev->dev_fd) != 0) {
 362                 exfat_err("failed to set VolumeDirty\n");
 363                 return -EIO;
 364         }
 365         return 0;
 366 }
 367
 368 static int read_boot_region(struct exfat_blk_dev *bd, struct pbr **pbr,
 369                             int bs_offset, unsigned int sect_size,
 370                             bool verbose)
 371 {
 372         struct pbr *bs;
 373         int ret = -EINVAL;
 374
 375         *pbr = NULL;
 376         bs = (struct pbr *)malloc(sizeof(struct pbr));
 377         if (!bs) {
 378                 exfat_err("failed to allocate memory\n");
 379                 return -ENOMEM;
 380         }
 381
 382         if (exfat_read(bd->dev_fd, bs, sizeof(*bs),
 383                         bs_offset * sect_size) != (ssize_t)sizeof(*bs)) {
 384                 exfat_err("failed to read a boot sector\n");
 385                 ret = -EIO;
 386                 goto err;
 387         }
 388
 389         if (memcmp(bs->bpb.oem_name, "EXFAT   ", 8) != 0) {
 390                 if (verbose)
 391                         exfat_err("failed to find exfat file system\n");
 392                 goto err;
 393         }
 394
 395         ret = boot_region_checksum(bd->dev_fd, bs_offset, sect_size);
 396         if (ret < 0)
 397                 goto err;
 398
 399         ret = -EINVAL;
 400         if (EXFAT_SECTOR_SIZE(bs) < 512 || EXFAT_SECTOR_SIZE(bs) > 4 * KB) {
 401                 if (verbose)
 402                         exfat_err("too small or big sector size: %d\n",
 403                                   EXFAT_SECTOR_SIZE(bs));
 404                 goto err;
 405         }
 406
 407         if (EXFAT_CLUSTER_SIZE(bs) > 32 * MB) {
 408                 if (verbose)
 409                         exfat_err("too big cluster size: %d\n",
 410                                   EXFAT_CLUSTER_SIZE(bs));
 411                 goto err;
 412         }
 413
 414         if (bs->bsx.fs_version[1] != 1 || bs->bsx.fs_version[0] != 0) {
 415                 if (verbose)
 416                         exfat_err("unsupported exfat version: %d.%d\n",
 417                                   bs->bsx.fs_version[1], bs->bsx.fs_version[0]);
 418                 goto err;
 419         }
 420
 421         if (bs->bsx.num_fats != 1) {
 422                 if (verbose)
 423                         exfat_err("unsupported FAT count: %d\n",
 424                                   bs->bsx.num_fats);
 425                 goto err;
 426         }
 427
 428         if (le64_to_cpu(bs->bsx.vol_length) * EXFAT_SECTOR_SIZE(bs) >
 429                         bd->size) {
 430                 if (verbose)
 431                         exfat_err("too large sector count: %" PRIu64 ", expected: %llu\n",
 432                                   le64_to_cpu(bs->bsx.vol_length),
 433                                   bd->num_sectors);
 434                 goto err;
 435         }
 436
 437         if (le32_to_cpu(bs->bsx.clu_count) * EXFAT_CLUSTER_SIZE(bs) >
 438                         bd->size) {
 439                 if (verbose)
 440                         exfat_err("too large cluster count: %u, expected: %u\n",
 441                                   le32_to_cpu(bs->bsx.clu_count),
 442                                   bd->num_clusters);
 443                 goto err;
 444         }
 445
 446         *pbr = bs;
 447         return 0;
 448 err:
 449         free(bs);
 450         return ret;
 451 }
 452
 453 static int restore_boot_region(struct exfat_blk_dev *bd, unsigned int sect_size)
 454 {
 455         int i;
 456         char *sector;
 457         int ret;
 458
 459         sector = malloc(sect_size);
 460         if (!sector)
 461                 return -ENOMEM;
 462
 463         for (i = 0; i < 12; i++) {
 464                 if (exfat_read(bd->dev_fd, sector, sect_size,
 465                                 BACKUP_BOOT_SEC_IDX * sect_size +
 466                                 i * sect_size) !=
 467                                 (ssize_t)sect_size) {
 468                         ret = -EIO;
 469                         goto free_sector;
 470                 }
 471                 if (i == 0)
 472                         ((struct pbr *)sector)->bsx.perc_in_use = 0xff;
 473
 474                 if (exfat_write(bd->dev_fd, sector, sect_size,
 475                                 BOOT_SEC_IDX * sect_size +
 476                                 i * sect_size) !=
 477                                 (ssize_t)sect_size) {
 478                         ret = -EIO;
 479                         goto free_sector;
 480                 }
 481         }
 482
 483         if (fsync(bd->dev_fd)) {
 484                 ret = -EIO;
 485                 goto free_sector;
 486         }
 487         ret = 0;
 488
 489 free_sector:
 490         free(sector);
 491         return ret;
 492 }
 493
 494 static int exfat_boot_region_check(struct exfat_blk_dev *blkdev,
 495                                    struct pbr **bs,
 496                                    bool ignore_bad_fs_name)
 497 {
 498         struct pbr *boot_sect;
 499         unsigned int sect_size;
 500         int ret;
 501
 502         /* First, find out the exfat sector size */
 503         boot_sect = malloc(sizeof(*boot_sect));
 504         if (boot_sect == NULL)
 505                 return -ENOMEM;
 506
 507         if (exfat_read(blkdev->dev_fd, boot_sect,
 508                        sizeof(*boot_sect), 0) != (ssize_t)sizeof(*boot_sect)) {
 509                 exfat_err("failed to read Main boot sector\n");
 510                 free(boot_sect);
 511                 return -EIO;
 512         }
 513
 514         if (memcmp(boot_sect->bpb.oem_name, "EXFAT   ", 8) != 0 &&
 515             !ignore_bad_fs_name) {
 516                 exfat_err("Bad fs_name in boot sector, which does not describe a valid exfat filesystem\n");
 517                 free(boot_sect);
 518                 return -ENOTSUP;
 519         }
 520
 521         sect_size = 1 << boot_sect->bsx.sect_size_bits;
 522         free(boot_sect);
 523
 524         /* check boot regions */
 525         ret = read_boot_region(blkdev, bs,
 526                                BOOT_SEC_IDX, sect_size, true);
 527         if (ret == -EINVAL &&
 528             exfat_repair_ask(&exfat_fsck, ER_BS_BOOT_REGION,
 529                              "boot region is corrupted. try to restore the region from backup"
 530                                 )) {
 531                 const unsigned int sector_sizes[] = {512, 4096, 1024, 2048};
 532                 unsigned int i;
 533
 534                 if (sect_size >= 512 && sect_size <= EXFAT_MAX_SECTOR_SIZE) {
 535                         ret = read_boot_region(blkdev, bs,
 536                                                BACKUP_BOOT_SEC_IDX, sect_size,
 537                                                false);
 538                         if (!ret)
 539                                 goto restore;
 540                 }
 541
 542                 for (i = 0; i < sizeof(sector_sizes)/sizeof(sector_sizes[0]); i++) {
 543                         if (sector_sizes[i] == sect_size)
 544                                 continue;
 545
 546                         ret = read_boot_region(blkdev, bs,
 547                                                BACKUP_BOOT_SEC_IDX,
 548                                                sector_sizes[i], false);
 549                         if (!ret) {
 550                                 sect_size = sector_sizes[i];
 551                                 goto restore;
 552                         }
 553                 }
 554                 exfat_err("backup boot region is also corrupted\n");
 555         }
 556
 557         return ret;
 558 restore:
 559         ret = restore_boot_region(blkdev, sect_size);
 560         if (ret) {
 561                 exfat_err("failed to restore boot region from backup\n");
 562                 free(*bs);
 563                 *bs = NULL;
 564         }
 565         return ret;
 566 }
 567
 568 static uint16_t file_calc_checksum(struct exfat_de_iter *iter)
 569 {
 570         uint16_t checksum;
 571         struct exfat_dentry *file_de, *de;
 572         int i;
 573
 574         checksum = 0;
 575         exfat_de_iter_get(iter, 0, &file_de);
 576
 577         exfat_calc_dentry_checksum(file_de, &checksum, true);
 578         for (i = 1; i <= file_de->file_num_ext; i++) {
 579                 exfat_de_iter_get(iter, i, &de);
 580                 exfat_calc_dentry_checksum(de, &checksum, false);
 581         }
 582         return checksum;
 583 }
 584
 585 /*
 586  * return 0 if there are no errors, or 1 if errors are fixed, or
 587  * an error code
 588  */
 589 static int check_inode(struct exfat_de_iter *iter, struct exfat_inode *node)
 590 {
 591         struct exfat *exfat = iter->exfat;
 592         struct exfat_dentry *dentry;
 593         int ret = 0;
 594         uint16_t checksum;
 595         bool valid = true;
 596
 597         ret = check_clus_chain(iter, node);
 598         if (ret < 0)
 599                 return ret;
 600
 601         if (node->size > le32_to_cpu(exfat->bs->bsx.clu_count) *
 602                                 (uint64_t)exfat->clus_size) {
 603                 fsck_err(iter->parent, node,
 604                         "size %" PRIu64 " is greater than cluster heap\n",
 605                         node->size);
 606                 valid = false;
 607         }
 608
 609         if (node->size == 0 && node->is_contiguous) {
 610                 if (repair_file_ask(iter, node, ER_FILE_ZERO_NOFAT,
 611                                 "empty, but has no Fat chain")) {
 612                         exfat_de_iter_get_dirty(iter, 1, &dentry);
 613                         dentry->stream_flags &= ~EXFAT_SF_CONTIGUOUS;
 614                         ret = 1;
 615                 } else
 616                         valid = false;
 617         }
 618
 619         if ((node->attr & ATTR_SUBDIR) &&
 620                         node->size % exfat->clus_size != 0) {
 621                 fsck_err(iter->parent, node,
 622                         "directory size %" PRIu64 " is not divisible by %d\n",
 623                         node->size, exfat->clus_size);
 624                 valid = false;
 625         }
 626
 627         checksum = file_calc_checksum(iter);
 628         exfat_de_iter_get(iter, 0, &dentry);
 629         if (checksum != le16_to_cpu(dentry->file_checksum)) {
 630                 exfat_de_iter_get_dirty(iter, 0, &dentry);
 631                 dentry->file_checksum = cpu_to_le16(checksum);
 632                 ret = 1;
 633         }
 634
 635         return valid ? ret : -EINVAL;
 636 }
 637
 638 static int handle_duplicated_filename(struct exfat_de_iter *iter,
 639                 struct exfat_inode *inode)
 640 {
 641         int ret;
 642         struct exfat_lookup_filter filter;
 643         char filename[PATH_MAX + 1] = {0};
 644
 645         ret = exfat_lookup_file_by_utf16name(iter->exfat, iter->parent,
 646                         inode->name, &filter);
 647         if (ret)
 648                 return ret;
 649
 650         free(filter.out.dentry_set);
 651
 652         /* Hash is same, but filename is not same */
 653         if (exfat_de_iter_device_offset(iter) == filter.out.dev_offset)
 654                 return 0;
 655
 656         ret = exfat_utf16_dec(inode->name, NAME_BUFFER_SIZE, filename,
 657                         PATH_MAX);
 658         if (ret < 0) {
 659                 exfat_err("failed to decode filename\n");
 660                 return ret;
 661         }
 662
 663         return exfat_repair_rename_ask(&exfat_fsck, iter, filename,
 664                         ER_DE_DUPLICATED_NAME, "filename is duplicated");
 665 }
 666
 667 static int check_name_dentry_set(struct exfat_de_iter *iter,
 668                                  struct exfat_inode *inode)
 669 {
 670         struct exfat_dentry *stream_de;
 671         size_t name_len;
 672         __u16 hash;
 673
 674         exfat_de_iter_get(iter, 1, &stream_de);
 675
 676         name_len = exfat_utf16_len(inode->name, NAME_BUFFER_SIZE);
 677         if (stream_de->stream_name_len != name_len) {
 678                 if (repair_file_ask(iter, NULL, ER_DE_NAME_LEN,
 679                                     "the name length of a file is wrong")) {
 680                         exfat_de_iter_get_dirty(iter, 1, &stream_de);
 681                         stream_de->stream_name_len = (__u8)name_len;
 682                 } else {
 683                         return -EINVAL;
 684                 }
 685         }
 686
 687         hash = exfat_calc_name_hash(iter->exfat, inode->name, (int)name_len);
 688         if (cpu_to_le16(hash) != stream_de->stream_name_hash) {
 689                 if (repair_file_ask(iter, NULL, ER_DE_NAME_HASH,
 690                                     "the name hash of a file is wrong")) {
 691                         exfat_de_iter_get_dirty(iter, 1, &stream_de);
 692                         stream_de->stream_name_hash = cpu_to_le16(hash);
 693                 } else {
 694                         return -EINVAL;
 695                 }
 696         }
 697
 698         if (BITMAP_GET(iter->name_hash_bitmap, hash)) {
 699                 int ret = handle_duplicated_filename(iter, inode);
 700
 701                 if (ret)
 702                         return ret;
 703         } else
 704                 BITMAP_SET(iter->name_hash_bitmap, hash);
 705
 706         return 0;
 707 }
 708
 709 const __le16 MSDOS_DOT[ENTRY_NAME_MAX] = {cpu_to_le16(46), 0, };
 710 const __le16 MSDOS_DOTDOT[ENTRY_NAME_MAX] = {cpu_to_le16(46), cpu_to_le16(46), 0, };
 711
 712 static int handle_dot_dotdot_filename(struct exfat_de_iter *iter,
 713                                       struct exfat_dentry *dentry,
 714                                       int strm_name_len)
 715 {
 716         char *filename;
 717
 718         if (!memcmp(dentry->name_unicode, MSDOS_DOT, strm_name_len * 2))
 719                 filename = ".";
 720         else if (!memcmp(dentry->name_unicode, MSDOS_DOTDOT,
 721                          strm_name_len * 2))
 722                 filename = "..";
 723         else
 724                 return 0;
 725
 726         return exfat_repair_rename_ask(&exfat_fsck, iter, filename,
 727                         ER_DE_DOT_NAME, "filename is not allowed");
 728 }
 729
 730 static int read_file_dentry_set(struct exfat_de_iter *iter,
 731                                 struct exfat_inode **new_node, int *skip_dentries)
 732 {
 733         struct exfat_dentry *file_de, *stream_de, *dentry;
 734         struct exfat_inode *node = NULL;
 735         int i, ret;
 736         bool need_delete = false;
 737         uint16_t checksum;
 738
 739         ret = exfat_de_iter_get(iter, 0, &file_de);
 740         if (ret || file_de->type != EXFAT_FILE) {
 741                 exfat_err("failed to get file dentry\n");
 742                 return -EINVAL;
 743         }
 744
 745         checksum = file_calc_checksum(iter);
 746         if (checksum != le16_to_cpu(file_de->file_checksum)) {
 747                 if (repair_file_ask(iter, NULL, ER_DE_CHECKSUM,
 748                                     "the checksum of a file is wrong"))
 749                         need_delete = true;
 750                 *skip_dentries = 1;
 751                 goto skip_dset;
 752         }
 753
 754         if (file_de->file_num_ext < 2) {
 755                 if (repair_file_ask(iter, NULL, ER_DE_SECONDARY_COUNT,
 756                                     "a file has too few secondary count. %d",
 757                                     file_de->file_num_ext))
 758                         need_delete = true;
 759                 *skip_dentries = 1;
 760                 goto skip_dset;
 761         }
 762
 763         ret = exfat_de_iter_get(iter, 1, &stream_de);
 764         if (ret || stream_de->type != EXFAT_STREAM) {
 765                 if (repair_file_ask(iter, NULL, ER_DE_STREAM,
 766                                     "failed to get stream dentry"))
 767                         need_delete = true;
 768                 *skip_dentries = 2;
 769                 goto skip_dset;
 770         }
 771
 772         *new_node = NULL;
 773         node = exfat_alloc_inode(le16_to_cpu(file_de->file_attr));
 774         if (!node)
 775                 return -ENOMEM;
 776
 777         for (i = 2; i <= MIN(file_de->file_num_ext, 1 + MAX_NAME_DENTRIES); i++) {
 778                 ret = exfat_de_iter_get(iter, i, &dentry);
 779                 if (ret || dentry->type != EXFAT_NAME) {
 780                         if (i > 2 && repair_file_ask(iter, NULL, ER_DE_NAME,
 781                                                      "failed to get name dentry")) {
 782                                 exfat_de_iter_get_dirty(iter, 0, &file_de);
 783                                 file_de->file_num_ext = i - 1;
 784                                 break;
 785                         }
 786                         *skip_dentries = i + 1;
 787                         goto skip_dset;
 788                 }
 789
 790                 memcpy(node->name +
 791                        (i - 2) * ENTRY_NAME_MAX, dentry->name_unicode,
 792                        sizeof(dentry->name_unicode));
 793         }
 794
 795         ret = check_name_dentry_set(iter, node);
 796         if (ret) {
 797                 *skip_dentries = file_de->file_num_ext + 1;
 798                 goto skip_dset;
 799         }
 800
 801         if (file_de->file_num_ext == 2 && stream_de->stream_name_len <= 2) {
 802                 ret = handle_dot_dotdot_filename(iter, dentry,
 803                                 stream_de->stream_name_len);
 804                 if (ret < 0) {
 805                         *skip_dentries = file_de->file_num_ext + 1;
 806                         goto skip_dset;
 807                 }
 808         }
 809
 810         node->first_clus = le32_to_cpu(stream_de->stream_start_clu);
 811         node->is_contiguous =
 812                 ((stream_de->stream_flags & EXFAT_SF_CONTIGUOUS) != 0);
 813         node->size = le64_to_cpu(stream_de->stream_size);
 814
 815         if (node->size < le64_to_cpu(stream_de->stream_valid_size)) {
 816                 *skip_dentries = file_de->file_num_ext + 1;
 817                 if (repair_file_ask(iter, node, ER_FILE_VALID_SIZE,
 818                                     "valid size %" PRIu64 " greater than size %" PRIu64,
 819                                     le64_to_cpu(stream_de->stream_valid_size),
 820                                     node->size)) {
 821                         exfat_de_iter_get_dirty(iter, 1, &stream_de);
 822                         stream_de->stream_valid_size =
 823                                         stream_de->stream_size;
 824                 } else {
 825                         *skip_dentries = file_de->file_num_ext + 1;
 826                         goto skip_dset;
 827                 }
 828         }
 829
 830         *skip_dentries = (file_de->file_num_ext + 1);
 831         *new_node = node;
 832         return 0;
 833 skip_dset:
 834         if (need_delete) {
 835                 exfat_de_iter_get_dirty(iter, 0, &dentry);
 836                 dentry->type &= EXFAT_DELETE;
 837         }
 838         for (i = 1; i < *skip_dentries; i++) {
 839                 exfat_de_iter_get(iter, i, &dentry);
 840                 if (dentry->type == EXFAT_FILE)
 841                         break;
 842                 if (need_delete) {
 843                         exfat_de_iter_get_dirty(iter, i, &dentry);
 844                         dentry->type &= EXFAT_DELETE;
 845                 }
 846         }
 847         *skip_dentries = i;
 848         *new_node = NULL;
 849         exfat_free_inode(node);
 850         return need_delete ? 1 : -EINVAL;
 851 }
 852
 853 static int read_file(struct exfat_de_iter *de_iter,
 854                 struct exfat_inode **new_node, int *dentry_count)
 855 {
 856         struct exfat_inode *node;
 857         int ret;
 858
 859         *new_node = NULL;
 860
 861         ret = read_file_dentry_set(de_iter, &node, dentry_count);
 862         if (ret)
 863                 return ret;
 864
 865         ret = check_inode(de_iter, node);
 866         if (ret < 0) {
 867                 exfat_free_inode(node);
 868                 return -EINVAL;
 869         }
 870
 871         if (node->attr & ATTR_SUBDIR)
 872                 exfat_stat.dir_count++;
 873         else
 874                 exfat_stat.file_count++;
 875         *new_node = node;
 876         return ret;
 877 }
 878
 879 static int read_bitmap(struct exfat *exfat)
 880 {
 881         struct exfat_lookup_filter filter = {
 882                 .in.type        = EXFAT_BITMAP,
 883                 .in.dentry_count = 0,
 884                 .in.filter      = NULL,
 885                 .in.param       = NULL,
 886         };
 887         struct exfat_dentry *dentry;
 888         int retval;
 889
 890         retval = exfat_lookup_dentry_set(exfat, exfat->root, &filter);
 891         if (retval)
 892                 return retval;
 893
 894         dentry = filter.out.dentry_set;
 895         exfat_debug("start cluster %#x, size %#" PRIx64 "\n",
 896                         le32_to_cpu(dentry->bitmap_start_clu),
 897                         le64_to_cpu(dentry->bitmap_size));
 898
 899         if (le64_to_cpu(dentry->bitmap_size) <
 900                         DIV_ROUND_UP(exfat->clus_count, 8)) {
 901                 exfat_err("invalid size of allocation bitmap. 0x%" PRIx64 "\n",
 902                                 le64_to_cpu(dentry->bitmap_size));
 903                 return -EINVAL;
 904         }
 905         if (!exfat_heap_clus(exfat, le32_to_cpu(dentry->bitmap_start_clu))) {
 906                 exfat_err("invalid start cluster of allocate bitmap. 0x%x\n",
 907                                 le32_to_cpu(dentry->bitmap_start_clu));
 908                 return -EINVAL;
 909         }
 910
 911         exfat->disk_bitmap_clus = le32_to_cpu(dentry->bitmap_start_clu);
 912         exfat->disk_bitmap_size = DIV_ROUND_UP(exfat->clus_count, 8);
 913
 914         exfat_bitmap_set_range(exfat, exfat->alloc_bitmap,
 915                                le64_to_cpu(dentry->bitmap_start_clu),
 916                                DIV_ROUND_UP(exfat->disk_bitmap_size,
 917                                             exfat->clus_size));
 918         free(filter.out.dentry_set);
 919
 920         if (exfat_read(exfat->blk_dev->dev_fd, exfat->disk_bitmap,
 921                         exfat->disk_bitmap_size,
 922                         exfat_c2o(exfat, exfat->disk_bitmap_clus)) !=
 923                         (ssize_t)exfat->disk_bitmap_size)
 924                 return -EIO;
 925         return 0;
 926 }
 927
 928 static int decompress_upcase_table(const __le16 *in_table, size_t in_len,
 929                                    __u16 *out_table, size_t out_len)
 930 {
 931         size_t i, k;
 932         uint16_t ch;
 933
 934         if (in_len > out_len)
 935                 return -E2BIG;
 936
 937         for (k = 0; k < out_len; k++)
 938                 out_table[k] = k;
 939
 940         for (i = 0, k = 0; i < in_len && k < out_len; i++) {
 941                 ch = le16_to_cpu(in_table[i]);
 942
 943                 if (ch == 0xFFFF && i + 1 < in_len) {
 944                         uint16_t len = le16_to_cpu(in_table[++i]);
 945
 946                         k += len;
 947                 } else {
 948                         out_table[k++] = ch;
 949                 }
 950         }
 951         return 0;
 952 }
 953
 954 static int read_upcase_table(struct exfat *exfat)
 955 {
 956         struct exfat_lookup_filter filter = {
 957                 .in.type        = EXFAT_UPCASE,
 958                 .in.dentry_count = 0,
 959                 .in.filter      = NULL,
 960                 .in.param       = NULL,
 961         };
 962         struct exfat_dentry *dentry = NULL;
 963         __le16 *upcase = NULL;
 964         int retval;
 965         ssize_t size;
 966         __le32 checksum;
 967
 968         retval = exfat_lookup_dentry_set(exfat, exfat->root, &filter);
 969         if (retval)
 970                 return retval;
 971
 972         dentry = filter.out.dentry_set;
 973
 974         if (!exfat_heap_clus(exfat, le32_to_cpu(dentry->upcase_start_clu))) {
 975                 exfat_err("invalid start cluster of upcase table. 0x%x\n",
 976                         le32_to_cpu(dentry->upcase_start_clu));
 977                 retval = -EINVAL;
 978                 goto out;
 979         }
 980
 981         size = (ssize_t)le64_to_cpu(dentry->upcase_size);
 982         if (size > (ssize_t)(EXFAT_MAX_UPCASE_CHARS * sizeof(__le16)) ||
 983                         size == 0 || size % sizeof(__le16)) {
 984                 exfat_err("invalid size of upcase table. 0x%" PRIx64 "\n",
 985                         le64_to_cpu(dentry->upcase_size));
 986                 retval = -EINVAL;
 987                 goto out;
 988         }
 989
 990         upcase = (__le16 *)malloc(size);
 991         if (!upcase) {
 992                 exfat_err("failed to allocate upcase table\n");
 993                 retval = -ENOMEM;
 994                 goto out;
 995         }
 996
 997         if (exfat_read(exfat->blk_dev->dev_fd, upcase, size,
 998                         exfat_c2o(exfat,
 999                         le32_to_cpu(dentry->upcase_start_clu))) != size) {
1000                 exfat_err("failed to read upcase table\n");
1001                 retval = -EIO;
1002                 goto out;
1003         }
1004
1005         checksum = 0;
1006         boot_calc_checksum((unsigned char *)upcase, size, false, &checksum);
1007         if (le32_to_cpu(dentry->upcase_checksum) != checksum) {
1008                 exfat_err("corrupted upcase table %#x (expected: %#x)\n",
1009                         checksum, le32_to_cpu(dentry->upcase_checksum));
1010                 retval = -EINVAL;
1011                 goto out;
1012         }
1013
1014         exfat_bitmap_set_range(exfat, exfat->alloc_bitmap,
1015                                le32_to_cpu(dentry->upcase_start_clu),
1016                                DIV_ROUND_UP(le64_to_cpu(dentry->upcase_size),
1017                                             exfat->clus_size));
1018
1019         exfat->upcase_table = calloc(1,
1020                                      sizeof(uint16_t) * EXFAT_UPCASE_TABLE_CHARS);
1021         if (!exfat->upcase_table) {
1022                 retval = -EIO;
1023                 goto out;
1024         }
1025
1026         decompress_upcase_table(upcase, size / 2,
1027                                 exfat->upcase_table, EXFAT_UPCASE_TABLE_CHARS);
1028 out:
1029         if (dentry)
1030                 free(dentry);
1031         if (upcase)
1032                 free(upcase);
1033         return retval;
1034 }
1035
1036 static int read_children(struct exfat_fsck *fsck, struct exfat_inode *dir)
1037 {
1038         struct exfat *exfat = fsck->exfat;
1039         struct exfat_inode *node = NULL;
1040         struct exfat_dentry *dentry;
1041         struct exfat_de_iter *de_iter;
1042         int dentry_count;
1043         int ret;
1044
1045         de_iter = &fsck->de_iter;
1046         ret = exfat_de_iter_init(de_iter, exfat, dir, fsck->buffer_desc);
1047         if (ret == EOF)
1048                 return 0;
1049         else if (ret)
1050                 return ret;
1051
1052         de_iter->name_hash_bitmap = fsck->name_hash_bitmap;
1053         memset(fsck->name_hash_bitmap, 0,
1054                         EXFAT_BITMAP_SIZE(EXFAT_MAX_HASH_COUNT));
1055
1056         while (1) {
1057                 ret = exfat_de_iter_get(de_iter, 0, &dentry);
1058                 if (ret == EOF) {
1059                         break;
1060                 } else if (ret) {
1061                         fsck_err(dir->parent, dir,
1062                                 "failed to get a dentry. %d\n", ret);
1063                         goto err;
1064                 }
1065
1066                 dentry_count = 1;
1067
1068                 switch (dentry->type) {
1069                 case EXFAT_FILE:
1070                         ret = read_file(de_iter, &node, &dentry_count);
1071                         if (ret < 0) {
1072                                 exfat_stat.error_count++;
1073                                 break;
1074                         } else if (ret) {
1075                                 exfat_stat.error_count++;
1076                                 exfat_stat.fixed_count++;
1077                         }
1078
1079                         if (node) {
1080                                 if ((node->attr & ATTR_SUBDIR) && node->size) {
1081                                         node->parent = dir;
1082                                         list_add_tail(&node->sibling,
1083                                                       &dir->children);
1084                                         list_add_tail(&node->list,
1085                                                       &exfat->dir_list);
1086                                 } else {
1087                                         exfat_free_inode(node);
1088                                 }
1089                         }
1090                         break;
1091                 case EXFAT_LAST:
1092                         goto out;
1093                 case EXFAT_VOLUME:
1094                 case EXFAT_BITMAP:
1095                 case EXFAT_UPCASE:
1096                 case EXFAT_GUID:
1097                         if (dir == exfat->root)
1098                                 break;
1099                         /* fallthrough */
1100                 default:
1101                         if (IS_EXFAT_DELETED(dentry->type))
1102                                 break;
1103                         if (repair_file_ask(de_iter, NULL, ER_DE_UNKNOWN,
1104                                             "unknown entry type %#x at %07" PRIx64,
1105                                             dentry->type,
1106                                             exfat_de_iter_file_offset(de_iter))) {
1107                                 struct exfat_dentry *dentry;
1108
1109                                 exfat_de_iter_get_dirty(de_iter, 0, &dentry);
1110                                 dentry->type &= EXFAT_DELETE;
1111                         }
1112                         break;
1113                 }
1114
1115                 exfat_de_iter_advance(de_iter, dentry_count);
1116         }
1117 out:
1118         exfat_de_iter_flush(de_iter);
1119         return 0;
1120 err:
1121         exfat_free_children(dir, false);
1122         INIT_LIST_HEAD(&dir->children);
1123         exfat_de_iter_flush(de_iter);
1124         return ret;
1125 }
1126
1127 /* write bitmap segments for clusters which are marked
1128  * as free, but allocated to files.
1129  */
1130 static int write_bitmap(struct exfat_fsck *fsck)
1131 {
1132         struct exfat *exfat = fsck->exfat;
1133         bitmap_t *disk_b, *alloc_b, *ohead_b;
1134         off_t dev_offset;
1135         unsigned int i, bitmap_bytes, byte_offset, write_bytes;
1136
1137         dev_offset = exfat_c2o(exfat, exfat->disk_bitmap_clus);
1138         bitmap_bytes = EXFAT_BITMAP_SIZE(le32_to_cpu(exfat->bs->bsx.clu_count));
1139
1140         disk_b = (bitmap_t *)exfat->disk_bitmap;
1141         alloc_b = (bitmap_t *)exfat->alloc_bitmap;
1142         ohead_b = (bitmap_t *)exfat->ohead_bitmap;
1143
1144         for (i = 0; i < bitmap_bytes / sizeof(bitmap_t); i++)
1145                 ohead_b[i] = alloc_b[i] | disk_b[i];
1146
1147         i = 0;
1148         while (i < bitmap_bytes / sizeof(bitmap_t)) {
1149                 if (ohead_b[i] == disk_b[i]) {
1150                         i++;
1151                         continue;
1152                 }
1153
1154                 byte_offset = ((i * sizeof(bitmap_t)) / 512) * 512;
1155                 write_bytes = MIN(512, bitmap_bytes - byte_offset);
1156
1157                 if (exfat_write(exfat->blk_dev->dev_fd,
1158                                 (char *)ohead_b + byte_offset, write_bytes,
1159                                 dev_offset + byte_offset) != (ssize_t)write_bytes)
1160                         return -EIO;
1161
1162                 i = (byte_offset + write_bytes) / sizeof(bitmap_t);
1163         }
1164         return 0;
1165
1166 }
1167
1168 /*
1169  * for each directory in @dir_list.
1170  * 1. read all dentries and allocate exfat_nodes for files and directories.
1171  *    and append directory exfat_nodes to the head of @dir_list
1172  * 2. free all of file exfat_nodes.
1173  * 3. if the directory does not have children, free its exfat_node.
1174  */
1175 static int exfat_filesystem_check(struct exfat_fsck *fsck)
1176 {
1177         struct exfat *exfat = fsck->exfat;
1178         struct exfat_inode *dir;
1179         int ret = 0, dir_errors;
1180
1181         if (!exfat->root) {
1182                 exfat_err("root is NULL\n");
1183                 return -ENOENT;
1184         }
1185
1186         fsck->name_hash_bitmap = malloc(EXFAT_BITMAP_SIZE(EXFAT_MAX_HASH_COUNT));
1187         if (!fsck->name_hash_bitmap) {
1188                 exfat_err("failed to allocate name hash bitmap\n");
1189                 return -ENOMEM;
1190         }
1191
1192         list_add(&exfat->root->list, &exfat->dir_list);
1193
1194         while (!list_empty(&exfat->dir_list)) {
1195                 dir = list_entry(exfat->dir_list.next,
1196                                  struct exfat_inode, list);
1197
1198                 if (!(dir->attr & ATTR_SUBDIR)) {
1199                         fsck_err(dir->parent, dir,
1200                                 "failed to travel directories. "
1201                                 "the node is not directory\n");
1202                         ret = -EINVAL;
1203                         goto out;
1204                 }
1205
1206                 dir_errors = read_children(fsck, dir);
1207                 if (dir_errors) {
1208                         exfat_resolve_path(&path_resolve_ctx, dir);
1209                         exfat_debug("failed to check dentries: %s\n",
1210                                         path_resolve_ctx.local_path);
1211                         ret = dir_errors;
1212                 }
1213
1214                 list_del(&dir->list);
1215                 exfat_free_file_children(dir);
1216                 exfat_free_ancestors(dir);
1217         }
1218 out:
1219         exfat_free_dir_list(exfat);
1220         free(fsck->name_hash_bitmap);
1221         return ret;
1222 }
1223
1224 static int exfat_root_dir_check(struct exfat *exfat)
1225 {
1226         struct exfat_inode *root;
1227         clus_t clus_count = 0;
1228         int err;
1229
1230         root = exfat_alloc_inode(ATTR_SUBDIR);
1231         if (!root)
1232                 return -ENOMEM;
1233
1234         exfat->root = root;
1235         root->first_clus = le32_to_cpu(exfat->bs->bsx.root_cluster);
1236         if (root_check_clus_chain(exfat, root, &clus_count)) {
1237                 exfat_err("failed to follow the cluster chain of root\n");
1238                 exfat_free_inode(root);
1239                 exfat->root = NULL;
1240                 return -EINVAL;
1241         }
1242         root->size = clus_count * exfat->clus_size;
1243
1244         exfat_stat.dir_count++;
1245         exfat_debug("root directory: start cluster[0x%x] size[0x%" PRIx64 "]\n",
1246                 root->first_clus, root->size);
1247
1248         err = exfat_read_volume_label(exfat);
1249         if (err && err != EOF)
1250                 exfat_err("failed to read volume label\n");
1251         err = 0;
1252
1253         err = read_bitmap(exfat);
1254         if (err) {
1255                 exfat_err("failed to read bitmap\n");
1256                 return -EINVAL;
1257         }
1258
1259         err = read_upcase_table(exfat);
1260         if (err) {
1261                 exfat_err("failed to read upcase table\n");
1262                 return -EINVAL;
1263         }
1264
1265         root->dev_offset = 0;
1266         err = exfat_build_file_dentry_set(exfat, " ", ATTR_SUBDIR,
1267                                           &root->dentry_set, &root->dentry_count);
1268         if (err) {
1269                 exfat_free_inode(root);
1270                 return -ENOMEM;
1271         }
1272         return 0;
1273 }
1274
1275 static int read_lostfound(struct exfat *exfat, struct exfat_inode **lostfound)
1276 {
1277         struct exfat_lookup_filter filter;
1278         struct exfat_inode *inode;
1279         int err;
1280
1281         err = exfat_lookup_file(exfat, exfat->root, "LOST+FOUND", &filter);
1282         if (err)
1283                 return err;
1284
1285         inode = exfat_alloc_inode(ATTR_SUBDIR);
1286         if (!inode) {
1287                 free(filter.out.dentry_set);
1288                 return -ENOMEM;
1289         }
1290
1291         inode->dentry_set = filter.out.dentry_set;
1292         inode->dentry_count = filter.out.dentry_count;
1293         inode->dev_offset = filter.out.dev_offset;
1294
1295         inode->first_clus =
1296                 le32_to_cpu(filter.out.dentry_set[1].dentry.stream.start_clu);
1297         inode->size =
1298                 le64_to_cpu(filter.out.dentry_set[1].dentry.stream.size);
1299
1300         *lostfound = inode;
1301         return 0;
1302 }
1303
1304 /* Create temporary files under LOST+FOUND and assign orphan
1305  * chains of clusters to these files.
1306  */
1307 static int rescue_orphan_clusters(struct exfat_fsck *fsck)
1308 {
1309         struct exfat *exfat = fsck->exfat;
1310         struct exfat_inode *lostfound;
1311         bitmap_t *disk_b, *alloc_b, *ohead_b;
1312         struct exfat_dentry *dset;
1313         clus_t clu_count, clu, s_clu, e_clu;
1314         int err, dcount;
1315         unsigned int i;
1316         char name[] = "FILE0000000.CHK";
1317         struct exfat_dentry_loc loc;
1318         struct exfat_lookup_filter lf = {
1319                 .in.type = EXFAT_INVAL,
1320                 .in.dentry_count = 0,
1321                 .in.filter = NULL,
1322         };
1323
1324         clu_count = le32_to_cpu(exfat->bs->bsx.clu_count);
1325
1326         /* find clusters which are not marked as free, but not allocated to
1327          * any files.
1328          */
1329         disk_b = (bitmap_t *)exfat->disk_bitmap;
1330         alloc_b = (bitmap_t *)exfat->alloc_bitmap;
1331         ohead_b = (bitmap_t *)exfat->ohead_bitmap;
1332         for (i = 0; i < EXFAT_BITMAP_SIZE(clu_count) / sizeof(bitmap_t); i++)
1333                 ohead_b[i] = disk_b[i] & ~alloc_b[i];
1334
1335         /* no orphan clusters */
1336         if (exfat_bitmap_find_one(exfat, exfat->ohead_bitmap,
1337                                 EXFAT_FIRST_CLUSTER, &s_clu))
1338                 return 0;
1339
1340         err = exfat_create_file(exfat_fsck.exfat,
1341                                 exfat_fsck.exfat->root,
1342                                 "LOST+FOUND",
1343                                 ATTR_SUBDIR);
1344         if (err) {
1345                 exfat_err("failed to create LOST+FOUND directory\n");
1346                 return err;
1347         }
1348
1349         if (fsync(exfat_fsck.exfat->blk_dev->dev_fd) != 0) {
1350                 exfat_err("failed to sync()\n");
1351                 return -EIO;
1352         }
1353
1354         err = read_lostfound(exfat, &lostfound);
1355         if (err) {
1356                 exfat_err("failed to find LOST+FOUND\n");
1357                 return err;
1358         }
1359
1360         /* get the last empty region of LOST+FOUND */
1361         err = exfat_lookup_dentry_set(exfat, lostfound, &lf);
1362         if (err && err != EOF) {
1363                 exfat_err("failed to find the last empty slot in LOST+FOUND\n");
1364                 goto out;
1365         }
1366
1367         loc.parent = lostfound;
1368         loc.file_offset = lf.out.file_offset;
1369         loc.dev_offset = lf.out.dev_offset;
1370
1371         /* build a template dentry set */
1372         err = exfat_build_file_dentry_set(exfat, name, 0, &dset, &dcount);
1373         if (err) {
1374                 exfat_err("failed to create a temporary file in LOST+FOUNDn");
1375                 goto out;
1376         }
1377         dset[1].dentry.stream.flags |= EXFAT_SF_CONTIGUOUS;
1378
1379         /* create temporary files and allocate contiguous orphan clusters
1380          * to each file.
1381          */
1382         for (clu = EXFAT_FIRST_CLUSTER; clu < clu_count + EXFAT_FIRST_CLUSTER &&
1383              exfat_bitmap_find_one(exfat, exfat->ohead_bitmap, clu, &s_clu) == 0;) {
1384                 if (exfat_bitmap_find_zero(exfat, exfat->ohead_bitmap, s_clu, &e_clu))
1385                         e_clu = clu_count + EXFAT_FIRST_CLUSTER;
1386                 clu = e_clu;
1387
1388                 snprintf(name, sizeof(name), "FILE%07d.CHK",
1389                          (unsigned int)(loc.file_offset >> 5));
1390                 err = exfat_update_file_dentry_set(exfat, dset, dcount,
1391                                                    name, s_clu, e_clu - s_clu);
1392                 if (err)
1393                         continue;
1394                 err = exfat_add_dentry_set(exfat, &loc, dset, dcount, true);
1395                 if (err)
1396                         continue;
1397         }
1398
1399         free(dset);
1400         err = 0;
1401 out:
1402         exfat_free_inode(lostfound);
1403         return err;
1404 }
1405
1406 static char *bytes_to_human_readable(size_t bytes)
1407 {
1408         static const char * const units[] = {"B", "KB", "MB", "GB", "TB", "PB"};
1409         static char buf[15*4];
1410         unsigned int i, shift, quoti, remain;
1411         i = sizeof(units) / sizeof(units[0]) - 1;
1412
1413         while (i && (bytes >> i * 10) == 0)
1414                 i--;
1415
1416         shift = i * 10;
1417         quoti = (unsigned int)(bytes / (1ULL << shift));
1418         remain = 0;
1419         if (shift > 0) {
1420                 remain = (unsigned int)
1421                         ((bytes & ((1ULL << shift) - 1)) >> (shift - 10));
1422                 remain = (remain * 100) / 1024;
1423         }
1424
1425         snprintf(buf, sizeof(buf), "%u.%02u %s", quoti, remain, units[i]);
1426         return buf;
1427 }
1428
1429 static void exfat_show_info(struct exfat_fsck *fsck, const char *dev_name)
1430 {
1431         struct exfat *exfat = fsck->exfat;
1432         bool clean;
1433
1434         exfat_info("sector size:  %s\n",
1435                 bytes_to_human_readable(1 << exfat->bs->bsx.sect_size_bits));
1436         exfat_info("cluster size: %s\n",
1437                 bytes_to_human_readable(exfat->clus_size));
1438         exfat_info("volume size:  %s\n",
1439                 bytes_to_human_readable(exfat->blk_dev->size));
1440
1441         clean = exfat_stat.error_count == 0 ||
1442                 exfat_stat.error_count == exfat_stat.fixed_count;
1443         printf("%s: %s. directories %ld, files %ld\n", dev_name,
1444                         clean ? "clean" : "corrupted",
1445                         exfat_stat.dir_count, exfat_stat.file_count);
1446         if (exfat_stat.error_count)
1447                 printf("%s: files corrupted %ld, files fixed %ld\n", dev_name,
1448                         exfat_stat.error_count - exfat_stat.fixed_count,
1449                         exfat_stat.fixed_count);
1450 }
1451
1452 int main(int argc, char * const argv[])
1453 {
1454         struct fsck_user_input ui;
1455         struct exfat_blk_dev bd;
1456         struct pbr *bs = NULL;
1457         int c, ret, exit_code;
1458         bool version_only = false;
1459
1460         memset(&ui, 0, sizeof(ui));
1461         memset(&bd, 0, sizeof(bd));
1462
1463         print_level = EXFAT_ERROR;
1464
1465         if (!setlocale(LC_CTYPE, ""))
1466                 exfat_err("failed to init locale/codeset\n");
1467
1468         opterr = 0;
1469         while ((c = getopt_long(argc, argv, "arynpbsVvh", opts, NULL)) != EOF) {
1470                 switch (c) {
1471                 case 'n':
1472                         if (ui.options & FSCK_OPTS_REPAIR_ALL)
1473                                 usage(argv[0]);
1474                         ui.options |= FSCK_OPTS_REPAIR_NO;
1475                         break;
1476                 case 'r':
1477                         if (ui.options & FSCK_OPTS_REPAIR_ALL)
1478                                 usage(argv[0]);
1479                         ui.options |= FSCK_OPTS_REPAIR_ASK;
1480                         break;
1481                 case 'y':
1482                         if (ui.options & FSCK_OPTS_REPAIR_ALL)
1483                                 usage(argv[0]);
1484                         ui.options |= FSCK_OPTS_REPAIR_YES;
1485                         break;
1486                 case 'a':
1487                 case 'p':
1488                         if (ui.options & FSCK_OPTS_REPAIR_ALL)
1489                                 usage(argv[0]);
1490                         ui.options |= FSCK_OPTS_REPAIR_AUTO;
1491                         break;
1492                 case 'b':
1493                         ui.options |= FSCK_OPTS_IGNORE_BAD_FS_NAME;
1494                         break;
1495                 case 's':
1496                         ui.options |= FSCK_OPTS_RESCUE_CLUS;
1497                         break;
1498                 case 'V':
1499                         version_only = true;
1500                         break;
1501                 case 'v':
1502                         if (print_level < EXFAT_DEBUG)
1503                                 print_level++;
1504                         break;
1505                 case '?':
1506                 case 'h':
1507                 default:
1508                         usage(argv[0]);
1509                 }
1510         }
1511
1512         show_version();
1513         if (optind != argc - 1)
1514                 usage(argv[0]);
1515
1516         if (version_only)
1517                 exit(FSCK_EXIT_SYNTAX_ERROR);
1518         if (ui.options & FSCK_OPTS_REPAIR_WRITE)
1519                 ui.ei.writeable = true;
1520         else {
1521                 if (ui.options & (FSCK_OPTS_IGNORE_BAD_FS_NAME |
1522                                   FSCK_OPTS_RESCUE_CLUS))
1523                         usage(argv[0]);
1524                 ui.options |= FSCK_OPTS_REPAIR_NO;
1525                 ui.ei.writeable = false;
1526         }
1527
1528         exfat_fsck.options = ui.options;
1529
1530         snprintf(ui.ei.dev_name, sizeof(ui.ei.dev_name), "%s", argv[optind]);
1531         ret = exfat_get_blk_dev_info(&ui.ei, &bd);
1532         if (ret < 0) {
1533                 exfat_err("failed to open %s. %d\n", ui.ei.dev_name, ret);
1534                 return FSCK_EXIT_OPERATION_ERROR;
1535         }
1536
1537         ret = exfat_boot_region_check(&bd, &bs,
1538                                       ui.options & FSCK_OPTS_IGNORE_BAD_FS_NAME ?
1539                                       true : false);
1540         if (ret)
1541                 goto err;
1542
1543         exfat_fsck.exfat = exfat_alloc_exfat(&bd, bs);
1544         if (!exfat_fsck.exfat) {
1545                 ret = -ENOMEM;
1546                 goto err;
1547         }
1548
1549         exfat_fsck.buffer_desc = exfat_alloc_buffer(2,
1550                                                     exfat_fsck.exfat->clus_size,
1551                                                     exfat_fsck.exfat->sect_size);
1552         if (!exfat_fsck.buffer_desc) {
1553                 ret = -ENOMEM;
1554                 goto err;
1555         }
1556
1557         if ((exfat_fsck.options & FSCK_OPTS_REPAIR_WRITE) &&
1558             exfat_mark_volume_dirty(exfat_fsck.exfat, true)) {
1559                 ret = -EIO;
1560                 goto err;
1561         }
1562
1563         exfat_debug("verifying root directory...\n");
1564         ret = exfat_root_dir_check(exfat_fsck.exfat);
1565         if (ret) {
1566                 exfat_err("failed to verify root directory.\n");
1567                 goto out;
1568         }
1569
1570         exfat_debug("verifying directory entries...\n");
1571         ret = exfat_filesystem_check(&exfat_fsck);
1572         if (ret)
1573                 goto out;
1574
1575         if (exfat_fsck.options & FSCK_OPTS_RESCUE_CLUS) {
1576                 rescue_orphan_clusters(&exfat_fsck);
1577                 exfat_fsck.dirty = true;
1578                 exfat_fsck.dirty_fat = true;
1579         }
1580
1581         if (exfat_fsck.options & FSCK_OPTS_REPAIR_WRITE) {
1582                 ret = write_bitmap(&exfat_fsck);
1583                 if (ret) {
1584                         exfat_err("failed to write bitmap\n");
1585                         goto out;
1586                 }
1587         }
1588
1589         if (ui.ei.writeable && fsync(bd.dev_fd)) {
1590                 exfat_err("failed to sync\n");
1591                 ret = -EIO;
1592                 goto out;
1593         }
1594         if (exfat_fsck.options & FSCK_OPTS_REPAIR_WRITE)
1595                 exfat_mark_volume_dirty(exfat_fsck.exfat, false);
1596
1597 out:
1598         exfat_show_info(&exfat_fsck, ui.ei.dev_name);
1599 err:
1600         if (ret && ret != -EINVAL)
1601                 exit_code = FSCK_EXIT_OPERATION_ERROR;
1602         else if (ret == -EINVAL ||
1603                  exfat_stat.error_count != exfat_stat.fixed_count)
1604                 exit_code = FSCK_EXIT_ERRORS_LEFT;
1605         else if (exfat_fsck.dirty)
1606                 exit_code = FSCK_EXIT_CORRECTED;
1607         else
1608                 exit_code = FSCK_EXIT_NO_ERRORS;
1609
1610         if (exfat_fsck.buffer_desc)
1611                 exfat_free_buffer(exfat_fsck.buffer_desc, 2);
1612         if (exfat_fsck.exfat)
1613                 exfat_free_exfat(exfat_fsck.exfat);
1614         close(bd.dev_fd);
1615         return exit_code;
1616 }