1 /* $NetBSD: ahdilabel.c,v 1.5 2004/11/12 09:52:15 he Exp $ */ 2 3 /* 4 * Copyright (c) 1999 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Julian Coleman. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 #include "privahdi.h" 40 #include <ctype.h> 41 #include <errno.h> 42 #include <stdio.h> 43 #include <stdlib.h> 44 #include <strings.h> 45 46 /* 47 * I think we can safely assume a fixed blocksize - AHDI won't support 48 * something different... 49 */ 50 #define BLPM ((1024 * 1024) / DEV_BSIZE) 51 #define UNITS_SECTORS 0 52 #define UNITS_CTS 1 53 #define PART_ROOT 0 54 #define PART_START 1 55 #define PART_END 2 56 57 int main (int, char*[]); 58 void show_parts (struct ahdi_ptable*, int, int, int); 59 int get_input (char *, int); 60 char *sec_to_cts (struct ahdi_ptable*, u_int32_t, char *); 61 u_int32_t read_sector (struct ahdi_ptable*, char *, int, int); 62 void change_part (struct ahdi_ptable*, int, int); 63 64 int 65 main (argc, argv) 66 int argc; 67 char *argv[]; 68 { 69 struct ahdi_ptable ptable; 70 int flags, rv, key, units; 71 72 if (argc < 2) { 73 fprintf (stderr, "usage: %s raw_disk\n", argv[0]); 74 exit (EXIT_FAILURE); 75 } 76 77 flags = AHDI_IGN_CKSUM; 78 while ((rv = ahdi_readlabel(&ptable, argv[1], flags)) != 1) { 79 switch (rv) { 80 case -1: 81 fprintf (stderr, 82 "%s: %s: %s\n", argv[0], argv[1], 83 strerror (errno)); 84 exit (EXIT_FAILURE); 85 break; 86 case -2: 87 fprintf (stderr, 88 "%s: disk not 512 bytes/sector\n", argv[0]); 89 exit (EXIT_FAILURE); 90 break; 91 case -3: 92 (void) fpurge(stdin); 93 printf ("No AHDI partitions found. Continue (y/N)?"); 94 if (toupper(getchar()) == 'Y') { 95 flags |= FORCE_AHDI; 96 } else 97 exit (EXIT_FAILURE); 98 break; 99 case -4: 100 case -5: 101 case -6: 102 (void) fpurge(stdin); 103 printf ("Errors reading AHDI partition table. Override (y/N)? "); 104 if (toupper(getchar()) == 'Y') { 105 flags |= AHDI_IGN_EXISTS | AHDI_IGN_EXT | 106 AHDI_IGN_SPU; 107 } else 108 exit (EXIT_FAILURE); 109 break; 110 case 1: 111 /* Everything is OK */ 112 break; 113 default: 114 exit (EXIT_FAILURE); 115 break; 116 } 117 } 118 119 units = UNITS_SECTORS; 120 flags = AHDI_KEEP_BOOT | AHDI_KEEP_BSL; 121 show_parts (&ptable, 0, ptable.nparts, units); 122 printf ("Preserve boot sector - "); 123 flags & AHDI_KEEP_BOOT ? printf ("yes\n") : 124 printf ("no\n"); 125 printf ("Preserve bad sector list - "); 126 flags & AHDI_KEEP_BSL ? printf ("yes\n") : 127 printf ("no\n"); 128 key = 0; 129 while (key != 'Q') { 130 (void) fpurge(stdin); 131 printf ("Change [a-p], r)ecalculate, s)how, u)nits, w)rite, z)ero or q)uit "); 132 key = toupper(getchar()); 133 if (key == EOF) 134 key = 'Q'; 135 if (key >= 'A' && key <= 'P') 136 change_part (&ptable, key - 'A', units); 137 if (key == 'R') { 138 if (ahdi_buildlabel (&ptable)) { 139 printf ("Partiton table adjusted\n"); 140 } else { 141 printf ("No changes necessary\n"); 142 } 143 } 144 if (key == 'S') { 145 show_parts (&ptable, 0, ptable.nparts, units); 146 printf ("Preserve boot sector - "); 147 flags & AHDI_KEEP_BOOT ? printf ("yes\n") : 148 printf ("no\n"); 149 printf ("Preserve bad sector list - "); 150 flags & AHDI_KEEP_BSL ? printf ("yes\n") : 151 printf ("no\n"); 152 } 153 if (key == 'U') { 154 if (units == UNITS_SECTORS) { 155 printf ("Units now cylinder/track/sector\n"); 156 units = UNITS_CTS; 157 } else { 158 printf ("Units now sector\n"); 159 units = UNITS_SECTORS; 160 } 161 } 162 if (key == 'W') { 163 if ((rv = ahdi_writelabel (&ptable, argv[1], flags)) < 0) { 164 if (rv == -1) 165 perror ("\0"); 166 if (rv == -2) 167 printf ("Invalid number of partitions!\n"); 168 if (rv == -3) 169 printf ("GEM partition should be BGM or BGM partition should be GEM!\n"); 170 if (rv == -4) 171 printf ("Partition overlaps root sector or bad sector list (starts before sector 2)!\n"); 172 if (rv == -5) 173 printf ("Partition extends past end of disk!\n"); 174 if (rv == -6) 175 printf ("Partitions overlap!\n"); 176 if (rv == -7) 177 printf ("Partition overlaps auxiliary root!\n"); 178 if (rv == -8) 179 printf ("More than 4 partitions in root sector!\n"); 180 if (rv == -9) 181 printf ("More than 1 partition in an auxiliary root!\n"); 182 if (rv < -1 && ahdi_errp1 != -1) 183 printf ("\tpartition %c has errors.\n", 184 ahdi_errp1 + 'a'); 185 if (rv < -1 && ahdi_errp2 != -1) 186 printf ("\tpartition %c has errors.\n", 187 ahdi_errp2 + 'a'); 188 } 189 } 190 if (key == 'Z') { 191 (void) fpurge(stdin); 192 printf ("Preserve boot sector? "); 193 if (flags & AHDI_KEEP_BOOT) { 194 printf ("[y] "); 195 if (toupper (getchar ()) == 'N') 196 flags &= ~AHDI_KEEP_BOOT; 197 } else { 198 printf ("[n] "); 199 if (toupper (getchar ()) == 'Y') 200 flags |= AHDI_KEEP_BOOT; 201 } 202 (void) fpurge(stdin); 203 printf ("Preserve bad sector list? "); 204 if (flags & AHDI_KEEP_BSL) { 205 printf ("[y] "); 206 if (toupper (getchar ()) == 'N') 207 flags &= ~AHDI_KEEP_BSL; 208 } else { 209 printf ("[n] "); 210 if (toupper (getchar ()) == 'Y') 211 flags |= AHDI_KEEP_BSL; 212 } 213 } 214 } 215 return (0); 216 } 217 218 void 219 show_parts (ptable, start, finish, units) 220 struct ahdi_ptable *ptable; 221 int start, finish, units; 222 { 223 int i; 224 225 printf ("Disk information :\n"); 226 printf (" sectors/track: %d\n", ptable->nsectors); 227 printf (" tracks/cylinder: %d\n", ptable->ntracks); 228 printf (" sectors/cylinder: %d\n", ptable->secpercyl); 229 printf (" cylinders: %d\n", ptable->ncylinders); 230 printf (" total sectors: %d\n", ptable->secperunit); 231 232 if (units == UNITS_SECTORS) { 233 printf (" # id root start end size MBs\n"); 234 for (i = start; i < finish; i++) { 235 if (finish - start > 10 && i - start == 8) { 236 (void) fpurge(stdin); 237 printf ("-- Press return for more -- "); 238 (void) getchar(); 239 } 240 printf (" %c %c%c%c %8u %8u %8u %8u (%4u)\n", 241 i + 'a', ptable->parts[i].id[0], 242 ptable->parts[i].id[1], ptable->parts[i].id[2], 243 ptable->parts[i].root, ptable->parts[i].start, 244 ptable->parts[i].start + 245 (ptable->parts[i].size ? 246 ptable->parts[i].size - 1 : 0), 247 ptable->parts[i].size, 248 (ptable->parts[i].size + (BLPM >> 1)) / BLPM); 249 } 250 } else { 251 u_int32_t cylinder, track, sector; 252 printf (" # id root start end size MBs\n"); 253 for (i = start; i < finish; i++) { 254 if (finish - start > 10 && i - start == 8) { 255 (void) fpurge(stdin); 256 printf ("-- Press return for more -- "); 257 (void) getchar(); 258 } 259 printf (" %c %c%c%c ", i + 'a', 260 ptable->parts[i].id[0], ptable->parts[i].id[1], 261 ptable->parts[i].id[2]); 262 sector = ptable->parts[i].root; 263 cylinder = sector / ptable->secpercyl; 264 sector -= cylinder * ptable->secpercyl; 265 track = sector / ptable->nsectors; 266 sector -= track * ptable->nsectors; 267 printf ("%5u/%2u/%3u ", cylinder, track, sector); 268 sector = ptable->parts[i].start; 269 cylinder = sector / ptable->secpercyl; 270 sector -= cylinder * ptable->secpercyl; 271 track = sector / ptable->nsectors; 272 sector -= track * ptable->nsectors; 273 printf ("%5u/%2u/%3u ", cylinder, track, sector); 274 sector = ptable->parts[i].start + 275 (ptable->parts[i].size ? 276 ptable->parts[i].size - 1 : 0), 277 cylinder = sector / ptable->secpercyl; 278 sector -= cylinder * ptable->secpercyl; 279 track = sector / ptable->nsectors; 280 sector -= track * ptable->nsectors; 281 printf ("%5u/%2u/%3u ", cylinder, track, sector); 282 sector = ptable->parts[i].size; 283 cylinder = sector / ptable->secpercyl; 284 sector -= cylinder * ptable->secpercyl; 285 track = sector / ptable->nsectors; 286 sector -= track * ptable->nsectors; 287 printf ("%5u/%2u/%3u ", cylinder, track, sector); 288 printf ("(%4u)\n", 289 (ptable->parts[i].size + (BLPM >> 1)) / BLPM); 290 } 291 } 292 } 293 294 int 295 get_input (buf, len) 296 char *buf; 297 int len; 298 { 299 int count, key; 300 301 count = 0; 302 (void) fpurge(stdin); 303 while (count < (len - 1) && (key = getchar()) != '\n' && key != '\r') { 304 buf[count] = key; 305 count++; 306 } 307 buf[count] = '\0'; 308 return(count); 309 } 310 311 char * 312 sec_to_cts (ptable, sector, cts) 313 struct ahdi_ptable *ptable; 314 u_int32_t sector; 315 char *cts; 316 { 317 u_int32_t cylinder, track; 318 319 cylinder = sector / ptable->secpercyl; 320 sector -= cylinder * ptable->secpercyl; 321 track = sector / ptable->nsectors; 322 sector -= track * ptable->nsectors; 323 sprintf (cts, "%u/%u/%u", cylinder, track, sector); 324 return (cts); 325 } 326 327 u_int32_t 328 read_sector (ptable, buf, part, se) 329 struct ahdi_ptable *ptable; 330 char *buf; 331 int part, se; 332 { 333 u_int32_t sector, track, cylinder; 334 int i; 335 336 sector = track = cylinder = 0; 337 if ((strchr (buf, '/') != NULL) && 338 ((sscanf (buf, "%u/%u/%u", &cylinder, &track, §or) == 3) || 339 (sscanf (buf, "%u/%u/", &cylinder, &track) == 2) || 340 (sscanf (buf, "%u/", &cylinder) == 1))) { 341 if (sector > ptable->nsectors || track > ptable->ntracks || 342 cylinder > ptable->ncylinders) 343 return (0); 344 sector += ptable->nsectors * track; 345 sector += ptable->secpercyl * cylinder; 346 return (sector); 347 } 348 if (buf[0] == '-' && buf[1]) { 349 if (buf[1] == '1' && se == PART_END) 350 /* Extend to end of disk */ 351 return (ptable->secperunit - 352 ptable->parts[part].start); 353 i = (int) (toupper ((unsigned char)(buf[1]) - 'A')); 354 if (i >= 0 && i <= ptable->nparts ) { 355 if (se == PART_ROOT && part > i) 356 /* Root after partition ... */ 357 return (ptable->parts[i].start + 358 ptable->parts[i].size); 359 if (se == PART_START && part > i) { 360 /* Start after partition ... */ 361 if (ptable->parts[part].root) 362 return (ptable->parts[i].start + 363 ptable->parts[i].size + 1); 364 else 365 return (ptable->parts[i].start + 366 ptable->parts[i].size); 367 } 368 if (se == PART_END && part < i) 369 /* End before partition ... */ 370 return (ptable->parts[i].root - 371 ptable->parts[part].start); 372 } 373 return (0); 374 } 375 if (sscanf (buf, "%u", §or) == 1) { 376 if (buf[strlen (buf) - 1] == 'm' || 377 buf[strlen (buf) - 1] == 'M') 378 sector *= BLPM; 379 return (sector); 380 } 381 return (0); 382 } 383 384 void 385 change_part (ptable, part, units) 386 struct ahdi_ptable *ptable; 387 int part, units; 388 { 389 #define BUFLEN 20 390 #define CTSLEN 64 391 char buf[BUFLEN], cts[CTSLEN]; 392 u_int32_t sector; 393 394 if (part > ptable->nparts) { 395 part = ptable->nparts; 396 printf ("Changing partition %c!\n", part + 'a'); 397 ptable->nparts++; 398 } 399 if (part == ptable->nparts) 400 ptable->nparts++; 401 show_parts (ptable, part, part + 1, units); 402 403 printf ("id [%c%c%c] ", ptable->parts[part].id[0], 404 ptable->parts[part].id[1], ptable->parts[part].id[2]); 405 if (get_input (&buf[0], BUFLEN) > 2) { 406 ptable->parts[part].id[0] = buf[0]; 407 ptable->parts[part].id[1] = buf[1]; 408 ptable->parts[part].id[2] = buf[2]; 409 } 410 411 printf ("root [%8u (%s)] ", ptable->parts[part].root, 412 sec_to_cts (ptable, ptable->parts[part].root, &cts[0])); 413 if (get_input (&buf[0], BUFLEN)) { 414 sector = read_sector (ptable, buf, part, PART_ROOT); 415 ptable->parts[part].root = sector; 416 } 417 418 printf ("start [%8u (%s)] ", ptable->parts[part].start, 419 sec_to_cts (ptable, ptable->parts[part].start, &cts[0])); 420 if (get_input (&buf[0], BUFLEN)) { 421 sector = read_sector (ptable, buf, part, PART_START); 422 ptable->parts[part].start = sector; 423 } 424 425 printf ("size [%8u (%s) (%4uM)] ", ptable->parts[part].size, 426 sec_to_cts (ptable, ptable->parts[part].size, &cts[0]), 427 (ptable->parts[part].size + (BLPM >> 1)) / BLPM); 428 if (get_input (&buf[0], BUFLEN)) { 429 sector = read_sector (ptable, buf, part, PART_END); 430 ptable->parts[part].size = sector; 431 } 432 433 /* 434 printf ("NetBSD disk letter [%c] ", ptable->parts[part].letter + 'a'); 435 if (get_input (&buf[0], BUFLEN)) { 436 buf[0] = tolower(buf[0]); 437 if (buf[0] == 'a' || (buf[0] >= 'd' && buf[0] <= 'p')) 438 ptable->parts[part].letter = buf[0] - 'a'; 439 */ 440 441 if (!ptable->parts[part].start && !ptable->parts[part].size) { 442 if (part == ptable->nparts - 1) 443 ptable->nparts--; 444 } 445 } 446