1 | #if ENABLE_FEATURE_OSF_LABEL
|
---|
2 | /*
|
---|
3 | * Copyright (c) 1987, 1988 Regents of the University of California.
|
---|
4 | * All rights reserved.
|
---|
5 | *
|
---|
6 | * Redistribution and use in source and binary forms, with or without
|
---|
7 | * modification, are permitted provided that the following conditions
|
---|
8 | * are met:
|
---|
9 | * 1. Redistributions of source code must retain the above copyright
|
---|
10 | * notice, this list of conditions and the following disclaimer.
|
---|
11 | * 2. Redistributions in binary form must reproduce the above copyright
|
---|
12 | * notice, this list of conditions and the following disclaimer in the
|
---|
13 | * documentation and/or other materials provided with the distribution.
|
---|
14 | * 3. All advertising materials mentioning features or use of this software
|
---|
15 | * must display the following acknowledgment:
|
---|
16 | * This product includes software developed by the University of
|
---|
17 | * California, Berkeley and its contributors.
|
---|
18 | * 4. Neither the name of the University nor the names of its contributors
|
---|
19 | * may be used to endorse or promote products derived from this software
|
---|
20 | * without specific prior written permission.
|
---|
21 | *
|
---|
22 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
---|
23 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
---|
24 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
---|
25 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
---|
26 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
---|
27 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
---|
28 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
---|
29 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
---|
30 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
---|
31 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
---|
32 | * SUCH DAMAGE.
|
---|
33 | */
|
---|
34 |
|
---|
35 |
|
---|
36 | #ifndef BSD_DISKMAGIC
|
---|
37 | #define BSD_DISKMAGIC ((uint32_t) 0x82564557)
|
---|
38 | #endif
|
---|
39 |
|
---|
40 | #ifndef BSD_MAXPARTITIONS
|
---|
41 | #define BSD_MAXPARTITIONS 16
|
---|
42 | #endif
|
---|
43 |
|
---|
44 | #define BSD_LINUX_BOOTDIR "/usr/ucb/mdec"
|
---|
45 |
|
---|
46 | #if defined(i386) || defined(__sparc__) || defined(__arm__) \
|
---|
47 | || defined(__m68k__) || defined(__mips__) || defined(__s390__) \
|
---|
48 | || defined(__sh__) || defined(__x86_64__)
|
---|
49 | #define BSD_LABELSECTOR 1
|
---|
50 | #define BSD_LABELOFFSET 0
|
---|
51 | #elif defined(__alpha__) || defined(__powerpc__) || defined(__ia64__) \
|
---|
52 | || defined(__hppa__)
|
---|
53 | #define BSD_LABELSECTOR 0
|
---|
54 | #define BSD_LABELOFFSET 64
|
---|
55 | #elif defined(__s390__) || defined(__s390x__)
|
---|
56 | #define BSD_LABELSECTOR 1
|
---|
57 | #define BSD_LABELOFFSET 0
|
---|
58 | #else
|
---|
59 | #error unknown architecture
|
---|
60 | #endif
|
---|
61 |
|
---|
62 | #define BSD_BBSIZE 8192 /* size of boot area, with label */
|
---|
63 | #define BSD_SBSIZE 8192 /* max size of fs superblock */
|
---|
64 |
|
---|
65 | struct xbsd_disklabel {
|
---|
66 | uint32_t d_magic; /* the magic number */
|
---|
67 | int16_t d_type; /* drive type */
|
---|
68 | int16_t d_subtype; /* controller/d_type specific */
|
---|
69 | char d_typename[16]; /* type name, e.g. "eagle" */
|
---|
70 | char d_packname[16]; /* pack identifier */
|
---|
71 | /* disk geometry: */
|
---|
72 | uint32_t d_secsize; /* # of bytes per sector */
|
---|
73 | uint32_t d_nsectors; /* # of data sectors per track */
|
---|
74 | uint32_t d_ntracks; /* # of tracks per cylinder */
|
---|
75 | uint32_t d_ncylinders; /* # of data cylinders per unit */
|
---|
76 | uint32_t d_secpercyl; /* # of data sectors per cylinder */
|
---|
77 | uint32_t d_secperunit; /* # of data sectors per unit */
|
---|
78 | /*
|
---|
79 | * Spares (bad sector replacements) below
|
---|
80 | * are not counted in d_nsectors or d_secpercyl.
|
---|
81 | * Spare sectors are assumed to be physical sectors
|
---|
82 | * which occupy space at the end of each track and/or cylinder.
|
---|
83 | */
|
---|
84 | uint16_t d_sparespertrack; /* # of spare sectors per track */
|
---|
85 | uint16_t d_sparespercyl; /* # of spare sectors per cylinder */
|
---|
86 | /*
|
---|
87 | * Alternate cylinders include maintenance, replacement,
|
---|
88 | * configuration description areas, etc.
|
---|
89 | */
|
---|
90 | uint32_t d_acylinders; /* # of alt. cylinders per unit */
|
---|
91 |
|
---|
92 | /* hardware characteristics: */
|
---|
93 | /*
|
---|
94 | * d_interleave, d_trackskew and d_cylskew describe perturbations
|
---|
95 | * in the media format used to compensate for a slow controller.
|
---|
96 | * Interleave is physical sector interleave, set up by the formatter
|
---|
97 | * or controller when formatting. When interleaving is in use,
|
---|
98 | * logically adjacent sectors are not physically contiguous,
|
---|
99 | * but instead are separated by some number of sectors.
|
---|
100 | * It is specified as the ratio of physical sectors traversed
|
---|
101 | * per logical sector. Thus an interleave of 1:1 implies contiguous
|
---|
102 | * layout, while 2:1 implies that logical sector 0 is separated
|
---|
103 | * by one sector from logical sector 1.
|
---|
104 | * d_trackskew is the offset of sector 0 on track N
|
---|
105 | * relative to sector 0 on track N-1 on the same cylinder.
|
---|
106 | * Finally, d_cylskew is the offset of sector 0 on cylinder N
|
---|
107 | * relative to sector 0 on cylinder N-1.
|
---|
108 | */
|
---|
109 | uint16_t d_rpm; /* rotational speed */
|
---|
110 | uint16_t d_interleave; /* hardware sector interleave */
|
---|
111 | uint16_t d_trackskew; /* sector 0 skew, per track */
|
---|
112 | uint16_t d_cylskew; /* sector 0 skew, per cylinder */
|
---|
113 | uint32_t d_headswitch; /* head switch time, usec */
|
---|
114 | uint32_t d_trkseek; /* track-to-track seek, usec */
|
---|
115 | uint32_t d_flags; /* generic flags */
|
---|
116 | #define NDDATA 5
|
---|
117 | uint32_t d_drivedata[NDDATA]; /* drive-type specific information */
|
---|
118 | #define NSPARE 5
|
---|
119 | uint32_t d_spare[NSPARE]; /* reserved for future use */
|
---|
120 | uint32_t d_magic2; /* the magic number (again) */
|
---|
121 | uint16_t d_checksum; /* xor of data incl. partitions */
|
---|
122 | /* filesystem and partition information: */
|
---|
123 | uint16_t d_npartitions; /* number of partitions in following */
|
---|
124 | uint32_t d_bbsize; /* size of boot area at sn0, bytes */
|
---|
125 | uint32_t d_sbsize; /* max size of fs superblock, bytes */
|
---|
126 | struct xbsd_partition { /* the partition table */
|
---|
127 | uint32_t p_size; /* number of sectors in partition */
|
---|
128 | uint32_t p_offset; /* starting sector */
|
---|
129 | uint32_t p_fsize; /* filesystem basic fragment size */
|
---|
130 | uint8_t p_fstype; /* filesystem type, see below */
|
---|
131 | uint8_t p_frag; /* filesystem fragments per block */
|
---|
132 | uint16_t p_cpg; /* filesystem cylinders per group */
|
---|
133 | } d_partitions[BSD_MAXPARTITIONS]; /* actually may be more */
|
---|
134 | };
|
---|
135 |
|
---|
136 | /* d_type values: */
|
---|
137 | #define BSD_DTYPE_SMD 1 /* SMD, XSMD; VAX hp/up */
|
---|
138 | #define BSD_DTYPE_MSCP 2 /* MSCP */
|
---|
139 | #define BSD_DTYPE_DEC 3 /* other DEC (rk, rl) */
|
---|
140 | #define BSD_DTYPE_SCSI 4 /* SCSI */
|
---|
141 | #define BSD_DTYPE_ESDI 5 /* ESDI interface */
|
---|
142 | #define BSD_DTYPE_ST506 6 /* ST506 etc. */
|
---|
143 | #define BSD_DTYPE_HPIB 7 /* CS/80 on HP-IB */
|
---|
144 | #define BSD_DTYPE_HPFL 8 /* HP Fiber-link */
|
---|
145 | #define BSD_DTYPE_FLOPPY 10 /* floppy */
|
---|
146 |
|
---|
147 | /* d_subtype values: */
|
---|
148 | #define BSD_DSTYPE_INDOSPART 0x8 /* is inside dos partition */
|
---|
149 | #define BSD_DSTYPE_DOSPART(s) ((s) & 3) /* dos partition number */
|
---|
150 | #define BSD_DSTYPE_GEOMETRY 0x10 /* drive params in label */
|
---|
151 |
|
---|
152 | static const char *const xbsd_dktypenames[] = {
|
---|
153 | "unknown",
|
---|
154 | "SMD",
|
---|
155 | "MSCP",
|
---|
156 | "old DEC",
|
---|
157 | "SCSI",
|
---|
158 | "ESDI",
|
---|
159 | "ST506",
|
---|
160 | "HP-IB",
|
---|
161 | "HP-FL",
|
---|
162 | "type 9",
|
---|
163 | "floppy",
|
---|
164 | 0
|
---|
165 | };
|
---|
166 |
|
---|
167 |
|
---|
168 | /*
|
---|
169 | * Filesystem type and version.
|
---|
170 | * Used to interpret other filesystem-specific
|
---|
171 | * per-partition information.
|
---|
172 | */
|
---|
173 | #define BSD_FS_UNUSED 0 /* unused */
|
---|
174 | #define BSD_FS_SWAP 1 /* swap */
|
---|
175 | #define BSD_FS_V6 2 /* Sixth Edition */
|
---|
176 | #define BSD_FS_V7 3 /* Seventh Edition */
|
---|
177 | #define BSD_FS_SYSV 4 /* System V */
|
---|
178 | #define BSD_FS_V71K 5 /* V7 with 1K blocks (4.1, 2.9) */
|
---|
179 | #define BSD_FS_V8 6 /* Eighth Edition, 4K blocks */
|
---|
180 | #define BSD_FS_BSDFFS 7 /* 4.2BSD fast file system */
|
---|
181 | #define BSD_FS_BSDLFS 9 /* 4.4BSD log-structured file system */
|
---|
182 | #define BSD_FS_OTHER 10 /* in use, but unknown/unsupported */
|
---|
183 | #define BSD_FS_HPFS 11 /* OS/2 high-performance file system */
|
---|
184 | #define BSD_FS_ISO9660 12 /* ISO-9660 filesystem (cdrom) */
|
---|
185 | #define BSD_FS_ISOFS BSD_FS_ISO9660
|
---|
186 | #define BSD_FS_BOOT 13 /* partition contains bootstrap */
|
---|
187 | #define BSD_FS_ADOS 14 /* AmigaDOS fast file system */
|
---|
188 | #define BSD_FS_HFS 15 /* Macintosh HFS */
|
---|
189 | #define BSD_FS_ADVFS 16 /* Digital Unix AdvFS */
|
---|
190 |
|
---|
191 | /* this is annoying, but it's also the way it is :-( */
|
---|
192 | #ifdef __alpha__
|
---|
193 | #define BSD_FS_EXT2 8 /* ext2 file system */
|
---|
194 | #else
|
---|
195 | #define BSD_FS_MSDOS 8 /* MS-DOS file system */
|
---|
196 | #endif
|
---|
197 |
|
---|
198 | static const char *const xbsd_fstypes[] = {
|
---|
199 | "\x00" "unused", /* BSD_FS_UNUSED */
|
---|
200 | "\x01" "swap", /* BSD_FS_SWAP */
|
---|
201 | "\x02" "Version 6", /* BSD_FS_V6 */
|
---|
202 | "\x03" "Version 7", /* BSD_FS_V7 */
|
---|
203 | "\x04" "System V", /* BSD_FS_SYSV */
|
---|
204 | "\x05" "4.1BSD", /* BSD_FS_V71K */
|
---|
205 | "\x06" "Eighth Edition", /* BSD_FS_V8 */
|
---|
206 | "\x07" "4.2BSD", /* BSD_FS_BSDFFS */
|
---|
207 | #ifdef __alpha__
|
---|
208 | "\x08" "ext2", /* BSD_FS_EXT2 */
|
---|
209 | #else
|
---|
210 | "\x08" "MS-DOS", /* BSD_FS_MSDOS */
|
---|
211 | #endif
|
---|
212 | "\x09" "4.4LFS", /* BSD_FS_BSDLFS */
|
---|
213 | "\x0a" "unknown", /* BSD_FS_OTHER */
|
---|
214 | "\x0b" "HPFS", /* BSD_FS_HPFS */
|
---|
215 | "\x0c" "ISO-9660", /* BSD_FS_ISO9660 */
|
---|
216 | "\x0d" "boot", /* BSD_FS_BOOT */
|
---|
217 | "\x0e" "ADOS", /* BSD_FS_ADOS */
|
---|
218 | "\x0f" "HFS", /* BSD_FS_HFS */
|
---|
219 | "\x10" "AdvFS", /* BSD_FS_ADVFS */
|
---|
220 | NULL
|
---|
221 | };
|
---|
222 |
|
---|
223 |
|
---|
224 | /*
|
---|
225 | * flags shared by various drives:
|
---|
226 | */
|
---|
227 | #define BSD_D_REMOVABLE 0x01 /* removable media */
|
---|
228 | #define BSD_D_ECC 0x02 /* supports ECC */
|
---|
229 | #define BSD_D_BADSECT 0x04 /* supports bad sector forw. */
|
---|
230 | #define BSD_D_RAMDISK 0x08 /* disk emulator */
|
---|
231 | #define BSD_D_CHAIN 0x10 /* can do back-back transfers */
|
---|
232 | #define BSD_D_DOSPART 0x20 /* within MSDOS partition */
|
---|
233 |
|
---|
234 | /*
|
---|
235 | Changes:
|
---|
236 | 19990319 - Arnaldo Carvalho de Melo <acme@conectiva.com.br> - i18n/nls
|
---|
237 |
|
---|
238 | 20000101 - David Huggins-Daines <dhuggins@linuxcare.com> - Better
|
---|
239 | support for OSF/1 disklabels on Alpha.
|
---|
240 | Also fixed unaligned accesses in alpha_bootblock_checksum()
|
---|
241 | */
|
---|
242 |
|
---|
243 | static int possibly_osf_label;
|
---|
244 |
|
---|
245 | #define FREEBSD_PARTITION 0xa5
|
---|
246 | #define NETBSD_PARTITION 0xa9
|
---|
247 |
|
---|
248 | static void xbsd_delete_part(void);
|
---|
249 | static void xbsd_new_part(void);
|
---|
250 | static void xbsd_write_disklabel(void);
|
---|
251 | static int xbsd_create_disklabel(void);
|
---|
252 | static void xbsd_edit_disklabel(void);
|
---|
253 | static void xbsd_write_bootstrap(void);
|
---|
254 | static void xbsd_change_fstype(void);
|
---|
255 | static int xbsd_get_part_index(int max);
|
---|
256 | static int xbsd_check_new_partition(int *i);
|
---|
257 | static void xbsd_list_types(void);
|
---|
258 | static uint16_t xbsd_dkcksum(struct xbsd_disklabel *lp);
|
---|
259 | static int xbsd_initlabel(struct partition *p);
|
---|
260 | static int xbsd_readlabel(struct partition *p);
|
---|
261 | static int xbsd_writelabel(struct partition *p);
|
---|
262 |
|
---|
263 | #if defined(__alpha__)
|
---|
264 | static void alpha_bootblock_checksum(char *boot);
|
---|
265 | #endif
|
---|
266 |
|
---|
267 | #if !defined(__alpha__)
|
---|
268 | static int xbsd_translate_fstype(int linux_type);
|
---|
269 | static void xbsd_link_part(void);
|
---|
270 | static struct partition *xbsd_part;
|
---|
271 | static int xbsd_part_index;
|
---|
272 | #endif
|
---|
273 |
|
---|
274 |
|
---|
275 | /* Group big globals data and allocate it in one go */
|
---|
276 | struct bsd_globals {
|
---|
277 | /* We access this through a uint64_t * when checksumming */
|
---|
278 | /* hopefully xmalloc gives us required alignment */
|
---|
279 | char disklabelbuffer[BSD_BBSIZE];
|
---|
280 | struct xbsd_disklabel xbsd_dlabel;
|
---|
281 | };
|
---|
282 |
|
---|
283 | static struct bsd_globals *bsd_globals_ptr;
|
---|
284 |
|
---|
285 | #define disklabelbuffer (bsd_globals_ptr->disklabelbuffer)
|
---|
286 | #define xbsd_dlabel (bsd_globals_ptr->xbsd_dlabel)
|
---|
287 |
|
---|
288 |
|
---|
289 | /* Code */
|
---|
290 |
|
---|
291 | #define bsd_cround(n) \
|
---|
292 | (display_in_cyl_units ? ((n)/xbsd_dlabel.d_secpercyl) + 1 : (n))
|
---|
293 |
|
---|
294 | /*
|
---|
295 | * Test whether the whole disk has BSD disk label magic.
|
---|
296 | *
|
---|
297 | * Note: often reformatting with DOS-type label leaves the BSD magic,
|
---|
298 | * so this does not mean that there is a BSD disk label.
|
---|
299 | */
|
---|
300 | static int
|
---|
301 | check_osf_label(void)
|
---|
302 | {
|
---|
303 | if (xbsd_readlabel(NULL) == 0)
|
---|
304 | return 0;
|
---|
305 | return 1;
|
---|
306 | }
|
---|
307 |
|
---|
308 | static int
|
---|
309 | bsd_trydev(const char * dev)
|
---|
310 | {
|
---|
311 | if (xbsd_readlabel(NULL) == 0)
|
---|
312 | return -1;
|
---|
313 | printf("\nBSD label for device: %s\n", dev);
|
---|
314 | xbsd_print_disklabel(0);
|
---|
315 | return 0;
|
---|
316 | }
|
---|
317 |
|
---|
318 | static void
|
---|
319 | bsd_menu(void)
|
---|
320 | {
|
---|
321 | puts("Command Action");
|
---|
322 | puts("d\tdelete a BSD partition");
|
---|
323 | puts("e\tedit drive data");
|
---|
324 | puts("i\tinstall bootstrap");
|
---|
325 | puts("l\tlist known filesystem types");
|
---|
326 | puts("n\tadd a new BSD partition");
|
---|
327 | puts("p\tprint BSD partition table");
|
---|
328 | puts("q\tquit without saving changes");
|
---|
329 | puts("r\treturn to main menu");
|
---|
330 | puts("s\tshow complete disklabel");
|
---|
331 | puts("t\tchange a partition's filesystem id");
|
---|
332 | puts("u\tchange units (cylinders/sectors)");
|
---|
333 | puts("w\twrite disklabel to disk");
|
---|
334 | #if !defined(__alpha__)
|
---|
335 | puts("x\tlink BSD partition to non-BSD partition");
|
---|
336 | #endif
|
---|
337 | }
|
---|
338 |
|
---|
339 | #if !defined(__alpha__)
|
---|
340 | static int
|
---|
341 | hidden(int type)
|
---|
342 | {
|
---|
343 | return type ^ 0x10;
|
---|
344 | }
|
---|
345 |
|
---|
346 | static int
|
---|
347 | is_bsd_partition_type(int type)
|
---|
348 | {
|
---|
349 | return (type == FREEBSD_PARTITION ||
|
---|
350 | type == hidden(FREEBSD_PARTITION) ||
|
---|
351 | type == NETBSD_PARTITION ||
|
---|
352 | type == hidden(NETBSD_PARTITION));
|
---|
353 | }
|
---|
354 | #endif
|
---|
355 |
|
---|
356 | static void
|
---|
357 | bsd_select(void)
|
---|
358 | {
|
---|
359 | #if !defined(__alpha__)
|
---|
360 | int t, ss;
|
---|
361 | struct partition *p;
|
---|
362 |
|
---|
363 | for (t = 0; t < 4; t++) {
|
---|
364 | p = get_part_table(t);
|
---|
365 | if (p && is_bsd_partition_type(p->sys_ind)) {
|
---|
366 | xbsd_part = p;
|
---|
367 | xbsd_part_index = t;
|
---|
368 | ss = get_start_sect(xbsd_part);
|
---|
369 | if (ss == 0) {
|
---|
370 | printf("Partition %s has invalid starting sector 0\n",
|
---|
371 | partname(disk_device, t+1, 0));
|
---|
372 | return;
|
---|
373 | }
|
---|
374 | printf("Reading disklabel of %s at sector %d\n",
|
---|
375 | partname(disk_device, t+1, 0), ss + BSD_LABELSECTOR);
|
---|
376 | if (xbsd_readlabel(xbsd_part) == 0)
|
---|
377 | if (xbsd_create_disklabel() == 0)
|
---|
378 | return;
|
---|
379 | break;
|
---|
380 | }
|
---|
381 | }
|
---|
382 |
|
---|
383 | if (t == 4) {
|
---|
384 | printf("There is no *BSD partition on %s\n", disk_device);
|
---|
385 | return;
|
---|
386 | }
|
---|
387 |
|
---|
388 | #elif defined(__alpha__)
|
---|
389 |
|
---|
390 | if (xbsd_readlabel(NULL) == 0)
|
---|
391 | if (xbsd_create_disklabel() == 0)
|
---|
392 | exit(EXIT_SUCCESS);
|
---|
393 |
|
---|
394 | #endif
|
---|
395 |
|
---|
396 | while (1) {
|
---|
397 | putchar('\n');
|
---|
398 | switch (tolower(read_nonempty("BSD disklabel command (m for help): "))) {
|
---|
399 | case 'd':
|
---|
400 | xbsd_delete_part();
|
---|
401 | break;
|
---|
402 | case 'e':
|
---|
403 | xbsd_edit_disklabel();
|
---|
404 | break;
|
---|
405 | case 'i':
|
---|
406 | xbsd_write_bootstrap();
|
---|
407 | break;
|
---|
408 | case 'l':
|
---|
409 | xbsd_list_types();
|
---|
410 | break;
|
---|
411 | case 'n':
|
---|
412 | xbsd_new_part();
|
---|
413 | break;
|
---|
414 | case 'p':
|
---|
415 | xbsd_print_disklabel(0);
|
---|
416 | break;
|
---|
417 | case 'q':
|
---|
418 | close(fd);
|
---|
419 | exit(EXIT_SUCCESS);
|
---|
420 | case 'r':
|
---|
421 | return;
|
---|
422 | case 's':
|
---|
423 | xbsd_print_disklabel(1);
|
---|
424 | break;
|
---|
425 | case 't':
|
---|
426 | xbsd_change_fstype();
|
---|
427 | break;
|
---|
428 | case 'u':
|
---|
429 | change_units();
|
---|
430 | break;
|
---|
431 | case 'w':
|
---|
432 | xbsd_write_disklabel();
|
---|
433 | break;
|
---|
434 | #if !defined(__alpha__)
|
---|
435 | case 'x':
|
---|
436 | xbsd_link_part();
|
---|
437 | break;
|
---|
438 | #endif
|
---|
439 | default:
|
---|
440 | bsd_menu();
|
---|
441 | break;
|
---|
442 | }
|
---|
443 | }
|
---|
444 | }
|
---|
445 |
|
---|
446 | static void
|
---|
447 | xbsd_delete_part(void)
|
---|
448 | {
|
---|
449 | int i;
|
---|
450 |
|
---|
451 | i = xbsd_get_part_index(xbsd_dlabel.d_npartitions);
|
---|
452 | xbsd_dlabel.d_partitions[i].p_size = 0;
|
---|
453 | xbsd_dlabel.d_partitions[i].p_offset = 0;
|
---|
454 | xbsd_dlabel.d_partitions[i].p_fstype = BSD_FS_UNUSED;
|
---|
455 | if (xbsd_dlabel.d_npartitions == i + 1)
|
---|
456 | while (xbsd_dlabel.d_partitions[xbsd_dlabel.d_npartitions-1].p_size == 0)
|
---|
457 | xbsd_dlabel.d_npartitions--;
|
---|
458 | }
|
---|
459 |
|
---|
460 | static void
|
---|
461 | xbsd_new_part(void)
|
---|
462 | {
|
---|
463 | off_t begin, end;
|
---|
464 | char mesg[256];
|
---|
465 | int i;
|
---|
466 |
|
---|
467 | if (!xbsd_check_new_partition(&i))
|
---|
468 | return;
|
---|
469 |
|
---|
470 | #if !defined(__alpha__) && !defined(__powerpc__) && !defined(__hppa__)
|
---|
471 | begin = get_start_sect(xbsd_part);
|
---|
472 | end = begin + get_nr_sects(xbsd_part) - 1;
|
---|
473 | #else
|
---|
474 | begin = 0;
|
---|
475 | end = xbsd_dlabel.d_secperunit - 1;
|
---|
476 | #endif
|
---|
477 |
|
---|
478 | snprintf(mesg, sizeof(mesg), "First %s", str_units(SINGULAR));
|
---|
479 | begin = read_int(bsd_cround(begin), bsd_cround(begin), bsd_cround(end),
|
---|
480 | 0, mesg);
|
---|
481 |
|
---|
482 | if (display_in_cyl_units)
|
---|
483 | begin = (begin - 1) * xbsd_dlabel.d_secpercyl;
|
---|
484 |
|
---|
485 | snprintf(mesg, sizeof(mesg), "Last %s or +size or +sizeM or +sizeK",
|
---|
486 | str_units(SINGULAR));
|
---|
487 | end = read_int(bsd_cround(begin), bsd_cround(end), bsd_cround(end),
|
---|
488 | bsd_cround(begin), mesg);
|
---|
489 |
|
---|
490 | if (display_in_cyl_units)
|
---|
491 | end = end * xbsd_dlabel.d_secpercyl - 1;
|
---|
492 |
|
---|
493 | xbsd_dlabel.d_partitions[i].p_size = end - begin + 1;
|
---|
494 | xbsd_dlabel.d_partitions[i].p_offset = begin;
|
---|
495 | xbsd_dlabel.d_partitions[i].p_fstype = BSD_FS_UNUSED;
|
---|
496 | }
|
---|
497 |
|
---|
498 | static void
|
---|
499 | xbsd_print_disklabel(int show_all)
|
---|
500 | {
|
---|
501 | struct xbsd_disklabel *lp = &xbsd_dlabel;
|
---|
502 | struct xbsd_partition *pp;
|
---|
503 | int i, j;
|
---|
504 |
|
---|
505 | if (show_all) {
|
---|
506 | #if defined(__alpha__)
|
---|
507 | printf("# %s:\n", disk_device);
|
---|
508 | #else
|
---|
509 | printf("# %s:\n", partname(disk_device, xbsd_part_index+1, 0));
|
---|
510 | #endif
|
---|
511 | if ((unsigned) lp->d_type < ARRAY_SIZE(xbsd_dktypenames)-1)
|
---|
512 | printf("type: %s\n", xbsd_dktypenames[lp->d_type]);
|
---|
513 | else
|
---|
514 | printf("type: %d\n", lp->d_type);
|
---|
515 | printf("disk: %.*s\n", (int) sizeof(lp->d_typename), lp->d_typename);
|
---|
516 | printf("label: %.*s\n", (int) sizeof(lp->d_packname), lp->d_packname);
|
---|
517 | printf("flags:");
|
---|
518 | if (lp->d_flags & BSD_D_REMOVABLE)
|
---|
519 | printf(" removable");
|
---|
520 | if (lp->d_flags & BSD_D_ECC)
|
---|
521 | printf(" ecc");
|
---|
522 | if (lp->d_flags & BSD_D_BADSECT)
|
---|
523 | printf(" badsect");
|
---|
524 | puts("");
|
---|
525 | /* On various machines the fields of *lp are short/int/long */
|
---|
526 | /* In order to avoid problems, we cast them all to long. */
|
---|
527 | printf("bytes/sector: %ld\n", (long) lp->d_secsize);
|
---|
528 | printf("sectors/track: %ld\n", (long) lp->d_nsectors);
|
---|
529 | printf("tracks/cylinder: %ld\n", (long) lp->d_ntracks);
|
---|
530 | printf("sectors/cylinder: %ld\n", (long) lp->d_secpercyl);
|
---|
531 | printf("cylinders: %ld\n", (long) lp->d_ncylinders);
|
---|
532 | printf("rpm: %d\n", lp->d_rpm);
|
---|
533 | printf("interleave: %d\n", lp->d_interleave);
|
---|
534 | printf("trackskew: %d\n", lp->d_trackskew);
|
---|
535 | printf("cylinderskew: %d\n", lp->d_cylskew);
|
---|
536 | printf("headswitch: %ld\t\t# milliseconds\n",
|
---|
537 | (long) lp->d_headswitch);
|
---|
538 | printf("track-to-track seek: %ld\t# milliseconds\n",
|
---|
539 | (long) lp->d_trkseek);
|
---|
540 | printf("drivedata: ");
|
---|
541 | for (i = NDDATA - 1; i >= 0; i--)
|
---|
542 | if (lp->d_drivedata[i])
|
---|
543 | break;
|
---|
544 | if (i < 0)
|
---|
545 | i = 0;
|
---|
546 | for (j = 0; j <= i; j++)
|
---|
547 | printf("%ld ", (long) lp->d_drivedata[j]);
|
---|
548 | }
|
---|
549 | printf("\n%d partitions:\n", lp->d_npartitions);
|
---|
550 | printf("# start end size fstype [fsize bsize cpg]\n");
|
---|
551 | pp = lp->d_partitions;
|
---|
552 | for (i = 0; i < lp->d_npartitions; i++, pp++) {
|
---|
553 | if (pp->p_size) {
|
---|
554 | if (display_in_cyl_units && lp->d_secpercyl) {
|
---|
555 | printf(" %c: %8ld%c %8ld%c %8ld%c ",
|
---|
556 | 'a' + i,
|
---|
557 | (long) pp->p_offset / lp->d_secpercyl + 1,
|
---|
558 | (pp->p_offset % lp->d_secpercyl) ? '*' : ' ',
|
---|
559 | (long) (pp->p_offset + pp->p_size + lp->d_secpercyl - 1) / lp->d_secpercyl,
|
---|
560 | ((pp->p_offset + pp->p_size) % lp->d_secpercyl) ? '*' : ' ',
|
---|
561 | (long) pp->p_size / lp->d_secpercyl,
|
---|
562 | (pp->p_size % lp->d_secpercyl) ? '*' : ' '
|
---|
563 | );
|
---|
564 | } else {
|
---|
565 | printf(" %c: %8ld %8ld %8ld ",
|
---|
566 | 'a' + i,
|
---|
567 | (long) pp->p_offset,
|
---|
568 | (long) pp->p_offset + pp->p_size - 1,
|
---|
569 | (long) pp->p_size
|
---|
570 | );
|
---|
571 | }
|
---|
572 |
|
---|
573 | if ((unsigned) pp->p_fstype < ARRAY_SIZE(xbsd_fstypes)-1)
|
---|
574 | printf("%8.8s", xbsd_fstypes[pp->p_fstype]);
|
---|
575 | else
|
---|
576 | printf("%8x", pp->p_fstype);
|
---|
577 |
|
---|
578 | switch (pp->p_fstype) {
|
---|
579 | case BSD_FS_UNUSED:
|
---|
580 | printf(" %5ld %5ld %5.5s ",
|
---|
581 | (long) pp->p_fsize, (long) pp->p_fsize * pp->p_frag, "");
|
---|
582 | break;
|
---|
583 | case BSD_FS_BSDFFS:
|
---|
584 | printf(" %5ld %5ld %5d ",
|
---|
585 | (long) pp->p_fsize, (long) pp->p_fsize * pp->p_frag, pp->p_cpg);
|
---|
586 | break;
|
---|
587 | default:
|
---|
588 | printf("%22.22s", "");
|
---|
589 | break;
|
---|
590 | }
|
---|
591 | puts("");
|
---|
592 | }
|
---|
593 | }
|
---|
594 | }
|
---|
595 |
|
---|
596 | static void
|
---|
597 | xbsd_write_disklabel(void)
|
---|
598 | {
|
---|
599 | #if defined(__alpha__)
|
---|
600 | printf("Writing disklabel to %s\n", disk_device);
|
---|
601 | xbsd_writelabel(NULL);
|
---|
602 | #else
|
---|
603 | printf("Writing disklabel to %s\n",
|
---|
604 | partname(disk_device, xbsd_part_index + 1, 0));
|
---|
605 | xbsd_writelabel(xbsd_part);
|
---|
606 | #endif
|
---|
607 | reread_partition_table(0); /* no exit yet */
|
---|
608 | }
|
---|
609 |
|
---|
610 | static int
|
---|
611 | xbsd_create_disklabel(void)
|
---|
612 | {
|
---|
613 | char c;
|
---|
614 |
|
---|
615 | #if defined(__alpha__)
|
---|
616 | printf("%s contains no disklabel\n", disk_device);
|
---|
617 | #else
|
---|
618 | printf("%s contains no disklabel\n",
|
---|
619 | partname(disk_device, xbsd_part_index + 1, 0));
|
---|
620 | #endif
|
---|
621 |
|
---|
622 | while (1) {
|
---|
623 | c = read_nonempty("Do you want to create a disklabel? (y/n) ");
|
---|
624 | if (c == 'y' || c == 'Y') {
|
---|
625 | if (xbsd_initlabel(
|
---|
626 | #if defined(__alpha__) || defined(__powerpc__) || defined(__hppa__) || \
|
---|
627 | defined(__s390__) || defined(__s390x__)
|
---|
628 | NULL
|
---|
629 | #else
|
---|
630 | xbsd_part
|
---|
631 | #endif
|
---|
632 | ) == 1) {
|
---|
633 | xbsd_print_disklabel(1);
|
---|
634 | return 1;
|
---|
635 | } else
|
---|
636 | return 0;
|
---|
637 | } else if (c == 'n')
|
---|
638 | return 0;
|
---|
639 | }
|
---|
640 | }
|
---|
641 |
|
---|
642 | static int
|
---|
643 | edit_int(int def, const char *mesg)
|
---|
644 | {
|
---|
645 | mesg = xasprintf("%s (%d): ", mesg, def);
|
---|
646 | do {
|
---|
647 | if (!read_line(mesg))
|
---|
648 | goto ret;
|
---|
649 | } while (!isdigit(*line_ptr));
|
---|
650 | def = atoi(line_ptr);
|
---|
651 | ret:
|
---|
652 | free((char*)mesg);
|
---|
653 | return def;
|
---|
654 | }
|
---|
655 |
|
---|
656 | static void
|
---|
657 | xbsd_edit_disklabel(void)
|
---|
658 | {
|
---|
659 | struct xbsd_disklabel *d;
|
---|
660 |
|
---|
661 | d = &xbsd_dlabel;
|
---|
662 |
|
---|
663 | #if defined(__alpha__) || defined(__ia64__)
|
---|
664 | d->d_secsize = edit_int(d->d_secsize , "bytes/sector");
|
---|
665 | d->d_nsectors = edit_int(d->d_nsectors , "sectors/track");
|
---|
666 | d->d_ntracks = edit_int(d->d_ntracks , "tracks/cylinder");
|
---|
667 | d->d_ncylinders = edit_int(d->d_ncylinders , "cylinders");
|
---|
668 | #endif
|
---|
669 |
|
---|
670 | /* d->d_secpercyl can be != d->d_nsectors * d->d_ntracks */
|
---|
671 | while (1) {
|
---|
672 | d->d_secpercyl = edit_int(d->d_nsectors * d->d_ntracks,
|
---|
673 | "sectors/cylinder");
|
---|
674 | if (d->d_secpercyl <= d->d_nsectors * d->d_ntracks)
|
---|
675 | break;
|
---|
676 |
|
---|
677 | printf("Must be <= sectors/track * tracks/cylinder (default)\n");
|
---|
678 | }
|
---|
679 | d->d_rpm = edit_int(d->d_rpm , "rpm");
|
---|
680 | d->d_interleave = edit_int(d->d_interleave, "interleave");
|
---|
681 | d->d_trackskew = edit_int(d->d_trackskew , "trackskew");
|
---|
682 | d->d_cylskew = edit_int(d->d_cylskew , "cylinderskew");
|
---|
683 | d->d_headswitch = edit_int(d->d_headswitch, "headswitch");
|
---|
684 | d->d_trkseek = edit_int(d->d_trkseek , "track-to-track seek");
|
---|
685 |
|
---|
686 | d->d_secperunit = d->d_secpercyl * d->d_ncylinders;
|
---|
687 | }
|
---|
688 |
|
---|
689 | static int
|
---|
690 | xbsd_get_bootstrap(char *path, void *ptr, int size)
|
---|
691 | {
|
---|
692 | int fdb;
|
---|
693 |
|
---|
694 | fdb = open(path, O_RDONLY);
|
---|
695 | if (fdb < 0) {
|
---|
696 | perror(path);
|
---|
697 | return 0;
|
---|
698 | }
|
---|
699 | if (read(fdb, ptr, size) < 0) {
|
---|
700 | perror(path);
|
---|
701 | close(fdb);
|
---|
702 | return 0;
|
---|
703 | }
|
---|
704 | printf(" ... %s\n", path);
|
---|
705 | close(fdb);
|
---|
706 | return 1;
|
---|
707 | }
|
---|
708 |
|
---|
709 | static void
|
---|
710 | sync_disks(void)
|
---|
711 | {
|
---|
712 | printf("Syncing disks\n");
|
---|
713 | sync();
|
---|
714 | /* sleep(4); What? */
|
---|
715 | }
|
---|
716 |
|
---|
717 | static void
|
---|
718 | xbsd_write_bootstrap(void)
|
---|
719 | {
|
---|
720 | char path[MAXPATHLEN];
|
---|
721 | const char *bootdir = BSD_LINUX_BOOTDIR;
|
---|
722 | const char *dkbasename;
|
---|
723 | struct xbsd_disklabel dl;
|
---|
724 | char *d, *p, *e;
|
---|
725 | int sector;
|
---|
726 |
|
---|
727 | if (xbsd_dlabel.d_type == BSD_DTYPE_SCSI)
|
---|
728 | dkbasename = "sd";
|
---|
729 | else
|
---|
730 | dkbasename = "wd";
|
---|
731 |
|
---|
732 | snprintf(path, sizeof(path), "Bootstrap: %sboot -> boot%s (%s): ",
|
---|
733 | dkbasename, dkbasename, dkbasename);
|
---|
734 | if (read_line(path)) {
|
---|
735 | dkbasename = line_ptr;
|
---|
736 | }
|
---|
737 | snprintf(path, sizeof(path), "%s/%sboot", bootdir, dkbasename);
|
---|
738 | if (!xbsd_get_bootstrap(path, disklabelbuffer, (int) xbsd_dlabel.d_secsize))
|
---|
739 | return;
|
---|
740 |
|
---|
741 | /* We need a backup of the disklabel (xbsd_dlabel might have changed). */
|
---|
742 | d = &disklabelbuffer[BSD_LABELSECTOR * SECTOR_SIZE];
|
---|
743 | memmove(&dl, d, sizeof(struct xbsd_disklabel));
|
---|
744 |
|
---|
745 | /* The disklabel will be overwritten by 0's from bootxx anyway */
|
---|
746 | memset(d, 0, sizeof(struct xbsd_disklabel));
|
---|
747 |
|
---|
748 | snprintf(path, sizeof(path), "%s/boot%s", bootdir, dkbasename);
|
---|
749 | if (!xbsd_get_bootstrap(path, &disklabelbuffer[xbsd_dlabel.d_secsize],
|
---|
750 | (int) xbsd_dlabel.d_bbsize - xbsd_dlabel.d_secsize))
|
---|
751 | return;
|
---|
752 |
|
---|
753 | e = d + sizeof(struct xbsd_disklabel);
|
---|
754 | for (p = d; p < e; p++)
|
---|
755 | if (*p) {
|
---|
756 | printf("Bootstrap overlaps with disk label!\n");
|
---|
757 | exit(EXIT_FAILURE);
|
---|
758 | }
|
---|
759 |
|
---|
760 | memmove(d, &dl, sizeof(struct xbsd_disklabel));
|
---|
761 |
|
---|
762 | #if defined(__powerpc__) || defined(__hppa__)
|
---|
763 | sector = 0;
|
---|
764 | #elif defined(__alpha__)
|
---|
765 | sector = 0;
|
---|
766 | alpha_bootblock_checksum(disklabelbuffer);
|
---|
767 | #else
|
---|
768 | sector = get_start_sect(xbsd_part);
|
---|
769 | #endif
|
---|
770 |
|
---|
771 | if (lseek(fd, sector * SECTOR_SIZE, SEEK_SET) == -1)
|
---|
772 | fdisk_fatal(unable_to_seek);
|
---|
773 | if (BSD_BBSIZE != write(fd, disklabelbuffer, BSD_BBSIZE))
|
---|
774 | fdisk_fatal(unable_to_write);
|
---|
775 |
|
---|
776 | #if defined(__alpha__)
|
---|
777 | printf("Bootstrap installed on %s\n", disk_device);
|
---|
778 | #else
|
---|
779 | printf("Bootstrap installed on %s\n",
|
---|
780 | partname(disk_device, xbsd_part_index+1, 0));
|
---|
781 | #endif
|
---|
782 |
|
---|
783 | sync_disks();
|
---|
784 | }
|
---|
785 |
|
---|
786 | static void
|
---|
787 | xbsd_change_fstype(void)
|
---|
788 | {
|
---|
789 | int i;
|
---|
790 |
|
---|
791 | i = xbsd_get_part_index(xbsd_dlabel.d_npartitions);
|
---|
792 | xbsd_dlabel.d_partitions[i].p_fstype = read_hex(xbsd_fstypes);
|
---|
793 | }
|
---|
794 |
|
---|
795 | static int
|
---|
796 | xbsd_get_part_index(int max)
|
---|
797 | {
|
---|
798 | char prompt[sizeof("Partition (a-%c): ") + 16];
|
---|
799 | char l;
|
---|
800 |
|
---|
801 | snprintf(prompt, sizeof(prompt), "Partition (a-%c): ", 'a' + max - 1);
|
---|
802 | do
|
---|
803 | l = tolower(read_nonempty(prompt));
|
---|
804 | while (l < 'a' || l > 'a' + max - 1);
|
---|
805 | return l - 'a';
|
---|
806 | }
|
---|
807 |
|
---|
808 | static int
|
---|
809 | xbsd_check_new_partition(int *i)
|
---|
810 | {
|
---|
811 | /* room for more? various BSD flavours have different maxima */
|
---|
812 | if (xbsd_dlabel.d_npartitions == BSD_MAXPARTITIONS) {
|
---|
813 | int t;
|
---|
814 |
|
---|
815 | for (t = 0; t < BSD_MAXPARTITIONS; t++)
|
---|
816 | if (xbsd_dlabel.d_partitions[t].p_size == 0)
|
---|
817 | break;
|
---|
818 |
|
---|
819 | if (t == BSD_MAXPARTITIONS) {
|
---|
820 | printf("The maximum number of partitions has been created\n");
|
---|
821 | return 0;
|
---|
822 | }
|
---|
823 | }
|
---|
824 |
|
---|
825 | *i = xbsd_get_part_index(BSD_MAXPARTITIONS);
|
---|
826 |
|
---|
827 | if (*i >= xbsd_dlabel.d_npartitions)
|
---|
828 | xbsd_dlabel.d_npartitions = (*i) + 1;
|
---|
829 |
|
---|
830 | if (xbsd_dlabel.d_partitions[*i].p_size != 0) {
|
---|
831 | printf("This partition already exists\n");
|
---|
832 | return 0;
|
---|
833 | }
|
---|
834 |
|
---|
835 | return 1;
|
---|
836 | }
|
---|
837 |
|
---|
838 | static void
|
---|
839 | xbsd_list_types(void)
|
---|
840 | {
|
---|
841 | list_types(xbsd_fstypes);
|
---|
842 | }
|
---|
843 |
|
---|
844 | static uint16_t
|
---|
845 | xbsd_dkcksum(struct xbsd_disklabel *lp)
|
---|
846 | {
|
---|
847 | uint16_t *start, *end;
|
---|
848 | uint16_t sum = 0;
|
---|
849 |
|
---|
850 | start = (uint16_t *) lp;
|
---|
851 | end = (uint16_t *) &lp->d_partitions[lp->d_npartitions];
|
---|
852 | while (start < end)
|
---|
853 | sum ^= *start++;
|
---|
854 | return sum;
|
---|
855 | }
|
---|
856 |
|
---|
857 | static int
|
---|
858 | xbsd_initlabel(struct partition *p)
|
---|
859 | {
|
---|
860 | struct xbsd_disklabel *d = &xbsd_dlabel;
|
---|
861 | struct xbsd_partition *pp;
|
---|
862 |
|
---|
863 | get_geometry();
|
---|
864 | memset(d, 0, sizeof(struct xbsd_disklabel));
|
---|
865 |
|
---|
866 | d->d_magic = BSD_DISKMAGIC;
|
---|
867 |
|
---|
868 | if (strncmp(disk_device, "/dev/sd", 7) == 0)
|
---|
869 | d->d_type = BSD_DTYPE_SCSI;
|
---|
870 | else
|
---|
871 | d->d_type = BSD_DTYPE_ST506;
|
---|
872 |
|
---|
873 | #if !defined(__alpha__)
|
---|
874 | d->d_flags = BSD_D_DOSPART;
|
---|
875 | #else
|
---|
876 | d->d_flags = 0;
|
---|
877 | #endif
|
---|
878 | d->d_secsize = SECTOR_SIZE; /* bytes/sector */
|
---|
879 | d->d_nsectors = sectors; /* sectors/track */
|
---|
880 | d->d_ntracks = heads; /* tracks/cylinder (heads) */
|
---|
881 | d->d_ncylinders = cylinders;
|
---|
882 | d->d_secpercyl = sectors * heads; /* sectors/cylinder */
|
---|
883 | if (d->d_secpercyl == 0)
|
---|
884 | d->d_secpercyl = 1; /* avoid segfaults */
|
---|
885 | d->d_secperunit = d->d_secpercyl * d->d_ncylinders;
|
---|
886 |
|
---|
887 | d->d_rpm = 3600;
|
---|
888 | d->d_interleave = 1;
|
---|
889 | d->d_trackskew = 0;
|
---|
890 | d->d_cylskew = 0;
|
---|
891 | d->d_headswitch = 0;
|
---|
892 | d->d_trkseek = 0;
|
---|
893 |
|
---|
894 | d->d_magic2 = BSD_DISKMAGIC;
|
---|
895 | d->d_bbsize = BSD_BBSIZE;
|
---|
896 | d->d_sbsize = BSD_SBSIZE;
|
---|
897 |
|
---|
898 | #if !defined(__alpha__)
|
---|
899 | d->d_npartitions = 4;
|
---|
900 | pp = &d->d_partitions[2]; /* Partition C should be NetBSD partition */
|
---|
901 |
|
---|
902 | pp->p_offset = get_start_sect(p);
|
---|
903 | pp->p_size = get_nr_sects(p);
|
---|
904 | pp->p_fstype = BSD_FS_UNUSED;
|
---|
905 | pp = &d->d_partitions[3]; /* Partition D should be whole disk */
|
---|
906 |
|
---|
907 | pp->p_offset = 0;
|
---|
908 | pp->p_size = d->d_secperunit;
|
---|
909 | pp->p_fstype = BSD_FS_UNUSED;
|
---|
910 | #else
|
---|
911 | d->d_npartitions = 3;
|
---|
912 | pp = &d->d_partitions[2]; /* Partition C should be
|
---|
913 | the whole disk */
|
---|
914 | pp->p_offset = 0;
|
---|
915 | pp->p_size = d->d_secperunit;
|
---|
916 | pp->p_fstype = BSD_FS_UNUSED;
|
---|
917 | #endif
|
---|
918 |
|
---|
919 | return 1;
|
---|
920 | }
|
---|
921 |
|
---|
922 | /*
|
---|
923 | * Read a xbsd_disklabel from sector 0 or from the starting sector of p.
|
---|
924 | * If it has the right magic, return 1.
|
---|
925 | */
|
---|
926 | static int
|
---|
927 | xbsd_readlabel(struct partition *p)
|
---|
928 | {
|
---|
929 | struct xbsd_disklabel *d;
|
---|
930 | int t, sector;
|
---|
931 |
|
---|
932 | if (!bsd_globals_ptr)
|
---|
933 | bsd_globals_ptr = xzalloc(sizeof(*bsd_globals_ptr));
|
---|
934 |
|
---|
935 | d = &xbsd_dlabel;
|
---|
936 |
|
---|
937 | /* p is used only to get the starting sector */
|
---|
938 | #if !defined(__alpha__)
|
---|
939 | sector = (p ? get_start_sect(p) : 0);
|
---|
940 | #else
|
---|
941 | sector = 0;
|
---|
942 | #endif
|
---|
943 |
|
---|
944 | if (lseek(fd, sector * SECTOR_SIZE, SEEK_SET) == -1)
|
---|
945 | fdisk_fatal(unable_to_seek);
|
---|
946 | if (BSD_BBSIZE != read(fd, disklabelbuffer, BSD_BBSIZE))
|
---|
947 | fdisk_fatal(unable_to_read);
|
---|
948 |
|
---|
949 | memmove(d, &disklabelbuffer[BSD_LABELSECTOR * SECTOR_SIZE + BSD_LABELOFFSET],
|
---|
950 | sizeof(struct xbsd_disklabel));
|
---|
951 |
|
---|
952 | if (d->d_magic != BSD_DISKMAGIC || d->d_magic2 != BSD_DISKMAGIC)
|
---|
953 | return 0;
|
---|
954 |
|
---|
955 | for (t = d->d_npartitions; t < BSD_MAXPARTITIONS; t++) {
|
---|
956 | d->d_partitions[t].p_size = 0;
|
---|
957 | d->d_partitions[t].p_offset = 0;
|
---|
958 | d->d_partitions[t].p_fstype = BSD_FS_UNUSED;
|
---|
959 | }
|
---|
960 |
|
---|
961 | if (d->d_npartitions > BSD_MAXPARTITIONS)
|
---|
962 | printf("Warning: too many partitions (%d, maximum is %d)\n",
|
---|
963 | d->d_npartitions, BSD_MAXPARTITIONS);
|
---|
964 | return 1;
|
---|
965 | }
|
---|
966 |
|
---|
967 | static int
|
---|
968 | xbsd_writelabel(struct partition *p)
|
---|
969 | {
|
---|
970 | struct xbsd_disklabel *d = &xbsd_dlabel;
|
---|
971 | unsigned int sector;
|
---|
972 |
|
---|
973 | #if !defined(__alpha__) && !defined(__powerpc__) && !defined(__hppa__)
|
---|
974 | sector = get_start_sect(p) + BSD_LABELSECTOR;
|
---|
975 | #else
|
---|
976 | sector = BSD_LABELSECTOR;
|
---|
977 | #endif
|
---|
978 |
|
---|
979 | d->d_checksum = 0;
|
---|
980 | d->d_checksum = xbsd_dkcksum(d);
|
---|
981 |
|
---|
982 | /* This is necessary if we want to write the bootstrap later,
|
---|
983 | otherwise we'd write the old disklabel with the bootstrap.
|
---|
984 | */
|
---|
985 | memmove(&disklabelbuffer[BSD_LABELSECTOR * SECTOR_SIZE + BSD_LABELOFFSET],
|
---|
986 | d, sizeof(struct xbsd_disklabel));
|
---|
987 |
|
---|
988 | #if defined(__alpha__) && BSD_LABELSECTOR == 0
|
---|
989 | alpha_bootblock_checksum(disklabelbuffer);
|
---|
990 | if (lseek(fd, 0, SEEK_SET) == -1)
|
---|
991 | fdisk_fatal(unable_to_seek);
|
---|
992 | if (BSD_BBSIZE != write(fd, disklabelbuffer, BSD_BBSIZE))
|
---|
993 | fdisk_fatal(unable_to_write);
|
---|
994 | #else
|
---|
995 | if (lseek(fd, sector * SECTOR_SIZE + BSD_LABELOFFSET, SEEK_SET) == -1)
|
---|
996 | fdisk_fatal(unable_to_seek);
|
---|
997 | if (sizeof(struct xbsd_disklabel) != write(fd, d, sizeof(struct xbsd_disklabel)))
|
---|
998 | fdisk_fatal(unable_to_write);
|
---|
999 | #endif
|
---|
1000 | sync_disks();
|
---|
1001 | return 1;
|
---|
1002 | }
|
---|
1003 |
|
---|
1004 |
|
---|
1005 | #if !defined(__alpha__)
|
---|
1006 | static int
|
---|
1007 | xbsd_translate_fstype(int linux_type)
|
---|
1008 | {
|
---|
1009 | switch (linux_type) {
|
---|
1010 | case 0x01: /* DOS 12-bit FAT */
|
---|
1011 | case 0x04: /* DOS 16-bit <32M */
|
---|
1012 | case 0x06: /* DOS 16-bit >=32M */
|
---|
1013 | case 0xe1: /* DOS access */
|
---|
1014 | case 0xe3: /* DOS R/O */
|
---|
1015 | case 0xf2: /* DOS secondary */
|
---|
1016 | return BSD_FS_MSDOS;
|
---|
1017 | case 0x07: /* OS/2 HPFS */
|
---|
1018 | return BSD_FS_HPFS;
|
---|
1019 | default:
|
---|
1020 | return BSD_FS_OTHER;
|
---|
1021 | }
|
---|
1022 | }
|
---|
1023 |
|
---|
1024 | static void
|
---|
1025 | xbsd_link_part(void)
|
---|
1026 | {
|
---|
1027 | int k, i;
|
---|
1028 | struct partition *p;
|
---|
1029 |
|
---|
1030 | k = get_partition(1, partitions);
|
---|
1031 |
|
---|
1032 | if (!xbsd_check_new_partition(&i))
|
---|
1033 | return;
|
---|
1034 |
|
---|
1035 | p = get_part_table(k);
|
---|
1036 |
|
---|
1037 | xbsd_dlabel.d_partitions[i].p_size = get_nr_sects(p);
|
---|
1038 | xbsd_dlabel.d_partitions[i].p_offset = get_start_sect(p);
|
---|
1039 | xbsd_dlabel.d_partitions[i].p_fstype = xbsd_translate_fstype(p->sys_ind);
|
---|
1040 | }
|
---|
1041 | #endif
|
---|
1042 |
|
---|
1043 | #if defined(__alpha__)
|
---|
1044 | static void
|
---|
1045 | alpha_bootblock_checksum(char *boot)
|
---|
1046 | {
|
---|
1047 | uint64_t *dp, sum;
|
---|
1048 | int i;
|
---|
1049 |
|
---|
1050 | dp = (uint64_t *)boot;
|
---|
1051 | sum = 0;
|
---|
1052 | for (i = 0; i < 63; i++)
|
---|
1053 | sum += dp[i];
|
---|
1054 | dp[63] = sum;
|
---|
1055 | }
|
---|
1056 | #endif /* __alpha__ */
|
---|
1057 |
|
---|
1058 | /* Undefine 'global' tricks */
|
---|
1059 | #undef disklabelbuffer
|
---|
1060 | #undef xbsd_dlabel
|
---|
1061 |
|
---|
1062 | #endif /* OSF_LABEL */
|
---|