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