mpartition.c

   1 /*  Copyright 1997-2003,2005-2007,2009 Alain Knaff.
   2  *  This file is part of mtools.
   3  *
   4  *  Mtools is free software: you can redistribute it and/or modify
   5  *  it under the terms of the GNU General Public License as published by
   6  *  the Free Software Foundation, either version 3 of the License, or
   7  *  (at your option) any later version.
   8  *
   9  *  Mtools is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *  GNU General Public License for more details.
  13  *
  14  *  You should have received a copy of the GNU General Public License
  15  *  along with Mtools.  If not, see <http://www.gnu.org/licenses/>.
  16  *
  17  * mformat.c
  18  */
  19 #define DONT_NEED_WAIT
  20
  21 #include "sysincludes.h"
  22 #include "msdos.h"
  23 #include "mtools.h"
  24 #include "mainloop.h"
  25 #include "fsP.h"
  26 #include "file.h"
  27 #include "plain_io.h"
  28 #include "nameclash.h"
  29 #include "buffer.h"
  30 #include "scsi.h"
  31 #include "partition.h"
  32
  33 #ifdef OS_linux
  34 #include "linux/hdreg.h"
  35
  36 #define _LINUX_STRING_H_
  37 #define kdev_t int
  38 #include "linux/fs.h"
  39 #undef _LINUX_STRING_H_
  40
  41 #endif
  42
  43 #define tolinear(x) \
  44 (sector(x)-1+(head(x)+cyl(x)*used_dev->heads)*used_dev->sectors)
  45
  46
  47 static __inline__ void print_hsc(hsc *h)
  48 {
  49         printf(" h=%d s=%d c=%d\n",
  50                head(*h), sector(*h), cyl(*h));
  51 }
  52
  53 static void set_offset(hsc *h, int offset, int heads, int sectors)
  54 {
  55         int head, sector, cyl;
  56
  57         if(! heads || !sectors)
  58                 head = sector = cyl = 0; /* linear mode */
  59         else {
  60                 sector = offset % sectors;
  61                 offset = offset / sectors;
  62
  63                 head = offset % heads;
  64                 cyl = offset / heads;
  65                 if(cyl > 1023) cyl = 1023;
  66         }
  67
  68         h->head = head;
  69         h->sector = ((sector+1) & 0x3f) | ((cyl & 0x300)>>2);
  70         h->cyl = cyl & 0xff;
  71 }
  72
  73 void setBeginEnd(struct partition *partTable,
  74                  unsigned int begin, unsigned int end,
  75                  unsigned int heads, unsigned int sectors,
  76                  int activate, int type, int fat_bits)
  77 {
  78         set_offset(&partTable->start, begin, heads, sectors);
  79         set_offset(&partTable->end, end-1, heads, sectors);
  80         set_dword(partTable->start_sect, begin);
  81         set_dword(partTable->nr_sects, end-begin);
  82         if(activate)
  83                 partTable->boot_ind = 0x80;
  84         else
  85                 partTable->boot_ind = 0;
  86         if(!type) {
  87                 if (fat_bits == 0) {
  88                         /**
  89                          * Fat bits unknown / not specified. We look
  90                          * at size to get a rough estimate what FAT
  91                          * bits are used.  Note: this is only an
  92                          * estimate, the precise calculation would
  93                          * involve the number of clusters, which is
  94                          * not necessarily known here.
  95                          */
  96                         /* cc977219 would have a cutoff number of 32680,
  97                          * corresponding to a FAT12 partition with 4K
  98                          * clusters, however other information hints that
  99                          * only partitions with less than 4096 sectors are
 100                          * considered */
 101                         if(end-begin < 4096)
 102                                 fat_bits = 12;
 103                         else
 104                                 fat_bits = 16;
 105                 }
 106
 107                 /* Description of various partition types in
 108                  * https://en.wikipedia.org/wiki/Partition_type#List_of_partition_IDs
 109                  * and
 110                  * https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-2000-server/cc977219(v=technet.10)
 111                  */
 112                 if (fat_bits == 32)
 113                         /* FAT 32 partition. For now, we disregard the
 114                          * possibility of FAT 32 CHS partitions */
 115                         type = 0x0C; /* Win95 FAT32, LBA */
 116                 else if (end < 65536) {
 117                         /* FAT 12 or FAT 16 partitions which fit entirely below
 118                            the 32M mark */
 119                         /* The 32M restriction doesn't apply to logical
 120                            partitions within an extended partition, but for the
 121                            moment mpartition only makes primary partitions */
 122                         if(fat_bits == 12)
 123                                 /* FAT 12 partition */
 124                                 type = 0x01; /* DOS FAT12, CHS */
 125                         else if (fat_bits == 16)
 126                                 /* FAT 16 partition */
 127                                 type = 0x04; /* DOS FAT16, CHS */
 128                 } else if (end <  sectors * heads * 1024)
 129                         /* FAT 12 or FAT16 partition above the 32M
 130                          * mark but below the 1024 cylinder mark.
 131                          * Indeed, there can be no CHS partition
 132                          * beyond 1024 cylinders */
 133                         type = 0x06; /* DOS BIG FAT16 or FAT12, CHS */
 134                 else
 135                         type = 0x0E; /* Win95 BIG FAT16, LBA */
 136         }
 137         partTable->sys_ind = type;
 138 }
 139
 140 int consistencyCheck(struct partition *partTable, int doprint, int verbose,
 141                      int *has_activated, unsigned int *last_end,
 142                      unsigned int *j,
 143                      struct device *used_dev, int target_partition)
 144 {
 145         int i;
 146         unsigned int inconsistency;
 147
 148         *j = 0;
 149         *last_end = 1;
 150
 151         /* quick consistency check */
 152         inconsistency = 0;
 153         *has_activated = 0;
 154         for(i=1; i<5; i++){
 155                 if(!partTable[i].sys_ind)
 156                         continue;
 157                 if(partTable[i].boot_ind)
 158                         (*has_activated)++;
 159                 if((used_dev &&
 160                     (used_dev->heads != head(partTable[i].end)+1 ||
 161                      used_dev->sectors != sector(partTable[i].end))) ||
 162                    sector(partTable[i].start) != 1){
 163                         fprintf(stderr,
 164                                 "Partition %d is not aligned\n",
 165                                 i);
 166                         inconsistency=1;
 167                 }
 168
 169                 if(*j &&
 170                    *last_end > BEGIN(partTable[i])) {
 171                         fprintf(stderr,
 172                                 "Partitions %d and %d badly ordered or overlapping\n",
 173                                 *j,i);
 174                         inconsistency=1;
 175                 }
 176
 177                 *last_end = END(partTable[i]);
 178                 *j = i;
 179
 180                 if(used_dev &&
 181                    cyl(partTable[i].start) != 1023 &&
 182                    tolinear(partTable[i].start) != BEGIN(partTable[i])) {
 183                         fprintf(stderr,
 184                                 "Start position mismatch for partition %d\n",
 185                                 i);
 186                         inconsistency=1;
 187                 }
 188                 if(used_dev &&
 189                    cyl(partTable[i].end) != 1023 &&
 190                    tolinear(partTable[i].end)+1 != END(partTable[i])) {
 191                         fprintf(stderr,
 192                                 "End position mismatch for partition %d\n",
 193                                 i);
 194                         inconsistency=1;
 195                 }
 196
 197                 if(doprint && verbose) {
 198                         if(i==target_partition)
 199                                 putchar('*');
 200                         else
 201                                 putchar(' ');
 202                         printf("Partition %d\n",i);
 203
 204                         printf("  active=%x\n", partTable[i].boot_ind);
 205                         printf("  start:");
 206                         print_hsc(&partTable[i].start);
 207                         printf("  type=0x%x\n", partTable[i].sys_ind);
 208                         printf("  end:");
 209                         print_hsc(&partTable[i].end);
 210                         printf("  start=%d\n", BEGIN(partTable[i]));
 211                         printf("  nr=%d\n", _DWORD(partTable[i].nr_sects));
 212                         printf("\n");
 213                 }
 214         }
 215         return inconsistency;
 216 }
 217
 218 /* setsize function.  Determines scsicam mapping if this cannot be inferred from
 219  * any existing partitions. Shamelessly snarfed from the Linux kernel ;-) */
 220
 221 /*
 222  * Function : static int setsize(unsigned long capacity,unsigned int *cyls,
 223  *      unsigned int *hds, unsigned int *secs);
 224  *
 225  * Purpose : to determine a near-optimal int 0x13 mapping for a
 226  *      SCSI disk in terms of lost space of size capacity, storing
 227  *      the results in *cyls, *hds, and *secs.
 228  *
 229  * Returns : -1 on failure, 0 on success.
 230  *
 231  * Extracted from
 232  *
 233  * WORKING                                                    X3T9.2
 234  * DRAFT                                                        792D
 235  *
 236  *
 237  *                                                        Revision 6
 238  *                                                         10-MAR-94
 239  * Information technology -
 240  * SCSI-2 Common access method
 241  * transport and SCSI interface module
 242  *
 243  * ANNEX A :
 244  *
 245  * setsize() converts a read capacity value to int 13h
 246  * head-cylinder-sector requirements. It minimizes the value for
 247  * number of heads and maximizes the number of cylinders. This
 248  * will support rather large disks before the number of heads
 249  * will not fit in 4 bits (or 6 bits). This algorithm also
 250  * minimizes the number of sectors that will be unused at the end
 251  * of the disk while allowing for very large disks to be
 252  * accommodated. This algorithm does not use physical geometry.
 253  */
 254
 255 static int setsize(unsigned long capacity,unsigned int *cyls,unsigned int *hds,
 256     unsigned int *secs) {
 257     unsigned int rv = 0;
 258     unsigned long heads, sectors, cylinders, temp;
 259
 260     cylinders = 1024L;                  /* Set number of cylinders to max */
 261     sectors = 62L;                      /* Maximize sectors per track */
 262
 263     temp = cylinders * sectors;         /* Compute divisor for heads */
 264     heads = capacity / temp;            /* Compute value for number of heads */
 265     if (capacity % temp) {              /* If no remainder, done! */
 266         heads++;                        /* Else, increment number of heads */
 267         temp = cylinders * heads;       /* Compute divisor for sectors */
 268         sectors = capacity / temp;      /* Compute value for sectors per
 269                                                track */
 270         if (capacity % temp) {          /* If no remainder, done! */
 271             sectors++;                  /* Else, increment number of sectors */
 272             temp = heads * sectors;     /* Compute divisor for cylinders */
 273             cylinders = capacity / temp;/* Compute number of cylinders */
 274         }
 275     }
 276     if (cylinders == 0) rv=(unsigned)-1;/* Give error if 0 cylinders */
 277
 278     *cyls = (unsigned int) cylinders;   /* Stuff return values */
 279     *secs = (unsigned int) sectors;
 280     *hds  = (unsigned int) heads;
 281     return(rv);
 282 }
 283
 284 static void setsize0(unsigned long capacity,unsigned int *cyls,
 285                      unsigned int *hds, unsigned int *secs)
 286 {
 287         int r;
 288
 289         /* 1. First try "Megabyte" sizes */
 290         if(capacity < 1024 * 2048 && !(capacity % 1024)) {
 291                 *cyls = capacity >> 11;
 292                 *hds  = 64;
 293                 *secs = 32;
 294                 return;
 295         }
 296
 297         /* then try scsicam's size */
 298         r = setsize(capacity,cyls,hds,secs);
 299         if(r || *hds > 255 || *secs > 63) {
 300                 /* scsicam failed. Do megabytes anyways */
 301                 *cyls = capacity >> 11;
 302                 *hds  = 64;
 303                 *secs = 32;
 304                 return;
 305         }
 306 }
 307
 308
 309 static void usage(int ret) NORETURN;
 310 static void usage(int ret)
 311 {
 312         fprintf(stderr,
 313                 "Mtools version %s, dated %s\n", mversion, mdate);
 314         fprintf(stderr,
 315                 "Usage: %s [-pradcv] [-I] [-B bootsect-template] [-s sectors] "
 316                         "[-t cylinders] "
 317                 "[-h heads] [-T type] [-b begin] [-l length] "
 318                 "drive\n", progname);
 319         exit(ret);
 320 }
 321
 322 void mpartition(int argc, char **argv, int dummy UNUSEDP) NORETURN;
 323 void mpartition(int argc, char **argv, int dummy UNUSEDP)
 324 {
 325         Stream_t *Stream;
 326         unsigned int dummy2;
 327
 328         unsigned int i,j;
 329
 330         int sec_per_cyl;
 331         int doprint = 0;
 332         int verbose = 0;
 333         int create = 0;
 334         int force = 0;
 335         unsigned int length = 0;
 336         int do_remove = 0;
 337         int initialize = 0;
 338         unsigned int tot_sectors=0;
 339         int type = 0;
 340         int begin_set = 0;
 341         int size_set = 0;
 342         int end_set = 0;
 343         unsigned int last_end = 0;
 344         int activate = 0;
 345         int has_activated = 0;
 346         int inconsistency=0;
 347         unsigned int begin=0;
 348         unsigned int end=0;
 349         int sizetest=0;
 350         int dirty = 0;
 351         int open2flags = NO_OFFSET;
 352
 353         int c;
 354         struct device used_dev;
 355         int argtracks, argheads, argsectors;
 356
 357         char drive, name[EXPAND_BUF];
 358         unsigned char buf[512];
 359         struct partition *partTable=(struct partition *)(buf+ 0x1ae);
 360         struct device *dev;
 361         char errmsg[200];
 362         char *bootSector=0;
 363
 364         argtracks = 0;
 365         argheads = 0;
 366         argsectors = 0;
 367
 368         /* get command line options */
 369         if(helpFlag(argc, argv))
 370                 usage(0);
 371         while ((c = getopt(argc, argv, "i:adprcIT:t:h:s:fvpb:l:S:B:")) != EOF) {
 372                 switch (c) {
 373                         case 'i':
 374                                 set_cmd_line_image(optarg);
 375                                 break;
 376                         case 'B':
 377                                 bootSector = optarg;
 378                                 break;
 379                         case 'a':
 380                                 /* no privs, as it could be abused to
 381                                  * make other partitions unbootable, or
 382                                  * to boot a rogue kernel from this one */
 383                                 open2flags |= NO_PRIV;
 384                                 activate = 1;
 385                                 dirty = 1;
 386                                 break;
 387                         case 'd':
 388                                 activate = -1;
 389                                 dirty = 1;
 390                                 break;
 391                         case 'p':
 392                                 doprint = 1;
 393                                 break;
 394                         case 'r':
 395                                 do_remove = 1;
 396                                 dirty = 1;
 397                                 break;
 398                         case 'I':
 399                                 /* could be abused to nuke all other
 400                                  * partitions */
 401                                 open2flags |= NO_PRIV;
 402                                 initialize = 1;
 403                                 dirty = 1;
 404                                 break;
 405                         case 'c':
 406                                 create = 1;
 407                                 dirty = 1;
 408                                 break;
 409
 410                         case 'T':
 411                                 /* could be abused to "manually" create
 412                                  * extended partitions */
 413                                 open2flags |= NO_PRIV;
 414                                 type = strtoul(optarg,0,0);
 415                                 break;
 416
 417                         case 't':
 418                                 argtracks = atoi(optarg);
 419                                 break;
 420                         case 'h':
 421                                 argheads = atoi(optarg);
 422                                 break;
 423                         case 's':
 424                                 argsectors = atoi(optarg);
 425                                 break;
 426
 427                         case 'f':
 428                                 /* could be abused by creating overlapping
 429                                  * partitions and other such Snafu */
 430                                 open2flags |= NO_PRIV;
 431                                 force = 1;
 432                                 break;
 433
 434                         case 'v':
 435                                 verbose++;
 436                                 break;
 437                         case 'S':
 438                                 /* testing only */
 439                                 /* could be abused to create partitions
 440                                  * extending beyond the actual size of the
 441                                  * device */
 442                                 open2flags |= NO_PRIV;
 443                                 tot_sectors = strtoul(optarg,0,0);
 444                                 sizetest = 1;
 445                                 break;
 446                         case 'b':
 447                                 begin_set = 1;
 448                                 begin = strtoul(optarg, NULL, 10);
 449                                 break;
 450                         case 'l':
 451                                 size_set = 1;
 452                                 length = strtoul(optarg, NULL, 10);
 453                                 break;
 454
 455                         default:
 456                                 usage(1);
 457                 }
 458         }
 459
 460         if (argc - optind != 1 ||
 461             !argv[optind][0] || argv[optind][1] != ':')
 462                 usage(1);
 463
 464         drive = toupper(argv[optind][0]);
 465
 466         /* check out a drive whose letter and parameters match */
 467         sprintf(errmsg, "Drive '%c:' not supported", drive);
 468         Stream = 0;
 469         for(dev=devices;dev->drive;dev++) {
 470                 int mode ;
 471
 472                 FREE(&(Stream));
 473                 /* drive letter */
 474                 if (dev->drive != drive)
 475                         continue;
 476                 if (dev->partition < 1 || dev->partition > 4) {
 477                         sprintf(errmsg,
 478                                 "Drive '%c:' is not a partition",
 479                                 drive);
 480                         continue;
 481                 }
 482                 used_dev = *dev;
 483
 484                 SET_INT(used_dev.tracks, argtracks);
 485                 SET_INT(used_dev.heads, argheads);
 486                 SET_INT(used_dev.sectors, argsectors);
 487
 488                 expand(dev->name, name);
 489
 490                 mode = dirty ? O_RDWR : O_RDONLY;
 491                 if(initialize)
 492                         mode |= O_CREAT;
 493
 494 #ifdef USING_NEW_VOLD
 495                 strcpy(name, getVoldName(dev, name));
 496 #endif
 497                 Stream = SimpleFileOpen(&used_dev, dev, name, mode,
 498                                         errmsg, open2flags, 1, 0);
 499
 500                 if (!Stream) {
 501 #ifdef HAVE_SNPRINTF
 502                         snprintf(errmsg,199,"init: open: %s", strerror(errno));
 503 #else
 504                         sprintf(errmsg,"init: open: %s", strerror(errno));
 505 #endif
 506                         continue;
 507                 }
 508
 509
 510                 /* try to find out the size */
 511                 if(!sizetest)
 512                         tot_sectors = 0;
 513                 if(IS_SCSI(dev)) {
 514                         unsigned char cmd[10];
 515                         unsigned char data[10];
 516                         cmd[0] = SCSI_READ_CAPACITY;
 517                         memset ((void *) &cmd[2], 0, 8);
 518                         memset ((void *) &data[0], 137, 10);
 519                         scsi_cmd(get_fd(Stream), cmd, 10, SCSI_IO_READ,
 520                                  data, 10, get_extra_data(Stream));
 521
 522                         tot_sectors = 1 +
 523                                 (data[0] << 24) +
 524                                 (data[1] << 16) +
 525                                 (data[2] <<  8) +
 526                                 (data[3]      );
 527                         if(verbose)
 528                                 printf("%d sectors in total\n", tot_sectors);
 529                 }
 530
 531 #ifdef OS_linux
 532                 if (tot_sectors == 0) {
 533                         ioctl(get_fd(Stream), BLKGETSIZE, &tot_sectors);
 534                 }
 535 #endif
 536
 537                 /* read the partition table */
 538                 if (READS(Stream, (char *) buf, 0, 512) != 512 && !initialize){
 539 #ifdef HAVE_SNPRINTF
 540                         snprintf(errmsg, 199,
 541                                 "Error reading from '%s', wrong parameters?",
 542                                 name);
 543 #else
 544                         sprintf(errmsg,
 545                                 "Error reading from '%s', wrong parameters?",
 546                                 name);
 547 #endif
 548                         continue;
 549                 }
 550                 if(verbose>=2)
 551                         print_sector("Read sector", buf, 512);
 552                 break;
 553         }
 554
 555         /* print error msg if needed */
 556         if ( dev->drive == 0 ){
 557                 FREE(&Stream);
 558                 fprintf(stderr,"%s: %s\n", argv[0],errmsg);
 559                 exit(1);
 560         }
 561
 562         if((used_dev.sectors || used_dev.heads) &&
 563            (!used_dev.sectors || !used_dev.heads)) {
 564                 fprintf(stderr,"You should either indicate both the number of sectors and the number of heads,\n");
 565                 fprintf(stderr," or none of them\n");
 566                 exit(1);
 567         }
 568
 569         if(initialize) {
 570                 if (bootSector) {
 571                         int fd;
 572                         fd = open(bootSector, O_RDONLY | O_BINARY | O_LARGEFILE);
 573                         if (fd < 0) {
 574                                 perror("open MBR");
 575                                 exit(1);
 576                         }
 577                         if(read(fd, (char *) buf, 512) < 512) {
 578                                 perror("read MBR");
 579                                 exit(1);
 580                         }
 581                 }
 582                 memset((char *)(partTable+1), 0, 4*sizeof(*partTable));
 583                 set_word(((unsigned char*)buf)+510, 0xaa55);
 584         }
 585
 586         /* check for boot signature, and place it if needed */
 587         if((buf[510] != 0x55) || (buf[511] != 0xaa)) {
 588                 fprintf(stderr,"Boot signature not set\n");
 589                 fprintf(stderr,
 590                         "Use the -I flag to initialize the partition table, and set the boot signature\n");
 591                 inconsistency = 1;
 592         }
 593
 594         if(do_remove){
 595                 if(!partTable[dev->partition].sys_ind)
 596                         fprintf(stderr,
 597                                 "Partition for drive %c: does not exist\n",
 598                                 drive);
 599                 if((partTable[dev->partition].sys_ind & 0x3f) == 5) {
 600                         fprintf(stderr,
 601                                 "Partition for drive %c: may be an extended partition\n",
 602                                 drive);
 603                         fprintf(stderr,
 604                                 "Use the -f flag to remove it anyways\n");
 605                         inconsistency = 1;
 606                 }
 607                 memset(&partTable[dev->partition], 0, sizeof(*partTable));
 608         }
 609
 610         if(create && partTable[dev->partition].sys_ind) {
 611                 fprintf(stderr,
 612                         "Partition for drive %c: already exists\n", drive);
 613                 fprintf(stderr,
 614                         "Use the -r flag to remove it before attempting to recreate it\n");
 615         }
 616
 617
 618         /* find out number of heads and sectors, and whether there is
 619         * any activated partition */
 620         has_activated = 0;
 621         for(i=1; i<5; i++){
 622                 if(!partTable[i].sys_ind)
 623                         continue;
 624
 625                 if(partTable[i].boot_ind)
 626                         has_activated++;
 627
 628                 /* set geometry from entry */
 629                 if (!used_dev.heads)
 630                         used_dev.heads = head(partTable[i].end)+1;
 631                 if(!used_dev.sectors)
 632                         used_dev.sectors = sector(partTable[i].end);
 633                 if(i<dev->partition && !begin_set)
 634                         begin = END(partTable[i]);
 635                 if(i>dev->partition && !end_set && !size_set) {
 636                         end = BEGIN(partTable[i]);
 637                         end_set = 1;
 638                 }
 639         }
 640
 641 #ifdef OS_linux
 642         if(!used_dev.sectors && !used_dev.heads) {
 643                 if(!IS_SCSI(dev)) {
 644                         struct hd_geometry geom;
 645                         if(ioctl(get_fd(Stream), HDIO_GETGEO, &geom) == 0) {
 646                                 used_dev.heads = geom.heads;
 647                                 used_dev.sectors = geom.sectors;
 648                         }
 649                 }
 650         }
 651 #endif
 652
 653         if(!used_dev.sectors && !used_dev.heads) {
 654                 if(tot_sectors)
 655                         setsize0(tot_sectors,&dummy2,&used_dev.heads,
 656                                          &used_dev.sectors);
 657                 else {
 658                         used_dev.heads = 64;
 659                         used_dev.sectors = 32;
 660                 }
 661         }
 662
 663         if(verbose)
 664                 fprintf(stderr,"sectors: %d heads: %d %d\n",
 665                         used_dev.sectors, used_dev.heads, tot_sectors);
 666
 667         sec_per_cyl = used_dev.sectors * used_dev.heads;
 668         if(create) {
 669                 if(!end_set && tot_sectors) {
 670                         end = tot_sectors - tot_sectors % sec_per_cyl;
 671                         end_set = 1;
 672                 }
 673
 674                 /* if the partition starts right at the beginning of
 675                  * the disk, keep one track unused to allow place for
 676                  * the master boot record */
 677                 if(!begin && !begin_set)
 678                         begin = used_dev.sectors;
 679                 if(!size_set && used_dev.tracks) {
 680                         size_set = 2;
 681                         length = sec_per_cyl * used_dev.tracks;
 682
 683                         /*  round the size in order to take
 684                          * into account any "hidden" sectors */
 685
 686                         /* do we anchor this at the beginning ?*/
 687                         if(begin_set || dev->partition <= 2 || !end_set)
 688                                 length -= begin % sec_per_cyl;
 689                         else if(end - length < begin)
 690                                 /* truncate any overlap */
 691                                 length = end - begin;
 692                 }
 693                 if(size_set) {
 694                         if(!begin_set && dev->partition >2 && end_set)
 695                                 begin = end - length;
 696                         else
 697                                 end = begin + length;
 698                 } else if(!end_set) {
 699                         fprintf(stderr,"Unknown size\n");
 700                         exit(1);
 701                 }
 702
 703                 setBeginEnd(&partTable[dev->partition], begin, end,
 704                             used_dev.heads, used_dev.sectors,
 705                             !has_activated, type,
 706                             dev->fat_bits);
 707         }
 708
 709         if(activate) {
 710                 if(!partTable[dev->partition].sys_ind) {
 711                         fprintf(stderr,
 712                                 "Partition for drive %c: does not exist\n",
 713                                 drive);
 714                 } else {
 715                         switch(activate) {
 716                                 case 1:
 717                                         partTable[dev->partition].boot_ind=0x80;
 718                                         break;
 719                                 case -1:
 720                                         partTable[dev->partition].boot_ind=0x00;
 721                                         break;
 722                         }
 723                 }
 724         }
 725
 726
 727         inconsistency |= consistencyCheck(partTable, doprint, verbose,
 728                                           &has_activated, &last_end, &j,
 729                                           &used_dev, dev->partition);
 730
 731         if(doprint && !inconsistency && partTable[dev->partition].sys_ind) {
 732                 printf("The following command will recreate the partition for drive %c:\n",
 733                        drive);
 734                 used_dev.tracks =
 735                         (_DWORD(partTable[dev->partition].nr_sects) +
 736                          (BEGIN(partTable[dev->partition]) % sec_per_cyl)) /
 737                         sec_per_cyl;
 738                 printf("mpartition -c -t %d -h %d -s %d -b %u %c:\n",
 739                        used_dev.tracks, used_dev.heads, used_dev.sectors,
 740                        BEGIN(partTable[dev->partition]), drive);
 741         }
 742
 743         if(tot_sectors && last_end >tot_sectors) {
 744                 fprintf(stderr,
 745                         "Partition %d exceeds beyond end of disk\n",
 746                         j);
 747                 exit(1);
 748         }
 749
 750
 751         switch(has_activated) {
 752                 case 0:
 753                         fprintf(stderr,
 754                                 "Warning: no active (bootable) partition present\n");
 755                         break;
 756                 case 1:
 757                         break;
 758                 default:
 759                         fprintf(stderr,
 760                                 "Warning: %d active (bootable) partitions present\n",
 761                                 has_activated);
 762                         fprintf(stderr,
 763                                 "Usually, a disk should have exactly one active partition\n");
 764                         break;
 765         }
 766
 767         if(inconsistency && !force) {
 768                 fprintf(stderr,
 769                         "inconsistency detected!\n" );
 770                 if(dirty)
 771                         fprintf(stderr,
 772                                 "Retry with the -f switch to go ahead anyways\n");
 773                 exit(1);
 774         }
 775
 776         if(dirty) {
 777                 /* write data back to the disk */
 778                 if(verbose>=2)
 779                         print_sector("Writing sector", buf, 512);
 780                 if (WRITES(Stream, (char *) buf, 0, 512) != 512) {
 781                         fprintf(stderr,"Error writing partition table");
 782                         exit(1);
 783                 }
 784                 if(verbose>=3)
 785                         print_sector("Sector written", buf, 512);
 786         }
 787         FREE(&Stream);
 788         exit(0);
 789 }