[reactos.git] / reactos / sdk / lib / fslib / vfatlib / check / boot.c

/* boot.c - Read and analyze ia PC/MS-DOS boot sector

   Copyright (C) 1993 Werner Almesberger <werner.almesberger@lrc.di.epfl.ch>
   Copyright (C) 1998 Roman Hodek <Roman.Hodek@informatik.uni-erlangen.de>
   Copyright (C) 2008-2014 Daniel Baumann <mail@daniel-baumann.ch>
   Copyright (C) 2015 Andreas Bombe <aeb@debian.org>

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program. If not, see <http://www.gnu.org/licenses/>.

   The complete text of the GNU General Public License
   can be found in /usr/share/common-licenses/GPL-3 file.
*/

/* FAT32, VFAT, Atari format support, and various fixes additions May 1998
 * by Roman Hodek <Roman.Hodek@informatik.uni-erlangen.de> */

#include "vfatlib.h"

#define NDEBUG
#include <debug.h>


#define ROUND_TO_MULTIPLE(n,m) ((n) && (m) ? (n)+(m)-1-((n)-1)%(m) : 0)
    /* don't divide by zero */

/* cut-over cluster counts for FAT12 and FAT16 */
#define FAT12_THRESHOLD  4085
#define FAT16_THRESHOLD 65525

static struct {
    uint8_t media;
    const char *descr;
} mediabytes[] = {
    { 0xf0, "5.25\" or 3.5\" HD floppy" },
    { 0xf8, "hard disk" },
    { 0xf9, "3.5\" 720k floppy 2s/80tr/9sec or "
            "5.25\" 1.2M floppy 2s/80tr/15sec" },
    { 0xfa, "5.25\" 320k floppy 1s/80tr/8sec" },
    { 0xfb, "3.5\" 640k floppy 2s/80tr/8sec" },
    { 0xfc, "5.25\" 180k floppy 1s/40tr/9sec" },
    { 0xfd, "5.25\" 360k floppy 2s/40tr/9sec" },
    { 0xfe, "5.25\" 160k floppy 1s/40tr/8sec" },
    { 0xff, "5.25\" 320k floppy 2s/40tr/8sec" },
};

#if defined __alpha || defined __ia64__ || defined __x86_64__ || defined __ppc64__
/* Unaligned fields must first be copied byte-wise (little endian) */
#define GET_UNALIGNED_W(u) \
    (((unsigned char*)(&u))[0] | (((unsigned char*)&(u))[1] << 8))
#elif defined __s390x__
/* Unaligned fields must first be copied byte-wise (big endian) */
#define GET_UNALIGNED_W(pu) \
    (((unsigned char*)&(u))[1] | (((unsigned char*)&(u))[0] << 8))
#else
#define GET_UNALIGNED_W(f) le16toh( *(unsigned short *)&f )
#endif

static const char *get_media_descr(unsigned char media)
{
    int i;

    for (i = 0; i < sizeof(mediabytes) / sizeof(*mediabytes); ++i) {
        if (mediabytes[i].media == media)
            return (mediabytes[i].descr);
    }
    return ("undefined");
}

