boot.c File Reference

#include "vfatlib.h"
#include <debug.h>

Include dependency graph for boot.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	ROUND_TO_MULTIPLE(n, m)   ((n) && (m) ? (n)+(m)-1-((n)-1)%(m) : 0)
#define	FAT12_THRESHOLD   4085
#define	FAT16_THRESHOLD   65525
#define	GET_UNALIGNED_W(f)    ( (uint16_t)f[0] | ((uint16_t)f[1]<<8) )

Functions
static const char *	get_media_descr (unsigned char media)
static void	dump_boot (DOS_FS *fs, struct boot_sector *b, unsigned lss)
static void	check_backup_boot (DOS_FS *fs, struct boot_sector *b, unsigned int lss)
static void	init_fsinfo (struct info_sector *i)
static void	read_fsinfo (DOS_FS *fs, struct boot_sector *b, unsigned int lss)
static char	print_fat_dirty_state (void)
static void	check_fat_state_bit (DOS_FS *fs, void *b)
void	read_boot (DOS_FS *fs)
static void	write_boot_label (DOS_FS *fs, char *label)
off_t	find_volume_de (DOS_FS *fs, DIR_ENT *de)
static void	write_volume_label (DOS_FS *fs, char *label)
void	write_label (DOS_FS *fs, char *label)

Variables
struct {
uint8_t   media
const char *   descr
}	mediabytes []

Macro Definition Documentation

FAT12_THRESHOLD

#define FAT12_THRESHOLD   4085

Definition at line 40 of file boot.c.

FAT16_THRESHOLD

#define FAT16_THRESHOLD   65525

Definition at line 41 of file boot.c.

GET_UNALIGNED_W

#define GET_UNALIGNED_W

(

f

)

( (uint16_t)f[0] | ((uint16_t)f[1]<<8) )

Definition at line 60 of file boot.c.

NDEBUG

#define NDEBUG

Definition at line 33 of file boot.c.

ROUND_TO_MULTIPLE

#define ROUND_TO_MULTIPLE	(		n,
			m
	)		((n) && (m) ? (n)+(m)-1-((n)-1)%(m) : 0)

Definition at line 36 of file boot.c.

Function Documentation

check_backup_boot()

static void check_backup_boot ( DOS_FS *  fs, struct boot_sector *  b, unsigned int  lss  )

static

Definition at line 127 of file boot.c.

{
    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') {
        unsigned 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) {
#ifndef __REACTOS__
        sprintf(buf, "%s%u:%02x/%02x", first ? "" : ", ",
#else
        RtlStringCbPrintfA(buf, sizeof(buf), "%s%u:%02x/%02x", first ? "" : ", ",
#endif // __REACTOS__
            (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;
    }
    }
}

Referenced by read_boot().

check_fat_state_bit()

static void check_fat_state_bit ( DOS_FS *  fs, void *  b  )

static

Definition at line 309 of file boot.c.

{
    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);
        }
    }
    }
}

Referenced by read_boot().

dump_boot()

static void dump_boot ( DOS_FS *  fs, struct boot_sector *  b, unsigned  lss  )

static

Definition at line 74 of file boot.c.

{
    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("%10lld bytes per FAT (= %llu sectors)\n", (long long)fs->fat_size,
       (long long)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));
}

Referenced by read_boot().

find_volume_de()

off_t find_volume_de	(	DOS_FS *	fs,
		DIR_ENT *	de
	)

Definition at line 524 of file boot.c.

{
    uint32_t cluster;
    off_t offset;
    int i;
 
    if (fs->root_cluster) {
    for (cluster = fs->root_cluster;
         cluster != 0 && cluster != -1;
         cluster = next_cluster(fs, cluster)) {
        offset = cluster_start(fs, cluster);
        for (i = 0; i * sizeof(DIR_ENT) < fs->cluster_size; i++) {
        fs_read(offset, sizeof(DIR_ENT), de);
        if (de->attr != VFAT_LN_ATTR && de->attr & ATTR_VOLUME)
            return offset;
        offset += sizeof(DIR_ENT);
        }
    }
    } else {
    for (i = 0; i < fs->root_entries; i++) {
        offset = fs->root_start + i * sizeof(DIR_ENT);
        fs_read(offset, sizeof(DIR_ENT), de);
        if (de->attr != VFAT_LN_ATTR && de->attr & ATTR_VOLUME)
        return offset;
    }
    }
 
    return 0;
}

Referenced by write_volume_label().

