usr/src/cmd/fs.d/pcfs/fsck/bpb.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2011 Gary Mills
  24  *
  25  * Copyright (c) 1999,2000 by Sun Microsystems, Inc.
  26  * All rights reserved.
  27  */
  28
  29 /*
  30  * fsck_pcfs -- routines for manipulating the BPB (BIOS parameter block)
  31  * of the file system.
  32  */
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <unistd.h>
  37 #include <libintl.h>
  38 #include <sys/types.h>
  39 #include <sys/dktp/fdisk.h>
  40 #include <sys/fs/pc_fs.h>
  41 #include <sys/fs/pc_dir.h>
  42 #include <sys/fs/pc_label.h>
  43 #include "pcfs_common.h"
  44 #include "fsck_pcfs.h"
  45 #include "pcfs_bpb.h"
  46
  47 extern  off64_t FirstClusterOffset;
  48 extern  off64_t PartitionOffset;
  49 extern  int32_t BytesPerCluster;
  50 extern  int32_t TotalClusters;
  51 extern  int32_t LastCluster;
  52 extern  int32_t RootDirSize;
  53 extern  int32_t FATSize;
  54 extern  short   FATEntrySize;
  55 extern  bpb_t   TheBIOSParameterBlock;
  56 extern  int     IsFAT32;
  57 extern  int     Verbose;
  58
  59 static void
  60 computeFileAreaSize(void)
  61 {
  62         int32_t dataSectors;
  63         int32_t overhead;
  64
  65         /*
  66          * Compute bytes/cluster for later reference
  67          */
  68         BytesPerCluster =  TheBIOSParameterBlock.bpb.sectors_per_cluster *
  69             TheBIOSParameterBlock.bpb.bytes_per_sector;
  70
  71         /*
  72          * First we'll find total number of sectors in the file area...
  73          */
  74         if (TheBIOSParameterBlock.bpb.sectors_in_volume > 0)
  75                 dataSectors = TheBIOSParameterBlock.bpb.sectors_in_volume;
  76         else
  77                 dataSectors =
  78                     TheBIOSParameterBlock.bpb.sectors_in_logical_volume;
  79
  80         overhead = TheBIOSParameterBlock.bpb.resv_sectors;
  81
  82         RootDirSize = TheBIOSParameterBlock.bpb.num_root_entries *
  83             sizeof (struct pcdir);
  84         overhead += RootDirSize / TheBIOSParameterBlock.bpb.bytes_per_sector;
  85
  86         if (TheBIOSParameterBlock.bpb.sectors_per_fat) {
  87                 /*
  88                  * Good old FAT12 or FAT16
  89                  */
  90                 overhead += TheBIOSParameterBlock.bpb.num_fats *
  91                     TheBIOSParameterBlock.bpb.sectors_per_fat;
  92                 /*
  93                  * Compute this for later - when we actually pull in a copy
  94                  * of the FAT
  95                  */
  96                 FATSize = TheBIOSParameterBlock.bpb.sectors_per_fat *
  97                     TheBIOSParameterBlock.bpb.bytes_per_sector;
  98         } else {
  99                 /*
 100                  *  FAT32
 101                  *  I'm unsure if this is always going to work.  At one
 102                  *  point during the creation of this program and mkfs_pcfs
 103                  *  it seemed that Windows had created an fs where it had
 104                  *  rounded big_sectors_per_fat up to a cluster boundary.
 105                  *  Later, though, I encountered a problem where I wasn't
 106                  *  finding the root directory because I was looking in the
 107                  *  wrong place by doing that same roundup.  So, for now,
 108                  *  I'm backing off on the cluster boundary thing and just
 109                  *  believing what I am told.
 110                  */
 111                 overhead += TheBIOSParameterBlock.bpb.num_fats *
 112                     TheBIOSParameterBlock.bpb32.big_sectors_per_fat;
 113                 /*
 114                  * Compute this for later - when we actually pull in a copy
 115                  * of the FAT
 116                  */
 117                 FATSize = TheBIOSParameterBlock.bpb32.big_sectors_per_fat *
 118                     TheBIOSParameterBlock.bpb.bytes_per_sector;
 119         }
 120
 121         /*
 122          * Now change sectors to clusters.  The computed value for
 123          * TotalClusters is persistent for the remainder of execution.
 124          */
 125         dataSectors -= overhead;
 126         TotalClusters = dataSectors /
 127             TheBIOSParameterBlock.bpb.sectors_per_cluster;
 128
 129         /*
 130          *  Also need to compute last cluster and offset of the first cluster
 131          */
 132         LastCluster = TotalClusters + FIRST_CLUSTER;
 133         FirstClusterOffset = overhead *
 134             TheBIOSParameterBlock.bpb.bytes_per_sector;
 135         FirstClusterOffset += PartitionOffset;
 136
 137         /*
 138          * XXX this should probably be more sophisticated
 139          */
 140         if (IsFAT32)
 141                 FATEntrySize = 32;
 142         else {
 143                 if (TotalClusters <= DOS_F12MAXC)
 144                         FATEntrySize = 12;
 145                 else
 146                         FATEntrySize = 16;
 147         }
 148
 149         if (Verbose) {
 150                 (void) fprintf(stderr,
 151                     gettext("Disk has a file area of %d "
 152                     "allocation units,\neach with %d sectors = %llu "
 153                     "bytes.\n"), TotalClusters,
 154                     TheBIOSParameterBlock.bpb.sectors_per_cluster,
 155                     (uint64_t)TotalClusters *
 156                     TheBIOSParameterBlock.bpb.sectors_per_cluster *
 157                     TheBIOSParameterBlock.bpb.bytes_per_sector);
 158                 (void) fprintf(stderr,
 159                     gettext("File system overhead of %d sectors.\n"), overhead);
 160                 (void) fprintf(stderr,
 161                     gettext("The last cluster is %d\n"), LastCluster);
 162         }
 163 }
 164
 165 /*
 166  *  XXX - right now we aren't attempting to fix anything that looks bad,
 167  *      instead we just give up.
 168  */
 169 void
 170 readBPB(int fd)
 171 {
 172         boot_sector_t ubpb;
 173
 174         /*
 175          *  The BPB is the first sector of the file system
 176          */
 177         if (lseek64(fd, PartitionOffset, SEEK_SET) < 0) {
 178                 mountSanityCheckFails();
 179                 perror(gettext("Cannot seek to start of disk partition"));
 180                 (void) close(fd);
 181                 exit(7);
 182         }
 183         if (Verbose)
 184                 (void) fprintf(stderr,
 185                     gettext("Reading BIOS parameter block\n"));
 186         if (read(fd, ubpb.buf, BPSEC) < BPSEC) {
 187                 mountSanityCheckFails();
 188                 perror(gettext("Read BIOS parameter block"));
 189                 (void) close(fd);
 190                 exit(2);
 191         }
 192
 193         if (ltohs(ubpb.mb.signature) != BOOTSECSIG) {
 194                 mountSanityCheckFails();
 195                 (void) fprintf(stderr,
 196                     gettext("Bad signature on BPB. Giving up.\n"));
 197                 exit(2);
 198         }
 199
 200 #ifdef _BIG_ENDIAN
 201         swap_pack_grabbpb(&TheBIOSParameterBlock, &(ubpb.bs));
 202 #else
 203         (void) memcpy(&(TheBIOSParameterBlock.bpb), &(ubpb.bs.bs_front.bs_bpb),
 204             sizeof (TheBIOSParameterBlock.bpb));
 205         (void) memcpy(&(TheBIOSParameterBlock.ebpb), &(ubpb.bs.bs_ebpb),
 206             sizeof (TheBIOSParameterBlock.ebpb));
 207 #endif
 208         /*
 209          * In general, we would expect the bytes per sector to
 210          * equal 256 (BPSEC).  I personally have yet to see a file
 211          * system where this isn't true but apparently some weird media
 212          * have different sector sizes.  So we'll accept a couple of
 213          * other small multiples of 256 as valid sizes.
 214          */
 215         if (TheBIOSParameterBlock.bpb.bytes_per_sector != BPSEC &&
 216             TheBIOSParameterBlock.bpb.bytes_per_sector != 2 * BPSEC &&
 217             TheBIOSParameterBlock.bpb.bytes_per_sector != 4 * BPSEC) {
 218                 mountSanityCheckFails();
 219                 (void) fprintf(stderr,
 220                     gettext("Bogus bytes per sector value.  Giving up.\n"));
 221                 exit(2);
 222         }
 223         if (!(ISP2(TheBIOSParameterBlock.bpb.sectors_per_cluster) &&
 224             IN_RANGE(TheBIOSParameterBlock.bpb.sectors_per_cluster,
 225             1, 128))) {
 226                 mountSanityCheckFails();
 227                 (void) fprintf(stderr,
 228                     gettext("Bogus sectors per cluster value.  Giving up.\n"));
 229                 (void) close(fd);
 230                 exit(6);
 231         }
 232         if (TheBIOSParameterBlock.bpb.sectors_per_fat == 0) {
 233 #ifdef _BIG_ENDIAN
 234                 swap_pack_grab32bpb(&TheBIOSParameterBlock, &(ubpb.bs));
 235 #else
 236                 (void) memcpy(&(TheBIOSParameterBlock.bpb32),
 237                     &(ubpb.bs32.bs_bpb32),
 238                     sizeof (TheBIOSParameterBlock.bpb32));
 239 #endif
 240                 IsFAT32 = 1;
 241         }
 242         if (!IsFAT32) {
 243                 if ((TheBIOSParameterBlock.bpb.num_root_entries == 0) ||
 244                     ((TheBIOSParameterBlock.bpb.num_root_entries *
 245                     sizeof (struct pcdir)) %
 246                     TheBIOSParameterBlock.bpb.bytes_per_sector) != 0) {
 247                         mountSanityCheckFails();
 248                         (void) fprintf(stderr,
 249                             gettext("Bogus number of root entries.  "
 250                             "Giving up.\n"));
 251                         exit(2);
 252                 }
 253         } else {
 254                 if (TheBIOSParameterBlock.bpb.num_root_entries != 0) {
 255                         mountSanityCheckFails();
 256                         (void) fprintf(stderr,
 257                             gettext("Bogus number of root entries.  "
 258                             "Giving up.\n"));
 259                         exit(2);
 260                 }
 261         }
 262         /*
 263          * In general, we would expect the number of FATs field to
 264          * equal 2.  Our mkfs and Windows have this as a default
 265          * value.  I suppose someone could override the default,
 266          * though, so we'll sort of arbitrarily accept any number
 267          * between 1 and 4 inclusive as reasonable values.
 268          *
 269          * XXX: Warn, but continue, if value is suspicious? (>2?)
 270          */
 271         if (TheBIOSParameterBlock.bpb.num_fats > 4 ||
 272             TheBIOSParameterBlock.bpb.num_fats < 1) {
 273                 mountSanityCheckFails();
 274                 (void) fprintf(stderr,
 275                     gettext("Bogus number of FATs.  Giving up.\n"));
 276                 exit(2);
 277         }
 278         computeFileAreaSize();
 279 }