static void dump_boot(DOS_FS * fs, struct boot_sector *b, unsigned lss)
{
    unsigned short sectors;

    printf("Boot sector contents:\n");
    if (!atari_format) {
        char id[9];
        strncpy(id, (const char *)b->system_id, 8);
        id[8] = 0;
        printf("System ID \"%s\"\n", id);
    } else {
        /* On Atari, a 24 bit serial number is stored at offset 8 of the boot
         * sector */
        printf("Serial number 0x%x\n",
               b->system_id[5] | (b->system_id[6] << 8) | (b->
                                                           system_id[7] << 16));
    }
    printf("Media byte 0x%02x (%s)\n", b->media, get_media_descr(b->media));
    printf("%10d bytes per logical sector\n", GET_UNALIGNED_W(b->sector_size));
    printf("%10d bytes per cluster\n", fs->cluster_size);
    printf("%10d reserved sector%s\n", le16toh(b->reserved),
           le16toh(b->reserved) == 1 ? "" : "s");
    printf("First FAT starts at byte %llu (sector %llu)\n",
           (unsigned long long)fs->fat_start,
           (unsigned long long)fs->fat_start / lss);
    printf("%10d FATs, %d bit entries\n", b->fats, fs->fat_bits);
    printf("%10d bytes per FAT (= %u sectors)\n", fs->fat_size,
           fs->fat_size / lss);
    if (!fs->root_cluster) {
        printf("Root directory starts at byte %llu (sector %llu)\n",
               (unsigned long long)fs->root_start,
               (unsigned long long)fs->root_start / lss);
        printf("%10d root directory entries\n", fs->root_entries);
    } else {
        printf("Root directory start at cluster %lu (arbitrary size)\n",
               (unsigned long)fs->root_cluster);
    }
    printf("Data area starts at byte %llu (sector %llu)\n",
           (unsigned long long)fs->data_start,
           (unsigned long long)fs->data_start / lss);
    printf("%10lu data clusters (%llu bytes)\n",
           (unsigned long)fs->data_clusters,
           (unsigned long long)fs->data_clusters * fs->cluster_size);
    printf("%u sectors/track, %u heads\n", le16toh(b->secs_track),
           le16toh(b->heads));
    printf("%10u hidden sectors\n", atari_format ?
           /* On Atari, the hidden field is only 16 bit wide and unused */
           (((unsigned char *)&b->hidden)[0] |
            ((unsigned char *)&b->hidden)[1] << 8) : le32toh(b->hidden));
    sectors = GET_UNALIGNED_W(b->sectors);
    printf("%10u sectors total\n", sectors ? sectors : le32toh(b->total_sect));
}

static void check_backup_boot(DOS_FS * fs, struct boot_sector *b, int lss)
{
    struct boot_sector b2;

    if (!fs->backupboot_start) {
        printf("There is no backup boot sector.\n");
        if (le16toh(b->reserved) < 3) {
            printf("And there is no space for creating one!\n");
            return;
        }
        if (interactive)
            printf("1) Create one\n2) Do without a backup\n");
        else
            printf("  Auto-creating backup boot block.\n");
        if (!interactive || get_key("12", "?") == '1') {
            int bbs;
            /* The usual place for the backup boot sector is sector 6. Choose
             * that or the last reserved sector. */
            if (le16toh(b->reserved) >= 7 && le16toh(b->info_sector) != 6)
                bbs = 6;
            else {
                bbs = le16toh(b->reserved) - 1;
                if (bbs == le16toh(b->info_sector))
                    --bbs;      /* this is never 0, as we checked reserved >= 3! */
            }
            fs->backupboot_start = bbs * lss;
            b->backup_boot = htole16(bbs);
            fs_write(fs->backupboot_start, sizeof(*b), b);
            fs_write(offsetof(struct boot_sector, backup_boot),
                     sizeof(b->backup_boot), &b->backup_boot);
            printf("Created backup of boot sector in sector %d\n", bbs);
            return;
        } else
            return;
    }

    fs_read(fs->backupboot_start, sizeof(b2), &b2);
    if (memcmp(b, &b2, sizeof(b2)) != 0) {
        /* there are any differences */
        uint8_t *p, *q;
        int i, pos, first = 1;
        char buf[20];

        printf("There are differences between boot sector and its backup.\n");
        printf("This is mostly harmless. Differences: (offset:original/backup)\n  ");
        pos = 2;
        for (p = (uint8_t *) b, q = (uint8_t *) & b2, i = 0; i < sizeof(b2);
             ++p, ++q, ++i) {
            if (*p != *q) {
                sprintf(buf, "%s%u:%02x/%02x", first ? "" : ", ",
                        (unsigned)(p - (uint8_t *) b), *p, *q);
                if (pos + strlen(buf) > 78)
                    printf("\n  "), pos = 2;
                printf("%s", buf);
                pos += strlen(buf);
                first = 0;
            }
        }
        printf("\n");

        if (interactive)
            printf("1) Copy original to backup\n"
                   "2) Copy backup to original\n" "3) No action\n");
        else
            printf("  Not automatically fixing this.\n");
        switch (interactive ? get_key("123", "?") : '3') {
        case '1':
            fs_write(fs->backupboot_start, sizeof(*b), b);
            break;
        case '2':
            fs_write(0, sizeof(b2), &b2);
            break;
        default:
            break;
        }
    }
}