get_media_descr()

static const char * get_media_descr ( unsigned char  media )

static

Definition at line 63 of file boot.c.

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

Referenced by dump_boot().

init_fsinfo()

static void init_fsinfo ( struct info_sector *  i )

static

Definition at line 209 of file boot.c.

{
    memset(i, 0, sizeof (struct info_sector));
    i->magic = htole32(0x41615252);
    i->signature = htole32(0x61417272);
    i->free_clusters = htole32(-1);
    i->next_cluster = htole32(2);
    i->boot_sign = htole32(0xaa550000);
}

Referenced by read_fsinfo().

print_fat_dirty_state()

static char print_fat_dirty_state ( void  )

static

Definition at line 288 of file boot.c.

{
    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", "?");
#ifndef __REACTOS__
    } else
#else
    } else if (rw) {
#endif
    printf(" Automatically removing dirty bit.\n");
    return '1';
#ifdef __REACTOS__
    }
    return '2';
#endif
}

Referenced by check_fat_state_bit().

read_boot()

void read_boot

(

DOS_FS *

fs

)

Definition at line 334 of file boot.c.

{
    struct boot_sector b;
    unsigned total_sectors;
    unsigned int logical_sector_size, sectors;
    off_t fat_length;
    unsigned total_fat_entries;
    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);
    if (!fat_length)
    die("FAT size is zero.");
 
    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;
    if (data_size < fs->cluster_size)
    die("Filesystem has no space for any data clusters");
 
    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.",
            (unsigned long)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
#ifdef __REACTOS__
    {
        free(fs->label);
#endif
        fs->label = NULL;
#ifdef __REACTOS__
    }
#endif
    } else if (fs->fat_bits == 32) {
    if (b.extended_sig == 0x29)
        memmove(fs->label, &b.label, 11);
    else
#ifdef __REACTOS__
    {
        free(fs->label);
#endif
        fs->label = NULL;
#ifdef __REACTOS__
    }
#endif
    }
 
    total_fat_entries = (uint64_t)fs->fat_size * 8 / fs->fat_bits;
    if (fs->data_clusters > total_fat_entries - 2)
    die("Filesystem has %u clusters but only space for %u FAT entries.",
        fs->data_clusters, total_fat_entries - 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 (%u 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);
}

Referenced by VfatChkdsk().

read_fsinfo()

static void read_fsinfo ( DOS_FS *  fs, struct boot_sector *  b, unsigned int  lss  )

static

Definition at line 219 of file boot.c.

{
    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 != htole32(0xaa550000)) {
    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 != htole32(0xaa550000))
        printf("  Offset %llu: 0x%08x != expected 0x%08x\n",
           (unsigned long long)offsetof(struct info_sector, boot_sign),
           le32toh(i.boot_sign), 0xaa550000);
    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);
}

Referenced by read_boot().

write_boot_label()

static void write_boot_label ( DOS_FS *  fs, char *  label  )

static

Definition at line 494 of file boot.c.

{
    if (fs->fat_bits == 12 || fs->fat_bits == 16) {
    struct boot_sector_16 b16;
 
    fs_read(0, sizeof(b16), &b16);
    if (b16.extended_sig != 0x29) {
        b16.extended_sig = 0x29;
        b16.serial = 0;
        memmove(b16.fs_type, fs->fat_bits == 12 ? "FAT12   " : "FAT16   ",
            8);
    }
    memmove(b16.label, label, 11);
    fs_write(0, sizeof(b16), &b16);
    } else if (fs->fat_bits == 32) {
    struct boot_sector b;
 
    fs_read(0, sizeof(b), &b);
    if (b.extended_sig != 0x29) {
        b.extended_sig = 0x29;
        b.serial = 0;
        memmove(b.fs_type, "FAT32   ", 8);
    }
    memmove(b.label, label, 11);
    fs_write(0, sizeof(b), &b);
    if (fs->backupboot_start)
        fs_write(fs->backupboot_start, sizeof(b), &b);
    }
}

Referenced by write_label().

write_label()

void write_label	(	DOS_FS *	fs,
		char *	label
	)

Definition at line 589 of file boot.c.

{
    int l = strlen(label);
 
    while (l < 11)
    label[l++] = ' ';
 
    write_boot_label(fs, label);
    write_volume_label(fs, label);
}

write_volume_label()

static void write_volume_label ( DOS_FS *  fs, char *  label  )

static

Definition at line 554 of file boot.c.

