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,
 256                    uint16_t *hds,  uint16_t *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                      uint16_t *hds, uint16_t *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[2100];
 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 = strtoi(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 = strtoui(optarg,0,0);
 444                                 sizetest = 1;
 445                                 break;
 446                         case 'b':
 447                                 begin_set = 1;
 448                                 begin = strtoui(optarg, NULL, 10);
 449                                 break;
 450                         case 'l':
 451                                 size_set = 1;
 452                                 length = strtoui(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 = ch_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,sizeof(errmsg)-1,
 503                                  "init: open: %s", strerror(errno));
 504 #else
 505                         sprintf(errmsg,"init: open: %s", strerror(errno));
 506 #endif
 507                         continue;
 508                 }
 509
 510
 511                 /* try to find out the size */
 512                 if(!sizetest)
 513                         tot_sectors = 0;
 514                 if(IS_SCSI(dev)) {
 515                         unsigned char cmd[10];
 516                         unsigned char data[10];
 517                         cmd[0] = SCSI_READ_CAPACITY;
 518                         memset ((void *) &cmd[2], 0, 8);
 519                         memset ((void *) &data[0], 137, 10);
 520                         scsi_cmd(get_fd(Stream), cmd, 10, SCSI_IO_READ,
 521                                  data, 10, get_extra_data(Stream));
 522
 523                         tot_sectors = 1 +
 524                                 (data[0] << 24) +
 525                                 (data[1] << 16) +
 526                                 (data[2] <<  8) +
 527                                 (data[3]      );
 528                         if(verbose)
 529                                 printf("%d sectors in total\n", tot_sectors);
 530                 }
 531
 532 #ifdef OS_linux
 533                 if (tot_sectors == 0) {
 534                         ioctl(get_fd(Stream), BLKGETSIZE, &tot_sectors);
 535                 }
 536 #endif
 537
 538                 /* read the partition table */
 539                 if (READS(Stream, (char *) buf, 0, 512) != 512 && !initialize){
 540 #ifdef HAVE_SNPRINTF
 541                         snprintf(errmsg, sizeof(errmsg)-1,
 542                                 "Error reading from '%s', wrong parameters?",
 543                                 name);
 544 #else
 545                         sprintf(errmsg,
 546                                 "Error reading from '%s', wrong parameters?",
 547                                 name);
 548 #endif
 549                         continue;
 550                 }
 551                 if(verbose>=2)
 552                         print_sector("Read sector", buf, 512);
 553                 break;
 554         }
 555
 556         /* print error msg if needed */
 557         if ( dev->drive == 0 ){
 558                 FREE(&Stream);
 559                 fprintf(stderr,"%s: %s\n", argv[0],errmsg);
 560                 exit(1);
 561         }
 562
 563         if((used_dev.sectors || used_dev.heads) &&
 564            (!used_dev.sectors || !used_dev.heads)) {
 565                 fprintf(stderr,"You should either indicate both the number of sectors and the number of heads,\n");
 566                 fprintf(stderr," or none of them\n");
 567                 exit(1);
 568         }
 569
 570         if(initialize) {
 571                 if (bootSector) {
 572                         int fd;
 573                         fd = open(bootSector, O_RDONLY | O_BINARY | O_LARGEFILE);
 574                         if (fd < 0) {
 575                                 perror("open MBR");
 576                                 exit(1);
 577                         }
 578                         if(read(fd, (char *) buf, 512) < 512) {
 579                                 perror("read MBR");
 580                                 exit(1);
 581                         }
 582                 }
 583                 memset((char *)(partTable+1), 0, 4*sizeof(*partTable));
 584                 set_word(((unsigned char*)buf)+510, 0xaa55);
 585         }
 586
 587         /* check for boot signature, and place it if needed */
 588         if((buf[510] != 0x55) || (buf[511] != 0xaa)) {
 589                 fprintf(stderr,"Boot signature not set\n");
 590                 fprintf(stderr,
 591                         "Use the -I flag to initialize the partition table, and set the boot signature\n");
 592                 inconsistency = 1;
 593         }
 594
 595         if(do_remove){
 596                 if(!partTable[dev->partition].sys_ind)
 597                         fprintf(stderr,
 598                                 "Partition for drive %c: does not exist\n",
 599                                 drive);
 600                 if((partTable[dev->partition].sys_ind & 0x3f) == 5) {
 601                         fprintf(stderr,
 602                                 "Partition for drive %c: may be an extended partition\n",
 603                                 drive);
 604                         fprintf(stderr,
 605                                 "Use the -f flag to remove it anyways\n");
 606                         inconsistency = 1;
 607                 }
 608                 memset(&partTable[dev->partition], 0, sizeof(*partTable));
 609         }
 610
 611         if(create && partTable[dev->partition].sys_ind) {
 612                 fprintf(stderr,
 613                         "Partition for drive %c: already exists\n", drive);
 614                 fprintf(stderr,
 615                         "Use the -r flag to remove it before attempting to recreate it\n");
 616         }
 617
 618
 619         /* find out number of heads and sectors, and whether there is
 620         * any activated partition */
 621         has_activated = 0;
 622         for(i=1; i<5; i++){
 623                 if(!partTable[i].sys_ind)
 624                         continue;
 625
 626                 if(partTable[i].boot_ind)
 627                         has_activated++;
 628
 629                 /* set geometry from entry */
 630                 if (!used_dev.heads)
 631                         used_dev.heads = head(partTable[i].end)+1;
 632                 if(!used_dev.sectors)
 633                         used_dev.sectors = sector(partTable[i].end);
 634                 if(i<dev->partition && !begin_set)
 635                         begin = END(partTable[i]);
 636                 if(i>dev->partition && !end_set && !size_set) {
 637                         end = BEGIN(partTable[i]);
 638                         end_set = 1;
 639                 }
 640         }
 641
 642 #ifdef OS_linux
 643         if(!used_dev.sectors && !used_dev.heads) {
 644                 if(!IS_SCSI(dev)) {
 645                         struct hd_geometry geom;
 646                         if(ioctl(get_fd(Stream), HDIO_GETGEO, &geom) == 0) {
 647                                 used_dev.heads = geom.heads;
 648                                 used_dev.sectors = geom.sectors;
 649                         }
 650                 }
 651         }
 652 #endif
 653
 654         if(!used_dev.sectors && !used_dev.heads) {
 655                 if(tot_sectors)
 656                         setsize0(tot_sectors,&dummy2,&used_dev.heads,
 657                                  &used_dev.sectors);
 658                 else {
 659                         used_dev.heads = 64;
 660                         used_dev.sectors = 32;
 661                 }
 662         }
 663
 664         if(verbose)
 665                 fprintf(stderr,"sectors: %d heads: %d %d\n",
 666                         used_dev.sectors, used_dev.heads, tot_sectors);
 667
 668         sec_per_cyl = used_dev.sectors * used_dev.heads;
 669         if(create) {
 670                 if(!end_set && tot_sectors) {
 671                         end = tot_sectors - tot_sectors % sec_per_cyl;
 672                         end_set = 1;
 673                 }
 674
 675                 /* if the partition starts right at the beginning of
 676                  * the disk, keep one track unused to allow place for
 677                  * the master boot record */
 678                 if(!begin && !begin_set)
 679                         begin = used_dev.sectors;
 680                 if(!size_set && used_dev.tracks) {
 681                         size_set = 2;
 682                         length = sec_per_cyl * used_dev.tracks;
 683
 684                         /*  round the size in order to take
 685                          * into account any "hidden" sectors */
 686
 687                         /* do we anchor this at the beginning ?*/
 688                         if(begin_set || dev->partition <= 2 || !end_set)
 689                                 length -= begin % sec_per_cyl;
 690                         else if(end - length < begin)
 691                                 /* truncate any overlap */
 692                                 length = end - begin;
 693                 }
 694                 if(size_set) {
 695                         if(!begin_set && dev->partition >2 && end_set)
 696                                 begin = end - length;
 697                         else
 698                                 end = begin + length;
 699                 } else if(!end_set) {
 700                         fprintf(stderr,"Unknown size\n");
 701                         exit(1);
 702                 }
 703
 704                 setBeginEnd(&partTable[dev->partition], begin, end,
 705                             used_dev.heads, used_dev.sectors,
 706                             !has_activated, type,
 707                             dev->fat_bits);
 708         }
 709
 710         if(activate) {
 711                 if(!partTable[dev->partition].sys_ind) {
 712                         fprintf(stderr,
 713                                 "Partition for drive %c: does not exist\n",
 714                                 drive);
 715                 } else {
 716                         switch(activate) {
 717                                 case 1:
 718                                         partTable[dev->partition].boot_ind=0x80;
 719                                         break;
 720                                 case -1:
 721                                         partTable[dev->partition].boot_ind=0x00;
 722                                         break;
 723                         }
 724                 }
 725         }
 726
 727
 728         inconsistency |= consistencyCheck(partTable, doprint, verbose,
 729                                           &has_activated, &last_end, &j,
 730                                           &used_dev, dev->partition);
 731
 732         if(doprint && !inconsistency && partTable[dev->partition].sys_ind) {
 733                 printf("The following command will recreate the partition for drive %c:\n",
 734                        drive);
 735                 used_dev.tracks =
 736                         (_DWORD(partTable[dev->partition].nr_sects) +
 737                          (BEGIN(partTable[dev->partition]) % sec_per_cyl)) /
 738                         sec_per_cyl;
 739                 printf("mpartition -c -t %d -h %d -s %d -b %u %c:\n",
 740                        used_dev.tracks, used_dev.heads, used_dev.sectors,
 741                        BEGIN(partTable[dev->partition]), drive);
 742         }
 743
 744         if(tot_sectors && last_end >tot_sectors) {
 745                 fprintf(stderr,
 746                         "Partition %d exceeds beyond end of disk\n",
 747                         j);
 748                 exit(1);
 749         }
 750
 751
 752         switch(has_activated) {
 753                 case 0:
 754                         fprintf(stderr,
 755                                 "Warning: no active (bootable) partition present\n");
 756                         break;
 757                 case 1:
 758                         break;
 759                 default:
 760                         fprintf(stderr,
 761                                 "Warning: %d active (bootable) partitions present\n",
 762                                 has_activated);
 763                         fprintf(stderr,
 764                                 "Usually, a disk should have exactly one active partition\n");
 765                         break;
 766         }
 767
 768         if(inconsistency && !force) {
 769                 fprintf(stderr,
 770                         "inconsistency detected!\n" );
 771                 if(dirty)
 772                         fprintf(stderr,
 773                                 "Retry with the -f switch to go ahead anyways\n");
 774                 exit(1);
 775         }
 776
 777         if(dirty) {
 778                 /* write data back to the disk */
 779                 if(verbose>=2)
 780                         print_sector("Writing sector", buf, 512);
 781                 if (WRITES(Stream, (char *) buf, 0, 512) != 512) {
 782                         fprintf(stderr,"Error writing partition table");
 783                         exit(1);
 784                 }
 785                 if(verbose>=3)
 786                         print_sector("Sector written", buf, 512);
 787         }
 788         FREE(&Stream);
 789         exit(0);
 790 }