static void init_fsinfo(struct info_sector *i)
{
    i->magic = htole32(0x41615252);
    i->signature = htole32(0x61417272);
    i->free_clusters = htole32(-1);
    i->next_cluster = htole32(2);
    i->boot_sign = htole16(0xaa55);
}

static void read_fsinfo(DOS_FS * fs, struct boot_sector *b, int lss)
{
    struct info_sector i;

    if (!b->info_sector) {
        printf("No FSINFO sector\n");
        if (interactive)
            printf("1) Create one\n2) Do without FSINFO\n");
        else
            printf("  Not automatically creating it.\n");
        if (interactive && get_key("12", "?") == '1') {
            /* search for a free reserved sector (not boot sector and not
             * backup boot sector) */
            uint32_t s;
            for (s = 1; s < le16toh(b->reserved); ++s)
                if (s != le16toh(b->backup_boot))
                    break;
            if (s > 0 && s < le16toh(b->reserved)) {
                init_fsinfo(&i);
                fs_write((off_t)s * lss, sizeof(i), &i);
                b->info_sector = htole16(s);
                fs_write(offsetof(struct boot_sector, info_sector),
                         sizeof(b->info_sector), &b->info_sector);
                if (fs->backupboot_start)
                    fs_write(fs->backupboot_start +
                             offsetof(struct boot_sector, info_sector),
                             sizeof(b->info_sector), &b->info_sector);
            } else {
                printf("No free reserved sector found -- "
                       "no space for FSINFO sector!\n");
                return;
            }
        } else
            return;
    }

    fs->fsinfo_start = le16toh(b->info_sector) * lss;
    fs_read(fs->fsinfo_start, sizeof(i), &i);

    if (i.magic != htole32(0x41615252) ||
        i.signature != htole32(0x61417272) || i.boot_sign != htole16(0xaa55)) {
        printf("FSINFO sector has bad magic number(s):\n");
        if (i.magic != htole32(0x41615252))
            printf("  Offset %llu: 0x%08x != expected 0x%08x\n",
                   (unsigned long long)offsetof(struct info_sector, magic),
                   le32toh(i.magic), 0x41615252);
        if (i.signature != htole32(0x61417272))
            printf("  Offset %llu: 0x%08x != expected 0x%08x\n",
                   (unsigned long long)offsetof(struct info_sector, signature),
                   le32toh(i.signature), 0x61417272);
        if (i.boot_sign != htole16(0xaa55))
            printf("  Offset %llu: 0x%04x != expected 0x%04x\n",
                   (unsigned long long)offsetof(struct info_sector, boot_sign),
                   le16toh(i.boot_sign), 0xaa55);
        if (interactive)
            printf("1) Correct\n2) Don't correct (FSINFO invalid then)\n");
        else
            printf("  Auto-correcting it.\n");
        if (!interactive || get_key("12", "?") == '1') {
            init_fsinfo(&i);
            fs_write(fs->fsinfo_start, sizeof(i), &i);
        } else
            fs->fsinfo_start = 0;
    }

    if (fs->fsinfo_start)
        fs->free_clusters = le32toh(i.free_clusters);
}

static char print_fat_dirty_state(void)
{
    printf("Dirty bit is set. Fs was not properly unmounted and"
           " some data may be corrupt.\n");

    if (interactive) {
        printf("1) Remove dirty bit\n" "2) No action\n");
        return get_key("12", "?");
    } else
        printf(" Automatically removing dirty bit.\n");
    return '1';
}

