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         unsigned 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)
 323 {
 324         Stream_t *Stream;
 325         unsigned int dummy2;
 326
 327         unsigned int i,j;
 328
 329         int sec_per_cyl;
 330         int doprint = 0;
 331         int verbose = 0;
 332         int create = 0;
 333         int force = 0;
 334         unsigned int length = 0;
 335         int do_remove = 0;
 336         int initialize = 0;
 337         unsigned int tot_sectors=0;
 338         int type = 0;
 339         int begin_set = 0;
 340         int size_set = 0;
 341         int end_set = 0;
 342         unsigned int last_end = 0;
 343         int activate = 0;
 344         int has_activated = 0;
 345         int inconsistency=0;
 346         unsigned int begin=0;
 347         unsigned int end=0;
 348         int sizetest=0;
 349         int dirty = 0;
 350         int open2flags = NO_OFFSET;
 351
 352         int c;
 353         struct device used_dev;
 354         int argtracks, argheads, argsectors;
 355
 356         char drive, name[EXPAND_BUF];
 357         unsigned char buf[512];
 358         struct partition *partTable=(struct partition *)(buf+ 0x1ae);
 359         struct device *dev;
 360         char errmsg[200];
 361         char *bootSector=0;
 362
 363         argtracks = 0;
 364         argheads = 0;
 365         argsectors = 0;
 366
 367         /* get command line options */
 368         if(helpFlag(argc, argv))
 369                 usage(0);
 370         while ((c = getopt(argc, argv, "i:adprcIT:t:h:s:fvpb:l:S:B:")) != EOF) {
 371                 switch (c) {
 372                         case 'i':
 373                                 set_cmd_line_image(optarg);
 374                                 break;
 375                         case 'B':
 376                                 bootSector = optarg;
 377                                 break;
 378                         case 'a':
 379                                 /* no privs, as it could be abused to
 380                                  * make other partitions unbootable, or
 381                                  * to boot a rogue kernel from this one */
 382                                 open2flags |= NO_PRIV;
 383                                 activate = 1;
 384                                 dirty = 1;
 385                                 break;
 386                         case 'd':
 387                                 activate = -1;
 388                                 dirty = 1;
 389                                 break;
 390                         case 'p':
 391                                 doprint = 1;
 392                                 break;
 393                         case 'r':
 394                                 do_remove = 1;
 395                                 dirty = 1;
 396                                 break;
 397                         case 'I':
 398                                 /* could be abused to nuke all other
 399                                  * partitions */
 400                                 open2flags |= NO_PRIV;
 401                                 initialize = 1;
 402                                 dirty = 1;
 403                                 break;
 404                         case 'c':
 405                                 create = 1;
 406                                 dirty = 1;
 407                                 break;
 408
 409                         case 'T':
 410                                 /* could be abused to "manually" create
 411                                  * extended partitions */
 412                                 open2flags |= NO_PRIV;
 413                                 type = strtoul(optarg,0,0);
 414                                 break;
 415
 416                         case 't':
 417                                 argtracks = atoi(optarg);
 418                                 break;
 419                         case 'h':
 420                                 argheads = atoi(optarg);
 421                                 break;
 422                         case 's':
 423                                 argsectors = atoi(optarg);
 424                                 break;
 425
 426                         case 'f':
 427                                 /* could be abused by creating overlapping
 428                                  * partitions and other such Snafu */
 429                                 open2flags |= NO_PRIV;
 430                                 force = 1;
 431                                 break;
 432
 433                         case 'v':
 434                                 verbose++;
 435                                 break;
 436                         case 'S':
 437                                 /* testing only */
 438                                 /* could be abused to create partitions
 439                                  * extending beyond the actual size of the
 440                                  * device */
 441                                 open2flags |= NO_PRIV;
 442                                 tot_sectors = strtoul(optarg,0,0);
 443                                 sizetest = 1;
 444                                 break;
 445                         case 'b':
 446                                 begin_set = 1;
 447                                 begin = strtoul(optarg, NULL, 10);
 448                                 break;
 449                         case 'l':
 450                                 size_set = 1;
 451                                 length = strtoul(optarg, NULL, 10);
 452                                 break;
 453
 454                         default:
 455                                 usage(1);
 456                 }
 457         }
 458
 459         if (argc - optind != 1 ||
 460             !argv[optind][0] || argv[optind][1] != ':')
 461                 usage(1);
 462
 463         drive = toupper(argv[optind][0]);
 464
 465         /* check out a drive whose letter and parameters match */
 466         sprintf(errmsg, "Drive '%c:' not supported", drive);
 467         Stream = 0;
 468         for(dev=devices;dev->drive;dev++) {
 469                 int mode ;
 470
 471                 FREE(&(Stream));
 472                 /* drive letter */
 473                 if (dev->drive != drive)
 474                         continue;
 475                 if (dev->partition < 1 || dev->partition > 4) {
 476                         sprintf(errmsg,
 477                                 "Drive '%c:' is not a partition",
 478                                 drive);
 479                         continue;
 480                 }
 481                 used_dev = *dev;
 482
 483                 SET_INT(used_dev.tracks, argtracks);
 484                 SET_INT(used_dev.heads, argheads);
 485                 SET_INT(used_dev.sectors, argsectors);
 486
 487                 expand(dev->name, name);
 488
 489                 mode = dirty ? O_RDWR : O_RDONLY;
 490                 if(initialize)
 491                         mode |= O_CREAT;
 492
 493 #ifdef USING_NEW_VOLD
 494                 strcpy(name, getVoldName(dev, name));
 495 #endif
 496                 Stream = SimpleFileOpen(&used_dev, dev, name, mode,
 497                                         errmsg, open2flags, 1, 0);
 498
 499                 if (!Stream) {
 500 #ifdef HAVE_SNPRINTF
 501                         snprintf(errmsg,199,"init: open: %s", strerror(errno));
 502 #else
 503                         sprintf(errmsg,"init: open: %s", strerror(errno));
 504 #endif
 505                         continue;
 506                 }
 507
 508
 509                 /* try to find out the size */
 510                 if(!sizetest)
 511                         tot_sectors = 0;
 512                 if(IS_SCSI(dev)) {
 513                         unsigned char cmd[10];
 514                         unsigned char data[10];
 515                         cmd[0] = SCSI_READ_CAPACITY;
 516                         memset ((void *) &cmd[2], 0, 8);
 517                         memset ((void *) &data[0], 137, 10);
 518                         scsi_cmd(get_fd(Stream), cmd, 10, SCSI_IO_READ,
 519                                  data, 10, get_extra_data(Stream));
 520
 521                         tot_sectors = 1 +
 522                                 (data[0] << 24) +
 523                                 (data[1] << 16) +
 524                                 (data[2] <<  8) +
 525                                 (data[3]      );
 526                         if(verbose)
 527                                 printf("%d sectors in total\n", tot_sectors);
 528                 }
 529
 530 #ifdef OS_linux
 531                 if (tot_sectors == 0) {
 532                         ioctl(get_fd(Stream), BLKGETSIZE, &tot_sectors);
 533                 }
 534 #endif
 535
 536                 /* read the partition table */
 537                 if (READS(Stream, (char *) buf, 0, 512) != 512 && !initialize){
 538 #ifdef HAVE_SNPRINTF
 539                         snprintf(errmsg, 199,
 540                                 "Error reading from '%s', wrong parameters?",
 541                                 name);
 542 #else
 543                         sprintf(errmsg,
 544                                 "Error reading from '%s', wrong parameters?",
 545                                 name);
 546 #endif
 547                         continue;
 548                 }
 549                 if(verbose>=2)
 550                         print_sector("Read sector", buf, 512);
 551                 break;
 552         }
 553
 554         /* print error msg if needed */
 555         if ( dev->drive == 0 ){
 556                 FREE(&Stream);
 557                 fprintf(stderr,"%s: %s\n", argv[0],errmsg);
 558                 exit(1);
 559         }
 560
 561         if((used_dev.sectors || used_dev.heads) &&
 562            (!used_dev.sectors || !used_dev.heads)) {
 563                 fprintf(stderr,"You should either indicate both the number of sectors and the number of heads,\n");
 564                 fprintf(stderr," or none of them\n");
 565                 exit(1);
 566         }
 567
 568         if(initialize) {
 569                 if (bootSector) {
 570                         int fd;
 571                         fd = open(bootSector, O_RDONLY | O_BINARY | O_LARGEFILE);
 572                         if (fd < 0) {
 573                                 perror("open MBR");
 574                                 exit(1);
 575                         }
 576                         if(read(fd, (char *) buf, 512) < 512) {
 577                                 perror("read MBR");
 578                                 exit(1);
 579                         }
 580                 }
 581                 memset((char *)(partTable+1), 0, 4*sizeof(*partTable));
 582                 set_word(((unsigned char*)buf)+510, 0xaa55);
 583         }
 584
 585         /* check for boot signature, and place it if needed */
 586         if((buf[510] != 0x55) || (buf[511] != 0xaa)) {
 587                 fprintf(stderr,"Boot signature not set\n");
 588                 fprintf(stderr,
 589                         "Use the -I flag to initialize the partition table, and set the boot signature\n");
 590                 inconsistency = 1;
 591         }
 592
 593         if(do_remove){
 594                 if(!partTable[dev->partition].sys_ind)
 595                         fprintf(stderr,
 596                                 "Partition for drive %c: does not exist\n",
 597                                 drive);
 598                 if((partTable[dev->partition].sys_ind & 0x3f) == 5) {
 599                         fprintf(stderr,
 600                                 "Partition for drive %c: may be an extended partition\n",
 601                                 drive);
 602                         fprintf(stderr,
 603                                 "Use the -f flag to remove it anyways\n");
 604                         inconsistency = 1;
 605                 }
 606                 memset(&partTable[dev->partition], 0, sizeof(*partTable));
 607         }
 608
 609         if(create && partTable[dev->partition].sys_ind) {
 610                 fprintf(stderr,
 611                         "Partition for drive %c: already exists\n", drive);
 612                 fprintf(stderr,
 613                         "Use the -r flag to remove it before attempting to recreate it\n");
 614         }
 615
 616
 617         /* find out number of heads and sectors, and whether there is
 618         * any activated partition */
 619         has_activated = 0;
 620         for(i=1; i<5; i++){
 621                 if(!partTable[i].sys_ind)
 622                         continue;
 623
 624                 if(partTable[i].boot_ind)
 625                         has_activated++;
 626
 627                 /* set geometry from entry */
 628                 if (!used_dev.heads)
 629                         used_dev.heads = head(partTable[i].end)+1;
 630                 if(!used_dev.sectors)
 631                         used_dev.sectors = sector(partTable[i].end);
 632                 if(i<dev->partition && !begin_set)
 633                         begin = END(partTable[i]);
 634                 if(i>dev->partition && !end_set && !size_set) {
 635                         end = BEGIN(partTable[i]);
 636                         end_set = 1;
 637                 }
 638         }
 639
 640 #ifdef OS_linux
 641         if(!used_dev.sectors && !used_dev.heads) {
 642                 if(!IS_SCSI(dev)) {
 643                         struct hd_geometry geom;
 644                         if(ioctl(get_fd(Stream), HDIO_GETGEO, &geom) == 0) {
 645                                 used_dev.heads = geom.heads;
 646                                 used_dev.sectors = geom.sectors;
 647                         }
 648                 }
 649         }
 650 #endif
 651
 652         if(!used_dev.sectors && !used_dev.heads) {
 653                 if(tot_sectors)
 654                         setsize0(tot_sectors,&dummy2,&used_dev.heads,
 655                                          &used_dev.sectors);
 656                 else {
 657                         used_dev.heads = 64;
 658                         used_dev.sectors = 32;
 659                 }
 660         }
 661
 662         if(verbose)
 663                 fprintf(stderr,"sectors: %d heads: %d %d\n",
 664                         used_dev.sectors, used_dev.heads, tot_sectors);
 665
 666         sec_per_cyl = used_dev.sectors * used_dev.heads;
 667         if(create) {
 668                 if(!end_set && tot_sectors) {
 669                         end = tot_sectors - tot_sectors % sec_per_cyl;
 670                         end_set = 1;
 671                 }
 672
 673                 /* if the partition starts right at the beginning of
 674                  * the disk, keep one track unused to allow place for
 675                  * the master boot record */
 676                 if(!begin && !begin_set)
 677                         begin = used_dev.sectors;
 678                 if(!size_set && used_dev.tracks) {
 679                         size_set = 2;
 680                         length = sec_per_cyl * used_dev.tracks;
 681
 682                         /*  round the size in order to take
 683                          * into account any "hidden" sectors */
 684
 685                         /* do we anchor this at the beginning ?*/
 686                         if(begin_set || dev->partition <= 2 || !end_set)
 687                                 length -= begin % sec_per_cyl;
 688                         else if(end - length < begin)
 689                                 /* truncate any overlap */
 690                                 length = end - begin;
 691                 }
 692                 if(size_set) {
 693                         if(!begin_set && dev->partition >2 && end_set)
 694                                 begin = end - length;
 695                         else
 696                                 end = begin + length;
 697                 } else if(!end_set) {
 698                         fprintf(stderr,"Unknown size\n");
 699                         exit(1);
 700                 }
 701
 702                 setBeginEnd(&partTable[dev->partition], begin, end,
 703                             used_dev.heads, used_dev.sectors,
 704                             !has_activated, type,
 705                             dev->fat_bits);
 706         }
 707
 708         if(activate) {
 709                 if(!partTable[dev->partition].sys_ind) {
 710                         fprintf(stderr,
 711                                 "Partition for drive %c: does not exist\n",
 712                                 drive);
 713                 } else {
 714                         switch(activate) {
 715                                 case 1:
 716                                         partTable[dev->partition].boot_ind=0x80;
 717                                         break;
 718                                 case -1:
 719                                         partTable[dev->partition].boot_ind=0x00;
 720                                         break;
 721                         }
 722                 }
 723         }
 724
 725
 726         inconsistency |= consistencyCheck(partTable, doprint, verbose,
 727                                           &has_activated, &last_end, &j,
 728                                           &used_dev, dev->partition);
 729
 730         if(doprint && !inconsistency && partTable[dev->partition].sys_ind) {
 731                 printf("The following command will recreate the partition for drive %c:\n",
 732                        drive);
 733                 used_dev.tracks =
 734                         (_DWORD(partTable[dev->partition].nr_sects) +
 735                          (BEGIN(partTable[dev->partition]) % sec_per_cyl)) /
 736                         sec_per_cyl;
 737                 printf("mpartition -c -t %d -h %d -s %d -b %u %c:\n",
 738                        used_dev.tracks, used_dev.heads, used_dev.sectors,
 739                        BEGIN(partTable[dev->partition]), drive);
 740         }
 741
 742         if(tot_sectors && last_end >tot_sectors) {
 743                 fprintf(stderr,
 744                         "Partition %d exceeds beyond end of disk\n",
 745                         j);
 746                 exit(1);
 747         }
 748
 749
 750         switch(has_activated) {
 751                 case 0:
 752                         fprintf(stderr,
 753                                 "Warning: no active (bootable) partition present\n");
 754                         break;
 755                 case 1:
 756                         break;
 757                 default:
 758                         fprintf(stderr,
 759                                 "Warning: %d active (bootable) partitions present\n",
 760                                 has_activated);
 761                         fprintf(stderr,
 762                                 "Usually, a disk should have exactly one active partition\n");
 763                         break;
 764         }
 765
 766         if(inconsistency && !force) {
 767                 fprintf(stderr,
 768                         "inconsistency detected!\n" );
 769                 if(dirty)
 770                         fprintf(stderr,
 771                                 "Retry with the -f switch to go ahead anyways\n");
 772                 exit(1);
 773         }
 774
 775         if(dirty) {
 776                 /* write data back to the disk */
 777                 if(verbose>=2)
 778                         print_sector("Writing sector", buf, 512);
 779                 if (WRITES(Stream, (char *) buf, 0, 512) != 512) {
 780                         fprintf(stderr,"Error writing partition table");
 781                         exit(1);
 782                 }
 783                 if(verbose>=3)
 784                         print_sector("Sector written", buf, 512);
 785         }
 786         FREE(&Stream);
 787         exit(0);
 788 }