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