home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / CMDS / mtools_3.6.src.lzh / MTOOLS_3.6 / mpartition.c < prev    next >
Text File  |  1997-11-12  |  15KB  |  630 lines
  1. /*
  2.  * mformat.c
  3.  */
  4.  
  5. #include "sysincludes.h"
  6. #include "msdos.h"
  7. #include "mtools.h"
  8. #include "mainloop.h"
  9. #include "fsP.h"
  10. #include "file.h"
  11. #include "plain_io.h"
  12. #include "nameclash.h"
  13. #include "buffer.h"
  14. #include "scsi.h"
  15. #include "partition.h"
  16.  
  17. #include <math.h>
  18.  
  19. #define tolinear(x) \
  20. (sector(x)-1+(head(x)+cyl(x)*used_dev.heads)*used_dev.sectors)
  21.  
  22.  
  23. static inline void print_hsc(hsc *h)
  24. {
  25.     printf(" h=%d s=%d c=%d\n", 
  26.            head(*h), sector(*h), cyl(*h));
  27. }
  28.  
  29. static void set_offset(hsc *h, int offset, int heads, int sectors)
  30. {
  31.     int head, sector, cyl;
  32.  
  33.     if(! heads || !sectors)
  34.         head = sector = cyl = 0; /* linear mode */
  35.     else {
  36.         sector = offset % sectors;
  37.         offset = offset / sectors;
  38.  
  39.         head = offset % heads;
  40.         cyl = offset / heads;
  41.     }
  42.  
  43.     h->head = head;
  44.     h->sector = ((sector+1) & 0x3f) | ((cyl & 0x300)>>2);
  45.     h->cyl = cyl & 0xff;
  46. }
  47.  
  48. /* setsize function.  Determines scsicam mapping if this cannot be inferred from
  49.  * any existing partitions. Shamelessly snarfed from the Linux kernel ;-) */
  50.  
  51. /*
  52.  * Function : static int setsize(unsigned long capacity,unsigned int *cyls,
  53.  *    unsigned int *hds, unsigned int *secs);
  54.  *
  55.  * Purpose : to determine a near-optimal int 0x13 mapping for a
  56.  *    SCSI disk in terms of lost space of size capacity, storing
  57.  *    the results in *cyls, *hds, and *secs.
  58.  *
  59.  * Returns : -1 on failure, 0 on success.
  60.  *
  61.  * Extracted from
  62.  *
  63.  * WORKING                                                    X3T9.2
  64.  * DRAFT                                                        792D
  65.  *
  66.  *
  67.  *                                                        Revision 6
  68.  *                                                         10-MAR-94
  69.  * Information technology -
  70.  * SCSI-2 Common access method
  71.  * transport and SCSI interface module
  72.  * 
  73.  * ANNEX A :
  74.  *
  75.  * setsize() converts a read capacity value to int 13h
  76.  * head-cylinder-sector requirements. It minimizes the value for
  77.  * number of heads and maximizes the number of cylinders. This
  78.  * will support rather large disks before the number of heads
  79.  * will not fit in 4 bits (or 6 bits). This algorithm also
  80.  * minimizes the number of sectors that will be unused at the end
  81.  * of the disk while allowing for very large disks to be
  82.  * accommodated. This algorithm does not use physical geometry. 
  83.  */
  84.  
  85. static int setsize(unsigned long capacity,unsigned int *cyls,unsigned int *hds,
  86.     unsigned int *secs) { 
  87.     unsigned int rv = 0; 
  88.     unsigned long heads, sectors, cylinders, temp; 
  89.  
  90.     cylinders = 1024L;            /* Set number of cylinders to max */ 
  91.     sectors = 62L;              /* Maximize sectors per track */ 
  92.  
  93.     temp = cylinders * sectors;        /* Compute divisor for heads */ 
  94.     heads = capacity / temp;        /* Compute value for number of heads */
  95.     if (capacity % temp) {        /* If no remainder, done! */ 
  96.         heads++;                    /* Else, increment number of heads */ 
  97.         temp = cylinders * heads;    /* Compute divisor for sectors */ 
  98.         sectors = capacity / temp;    /* Compute value for sectors per
  99.                            track */ 
  100.         if (capacity % temp) {        /* If no remainder, done! */ 
  101.               sectors++;                  /* Else, increment number of sectors */ 
  102.               temp = heads * sectors;    /* Compute divisor for cylinders */
  103.               cylinders = capacity / temp;/* Compute number of cylinders */ 
  104.           } 
  105.     } 
  106.     if (cylinders == 0) rv=(unsigned)-1;/* Give error if 0 cylinders */ 
  107.  
  108.     *cyls = (unsigned int) cylinders;    /* Stuff return values */ 
  109.     *secs = (unsigned int) sectors; 
  110.     *hds  = (unsigned int) heads; 
  111.     return(rv); 
  112. } 
  113.  
  114. static void setsize0(unsigned long capacity,unsigned int *cyls,
  115.              unsigned int *hds, unsigned int *secs)
  116. {
  117.     int r;
  118.  
  119.     /* 1. First try "Megabyte" sizes */
  120.     if(capacity < 1024 * 2048 && !(capacity % 1024)) {
  121.         *cyls = capacity >> 11;
  122.         *hds  = 64;
  123.         *secs = 32;
  124.         return;
  125.     }
  126.  
  127.     /* then try scsicam's size */
  128.     r = setsize(capacity,cyls,hds,secs);
  129.     if(r || *hds > 255 || *secs > 63) {
  130.         /* scsicam failed. Do megabytes anyways */
  131.         *cyls = capacity >> 11;
  132.         *hds  = 64;
  133.         *secs = 32;
  134.         return;
  135.     }
  136. }
  137.  
  138.  
  139. static void usage(void)
  140. {
  141.     fprintf(stderr, 
  142.         "Mtools version %s, dated %s\n", mversion, mdate);
  143.     fprintf(stderr, 
  144.         "Usage: %s [-prIadcv] [-s sectors] [-t cylinders] "
  145.         "[-h heads] [-T type] [-b begin] [-l length] "
  146.         "drive\n", progname);
  147.     exit(1);
  148. }
  149.  
  150. void mpartition(int argc, char **argv, int dummy)
  151. {
  152.     Stream_t *Stream;
  153.     unsigned int dummy2;
  154.  
  155.     int i,j;
  156.  
  157.     int sec_per_cyl;
  158.     int doprint = 0;
  159.     int verbose = 0;
  160.     int create = 0;
  161.     int force = 0;
  162.     int length = 0;
  163.     int remove = 0;
  164.     int initialize = 0;
  165.     int tot_sectors=0;
  166.     int type = 0;
  167.     int begin_set = 0;
  168.     int size_set = 0;
  169.     int end_set = 0;
  170.     int last_end = 0;
  171.     int activate = 0;
  172.     int has_activated = 0;
  173.     int inconsistency=0;
  174.     int begin=0;
  175.     int end=0;
  176.     int sizetest=0;
  177.     int dirty = 0;
  178.     int open2flags = NO_OFFSET;
  179.     
  180.     int c;
  181.     struct device used_dev;
  182.     int argtracks, argheads, argsectors;
  183.  
  184.     char drive, name[EXPAND_BUF];
  185.     unsigned char buf[512];
  186.     struct partition *partTable=(struct partition *)(buf+ 0x1ae);
  187.     struct device *dev;
  188.     char errmsg[200];
  189.  
  190.     argtracks = 0;
  191.     argheads = 0;
  192.     argsectors = 0;
  193.  
  194.     /* get command line options */
  195.     while ((c = getopt(argc, argv, "adprcIT:t:h:s:fvpb:l:S:")) != EOF) {
  196.         switch (c) {
  197.             case 'a':
  198.                 /* no privs, as it could be abused to
  199.                  * make other partitions unbootable, or
  200.                  * to boot a rogue kernel from this one */
  201.                 open2flags |= NO_PRIV;
  202.                 activate = 1;
  203.                 dirty = 1;
  204.                 break;
  205.             case 'd':
  206.                 activate = -1;
  207.                 dirty = 1;
  208.                 break;
  209.             case 'p':
  210.                 doprint = 1;
  211.                 break;
  212.             case 'r':
  213.                 remove = 1;
  214.                 dirty = 1;
  215.                 break;
  216.             case 'I':
  217.                 /* could be abused to nuke all other 
  218.                  * partitions */
  219.                 open2flags |= NO_PRIV;
  220.                 initialize = 1;
  221.                 dirty = 1;
  222.                 break;
  223.             case 'c':
  224.                 create = 1;
  225.                 dirty = 1;
  226.                 break;
  227.  
  228.             case 'T':
  229.                 /* could be abused to "manually" create
  230.                  * extended partitions */
  231.                 open2flags |= NO_PRIV;
  232.                 type = strtoul(optarg,0,0);
  233.                 break;
  234.  
  235.             case 't':
  236.                 argtracks = atoi(optarg);
  237.                 break;
  238.             case 'h':
  239.                 argheads = atoi(optarg);
  240.                 break;
  241.             case 's':
  242.                 argsectors = atoi(optarg);
  243.                 break;
  244.  
  245.             case 'f':
  246.                 /* could be abused by creating overlapping
  247.                  * partitions and other such Snafu */
  248.                 open2flags |= NO_PRIV;
  249.                 force = 1;
  250.                 break;
  251.  
  252.             case 'v':
  253.                 verbose++;
  254.                 break;
  255.             case 'S':
  256.                 /* testing only */
  257.                 /* could be abused to create partitions
  258.                  * extending beyond the actual size of the
  259.                  * device */
  260.                 open2flags |= NO_PRIV;
  261.                 tot_sectors = strtoul(optarg,0,0);
  262.                 sizetest = 1;
  263.                 break;
  264.             case 'b':
  265.                 begin_set = 1;
  266.                 begin = atoi(optarg);
  267.                 break;
  268.             case 'l':
  269.                 size_set = 1;
  270.                 length = atoi(optarg);
  271.                 break;
  272.  
  273.             default:
  274.                 usage();
  275.         }
  276.     }
  277.  
  278.     if (argc - optind != 1 ||
  279.         !argv[optind][0] || argv[optind][1] != ':')
  280.         usage();
  281.     
  282.     drive = toupper(argv[optind][0]);
  283.  
  284.     /* check out a drive whose letter and parameters match */    
  285.     sprintf(errmsg, "Drive '%c:' not supported", drive);    
  286.     for(dev=devices;dev->drive;dev++) {
  287.         FREE(&(Stream));
  288.         /* drive letter */
  289.         if (dev->drive != drive)
  290.             continue;
  291.         if (dev->partition < 1 || dev->partition > 4) {
  292.             sprintf(errmsg, 
  293.                 "Drive '%c:' is not a partition", 
  294.                 drive);
  295.             continue;
  296.         }
  297.         used_dev = *dev;
  298.  
  299.         SET_INT(used_dev.tracks, argtracks);
  300.         SET_INT(used_dev.heads, argheads);
  301.         SET_INT(used_dev.sectors, argsectors);
  302.         
  303.         expand(dev->name, name);
  304.         Stream = SimpleFileOpen(&used_dev, dev, name,
  305.                     dirty ? O_RDWR : O_RDONLY, 
  306.                     errmsg, open2flags);
  307.  
  308.         if (!Stream) {
  309.             sprintf(errmsg,"init: open: %s", strerror(errno));
  310.             continue;
  311.         }            
  312.  
  313.  
  314.         /* try to find out the size */
  315.         if(!sizetest)
  316.             tot_sectors = 0;
  317.         if(dev->scsi) {
  318.             unsigned char cmd[10];
  319.             unsigned char data[10];
  320.             cmd[0] = SCSI_READ_CAPACITY;
  321.             memset ((void *) &cmd[2], 0, 8);
  322.             memset ((void *) &data[0], 137, 10);
  323.             scsi_cmd(get_fd(Stream), cmd, 10, SCSI_IO_READ,
  324.                  data, 10);
  325.             
  326.             tot_sectors = 1 +
  327.                 (data[0] << 24) +
  328.                 (data[1] << 16) +
  329.                 (data[2] <<  8) +
  330.                 (data[3]      );
  331.             if(verbose)
  332.                 printf("%d sectors in total\n", tot_sectors);
  333.         }
  334.  
  335.         /* read the partition table */
  336.         if (READS(Stream, (char *) buf, 0, 512) != 512) {
  337.             sprintf(errmsg, 
  338.                 "Error reading from '%s', wrong parameters?",
  339.                 name);
  340.             continue;
  341.         }
  342.         if(verbose>=2)
  343.             print_sector("Read sector", buf);
  344.         break;
  345.     }
  346.  
  347.     /* print error msg if needed */    
  348.     if ( dev->drive == 0 ){
  349.         FREE(&Stream);
  350.         fprintf(stderr,"%s: %s\n", argv[0],errmsg);
  351.         exit(1);
  352.     }
  353.  
  354.     if((used_dev.sectors || used_dev.heads) &&
  355.        (!used_dev.sectors || !used_dev.heads)) {
  356.         fprintf(stderr,"You should either indicate both the number of sectors and the number of heads,\n");
  357.         fprintf(stderr," or none of them\n");
  358.         exit(1);
  359.     }
  360.  
  361.     if(initialize) {
  362.         memset((char *)(partTable+1), 0, 4*sizeof(*partTable));
  363.         buf[510] = 0x55;
  364.         buf[511] = 0xaa;
  365.     }
  366.  
  367.     /* check for boot signature, and place it if needed */
  368.     if((buf[510] != 0x55) || (buf[511] != 0xaa)) {
  369.         fprintf(stderr,"Boot signature not set\n");
  370.         fprintf(stderr,
  371.             "Use the -I flag to initialize the partition table, and set the boot signature\n");
  372.         inconsistency = 1;
  373.     }
  374.     
  375.     if(remove){
  376.         if(!partTable[dev->partition].sys_ind)
  377.             fprintf(stderr,
  378.                 "Partition for drive %c: does not exist\n",
  379.                 drive);
  380.         if((partTable[dev->partition].sys_ind & 0x3f) == 5) {
  381.             fprintf(stderr,
  382.                 "Partition for drive %c: may be an extended partition\n",
  383.                 drive);
  384.             fprintf(stderr,
  385.                 "Use the -f flag to remove it anyways\n");
  386.             inconsistency = 1;
  387.         }
  388.         memset(&partTable[dev->partition], 0, sizeof(*partTable));
  389.     }
  390.  
  391.     if(create && partTable[dev->partition].sys_ind) {
  392.         fprintf(stderr,
  393.             "Partition for drive %c: already exists\n", drive);
  394.         fprintf(stderr,
  395.             "Use the -r flag to remove it before attempting to recreate it\n");
  396.     }
  397.  
  398.  
  399.     /* find out number of heads and sectors, and whether there is
  400.     * any activated partition */
  401.     has_activated = 0;
  402.     for(i=1; i<5; i++){
  403.         if(!partTable[i].sys_ind)
  404.             continue;
  405.         
  406.         if(partTable[i].boot_ind)
  407.             has_activated++;
  408.  
  409.         /* set geometry from entry */
  410.         if (!used_dev.heads)
  411.             used_dev.heads = head(partTable[i].end)+1;
  412.         if(!used_dev.sectors)
  413.             used_dev.sectors = sector(partTable[i].end);
  414.         if(i<dev->partition && !begin_set)
  415.             begin = END(partTable[i]);
  416.         if(i>dev->partition && !end_set && !size_set) {
  417.             end = BEGIN(partTable[i]);
  418.             end_set = 1;
  419.         }
  420.     }
  421.     
  422.     if(!used_dev.sectors && !used_dev.heads) {
  423.         if(tot_sectors)
  424.             setsize0(tot_sectors,&dummy2,&used_dev.heads,
  425.                  &used_dev.sectors);
  426.         else {
  427.             used_dev.heads = 64;
  428.             used_dev.heads = 32;
  429.         }
  430.     }
  431.  
  432.     if(verbose)
  433.         fprintf(stderr,"sectors: %d heads: %d\n",
  434.             used_dev.sectors, used_dev.heads);
  435.  
  436.     sec_per_cyl = used_dev.sectors * used_dev.heads;
  437.     if(create) {
  438.         if(!end_set && tot_sectors) {
  439.             end = tot_sectors - tot_sectors % sec_per_cyl;
  440.             end_set = 1;
  441.         }
  442.         
  443.         /* if the partition starts right at the beginning of
  444.          * the disk, keep one track unused to allow place for
  445.          * the master boot record */
  446.         if(!begin && !begin_set)
  447.             begin = used_dev.sectors;
  448.         if(!size_set && used_dev.tracks) {
  449.             size_set = 2;
  450.             length = sec_per_cyl * used_dev.tracks;
  451.  
  452.             /*  round the size in order to take
  453.              * into account any "hidden" sectors */
  454.  
  455.             /* do we anchor this at the beginning ?*/
  456.             if(begin_set || dev->partition <= 2 || !end_set)
  457.                 length -= begin % sec_per_cyl;
  458.             else if(end - length < begin)
  459.                 /* truncate any overlap */
  460.                 length = end - begin;
  461.         }
  462.         if(size_set) {
  463.             if(!begin_set && dev->partition >2 && end_set)
  464.                 begin = end - length;
  465.             else
  466.                 end = begin + length;
  467.         } else if(!end_set) {
  468.             fprintf(stderr,"Unknown size\n");
  469.             exit(1);
  470.         }
  471.  
  472.         set_offset(&partTable[dev->partition].start, begin, 
  473.                used_dev.heads, used_dev.sectors);
  474.         set_offset(&partTable[dev->partition].end, end-1, 
  475.                used_dev.heads, used_dev.sectors);
  476.         set_dword(partTable[dev->partition].start_sect, begin);
  477.         set_dword(partTable[dev->partition].nr_sects, end-begin);
  478.         if(has_activated)
  479.             partTable[dev->partition].boot_ind = 0;
  480.         else
  481.             partTable[dev->partition].boot_ind = 0x80;
  482.         if(!type) {
  483.             if(end-begin < 4096)
  484.                 type = 1; /* DOS 12-bit FAT */
  485.             else if(end-begin<32*2048)
  486.                 type = 4; /* DOS 16-bit FAT, <32M */
  487.             else
  488.                 type = 6; /* DOS 16-bit FAT >= 32M */
  489.         }
  490.         partTable[dev->partition].sys_ind = type;
  491.     }
  492.  
  493.     j = 0;
  494.     last_end = 1;
  495.  
  496.     if(activate) {
  497.         if(!partTable[dev->partition].sys_ind) {
  498.             fprintf(stderr,
  499.                 "Partition for drive %c: does not exist\n",
  500.                 drive);
  501.         } else {
  502.             switch(activate) {
  503.                 case 1:
  504.                     partTable[dev->partition].boot_ind=0x80;
  505.                     break;
  506.                 case -1:
  507.                     partTable[dev->partition].boot_ind=0x00;
  508.                     break;
  509.             }
  510.         }
  511.     }
  512.  
  513.     /* quick consistency check */
  514.     has_activated = 0;
  515.     for(i=1; i<5; i++){
  516.         if(!partTable[i].sys_ind)
  517.             continue;
  518.         if(partTable[i].boot_ind)
  519.             has_activated++;
  520.         if(used_dev.heads != head(partTable[i].end)+1 ||
  521.            used_dev.sectors != sector(partTable[i].end) ||
  522.            sector(partTable[i].start) != 1){
  523.             fprintf(stderr,
  524.                 "Partition %d is not aligned\n",
  525.                 i);
  526.             inconsistency=1;
  527.         }
  528.         
  529.         if(j && last_end > BEGIN(partTable[i])) {
  530.             fprintf(stderr,
  531.                 "Partitions %d and %d badly ordered or overlapping\n",
  532.                 j,i);
  533.             inconsistency=1;
  534.         }
  535.             
  536.         last_end = END(partTable[i]);
  537.         j = i;
  538.  
  539.         if(tolinear(partTable[i].start) != BEGIN(partTable[i])) {
  540.             fprintf(stderr,
  541.                 "Start position mismatch for partition %d\n",
  542.                 i);
  543.             inconsistency=1;
  544.         }
  545.         if(tolinear(partTable[i].end)+1 != END(partTable[i])) {
  546.             fprintf(stderr,
  547.                 "End position mismatch for partition %d\n",
  548.                 i);
  549.             inconsistency=1;
  550.         }
  551.  
  552.         if(doprint && verbose) {
  553.             if(i==dev->partition)
  554.                 putchar('*');
  555.             else
  556.                 putchar(' ');
  557.             printf("Partition %d\n",i);
  558.  
  559.             printf("  active=%x\n", partTable[i].boot_ind);
  560.             printf("  start:");
  561.             print_hsc(&partTable[i].start);
  562.             printf("  type=0x%x\n", partTable[i].sys_ind);
  563.             printf("  end:");
  564.             print_hsc(&partTable[i].end);
  565.             printf("  start=%d\n", BEGIN(partTable[i]));
  566.             printf("  nr=%d\n", _DWORD(partTable[i].nr_sects));
  567.             printf("\n");
  568.         }
  569.     }
  570.  
  571.     if(doprint && !inconsistency && partTable[dev->partition].sys_ind) {
  572.         printf("The following command will recreate the partition for drive %c:\n", 
  573.                drive);
  574.         used_dev.tracks = 
  575.             (_DWORD(partTable[dev->partition].nr_sects) +
  576.              (BEGIN(partTable[dev->partition]) % sec_per_cyl)) / 
  577.             sec_per_cyl;
  578.         printf("mpartition -c -t %d -h %d -s %d -b %u %c:\n",
  579.                used_dev.tracks, used_dev.heads, used_dev.sectors,
  580.                BEGIN(partTable[dev->partition]), drive);
  581.     }
  582.  
  583.     if(tot_sectors && last_end >tot_sectors) {
  584.         fprintf(stderr,
  585.             "Partition %d exceeds beyond end of disk\n",
  586.             j);
  587.         exit(1);
  588.     }
  589.  
  590.     
  591.     switch(has_activated) {
  592.         case 0:
  593.             fprintf(stderr,
  594.                 "Warning: no active (bootable) partition present\n");
  595.             break;
  596.         case 1:
  597.             break;
  598.         default:
  599.             fprintf(stderr,
  600.                 "Warning: %d active (bootable) partitions present\n",
  601.                 has_activated);
  602.             fprintf(stderr,
  603.                 "Usually, a disk should have exactly one active partition\n");
  604.             break;
  605.     }
  606.     
  607.     if(inconsistency && !force) {
  608.         fprintf(stderr,
  609.             "inconsistency detected!\n" );
  610.         if(dirty)
  611.             fprintf(stderr,
  612.                 "Retry with the -f switch to go ahead anyways\n");
  613.         exit(1);
  614.     }
  615.  
  616.     if(dirty) {
  617.         /* write data back to the disk */
  618.         if(verbose>=2)
  619.             print_sector("Writing sector", buf);
  620.         if (WRITES(Stream, (char *) buf, 0, 512) != 512) {
  621.             fprintf(stderr,"Error writing partition table");
  622.             exit(1);
  623.         }
  624.         if(verbose>=3)
  625.             print_sector("Sector written", buf);
  626.         FREE(&Stream);
  627.     }
  628.     exit(0);
  629. }
  630.