static void check_fat_state_bit(DOS_FS * fs, void *b)
{
    if (fs->fat_bits == 32) {
        struct boot_sector *b32 = b;

        if (b32->reserved3 & FAT_STATE_DIRTY) {
            printf("0x41: ");
            if (print_fat_dirty_state() == '1') {
                b32->reserved3 &= ~FAT_STATE_DIRTY;
                fs_write(0, sizeof(*b32), b32);
            }
        }
    } else {
        struct boot_sector_16 *b16 = b;

        if (b16->reserved2 & FAT_STATE_DIRTY) {
            printf("0x25: ");
            if (print_fat_dirty_state() == '1') {
                b16->reserved2 &= ~FAT_STATE_DIRTY;
                fs_write(0, sizeof(*b16), b16);
            }
        }
    }
}

void read_boot(DOS_FS * fs)
{
    struct boot_sector b;
    unsigned total_sectors;
    unsigned short logical_sector_size, sectors;
    unsigned fat_length;
    off_t data_size;

    fs_read(0, sizeof(b), &b);
    logical_sector_size = GET_UNALIGNED_W(b.sector_size);
    if (!logical_sector_size)
        die("Logical sector size is zero.");

    /* This was moved up because it's the first thing that will fail */
    /* if the platform needs special handling of unaligned multibyte accesses */
    /* but such handling isn't being provided. See GET_UNALIGNED_W() above. */
    if (logical_sector_size & (SECTOR_SIZE - 1))
        die("Logical sector size (%d bytes) is not a multiple of the physical "
            "sector size.", logical_sector_size);

    fs->cluster_size = b.cluster_size * logical_sector_size;
    if (!fs->cluster_size)
        die("Cluster size is zero.");
    if (b.fats != 2 && b.fats != 1)
        die("Currently, only 1 or 2 FATs are supported, not %d.\n", b.fats);
    fs->nfats = b.fats;
    sectors = GET_UNALIGNED_W(b.sectors);
    total_sectors = sectors ? sectors : le32toh(b.total_sect);
    if (verbose)
        printf("Checking we can access the last sector of the filesystem\n");
    /* Can't access last odd sector anyway, so round down */
    fs_test((off_t)((total_sectors & ~1) - 1) * logical_sector_size,
            logical_sector_size);
    fat_length = le16toh(b.fat_length) ?
        le16toh(b.fat_length) : le32toh(b.fat32_length);
    fs->fat_start = (off_t)le16toh(b.reserved) * logical_sector_size;
    fs->root_start = ((off_t)le16toh(b.reserved) + b.fats * fat_length) *
        logical_sector_size;
    fs->root_entries = GET_UNALIGNED_W(b.dir_entries);
    fs->data_start = fs->root_start + ROUND_TO_MULTIPLE(fs->root_entries <<
                                                        MSDOS_DIR_BITS,
                                                        logical_sector_size);
    data_size = (off_t)total_sectors * logical_sector_size - fs->data_start;
    fs->data_clusters = data_size / fs->cluster_size;
    fs->root_cluster = 0;       /* indicates standard, pre-FAT32 root dir */
    fs->fsinfo_start = 0;       /* no FSINFO structure */
    fs->free_clusters = -1;     /* unknown */
    if (!b.fat_length && b.fat32_length) {
        fs->fat_bits = 32;
        fs->root_cluster = le32toh(b.root_cluster);
        if (!fs->root_cluster && fs->root_entries)
            /* M$ hasn't specified this, but it looks reasonable: If
             * root_cluster is 0 but there is a separate root dir
             * (root_entries != 0), we handle the root dir the old way. Give a
             * warning, but convertig to a root dir in a cluster chain seems
             * to complex for now... */
            printf("Warning: FAT32 root dir not in cluster chain! "
                   "Compatibility mode...\n");
        else if (!fs->root_cluster && !fs->root_entries)
            die("No root directory!");
        else if (fs->root_cluster && fs->root_entries)
            printf("Warning: FAT32 root dir is in a cluster chain, but "
                   "a separate root dir\n"
                   "  area is defined. Cannot fix this easily.\n");
        if (fs->data_clusters < FAT16_THRESHOLD)
            printf("Warning: Filesystem is FAT32 according to fat_length "
                   "and fat32_length fields,\n"
                   "  but has only %lu clusters, less than the required "
                   "minimum of %d.\n"
                   "  This may lead to problems on some systems.\n",
                   (unsigned long)fs->data_clusters, FAT16_THRESHOLD);

        check_fat_state_bit(fs, &b);
        fs->backupboot_start = le16toh(b.backup_boot) * logical_sector_size;
        check_backup_boot(fs, &b, logical_sector_size);

        read_fsinfo(fs, &b, logical_sector_size);
    } else if (!atari_format) {
        /* On real MS-DOS, a 16 bit FAT is used whenever there would be too
         * much clusers otherwise. */
        fs->fat_bits = (fs->data_clusters >= FAT12_THRESHOLD) ? 16 : 12;
        if (fs->data_clusters >= FAT16_THRESHOLD)
            die("Too many clusters (%lu) for FAT16 filesystem.", fs->data_clusters);
        check_fat_state_bit(fs, &b);
    } else {
        /* On Atari, things are more difficult: GEMDOS always uses 12bit FATs
         * on floppies, and always 16 bit on harddisks. */
        fs->fat_bits = 16;      /* assume 16 bit FAT for now */
        /* If more clusters than fat entries in 16-bit fat, we assume
         * it's a real MSDOS FS with 12-bit fat. */
        if (fs->data_clusters + 2 > fat_length * logical_sector_size * 8 / 16 ||
            /* if it has one of the usual floppy sizes -> 12bit FAT  */
            (total_sectors == 720 || total_sectors == 1440 ||
             total_sectors == 2880))
            fs->fat_bits = 12;
    }
    /* On FAT32, the high 4 bits of a FAT entry are reserved */
    fs->eff_fat_bits = (fs->fat_bits == 32) ? 28 : fs->fat_bits;
    fs->fat_size = fat_length * logical_sector_size;

    fs->label = calloc(12, sizeof(uint8_t));
    if (fs->fat_bits == 12 || fs->fat_bits == 16) {
        struct boot_sector_16 *b16 = (struct boot_sector_16 *)&b;
        if (b16->extended_sig == 0x29)
            memmove(fs->label, b16->label, 11);
        else
            fs->label = NULL;
    } else if (fs->fat_bits == 32) {
        if (b.extended_sig == 0x29)
            memmove(fs->label, &b.label, 11);
        else
            fs->label = NULL;
    }

    if (fs->data_clusters >
        ((uint64_t)fs->fat_size * 8 / fs->fat_bits) - 2)
        die("Filesystem has %d clusters but only space for %d FAT entries.",
            fs->data_clusters,
            ((unsigned long long)fs->fat_size * 8 / fs->fat_bits) - 2);
    if (!fs->root_entries && !fs->root_cluster)
        die("Root directory has zero size.");
    if (fs->root_entries & (MSDOS_DPS - 1))
        die("Root directory (%d entries) doesn't span an integral number of "
            "sectors.", fs->root_entries);
    if (logical_sector_size & (SECTOR_SIZE - 1))
        die("Logical sector size (%d bytes) is not a multiple of the physical "
            "sector size.", logical_sector_size);
#if 0                           /* linux kernel doesn't check that either */
    /* ++roman: On Atari, these two fields are often left uninitialized */
    if (!atari_format && (!b.secs_track || !b.heads))
        die("Invalid disk format in boot sector.");
#endif
    if (verbose)
        dump_boot(fs, &b, logical_sector_size);
}