libparted/fs/fat/bootsector.c

   1 /*
   2     libparted
   3     Copyright (C) 1998, 1999, 2000, 2002, 2004, 2007 Free Software Foundation, Inc.
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 3 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19 #include <config.h>
  20 #include "fat.h"
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <sys/types.h>
  26 #include <sys/stat.h>
  27 #include <fcntl.h>
  28 #include <errno.h>
  29
  30 /* Reads in the boot sector (superblock), and does a minimum of sanity
  31  * checking.  The goals are:
  32  *      - to detect fat file systems, even if they are damaged [i.e. not
  33  * return an error / throw an exception]
  34  *      - to fail detection if there's not enough information for
  35  * fat_boot_sector_probe_type() to work (or possibly crash on a divide-by-zero)
  36  */
  37 int
  38 fat_boot_sector_read (FatBootSector* bs, const PedGeometry *geom)
  39 {
  40         PED_ASSERT (bs != NULL, return 0);
  41         PED_ASSERT (geom != NULL, return 0);
  42
  43         if (!ped_geometry_read (geom, bs, 0, 1))
  44                 return 0;
  45
  46         if (PED_LE16_TO_CPU (bs->boot_sign) != 0xAA55) {
  47                 ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
  48                         _("File system has an invalid signature for a FAT "
  49                           "file system."));
  50                 return 0;
  51         }
  52
  53         if (!bs->system_id[0]) {
  54                 ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
  55                         _("File system has an invalid signature for a FAT "
  56                           "file system."));
  57                 return 0;
  58         }
  59
  60         if (!bs->sector_size
  61             || PED_LE16_TO_CPU (bs->sector_size) % PED_SECTOR_SIZE_DEFAULT) {
  62                 ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
  63                         _("File system has an invalid sector size for a FAT "
  64                           "file system."));
  65                 return 0;
  66         }
  67
  68         if (!bs->cluster_size) {
  69                 ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
  70                         _("File system has an invalid cluster size for a FAT "
  71                           "file system."));
  72                 return 0;
  73         }
  74
  75         if (!bs->reserved) {
  76                 ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
  77                         _("File system has an invalid number of reserved "
  78                           "sectors for a FAT file system."));
  79                 return 0;
  80         }
  81
  82         if (bs->fats < 1 || bs->fats > 4) {
  83                 ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
  84                         _("File system has an invalid number of FATs."));
  85                 return 0;
  86         }
  87
  88         return 1;
  89 }
  90
  91 /*
  92     Don't trust the FAT12, FAT16 or FAT32 label string.
  93  */
  94 FatType
  95 fat_boot_sector_probe_type (const FatBootSector* bs, const PedGeometry* geom)
  96 {
  97         PedSector       logical_sector_size;
  98         PedSector       first_cluster_sector;
  99         FatCluster      cluster_count;
 100
 101         if (!PED_LE16_TO_CPU (bs->dir_entries))
 102                 return FAT_TYPE_FAT32;
 103
 104         logical_sector_size = PED_LE16_TO_CPU (bs->sector_size) / 512;
 105
 106         first_cluster_sector
 107                 = PED_LE16_TO_CPU (bs->reserved) * logical_sector_size
 108                   + 2 * PED_LE16_TO_CPU (bs->fat_length) * logical_sector_size
 109                   + PED_LE16_TO_CPU (bs->dir_entries)
 110                         / (512 / sizeof (FatDirEntry));
 111         cluster_count = (geom->length - first_cluster_sector)
 112                         / bs->cluster_size / logical_sector_size;
 113         if (cluster_count > MAX_FAT12_CLUSTERS)
 114                 return FAT_TYPE_FAT16;
 115         else
 116                 return FAT_TYPE_FAT12;
 117 }
 118
 119 /* Analyses the boot sector, and sticks appropriate numbers in
 120    fs->type_specific.
 121
 122    Note: you need to subtract (2 * cluster_sectors) off cluster offset,
 123    because the first cluster is number 2.  (0 and 1 are not real clusters,
 124    and referencing them is a bug)
 125  */
 126 int
 127 fat_boot_sector_analyse (FatBootSector* bs, PedFileSystem* fs)
 128 {
 129         FatSpecific*            fs_info = FAT_SPECIFIC (fs);
 130         int                     fat_entry_size;
 131
 132         PED_ASSERT (bs != NULL, return 0);
 133
 134         if (PED_LE16_TO_CPU (bs->sector_size) != 512) {
 135                 if (ped_exception_throw (
 136                         PED_EXCEPTION_BUG,
 137                         PED_EXCEPTION_IGNORE_CANCEL,
 138                         _("This file system has a logical sector size of %d.  "
 139                         "GNU Parted is known not to work properly with sector "
 140                         "sizes other than 512 bytes."),
 141                         (int) PED_LE16_TO_CPU (bs->sector_size))
 142                                 != PED_EXCEPTION_IGNORE)
 143                         return 0;
 144         }
 145
 146         fs_info->logical_sector_size = PED_LE16_TO_CPU (bs->sector_size) / 512;
 147
 148         fs_info->sectors_per_track = PED_LE16_TO_CPU (bs->secs_track);
 149         fs_info->heads = PED_LE16_TO_CPU (bs->heads);
 150         if (fs_info->sectors_per_track < 1 || fs_info->sectors_per_track > 63
 151             || fs_info->heads < 1 || fs_info->heads > 255) {
 152                 PedCHSGeometry* bios_geom = &fs->geom->dev->bios_geom;
 153                 int cyl_count = 0;
 154
 155                 if (fs_info->heads > 0 && fs_info->sectors_per_track > 0)
 156                         cyl_count = fs->geom->dev->length / fs_info->heads
 157                                         / fs_info->sectors_per_track;
 158
 159                 switch (ped_exception_throw (
 160                         PED_EXCEPTION_ERROR,
 161                         PED_EXCEPTION_FIX + PED_EXCEPTION_IGNORE
 162                         + PED_EXCEPTION_CANCEL,
 163                         _("The file system's CHS geometry is (%d, %d, %d), "
 164                           "which is invalid.  The partition table's CHS "
 165                           "geometry is (%d, %d, %d).  If you select Ignore, "
 166                           "the file system's CHS geometry will be left "
 167                           "unchanged.  If you select Fix, the file system's "
 168                           "CHS geometry will be set to match the partition "
 169                           "table's CHS geometry."),
 170                          cyl_count, fs_info->heads, fs_info->sectors_per_track,
 171                          bios_geom->cylinders, bios_geom->heads,
 172                          bios_geom->sectors)) {
 173
 174                 case PED_EXCEPTION_FIX:
 175                         fs_info->sectors_per_track = bios_geom->sectors;
 176                         fs_info->heads = bios_geom->heads;
 177                         bs->secs_track
 178                                 = PED_CPU_TO_LE16 (fs_info->sectors_per_track);
 179                         bs->heads = PED_CPU_TO_LE16 (fs_info->heads);
 180                         if (!fat_boot_sector_write (bs, fs))
 181                                 return 0;
 182                         break;
 183
 184                 case PED_EXCEPTION_CANCEL:
 185                         return 0;
 186
 187                 case PED_EXCEPTION_IGNORE:
 188                         break;
 189
 190                 default:
 191                         break;
 192                 }
 193         }
 194
 195         if (bs->sectors)
 196                 fs_info->sector_count = PED_LE16_TO_CPU (bs->sectors)
 197                                                 * fs_info->logical_sector_size;
 198         else
 199                 fs_info->sector_count = PED_LE32_TO_CPU (bs->sector_count)
 200                                                 * fs_info->logical_sector_size;
 201
 202         fs_info->fat_table_count = bs->fats;
 203         fs_info->root_dir_entry_count = PED_LE16_TO_CPU (bs->dir_entries);
 204         fs_info->fat_offset = PED_LE16_TO_CPU (bs->reserved)
 205                                         * fs_info->logical_sector_size;
 206         fs_info->cluster_sectors = bs->cluster_size
 207                                    * fs_info->logical_sector_size;
 208         fs_info->cluster_size = fs_info->cluster_sectors * 512;
 209
 210         if (fs_info->logical_sector_size == 0) {
 211                 ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
 212                         _("FAT boot sector says logical sector size is 0.  "
 213                           "This is weird. "));
 214                 return 0;
 215         }
 216         if (fs_info->fat_table_count == 0) {
 217                 ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
 218                         _("FAT boot sector says there are no FAT tables.  This "
 219                           "is weird. "));
 220                 return 0;
 221         }
 222         if (fs_info->cluster_sectors == 0) {
 223                 ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
 224                         _("FAT boot sector says clusters are 0 sectors.  This "
 225                           "is weird. "));
 226                 return 0;
 227         }
 228
 229         fs_info->fat_type = fat_boot_sector_probe_type (bs, fs->geom);
 230         if (fs_info->fat_type == FAT_TYPE_FAT12) {
 231                 ped_exception_throw (
 232                         PED_EXCEPTION_NO_FEATURE,
 233                         PED_EXCEPTION_CANCEL,
 234                         _("File system is FAT12, which is unsupported."));
 235                 return 0;
 236         }
 237         if (fs_info->fat_type == FAT_TYPE_FAT16) {
 238                 fs_info->fat_sectors = PED_LE16_TO_CPU (bs->fat_length)
 239                                        * fs_info->logical_sector_size;
 240                 fs_info->serial_number
 241                         = PED_LE32_TO_CPU (bs->u.fat16.serial_number);
 242                 fs_info->root_cluster = 0;
 243                 fs_info->root_dir_offset
 244                         = fs_info->fat_offset
 245                           + fs_info->fat_sectors * fs_info->fat_table_count;
 246                 fs_info->root_dir_sector_count
 247                         = fs_info->root_dir_entry_count * sizeof (FatDirEntry)
 248                           / (512 * fs_info->logical_sector_size);
 249                 fs_info->cluster_offset
 250                         = fs_info->root_dir_offset
 251                           + fs_info->root_dir_sector_count;
 252         }
 253         if (fs_info->fat_type == FAT_TYPE_FAT32) {
 254                 fs_info->fat_sectors = PED_LE32_TO_CPU (bs->u.fat32.fat_length)
 255                                         * fs_info->logical_sector_size;
 256                 fs_info->serial_number
 257                         = PED_LE32_TO_CPU (bs->u.fat32.serial_number);
 258                 fs_info->info_sector_offset
 259                     = PED_LE16_TO_CPU (fs_info->boot_sector.u.fat32.info_sector)
 260                           * fs_info->logical_sector_size;
 261                 fs_info->boot_sector_backup_offset
 262                   = PED_LE16_TO_CPU (fs_info->boot_sector.u.fat32.backup_sector)
 263                           * fs_info->logical_sector_size;
 264                 fs_info->root_cluster
 265                         = PED_LE32_TO_CPU (bs->u.fat32.root_dir_cluster);
 266                 fs_info->root_dir_offset = 0;
 267                 fs_info->root_dir_sector_count = 0;
 268                 fs_info->cluster_offset
 269                         = fs_info->fat_offset
 270                           + fs_info->fat_sectors * fs_info->fat_table_count;
 271         }
 272
 273         fs_info->cluster_count
 274                 = (fs_info->sector_count - fs_info->cluster_offset)
 275                   / fs_info->cluster_sectors;
 276
 277         fat_entry_size = fat_table_entry_size (fs_info->fat_type);
 278         if (fs_info->cluster_count + 2
 279                         > fs_info->fat_sectors * 512 / fat_entry_size)
 280                 fs_info->cluster_count
 281                         = fs_info->fat_sectors * 512 / fat_entry_size - 2;
 282
 283         fs_info->dir_entries_per_cluster
 284                 = fs_info->cluster_size / sizeof (FatDirEntry);
 285         return 1;
 286 }
 287
 288 #ifndef DISCOVER_ONLY
 289 int
 290 fat_boot_sector_set_boot_code (FatBootSector* bs)
 291 {
 292         PED_ASSERT (bs != NULL, return 0);
 293
 294         memset (bs, 0, 512);
 295         memcpy (bs->boot_jump, FAT_BOOT_JUMP, 3);
 296         memcpy (bs->u.fat32.boot_code, FAT_BOOT_CODE, FAT_BOOT_CODE_LENGTH);
 297         return 1;
 298 }
 299
 300 int
 301 fat_boot_sector_generate (FatBootSector* bs, const PedFileSystem* fs)
 302 {
 303         FatSpecific*    fs_info = FAT_SPECIFIC (fs);
 304
 305         PED_ASSERT (bs != NULL, return 0);
 306
 307         memcpy (bs->system_id, "MSWIN4.1", 8);
 308         bs->sector_size = PED_CPU_TO_LE16 (fs_info->logical_sector_size * 512);
 309         bs->cluster_size = fs_info->cluster_sectors
 310                                 / fs_info->logical_sector_size;
 311         bs->reserved = PED_CPU_TO_LE16 (fs_info->fat_offset
 312                                         / fs_info->logical_sector_size);
 313         bs->fats = fs_info->fat_table_count;
 314
 315         bs->dir_entries = (fs_info->fat_type == FAT_TYPE_FAT16)
 316                           ? PED_CPU_TO_LE16 (fs_info->root_dir_entry_count)
 317                           : 0;
 318
 319         if (fs_info->sector_count / fs_info->logical_sector_size > 0xffff
 320                 || fs_info->fat_type == FAT_TYPE_FAT32) {
 321                 bs->sectors = 0;
 322                 bs->sector_count = PED_CPU_TO_LE32 (fs_info->sector_count
 323                                                 / fs_info->logical_sector_size);
 324         } else {
 325                 bs->sectors = PED_CPU_TO_LE16 (fs_info->sector_count
 326                                                / fs_info->logical_sector_size);
 327                 bs->sector_count = 0;
 328         }
 329
 330         bs->media = 0xf8;
 331
 332         bs->secs_track = PED_CPU_TO_LE16 (fs_info->sectors_per_track);
 333         bs->heads = PED_CPU_TO_LE16 (fs_info->heads);
 334         bs->hidden = PED_CPU_TO_LE32 (fs->geom->start);
 335
 336         if (fs_info->fat_type == FAT_TYPE_FAT32) {
 337                 bs->fat_length = 0;
 338                 bs->u.fat32.fat_length = PED_CPU_TO_LE32 (fs_info->fat_sectors
 339                                                 / fs_info->logical_sector_size);
 340                 bs->u.fat32.flags = 0;  /* FIXME: what the hell are these? */
 341                 bs->u.fat32.version = 0;  /* must be 0, for Win98 bootstrap */
 342                 bs->u.fat32.root_dir_cluster
 343                         = PED_CPU_TO_LE32 (fs_info->root_cluster);
 344                 bs->u.fat32.info_sector
 345                         = PED_CPU_TO_LE16 (fs_info->info_sector_offset
 346                                            / fs_info->logical_sector_size);
 347                 bs->u.fat32.backup_sector
 348                         = PED_CPU_TO_LE16 (fs_info->boot_sector_backup_offset
 349                                            / fs_info->logical_sector_size);
 350
 351                 bs->u.fat32.drive_num = 0x80;   /* _ALWAYS_ 0x80.  silly DOS */
 352
 353                 memset (bs->u.fat32.empty_1, 0, 12);
 354
 355                 bs->u.fat32.ext_signature = 0x29;
 356                 bs->u.fat32.serial_number
 357                         = PED_CPU_TO_LE32 (fs_info->serial_number);
 358                 memcpy (bs->u.fat32.volume_name, "NO NAME    ", 11);
 359                 memcpy (bs->u.fat32.fat_name, "FAT32   ", 8);
 360         } else {
 361                 bs->fat_length
 362                         = PED_CPU_TO_LE16 (fs_info->fat_sectors
 363                                            / fs_info->logical_sector_size);
 364
 365                 bs->u.fat16.drive_num = 0x80;   /* _ALWAYS_ 0x80.  silly DOS */
 366
 367                 bs->u.fat16.ext_signature = 0x29;
 368                 bs->u.fat16.serial_number
 369                         = PED_CPU_TO_LE32 (fs_info->serial_number);
 370                 memcpy (bs->u.fat16.volume_name, "NO NAME    ", 11);
 371                 memcpy (bs->u.fat16.fat_name, "FAT16   ", 8);
 372         }
 373
 374         bs->boot_sign = PED_CPU_TO_LE16 (0xaa55);
 375
 376         return 1;
 377 }
 378
 379 int
 380 fat_boot_sector_write (const FatBootSector* bs, PedFileSystem* fs)
 381 {
 382         FatSpecific*    fs_info = FAT_SPECIFIC (fs);
 383
 384         PED_ASSERT (bs != NULL, return 0);
 385
 386         if (!ped_geometry_write (fs->geom, bs, 0, 1))
 387                 return 0;
 388         if (fs_info->fat_type == FAT_TYPE_FAT32) {
 389                 if (!ped_geometry_write (fs->geom, bs,
 390                                          fs_info->boot_sector_backup_offset, 1))
 391                         return 0;
 392         }
 393         return ped_geometry_sync (fs->geom);
 394 }
 395
 396 int
 397 fat_info_sector_read (FatInfoSector* is, const PedFileSystem* fs)
 398 {
 399         FatSpecific*    fs_info = FAT_SPECIFIC (fs);
 400         int             status;
 401
 402         PED_ASSERT (is != NULL, return 0);
 403
 404         if (!ped_geometry_read (fs->geom, is, fs_info->info_sector_offset, 1))
 405                 return 0;
 406
 407         if (PED_LE32_TO_CPU (is->signature_2) != FAT32_INFO_MAGIC2) {
 408                 status = ped_exception_throw (PED_EXCEPTION_WARNING,
 409                                 PED_EXCEPTION_IGNORE_CANCEL,
 410                                 _("The information sector has the wrong "
 411                                 "signature (%x).  Select cancel for now, "
 412                                 "and send in a bug report.  If you're "
 413                                 "desperate, it's probably safe to ignore."),
 414                                 PED_LE32_TO_CPU (is->signature_2));
 415                 if (status == PED_EXCEPTION_CANCEL) return 0;
 416         }
 417         return 1;
 418 }
 419
 420 int
 421 fat_info_sector_generate (FatInfoSector* is, const PedFileSystem* fs)
 422 {
 423         FatSpecific*    fs_info = FAT_SPECIFIC (fs);
 424
 425         PED_ASSERT (is != NULL, return 0);
 426
 427         fat_table_count_stats (fs_info->fat);
 428
 429         memset (is, 0, 512);
 430
 431         is->signature_1 = PED_CPU_TO_LE32 (FAT32_INFO_MAGIC1);
 432         is->signature_2 = PED_CPU_TO_LE32 (FAT32_INFO_MAGIC2);
 433         is->free_clusters = PED_CPU_TO_LE32 (fs_info->fat->free_cluster_count);
 434         is->next_cluster = PED_CPU_TO_LE32 (fs_info->fat->last_alloc);
 435         is->signature_3 = PED_CPU_TO_LE16 (FAT32_INFO_MAGIC3);
 436
 437         return 1;
 438 }
 439
 440 int
 441 fat_info_sector_write (const FatInfoSector* is, PedFileSystem *fs)
 442 {
 443         FatSpecific*    fs_info = FAT_SPECIFIC (fs);
 444
 445         PED_ASSERT (is != NULL, return 0);
 446
 447         if (!ped_geometry_write (fs->geom, is, fs_info->info_sector_offset, 1))
 448                 return 0;
 449         return ped_geometry_sync (fs->geom);
 450 }
 451 #endif /* !DISCOVER_ONLY */
 452