{
    time_t now = time(NULL);
    struct tm *mtime = localtime(&now);
    off_t offset;
    int created;
    DIR_ENT de;
 
    created = 0;
    offset = find_volume_de(fs, &de);
    if (offset == 0) {
    created = 1;
    offset = alloc_rootdir_entry(fs, &de, label, 0);
    }
    memcpy(de.name, label, 11);
    de.time = htole16((unsigned short)((mtime->tm_sec >> 1) +
                       (mtime->tm_min << 5) +
                       (mtime->tm_hour << 11)));
    de.date = htole16((unsigned short)(mtime->tm_mday +
                       ((mtime->tm_mon + 1) << 5) +
                       ((mtime->tm_year - 80) << 9)));
    if (created) {
    de.attr = ATTR_VOLUME;
    de.ctime_ms = 0;
    de.ctime = de.time;
    de.cdate = de.date;
    de.adate = de.date;
    de.starthi = 0;
    de.start = 0;
    de.size = 0;
    }
 
    fs_write(offset, sizeof(DIR_ENT), &de);
}

Referenced by write_label().

Variable Documentation

descr

const char* descr

Definition at line 45 of file boot.c.

Referenced by AddItem(), CRYPT_AsnDecodeAccessDescription(), CRYPT_AsnEncodeAccessDescription(), CxxHandleV8Frame(), dwarf2_parse_line_numbers(), get_dc_data_ex(), get_item_data(), get_item_height(), get_item_string(), get_media_descr(), get_sizeof_item(), insert_item_data(), is_item_selected(), LISTBOX_Create(), LISTBOX_DeleteItem(), LISTBOX_Destroy(), LISTBOX_Directory(), LISTBOX_DrawFocusRect(), LISTBOX_FindFileStrPos(), LISTBOX_FindString(), LISTBOX_FindStringPos(), LISTBOX_GetCurrentPageSize(), LISTBOX_GetItemFromPoint(), LISTBOX_GetItemHeight(), LISTBOX_GetItemRect(), LISTBOX_GetMaxTopIndex(), LISTBOX_GetSelCount(), LISTBOX_GetSelItems(), LISTBOX_GetText(), LISTBOX_HandleChar(), LISTBOX_HandleHScroll(), LISTBOX_HandleKeyDown(), LISTBOX_HandleLButtonDown(), LISTBOX_HandleLButtonDownCombo(), LISTBOX_HandleLButtonUp(), LISTBOX_HandleMouseMove(), LISTBOX_HandleMouseWheel(), LISTBOX_HandleSystemTimer(), LISTBOX_HandleTimer(), LISTBOX_HandleVScroll(), LISTBOX_InitStorage(), LISTBOX_InsertItem(), LISTBOX_InsertString(), LISTBOX_InvalidateItemRect(), LISTBOX_InvalidateItems(), LISTBOX_MakeItemVisible(), LISTBOX_MoveCaret(), LISTBOX_NCPaint(), LISTBOX_Paint(), LISTBOX_PaintItem(), LISTBOX_RemoveItem(), LISTBOX_RepaintItem(), LISTBOX_ResetContent(), LISTBOX_SelectItemRange(), LISTBOX_SetCaretIndex(), LISTBOX_SetColumnWidth(), LISTBOX_SetCount(), LISTBOX_SetFont(), LISTBOX_SetHorizontalExtent(), LISTBOX_SetHorizontalPos(), LISTBOX_SetItemHeight(), LISTBOX_SetRedraw(), LISTBOX_SetSelection(), LISTBOX_SetTabStops(), LISTBOX_SetTopItem(), LISTBOX_update_uistate(), LISTBOX_UpdatePage(), LISTBOX_UpdateScroll(), LISTBOX_UpdateSize(), LISTBOX_WindowProc(), ListBoxWndProc_common(), NtUserGetListBoxInfo(), output_typelib_regscript(), process_comment(), process_extra(), remove_item_data(), resize_storage(), set_item_data(), set_item_height(), set_item_selected_state(), set_item_string(), sw_DescribePixelFormat(), test_DC_bitmap(), test_device_caps(), test_import_resolution(), test_multiselect(), test_stdout_handle(), wglDescribePixelFormat(), write_coclass(), and write_progid().

media

uint8_t media

Definition at line 44 of file boot.c.

Referenced by get_media_descr().

struct { ... } mediabytes[]

Initial value:

= {
    {
    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"},}

Referenced by get_media_descr().