commands/ibm/repartition.c

   1 /*      repartition 1.18 - Load a partition table       Author: Kees J. Bot
   2  *                                                              30 Nov 1991
   3  */
   4 #define nil 0
   5 #include <stdio.h>
   6 #include <sys/types.h>
   7 #include <sys/ioctl.h>
   8 #include <stdlib.h>
   9 #include <unistd.h>
  10 #include <fcntl.h>
  11 #include <minix/config.h>
  12 #include <minix/const.h>
  13 #include <minix/partition.h>
  14 #include <minix/u64.h>
  15 #include <machine/partition.h>
  16 #include <sys/stat.h>
  17 #include <string.h>
  18 #include <errno.h>
  19 #include <dirent.h>
  20 #include <limits.h>
  21
  22 #define DEV_FD0         0x200
  23
  24 #define SECTOR_SIZE     512
  25
  26 #define arraysize(a)    (sizeof(a)/sizeof((a)[0]))
  27 #define arraylimit(a)   ((a) + arraysize(a))
  28
  29 char *arg0;
  30 char *dev_file;         /* Device to repartition. */
  31
  32 #ifndef S_ISLNK
  33 /* There were no symlinks in medieval times. */
  34 #define lstat           stat
  35 #endif
  36
  37 void report(const char *label)
  38 {
  39         fprintf(stderr, "%s: %s: %s\n", arg0, label, strerror(errno));
  40 }
  41
  42 void fatal(const char *label)
  43 {
  44         report(label);
  45         exit(1);
  46 }
  47
  48 #ifndef makedev
  49 #define minor(dev)      (((dev) >> MINOR) & BYTE)
  50 #define major(dev)      (((dev) >> MAJOR) & BYTE)
  51 #define makedev(major, minor)   \
  52                         ((dev_t) (((major) << MAJOR) | ((minor) << MINOR)))
  53 #endif
  54
  55 #define MINOR_d0p0s0    128
  56
  57 void partsort(struct part_entry *pe)
  58 /* DOS has the misguided idea that partition tables must be sorted. */
  59 {
  60   int i,j;
  61   struct part_entry tmp;
  62
  63   for (i = 0; i < NR_PARTITIONS; i++)
  64         for (j = 0; j < NR_PARTITIONS-1; j++)
  65                 if ((pe[j].sysind == NO_PART && pe[j+1].sysind != NO_PART) ||
  66                  (pe[j].lowsec > pe[j+1].lowsec && pe[j+1].sysind != NO_PART)) {
  67                         tmp = pe[j];
  68                         pe[j] = pe[j+1];
  69                         pe[j+1] = tmp;
  70                 }
  71 }
  72
  73 char *finddev(dev_t device)
  74 /* Find the device next to dev_file with the given device number. */
  75 {
  76         DIR *dp;
  77         struct dirent *de;
  78         static char name[PATH_MAX];
  79         char *np;
  80         size_t nlen;
  81         struct stat st;
  82
  83         if ((np= strrchr(dev_file, '/')) == nil) np= dev_file; else np++;
  84         nlen= np - dev_file;
  85         if (nlen > PATH_MAX - NAME_MAX - 1) {
  86                 fprintf(stderr, "%s: %s: Name is way too long\n",
  87                         arg0, dev_file);
  88                 exit(1);
  89         }
  90         memcpy(name, dev_file, nlen);
  91
  92         if ((dp= opendir("/dev")) == nil) fatal("/dev");
  93         while ((de= readdir(dp)) != nil) {
  94                 strcpy(name+nlen, de->d_name);
  95                 if (lstat(name, &st) == 0
  96                         && (S_ISBLK(st.st_mode) || S_ISCHR(st.st_mode))
  97                         && st.st_rdev == device
  98                 ) {
  99                         closedir(dp);
 100                         return name;
 101                 }
 102         }
 103         fprintf(stderr, "%s: Can't find partition devices associated with %s\n",
 104                 arg0, dev_file);
 105         exit(1);
 106 }
 107
 108 #define DSETP   0
 109 #define DGETP   1
 110
 111 int diocntl(dev_t device, int request, struct partition *entry)
 112 /* Get or set the geometry of a device. */
 113 {
 114         char *name;
 115         int r, f, err;
 116         struct partition geometry;
 117
 118         name= finddev(device);
 119         if ((f= open(name, O_RDONLY)) < 0) return -1;
 120         r= ioctl(f, request == DSETP ? DIOCSETP : DIOCGETP, (void *) entry);
 121         err= errno;
 122         (void) close(f);
 123         errno= err;
 124         return r;
 125 }
 126
 127 struct partition geometry;      /* Geometry of the device. */
 128
 129 void print_chs(unsigned long sector)
 130 {
 131         unsigned secspcyl = geometry.heads * geometry.sectors;
 132         int delta= 0;
 133
 134         if (sector == -1) { sector= 0; delta= -1; }
 135
 136         printf(" %5d/%03d/%02d",
 137                 (int) (sector / secspcyl),
 138                 (int) (sector % secspcyl) / geometry.sectors,
 139                 (int) (sector % geometry.sectors) + delta);
 140 }
 141
 142 void show_part(char *name, unsigned long base, unsigned long size)
 143 {
 144         int i;
 145         static int len= 0;
 146
 147         if (len == 0) {
 148                 len= strlen(name) + 3;
 149                 printf("device");
 150                 for (i = 6; i < len; i++) fputc(' ', stdout);
 151                 printf(
 152         "      first         last        base      size        kb\n");
 153         }
 154
 155         printf("%s", name);
 156         for (i = strlen(name); i < len; i++) fputc(' ', stdout);
 157
 158         print_chs(base);
 159         print_chs(base + size - 1);
 160         printf(" %9lu %9lu %9lu\n", base, size, size / (1024/SECTOR_SIZE));
 161 }
 162
 163 int main(int argc, char **argv)
 164 {
 165         struct stat hdst;
 166         struct partition whole, entry;
 167         struct part_entry table[4], *pe;
 168         int drive, par, device, incr;
 169         int partf;
 170         char *table_file;
 171         int hd_major, hd_minor;
 172         int needsort;
 173         int shrink;             /* True if partitions are shrinked to fit. */
 174         unsigned long base, size, limit;
 175
 176         if ((arg0= strrchr(argv[0], '/')) == nil) arg0= argv[0]; else arg0++;
 177
 178         if (argc < 2 || argc > 3) {
 179                 fprintf(stderr,
 180                         "Usage: %s device [partition-file]\n", arg0);
 181                 exit(1);
 182         }
 183         dev_file= argv[1];
 184         table_file= argv[argc - 1];
 185         shrink= (argc == 2);
 186
 187         if (stat(dev_file, &hdst) < 0) fatal(dev_file);
 188
 189         /* Geometry (to print nice numbers.) */
 190         if (diocntl(hdst.st_rdev, DGETP, &geometry) < 0) fatal(dev_file);
 191
 192         if (!S_ISBLK(hdst.st_mode)) {
 193                 fprintf(stderr, "%s: %s is not a device\n", arg0, dev_file);
 194                 exit(1);
 195         }
 196         hd_major= major(hdst.st_rdev);
 197         hd_minor= minor(hdst.st_rdev);
 198
 199         if (hd_minor >= MINOR_d0p0s0) {
 200                 errno= EINVAL;
 201                 fatal(dev_file);
 202         }
 203
 204         if (hd_major == major(DEV_FD0)) {
 205                 /* HD is actually a floppy. */
 206                 if (hd_minor >= 4) {
 207                         errno= EINVAL;
 208                         fatal(dev_file);
 209                 }
 210                 device= hd_minor + (28 << 2);
 211                 incr= 4;
 212                 needsort= 0;
 213         } else
 214         if (hd_minor % (1 + NR_PARTITIONS) == 0) {
 215                 /* Partitioning hd0, hd5, ... */
 216                 device= hd_minor + 1;
 217                 incr= 1;
 218                 needsort= 1;
 219         } else {
 220                 /* Subpartitioning hd[1-4], hd[6-9], ... */
 221                 drive= hd_minor / (1 + NR_PARTITIONS);
 222                 par= hd_minor % (1 + NR_PARTITIONS) - 1;
 223
 224                 device= MINOR_d0p0s0
 225                                 + (drive * NR_PARTITIONS + par) * NR_PARTITIONS;
 226                 if (device + NR_PARTITIONS - 1 > BYTE) {
 227                         errno= EINVAL;
 228                         fatal(dev_file);
 229                 }
 230                 incr= 1;
 231                 needsort= 0;
 232         }
 233         /* Device is now the first of the minor devices to be repartitioned. */
 234
 235         /* Read the partition table from the boot block. */
 236         if ((partf= open(table_file, O_RDONLY)) < 0
 237                 || lseek(partf, (off_t) PART_TABLE_OFF, SEEK_SET) == -1
 238                 || (par= read(partf, (char *) table, (int) sizeof(table))) < 0
 239         ) fatal(table_file);
 240
 241         if (par < sizeof(table)) {
 242                 fprintf(stderr, "%s: %s does not contain a partition table\n",
 243                         arg0, table_file);
 244                 exit(1);
 245         }
 246         if (needsort) partsort(table);
 247
 248         /* Show the geometry of the affected drive or partition. */
 249         if (diocntl(hdst.st_rdev, DGETP, &whole) < 0) fatal(dev_file);
 250
 251         /* Use sector numbers. */
 252         base = div64u(whole.base, SECTOR_SIZE);
 253         size = div64u(whole.size, SECTOR_SIZE);
 254         limit = base + size;
 255
 256         show_part(dev_file, base, size);
 257
 258         /* Send the partition table entries to the device driver. */
 259         for (par= 0; par < NR_PARTITIONS; par++, device+= incr) {
 260                 pe = &table[par];
 261                 if (shrink && pe->size != 0) {
 262                         /* Shrink the partition entry to fit within the
 263                          * enclosing device just like the driver does.
 264                          */
 265                         unsigned long part_limit= pe->lowsec + pe->size;
 266
 267                         if (part_limit < pe->lowsec) part_limit= limit;
 268                         if (part_limit > limit) part_limit= limit;
 269                         if (pe->lowsec < base) pe->lowsec= base;
 270                         if (part_limit < pe->lowsec) part_limit= pe->lowsec;
 271                         pe->size= part_limit - pe->lowsec;
 272                 }
 273
 274                 entry.base= mul64u(pe->lowsec, SECTOR_SIZE);
 275                 entry.size= mul64u(pe->size, SECTOR_SIZE);
 276                 if (diocntl(makedev(hd_major, device), DSETP, &entry) < 0)
 277                         fatal(dev_file);
 278
 279                 show_part(finddev(makedev(hd_major, device)),
 280                                                         pe->lowsec, pe->size);
 281         }
 282         exit(0);
 283 }