?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
svlogd: fix compat problem: svlogd -tt should timestanp stderr too
[busybox.git] / util-linux / fdisk_sgi.c
blob25e75b06c6eb6aac7136a35b16bf520ef53cbcc3
1 #if ENABLE_FEATURE_SGI_LABEL
2
3 /*
4 * Copyright (C) Andreas Neuper, Sep 1998.
5 * This file may be modified and redistributed under
6 * the terms of the GNU Public License.
7 */
8
9 #define SGI_VOLHDR 0x00
10 /* 1 and 2 were used for drive types no longer supported by SGI */
11 #define SGI_SWAP 0x03
12 /* 4 and 5 were for filesystem types SGI haven't ever supported on MIPS CPUs */
13 #define SGI_VOLUME 0x06
14 #define SGI_EFS 0x07
15 #define SGI_LVOL 0x08
16 #define SGI_RLVOL 0x09
17 #define SGI_XFS 0x0a
18 #define SGI_XFSLOG 0x0b
19 #define SGI_XLV 0x0c
20 #define SGI_XVM 0x0d
21 #define SGI_ENTIRE_DISK SGI_VOLUME
22
23 struct device_parameter { /* 48 bytes */
24 unsigned char skew;
25 unsigned char gap1;
26 unsigned char gap2;
27 unsigned char sparecyl;
28 unsigned short pcylcount;
29 unsigned short head_vol0;
30 unsigned short ntrks; /* tracks in cyl 0 or vol 0 */
31 unsigned char cmd_tag_queue_depth;
32 unsigned char unused0;
33 unsigned short unused1;
34 unsigned short nsect; /* sectors/tracks in cyl 0 or vol 0 */
35 unsigned short bytes;
36 unsigned short ilfact;
37 unsigned int flags; /* controller flags */
38 unsigned int datarate;
39 unsigned int retries_on_error;
40 unsigned int ms_per_word;
41 unsigned short xylogics_gap1;
42 unsigned short xylogics_syncdelay;
43 unsigned short xylogics_readdelay;
44 unsigned short xylogics_gap2;
45 unsigned short xylogics_readgate;
46 unsigned short xylogics_writecont;
47 };
48
49 /*
50 * controller flags
51 */
52 #define SECTOR_SLIP 0x01
53 #define SECTOR_FWD 0x02
54 #define TRACK_FWD 0x04
55 #define TRACK_MULTIVOL 0x08
56 #define IGNORE_ERRORS 0x10
57 #define RESEEK 0x20
58 #define ENABLE_CMDTAGQ 0x40
59
60 typedef struct {
61 unsigned int magic; /* expect SGI_LABEL_MAGIC */
62 unsigned short boot_part; /* active boot partition */
63 unsigned short swap_part; /* active swap partition */
64 unsigned char boot_file[16]; /* name of the bootfile */
65 struct device_parameter devparam; /* 1 * 48 bytes */
66 struct volume_directory { /* 15 * 16 bytes */
67 unsigned char vol_file_name[8]; /* a character array */
68 unsigned int vol_file_start; /* number of logical block */
69 unsigned int vol_file_size; /* number of bytes */
70 } directory[15];
71 struct sgi_partinfo { /* 16 * 12 bytes */
72 unsigned int num_sectors; /* number of blocks */
73 unsigned int start_sector; /* must be cylinder aligned */
74 unsigned int id;
75 } partitions[16];
76 unsigned int csum;
77 unsigned int fillbytes;
78 } sgi_partition;
79
80 typedef struct {
81 unsigned int magic; /* looks like a magic number */
82 unsigned int a2;
83 unsigned int a3;
84 unsigned int a4;
85 unsigned int b1;
86 unsigned short b2;
87 unsigned short b3;
88 unsigned int c[16];
89 unsigned short d[3];
90 unsigned char scsi_string[50];
91 unsigned char serial[137];
92 unsigned short check1816;
93 unsigned char installer[225];
94 } sgiinfo;
95
96 #define SGI_LABEL_MAGIC 0x0be5a941
97 #define SGI_LABEL_MAGIC_SWAPPED 0x41a9e50b
98 #define SGI_INFO_MAGIC 0x00072959
99 #define SGI_INFO_MAGIC_SWAPPED 0x59290700
100
101 #define SGI_SSWAP16(x) (sgi_other_endian ? fdisk_swap16(x) : (uint16_t)(x))
102 #define SGI_SSWAP32(x) (sgi_other_endian ? fdisk_swap32(x) : (uint32_t)(x))
103
104 #define sgilabel ((sgi_partition *)MBRbuffer)
105 #define sgiparam (sgilabel->devparam)
106
107 /*
108 *
109 * fdisksgilabel.c
110 *
111 * Copyright (C) Andreas Neuper, Sep 1998.
112 * This file may be modified and redistributed under
113 * the terms of the GNU Public License.
114 *
115 * Sat Mar 20 EST 1999 Arnaldo Carvalho de Melo <acme@conectiva.com.br>
116 * Internationalization
117 */
118
119
120 static int sgi_other_endian;
121 static int debug;
122 static short sgi_volumes = 1;
123
124 /*
125 * only dealing with free blocks here
126 */
127
128 typedef struct {
129 unsigned int first;
130 unsigned int last;
131 } freeblocks;
132 static freeblocks freelist[17]; /* 16 partitions can produce 17 vacant slots */
133
134 static void
135 setfreelist(int i, unsigned int f, unsigned int l)
136 {
137 freelist[i].first = f;
138 freelist[i].last = l;
139 }
140
141 static void
142 add2freelist(unsigned int f, unsigned int l)
143 {
144 int i;
145 for (i = 0; i < 17; i++)
146 if (freelist[i].last == 0)
147 break;
148 setfreelist(i, f, l);
149 }
150
151 static void
152 clearfreelist(void)
153 {
154 int i;
155
156 for (i = 0; i < 17; i++)
157 setfreelist(i, 0, 0);
158 }
159
160 static unsigned int
161 isinfreelist(unsigned int b)
162 {
163 int i;
164
165 for (i = 0; i < 17; i++)
166 if (freelist[i].first <= b && freelist[i].last >= b)
167 return freelist[i].last;
168 return 0;
169 }
170 /* return last vacant block of this stride (never 0). */
171 /* the '>=' is not quite correct, but simplifies the code */
172 /*
173 * end of free blocks section
174 */
175
176 static const char *const sgi_sys_types[] = {
177 /* SGI_VOLHDR */ "\x00" "SGI volhdr" ,
178 /* 0x01 */ "\x01" "SGI trkrepl" ,
179 /* 0x02 */ "\x02" "SGI secrepl" ,
180 /* SGI_SWAP */ "\x03" "SGI raw" ,
181 /* 0x04 */ "\x04" "SGI bsd" ,
182 /* 0x05 */ "\x05" "SGI sysv" ,
183 /* SGI_ENTIRE_DISK */ "\x06" "SGI volume" ,
184 /* SGI_EFS */ "\x07" "SGI efs" ,
185 /* 0x08 */ "\x08" "SGI lvol" ,
186 /* 0x09 */ "\x09" "SGI rlvol" ,
187 /* SGI_XFS */ "\x0a" "SGI xfs" ,
188 /* SGI_XFSLOG */ "\x0b" "SGI xfslog" ,
189 /* SGI_XLV */ "\x0c" "SGI xlv" ,
190 /* SGI_XVM */ "\x0d" "SGI xvm" ,
191 /* LINUX_SWAP */ "\x82" "Linux swap" ,
192 /* LINUX_NATIVE */ "\x83" "Linux native",
193 /* LINUX_LVM */ "\x8d" "Linux LVM" ,
194 /* LINUX_RAID */ "\xfd" "Linux RAID" ,
195 NULL
196 };
197
198
199 static int
200 sgi_get_nsect(void)
201 {
202 return SGI_SSWAP16(sgilabel->devparam.nsect);
203 }
204
205 static int
206 sgi_get_ntrks(void)
207 {
208 return SGI_SSWAP16(sgilabel->devparam.ntrks);
209 }
210
211 static unsigned int
212 two_s_complement_32bit_sum(unsigned int* base, int size /* in bytes */)
213 {
214 int i = 0;
215 unsigned int sum = 0;
216
217 size /= sizeof(unsigned int);
218 for (i = 0; i < size; i++)
219 sum -= SGI_SSWAP32(base[i]);
220 return sum;
221 }
222
223 void BUG_bad_sgi_partition_size(void);
224
225 static int
226 check_sgi_label(void)
227 {
228 if (sizeof(sgi_partition) > 512) {
229 /* According to MIPS Computer Systems, Inc the label
230 * must not contain more than 512 bytes */
231 BUG_bad_sgi_partition_size();
232 }
233
234 if (sgilabel->magic != SGI_LABEL_MAGIC
235 && sgilabel->magic != SGI_LABEL_MAGIC_SWAPPED
236 ) {
237 current_label_type = label_dos;
238 return 0;
239 }
240
241 sgi_other_endian = (sgilabel->magic == SGI_LABEL_MAGIC_SWAPPED);
242 /*
243 * test for correct checksum
244 */
245 if (two_s_complement_32bit_sum((unsigned int*)sgilabel,
246 sizeof(*sgilabel))) {
247 printf("Detected sgi disklabel with wrong checksum\n");
248 }
249 update_units();
250 current_label_type = label_sgi;
251 partitions = 16;
252 sgi_volumes = 15;
253 return 1;
254 }
255
256 static unsigned int
257 sgi_get_start_sector(int i)
258 {
259 return SGI_SSWAP32(sgilabel->partitions[i].start_sector);
260 }
261
262 static unsigned int
263 sgi_get_num_sectors(int i)
264 {
265 return SGI_SSWAP32(sgilabel->partitions[i].num_sectors);
266 }
267
268 static int
269 sgi_get_sysid(int i)
270 {
271 return SGI_SSWAP32(sgilabel->partitions[i].id);
272 }
273
274 static int
275 sgi_get_bootpartition(void)
276 {
277 return SGI_SSWAP16(sgilabel->boot_part);
278 }
279
280 static int
281 sgi_get_swappartition(void)
282 {
283 return SGI_SSWAP16(sgilabel->swap_part);
284 }
285
286 static void
287 sgi_list_table(int xtra)
288 {
289 int i, w, wd;
290 int kpi = 0; /* kernel partition ID */
291
292 if (xtra) {
293 printf("\nDisk %s (SGI disk label): %d heads, %d sectors\n"
294 "%d cylinders, %d physical cylinders\n"
295 "%d extra sects/cyl, interleave %d:1\n"
296 "%s\n"
297 "Units = %s of %d * 512 bytes\n\n",
298 disk_device, heads, sectors, cylinders,
299 SGI_SSWAP16(sgiparam.pcylcount),
300 SGI_SSWAP16(sgiparam.sparecyl),
301 SGI_SSWAP16(sgiparam.ilfact),
302 (char *)sgilabel,
303 str_units(PLURAL), units_per_sector);
304 } else {
305 printf("\nDisk %s (SGI disk label): "
306 "%d heads, %d sectors, %d cylinders\n"
307 "Units = %s of %d * 512 bytes\n\n",
308 disk_device, heads, sectors, cylinders,
309 str_units(PLURAL), units_per_sector );
310 }
311
312 w = strlen(disk_device);
313 wd = sizeof("Device") - 1;
314 if (w < wd)
315 w = wd;
316
317 printf("----- partitions -----\n"
318 "Pt# %*s Info Start End Sectors Id System\n",
319 w + 2, "Device");
320 for (i = 0; i < partitions; i++) {
321 if (sgi_get_num_sectors(i) || debug ) {
322 uint32_t start = sgi_get_start_sector(i);
323 uint32_t len = sgi_get_num_sectors(i);
324 kpi++; /* only count nonempty partitions */
325 printf(
326 "%2d: %s %4s %9ld %9ld %9ld %2x %s\n",
327 /* fdisk part number */ i+1,
328 /* device */ partname(disk_device, kpi, w+3),
329 /* flags */ (sgi_get_swappartition() == i) ? "swap" :
330 /* flags */ (sgi_get_bootpartition() == i) ? "boot" : " ",
331 /* start */ (long) scround(start),
332 /* end */ (long) scround(start+len)-1,
333 /* no odd flag on end */(long) len,
334 /* type id */ sgi_get_sysid(i),
335 /* type name */ partition_type(sgi_get_sysid(i)));
336 }
337 }
338 printf("----- Bootinfo -----\nBootfile: %s\n"
339 "----- Directory Entries -----\n",
340 sgilabel->boot_file);
341 for (i = 0; i < sgi_volumes; i++) {
342 if (sgilabel->directory[i].vol_file_size) {
343 uint32_t start = SGI_SSWAP32(sgilabel->directory[i].vol_file_start);
344 uint32_t len = SGI_SSWAP32(sgilabel->directory[i].vol_file_size);
345 unsigned char *name = sgilabel->directory[i].vol_file_name;
346
347 printf("%2d: %-10s sector%5u size%8u\n",
348 i, (char*)name, (unsigned int) start, (unsigned int) len);
349 }
350 }
351 }
352
353 static void
354 sgi_set_bootpartition(int i)
355 {
356 sgilabel->boot_part = SGI_SSWAP16(((short)i));
357 }
358
359 static unsigned int
360 sgi_get_lastblock(void)
361 {
362 return heads * sectors * cylinders;
363 }
364
365 static void
366 sgi_set_swappartition(int i)
367 {
368 sgilabel->swap_part = SGI_SSWAP16(((short)i));
369 }
370
371 static int
372 sgi_check_bootfile(const char* aFile)
373 {
374 if (strlen(aFile) < 3) /* "/a\n" is minimum */ {
375 printf("\nInvalid Bootfile!\n"
376 "\tThe bootfile must be an absolute non-zero pathname,\n"
377 "\te.g. \"/unix\" or \"/unix.save\".\n");
378 return 0;
379 }
380 if (strlen(aFile) > 16) {
381 printf("\nName of Bootfile too long (>16 bytes)\n");
382 return 0;
383 }
384 if (aFile[0] != '/') {
385 printf("\nBootfile must have a fully qualified pathname\n");
386 return 0;
387 }
388 if (strncmp(aFile, (char*)sgilabel->boot_file, 16)) {
389 printf("\nBe aware, that the bootfile is not checked for existence.\n"
390 "\tSGI's default is \"/unix\" and for backup \"/unix.save\".\n");
391 /* filename is correct and did change */
392 return 1;
393 }
394 return 0; /* filename did not change */
395 }
396
397 static const char *
398 sgi_get_bootfile(void)
399 {
400 return (char*)sgilabel->boot_file;
401 }
402
403 static void
404 sgi_set_bootfile(const char* aFile)
405 {
406 int i = 0;
407
408 if (sgi_check_bootfile(aFile)) {
409 while (i < 16) {
410 if ((aFile[i] != '\n') /* in principle caught again by next line */
411 && (strlen(aFile) > i))
412 sgilabel->boot_file[i] = aFile[i];
413 else
414 sgilabel->boot_file[i] = 0;
415 i++;
416 }
417 printf("\n\tBootfile is changed to \"%s\"\n", sgilabel->boot_file);
418 }
419 }
420
421 static void
422 create_sgiinfo(void)
423 {
424 /* I keep SGI's habit to write the sgilabel to the second block */
425 sgilabel->directory[0].vol_file_start = SGI_SSWAP32(2);
426 sgilabel->directory[0].vol_file_size = SGI_SSWAP32(sizeof(sgiinfo));
427 strncpy((char*)sgilabel->directory[0].vol_file_name, "sgilabel", 8);
428 }
429
430 static sgiinfo *fill_sgiinfo(void);
431
432 static void
433 sgi_write_table(void)
434 {
435 sgilabel->csum = 0;
436 sgilabel->csum = SGI_SSWAP32(two_s_complement_32bit_sum(
437 (unsigned int*)sgilabel, sizeof(*sgilabel)));
438 assert(two_s_complement_32bit_sum(
439 (unsigned int*)sgilabel, sizeof(*sgilabel)) == 0);
440
441 if (lseek(fd, 0, SEEK_SET) < 0)
442 fdisk_fatal(unable_to_seek);
443 if (write(fd, sgilabel, SECTOR_SIZE) != SECTOR_SIZE)
444 fdisk_fatal(unable_to_write);
445 if (!strncmp((char*)sgilabel->directory[0].vol_file_name, "sgilabel", 8)) {
446 /*
447 * keep this habit of first writing the "sgilabel".
448 * I never tested whether it works without (AN 981002).
449 */
450 sgiinfo *info = fill_sgiinfo();
451 int infostartblock = SGI_SSWAP32(sgilabel->directory[0].vol_file_start);
452 if (lseek(fd, infostartblock*SECTOR_SIZE, SEEK_SET) < 0)
453 fdisk_fatal(unable_to_seek);
454 if (write(fd, info, SECTOR_SIZE) != SECTOR_SIZE)
455 fdisk_fatal(unable_to_write);
456 free(info);
457 }
458 }
459
460 static int
461 compare_start(int *x, int *y)
462 {
463 /*
464 * sort according to start sectors
465 * and prefers largest partition:
466 * entry zero is entire disk entry
467 */
468 unsigned int i = *x;
469 unsigned int j = *y;
470 unsigned int a = sgi_get_start_sector(i);
471 unsigned int b = sgi_get_start_sector(j);
472 unsigned int c = sgi_get_num_sectors(i);
473 unsigned int d = sgi_get_num_sectors(j);
474
475 if (a == b)
476 return (d > c) ? 1 : (d == c) ? 0 : -1;
477 return (a > b) ? 1 : -1;
478 }
479
480
481 static int
482 verify_sgi(int verbose)
483 {
484 int Index[16]; /* list of valid partitions */
485 int sortcount = 0; /* number of used partitions, i.e. non-zero lengths */
486 int entire = 0, i = 0;
487 unsigned int start = 0;
488 long long gap = 0; /* count unused blocks */
489 unsigned int lastblock = sgi_get_lastblock();
490
491 clearfreelist();
492 for (i = 0; i < 16; i++) {
493 if (sgi_get_num_sectors(i) != 0) {
494 Index[sortcount++] = i;
495 if (sgi_get_sysid(i) == SGI_ENTIRE_DISK) {
496 if (entire++ == 1) {
497 if (verbose)
498 printf("More than one entire disk entry present\n");
499 }
500 }
501 }
502 }
503 if (sortcount == 0) {
504 if (verbose)
505 printf("No partitions defined\n");
506 return (lastblock > 0) ? 1 : (lastblock == 0) ? 0 : -1;
507 }
508 qsort(Index, sortcount, sizeof(Index[0]), (void*)compare_start);
509 if (sgi_get_sysid(Index[0]) == SGI_ENTIRE_DISK) {
510 if ((Index[0] != 10) && verbose)
511 printf("IRIX likes when Partition 11 covers the entire disk\n");
512 if ((sgi_get_start_sector(Index[0]) != 0) && verbose)
513 printf("The entire disk partition should start "
514 "at block 0,\n"
515 "not at diskblock %d\n",
516 sgi_get_start_sector(Index[0]));
517 if (debug) /* I do not understand how some disks fulfil it */
518 if ((sgi_get_num_sectors(Index[0]) != lastblock) && verbose)
519 printf("The entire disk partition is only %d diskblock large,\n"
520 "but the disk is %d diskblocks long\n",
521 sgi_get_num_sectors(Index[0]), lastblock);
522 lastblock = sgi_get_num_sectors(Index[0]);
523 } else {
524 if (verbose)
525 printf("One Partition (#11) should cover the entire disk\n");
526 if (debug > 2)
527 printf("sysid=%d\tpartition=%d\n",
528 sgi_get_sysid(Index[0]), Index[0]+1);
529 }
530 for (i = 1, start = 0; i < sortcount; i++) {
531 int cylsize = sgi_get_nsect() * sgi_get_ntrks();
532
533 if ((sgi_get_start_sector(Index[i]) % cylsize) != 0) {
534 if (debug) /* I do not understand how some disks fulfil it */
535 if (verbose)
536 printf("Partition %d does not start on cylinder boundary\n",
537 Index[i]+1);
538 }
539 if (sgi_get_num_sectors(Index[i]) % cylsize != 0) {
540 if (debug) /* I do not understand how some disks fulfil it */
541 if (verbose)
542 printf("Partition %d does not end on cylinder boundary\n",
543 Index[i]+1);
544 }
545 /* We cannot handle several "entire disk" entries. */
546 if (sgi_get_sysid(Index[i]) == SGI_ENTIRE_DISK) continue;
547 if (start > sgi_get_start_sector(Index[i])) {
548 if (verbose)
549 printf("Partitions %d and %d overlap by %d sectors\n",
550 Index[i-1]+1, Index[i]+1,
551 start - sgi_get_start_sector(Index[i]));
552 if (gap > 0) gap = -gap;
553 if (gap == 0) gap = -1;
554 }
555 if (start < sgi_get_start_sector(Index[i])) {
556 if (verbose)
557 printf("Unused gap of %8u sectors - sectors %8u-%8u\n",
558 sgi_get_start_sector(Index[i]) - start,
559 start, sgi_get_start_sector(Index[i])-1);
560 gap += sgi_get_start_sector(Index[i]) - start;
561 add2freelist(start, sgi_get_start_sector(Index[i]));
562 }
563 start = sgi_get_start_sector(Index[i])
564 + sgi_get_num_sectors(Index[i]);
565 if (debug > 1) {
566 if (verbose)
567 printf("%2d:%12d\t%12d\t%12d\n", Index[i],
568 sgi_get_start_sector(Index[i]),
569 sgi_get_num_sectors(Index[i]),
570 sgi_get_sysid(Index[i]));
571 }
572 }
573 if (start < lastblock) {
574 if (verbose)
575 printf("Unused gap of %8u sectors - sectors %8u-%8u\n",
576 lastblock - start, start, lastblock-1);
577 gap += lastblock - start;
578 add2freelist(start, lastblock);
579 }
580 /*
581 * Done with arithmetics
582 * Go for details now
583 */
584 if (verbose) {
585 if (!sgi_get_num_sectors(sgi_get_bootpartition())) {
586 printf("\nThe boot partition does not exist\n");
587 }
588 if (!sgi_get_num_sectors(sgi_get_swappartition())) {
589 printf("\nThe swap partition does not exist\n");
590 } else {
591 if ((sgi_get_sysid(sgi_get_swappartition()) != SGI_SWAP)
592 && (sgi_get_sysid(sgi_get_swappartition()) != LINUX_SWAP))
593 printf("\nThe swap partition has no swap type\n");
594 }
595 if (sgi_check_bootfile("/unix"))
596 printf("\tYou have chosen an unusual boot file name\n");
597 }
598 return (gap > 0) ? 1 : (gap == 0) ? 0 : -1;
599 }
600
601 static int
602 sgi_gaps(void)
603 {
604 /*
605 * returned value is:
606 * = 0 : disk is properly filled to the rim
607 * < 0 : there is an overlap
608 * > 0 : there is still some vacant space
609 */
610 return verify_sgi(0);
611 }
612
613 static void
614 sgi_change_sysid(int i, int sys)
615 {
616 if (sgi_get_num_sectors(i) == 0) { /* caught already before, ... */
617 printf("Sorry you may change the Tag of non-empty partitions\n");
618 return;
619 }
620 if ((sys != SGI_ENTIRE_DISK) && (sys != SGI_VOLHDR)
621 && (sgi_get_start_sector(i) < 1)
622 ) {
623 read_maybe_empty(
624 "It is highly recommended that the partition at offset 0\n"
625 "is of type \"SGI volhdr\", the IRIX system will rely on it to\n"
626 "retrieve from its directory standalone tools like sash and fx.\n"
627 "Only the \"SGI volume\" entire disk section may violate this.\n"
628 "Type YES if you are sure about tagging this partition differently.\n");
629 if (strcmp(line_ptr, "YES\n") != 0)
630 return;
631 }
632 sgilabel->partitions[i].id = SGI_SSWAP32(sys);
633 }
634
635 /* returns partition index of first entry marked as entire disk */
636 static int
637 sgi_entire(void)
638 {
639 int i;
640
641 for (i = 0; i < 16; i++)
642 if (sgi_get_sysid(i) == SGI_VOLUME)
643 return i;
644 return -1;
645 }
646
647 static void
648 sgi_set_partition(int i, unsigned int start, unsigned int length, int sys)
649 {
650 sgilabel->partitions[i].id = SGI_SSWAP32(sys);
651 sgilabel->partitions[i].num_sectors = SGI_SSWAP32(length);
652 sgilabel->partitions[i].start_sector = SGI_SSWAP32(start);
653 set_changed(i);
654 if (sgi_gaps() < 0) /* rebuild freelist */
655 printf("Partition overlap detected\n");
656 }
657
658 static void
659 sgi_set_entire(void)
660 {
661 int n;
662
663 for (n = 10; n < partitions; n++) {
664 if (!sgi_get_num_sectors(n) ) {
665 sgi_set_partition(n, 0, sgi_get_lastblock(), SGI_VOLUME);
666 break;
667 }
668 }
669 }
670
671 static void
672 sgi_set_volhdr(void)
673 {
674 int n;
675
676 for (n = 8; n < partitions; n++) {
677 if (!sgi_get_num_sectors(n)) {
678 /*
679 * 5 cylinders is an arbitrary value I like
680 * IRIX 5.3 stored files in the volume header
681 * (like sash, symmon, fx, ide) with ca. 3200
682 * sectors.
683 */
684 if (heads * sectors * 5 < sgi_get_lastblock())
685 sgi_set_partition(n, 0, heads * sectors * 5, SGI_VOLHDR);
686 break;
687 }
688 }
689 }
690
691 static void
692 sgi_delete_partition(int i)
693 {
694 sgi_set_partition(i, 0, 0, 0);
695 }
696
697 static void
698 sgi_add_partition(int n, int sys)
699 {
700 char mesg[256];
701 unsigned int first = 0, last = 0;
702
703 if (n == 10) {
704 sys = SGI_VOLUME;
705 } else if (n == 8) {
706 sys = 0;
707 }
708 if (sgi_get_num_sectors(n)) {
709 printf(msg_part_already_defined, n + 1);
710 return;
711 }
712 if ((sgi_entire() == -1) && (sys != SGI_VOLUME)) {
713 printf("Attempting to generate entire disk entry automatically\n");
714 sgi_set_entire();
715 sgi_set_volhdr();
716 }
717 if ((sgi_gaps() == 0) && (sys != SGI_VOLUME)) {
718 printf("The entire disk is already covered with partitions\n");
719 return;
720 }
721 if (sgi_gaps() < 0) {
722 printf("You got a partition overlap on the disk. Fix it first!\n");
723 return;
724 }
725 snprintf(mesg, sizeof(mesg), "First %s", str_units(SINGULAR));
726 while (1) {
727 if (sys == SGI_VOLUME) {
728 last = sgi_get_lastblock();
729 first = read_int(0, 0, last-1, 0, mesg);
730 if (first != 0) {
731 printf("It is highly recommended that eleventh partition\n"
732 "covers the entire disk and is of type 'SGI volume'\n");
733 }
734 } else {
735 first = freelist[0].first;
736 last = freelist[0].last;
737 first = read_int(scround(first), scround(first), scround(last)-1,
738 0, mesg);
739 }
740 if (display_in_cyl_units)
741 first *= units_per_sector;
742 else
743 first = first; /* align to cylinder if you know how ... */
744 if (!last )
745 last = isinfreelist(first);
746 if (last != 0)
747 break;
748 printf("You will get a partition overlap on the disk. "
749 "Fix it first!\n");
750 }
751 snprintf(mesg, sizeof(mesg), " Last %s", str_units(SINGULAR));
752 last = read_int(scround(first), scround(last)-1, scround(last)-1,
753 scround(first), mesg)+1;
754 if (display_in_cyl_units)
755 last *= units_per_sector;
756 else
757 last = last; /* align to cylinder if You know how ... */
758 if ( (sys == SGI_VOLUME) && (first != 0 || last != sgi_get_lastblock() ) )
759 printf("It is highly recommended that eleventh partition\n"
760 "covers the entire disk and is of type 'SGI volume'\n");
761 sgi_set_partition(n, first, last-first, sys);
762 }
763
764 #if ENABLE_FEATURE_FDISK_ADVANCED
765 static void
766 create_sgilabel(void)
767 {
768 struct hd_geometry geometry;
769 struct {
770 unsigned int start;
771 unsigned int nsect;
772 int sysid;
773 } old[4];
774 int i = 0;
775 long longsectors; /* the number of sectors on the device */
776 int res; /* the result from the ioctl */
777 int sec_fac; /* the sector factor */
778
779 sec_fac = sector_size / 512; /* determine the sector factor */
780
781 printf(msg_building_new_label, "SGI disklabel");
782
783 sgi_other_endian = (BYTE_ORDER == LITTLE_ENDIAN);
784 res = ioctl(fd, BLKGETSIZE, &longsectors);
785 if (!ioctl(fd, HDIO_GETGEO, &geometry)) {
786 heads = geometry.heads;
787 sectors = geometry.sectors;
788 if (res == 0) {
789 /* the get device size ioctl was successful */
790 cylinders = longsectors / (heads * sectors);
791 cylinders /= sec_fac;
792 } else {
793 /* otherwise print error and use truncated version */
794 cylinders = geometry.cylinders;
795 printf(
796 "Warning: BLKGETSIZE ioctl failed on %s. Using geometry cylinder value of %d.\n"
797 "This value may be truncated for devices > 33.8 GB.\n", disk_device, cylinders);
798 }
799 }
800 for (i = 0; i < 4; i++) {
801 old[i].sysid = 0;
802 if (valid_part_table_flag(MBRbuffer)) {
803 if (get_part_table(i)->sys_ind) {
804 old[i].sysid = get_part_table(i)->sys_ind;
805 old[i].start = get_start_sect(get_part_table(i));
806 old[i].nsect = get_nr_sects(get_part_table(i));
807 printf("Trying to keep parameters of partition %d\n", i);
808 if (debug)
809 printf("ID=%02x\tSTART=%d\tLENGTH=%d\n",
810 old[i].sysid, old[i].start, old[i].nsect);
811 }
812 }
813 }
814
815 memset(MBRbuffer, 0, sizeof(MBRbuffer));
816 /* fields with '//' are already zeroed out by memset above */
817
818 sgilabel->magic = SGI_SSWAP32(SGI_LABEL_MAGIC);
819 //sgilabel->boot_part = SGI_SSWAP16(0);
820 sgilabel->swap_part = SGI_SSWAP16(1);
821
822 //memset(sgilabel->boot_file, 0, 16);
823 strcpy((char*)sgilabel->boot_file, "/unix"); /* sizeof(sgilabel->boot_file) == 16 > 6 */
824
825 //sgilabel->devparam.skew = (0);
826 //sgilabel->devparam.gap1 = (0);
827 //sgilabel->devparam.gap2 = (0);
828 //sgilabel->devparam.sparecyl = (0);
829 sgilabel->devparam.pcylcount = SGI_SSWAP16(geometry.cylinders);
830 //sgilabel->devparam.head_vol0 = SGI_SSWAP16(0);
831 /* tracks/cylinder (heads) */
832 sgilabel->devparam.ntrks = SGI_SSWAP16(geometry.heads);
833 //sgilabel->devparam.cmd_tag_queue_depth = (0);
834 //sgilabel->devparam.unused0 = (0);
835 //sgilabel->devparam.unused1 = SGI_SSWAP16(0);
836 /* sectors/track */
837 sgilabel->devparam.nsect = SGI_SSWAP16(geometry.sectors);
838 sgilabel->devparam.bytes = SGI_SSWAP16(512);
839 sgilabel->devparam.ilfact = SGI_SSWAP16(1);
840 sgilabel->devparam.flags = SGI_SSWAP32(TRACK_FWD|
841 IGNORE_ERRORS|RESEEK);
842 //sgilabel->devparam.datarate = SGI_SSWAP32(0);
843 sgilabel->devparam.retries_on_error = SGI_SSWAP32(1);
844 //sgilabel->devparam.ms_per_word = SGI_SSWAP32(0);
845 //sgilabel->devparam.xylogics_gap1 = SGI_SSWAP16(0);
846 //sgilabel->devparam.xylogics_syncdelay = SGI_SSWAP16(0);
847 //sgilabel->devparam.xylogics_readdelay = SGI_SSWAP16(0);
848 //sgilabel->devparam.xylogics_gap2 = SGI_SSWAP16(0);
849 //sgilabel->devparam.xylogics_readgate = SGI_SSWAP16(0);
850 //sgilabel->devparam.xylogics_writecont = SGI_SSWAP16(0);
851 //memset( &(sgilabel->directory), 0, sizeof(struct volume_directory)*15 );
852 //memset( &(sgilabel->partitions), 0, sizeof(struct sgi_partinfo)*16 );
853 current_label_type = label_sgi;
854 partitions = 16;
855 sgi_volumes = 15;
856 sgi_set_entire();
857 sgi_set_volhdr();
858 for (i = 0; i < 4; i++) {
859 if (old[i].sysid) {
860 sgi_set_partition(i, old[i].start, old[i].nsect, old[i].sysid);
861 }
862 }
863 }
864
865 static void
866 sgi_set_xcyl(void)
867 {
868 /* do nothing in the beginning */
869 }
870 #endif /* FEATURE_FDISK_ADVANCED */
871
872 /* _____________________________________________________________
873 */
874
875 static sgiinfo *
876 fill_sgiinfo(void)
877 {
878 sgiinfo *info = xzalloc(sizeof(sgiinfo));
879
880 info->magic = SGI_SSWAP32(SGI_INFO_MAGIC);
881 info->b1 = SGI_SSWAP32(-1);
882 info->b2 = SGI_SSWAP16(-1);
883 info->b3 = SGI_SSWAP16(1);
884 /* You may want to replace this string !!!!!!! */
885 strcpy( (char*)info->scsi_string, "IBM OEM 0662S12 3 30" );
886 strcpy( (char*)info->serial, "0000" );
887 info->check1816 = SGI_SSWAP16(18*256 +16 );
888 strcpy( (char*)info->installer, "Sfx version 5.3, Oct 18, 1994" );
889 return info;
890 }
891 #endif /* SGI_LABEL */
Busybox: The Swiss Army Knife of Embedded Linux