Denis Vlasenko | 6a5dc5d | 2006-12-30 18:42:29 +0000 | [diff] [blame] | 1 | #if ENABLE_FEATURE_OSF_LABEL |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 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 | |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 46 | #if defined(i386) || defined(__sparc__) || defined(__arm__) \ |
| 47 | || defined(__m68k__) || defined(__mips__) || defined(__s390__) \ |
| 48 | || defined(__sh__) || defined(__x86_64__) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 49 | #define BSD_LABELSECTOR 1 |
| 50 | #define BSD_LABELOFFSET 0 |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 51 | #elif defined(__alpha__) || defined(__powerpc__) || defined(__ia64__) \ |
| 52 | || defined(__hppa__) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 53 | #define BSD_LABELSECTOR 0 |
| 54 | #define BSD_LABELOFFSET 64 |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 55 | #elif defined(__s390__) || defined(__s390x__) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 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 | |
Denis Vlasenko | 6ca409e | 2007-08-12 20:58:27 +0000 | [diff] [blame] | 152 | static const char *const xbsd_dktypenames[] = { |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 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 | }; |
Denis Vlasenko | 80b8b39 | 2007-06-25 10:55:35 +0000 | [diff] [blame] | 166 | |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 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 | |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 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 */ |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 207 | #ifdef __alpha__ |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 208 | "\x08" "ext2", /* BSD_FS_EXT2 */ |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 209 | #else |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 210 | "\x08" "MS-DOS", /* BSD_FS_MSDOS */ |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 211 | #endif |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 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 |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 221 | }; |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 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 | |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 243 | #define FREEBSD_PARTITION 0xa5 |
| 244 | #define NETBSD_PARTITION 0xa9 |
| 245 | |
| 246 | static void xbsd_delete_part(void); |
| 247 | static void xbsd_new_part(void); |
| 248 | static void xbsd_write_disklabel(void); |
| 249 | static int xbsd_create_disklabel(void); |
| 250 | static void xbsd_edit_disklabel(void); |
| 251 | static void xbsd_write_bootstrap(void); |
| 252 | static void xbsd_change_fstype(void); |
| 253 | static int xbsd_get_part_index(int max); |
| 254 | static int xbsd_check_new_partition(int *i); |
| 255 | static void xbsd_list_types(void); |
Denis Vlasenko | 2870301 | 2006-12-19 20:32:02 +0000 | [diff] [blame] | 256 | static uint16_t xbsd_dkcksum(struct xbsd_disklabel *lp); |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 257 | static int xbsd_initlabel(struct partition *p); |
| 258 | static int xbsd_readlabel(struct partition *p); |
| 259 | static int xbsd_writelabel(struct partition *p); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 260 | |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 261 | #if defined(__alpha__) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 262 | static void alpha_bootblock_checksum(char *boot); |
| 263 | #endif |
| 264 | |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 265 | #if !defined(__alpha__) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 266 | static int xbsd_translate_fstype(int linux_type); |
| 267 | static void xbsd_link_part(void); |
| 268 | static struct partition *xbsd_part; |
| 269 | static int xbsd_part_index; |
| 270 | #endif |
| 271 | |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 272 | |
| 273 | /* Group big globals data and allocate it in one go */ |
| 274 | struct bsd_globals { |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 275 | /* We access this through a uint64_t * when checksumming */ |
Denis Vlasenko | d547083 | 2007-01-03 02:58:54 +0000 | [diff] [blame] | 276 | /* hopefully xmalloc gives us required alignment */ |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 277 | char disklabelbuffer[BSD_BBSIZE]; |
| 278 | struct xbsd_disklabel xbsd_dlabel; |
| 279 | }; |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 280 | |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 281 | static struct bsd_globals *bsd_globals_ptr; |
| 282 | |
| 283 | #define disklabelbuffer (bsd_globals_ptr->disklabelbuffer) |
Denis Vlasenko | c86e052 | 2007-03-20 11:30:28 +0000 | [diff] [blame] | 284 | #define xbsd_dlabel (bsd_globals_ptr->xbsd_dlabel) |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 285 | |
| 286 | |
| 287 | /* Code */ |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 288 | |
| 289 | #define bsd_cround(n) \ |
| 290 | (display_in_cyl_units ? ((n)/xbsd_dlabel.d_secpercyl) + 1 : (n)) |
| 291 | |
| 292 | /* |
| 293 | * Test whether the whole disk has BSD disk label magic. |
| 294 | * |
| 295 | * Note: often reformatting with DOS-type label leaves the BSD magic, |
| 296 | * so this does not mean that there is a BSD disk label. |
| 297 | */ |
| 298 | static int |
| 299 | check_osf_label(void) |
| 300 | { |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 301 | if (xbsd_readlabel(NULL) == 0) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 302 | return 0; |
| 303 | return 1; |
| 304 | } |
| 305 | |
| 306 | static int |
Denis Vlasenko | d547083 | 2007-01-03 02:58:54 +0000 | [diff] [blame] | 307 | bsd_trydev(const char * dev) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 308 | { |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 309 | if (xbsd_readlabel(NULL) == 0) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 310 | return -1; |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 311 | printf("\nBSD label for device: %s\n", dev); |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 312 | xbsd_print_disklabel(0); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 313 | return 0; |
| 314 | } |
| 315 | |
| 316 | static void |
Denis Vlasenko | d547083 | 2007-01-03 02:58:54 +0000 | [diff] [blame] | 317 | bsd_menu(void) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 318 | { |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 319 | puts("Command Action"); |
| 320 | puts("d\tdelete a BSD partition"); |
| 321 | puts("e\tedit drive data"); |
| 322 | puts("i\tinstall bootstrap"); |
| 323 | puts("l\tlist known filesystem types"); |
| 324 | puts("n\tadd a new BSD partition"); |
| 325 | puts("p\tprint BSD partition table"); |
| 326 | puts("q\tquit without saving changes"); |
| 327 | puts("r\treturn to main menu"); |
| 328 | puts("s\tshow complete disklabel"); |
| 329 | puts("t\tchange a partition's filesystem id"); |
| 330 | puts("u\tchange units (cylinders/sectors)"); |
| 331 | puts("w\twrite disklabel to disk"); |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 332 | #if !defined(__alpha__) |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 333 | puts("x\tlink BSD partition to non-BSD partition"); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 334 | #endif |
| 335 | } |
| 336 | |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 337 | #if !defined(__alpha__) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 338 | static int |
| 339 | hidden(int type) |
| 340 | { |
| 341 | return type ^ 0x10; |
| 342 | } |
| 343 | |
| 344 | static int |
| 345 | is_bsd_partition_type(int type) |
| 346 | { |
| 347 | return (type == FREEBSD_PARTITION || |
| 348 | type == hidden(FREEBSD_PARTITION) || |
| 349 | type == NETBSD_PARTITION || |
| 350 | type == hidden(NETBSD_PARTITION)); |
| 351 | } |
| 352 | #endif |
| 353 | |
| 354 | static void |
Denis Vlasenko | efeed5e | 2006-10-14 16:16:03 +0000 | [diff] [blame] | 355 | bsd_select(void) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 356 | { |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 357 | #if !defined(__alpha__) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 358 | int t, ss; |
| 359 | struct partition *p; |
| 360 | |
| 361 | for (t = 0; t < 4; t++) { |
| 362 | p = get_part_table(t); |
| 363 | if (p && is_bsd_partition_type(p->sys_ind)) { |
| 364 | xbsd_part = p; |
| 365 | xbsd_part_index = t; |
| 366 | ss = get_start_sect(xbsd_part); |
| 367 | if (ss == 0) { |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 368 | printf("Partition %s has invalid starting sector 0\n", |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 369 | partname(disk_device, t+1, 0)); |
| 370 | return; |
| 371 | } |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 372 | printf("Reading disklabel of %s at sector %d\n", |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 373 | partname(disk_device, t+1, 0), ss + BSD_LABELSECTOR); |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 374 | if (xbsd_readlabel(xbsd_part) == 0) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 375 | if (xbsd_create_disklabel() == 0) |
| 376 | return; |
| 377 | break; |
| 378 | } |
| 379 | } |
| 380 | |
| 381 | if (t == 4) { |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 382 | printf("There is no *BSD partition on %s\n", disk_device); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 383 | return; |
| 384 | } |
| 385 | |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 386 | #elif defined(__alpha__) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 387 | |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 388 | if (xbsd_readlabel(NULL) == 0) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 389 | if (xbsd_create_disklabel() == 0) |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 390 | exit(EXIT_SUCCESS); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 391 | |
| 392 | #endif |
| 393 | |
| 394 | while (1) { |
Denis Vlasenko | 4daad90 | 2007-09-27 10:20:47 +0000 | [diff] [blame] | 395 | bb_putchar('\n'); |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 396 | switch (tolower(read_nonempty("BSD disklabel command (m for help): "))) { |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 397 | case 'd': |
| 398 | xbsd_delete_part(); |
| 399 | break; |
| 400 | case 'e': |
| 401 | xbsd_edit_disklabel(); |
| 402 | break; |
| 403 | case 'i': |
| 404 | xbsd_write_bootstrap(); |
| 405 | break; |
| 406 | case 'l': |
| 407 | xbsd_list_types(); |
| 408 | break; |
| 409 | case 'n': |
| 410 | xbsd_new_part(); |
| 411 | break; |
| 412 | case 'p': |
| 413 | xbsd_print_disklabel(0); |
| 414 | break; |
| 415 | case 'q': |
Denis Vlasenko | 4437d19 | 2008-04-17 00:12:10 +0000 | [diff] [blame] | 416 | if (ENABLE_FEATURE_CLEAN_UP) |
Denis Vlasenko | c033d51 | 2008-04-17 01:52:28 +0000 | [diff] [blame] | 417 | close_dev_fd(); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 418 | exit(EXIT_SUCCESS); |
| 419 | case 'r': |
| 420 | return; |
| 421 | case 's': |
| 422 | xbsd_print_disklabel(1); |
| 423 | break; |
| 424 | case 't': |
| 425 | xbsd_change_fstype(); |
| 426 | break; |
| 427 | case 'u': |
| 428 | change_units(); |
| 429 | break; |
| 430 | case 'w': |
| 431 | xbsd_write_disklabel(); |
| 432 | break; |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 433 | #if !defined(__alpha__) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 434 | case 'x': |
| 435 | xbsd_link_part(); |
| 436 | break; |
| 437 | #endif |
| 438 | default: |
Denis Vlasenko | d547083 | 2007-01-03 02:58:54 +0000 | [diff] [blame] | 439 | bsd_menu(); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 440 | break; |
| 441 | } |
| 442 | } |
| 443 | } |
| 444 | |
| 445 | static void |
| 446 | xbsd_delete_part(void) |
| 447 | { |
| 448 | int i; |
| 449 | |
| 450 | i = xbsd_get_part_index(xbsd_dlabel.d_npartitions); |
| 451 | xbsd_dlabel.d_partitions[i].p_size = 0; |
| 452 | xbsd_dlabel.d_partitions[i].p_offset = 0; |
| 453 | xbsd_dlabel.d_partitions[i].p_fstype = BSD_FS_UNUSED; |
| 454 | if (xbsd_dlabel.d_npartitions == i + 1) |
| 455 | while (xbsd_dlabel.d_partitions[xbsd_dlabel.d_npartitions-1].p_size == 0) |
| 456 | xbsd_dlabel.d_npartitions--; |
| 457 | } |
| 458 | |
| 459 | static void |
| 460 | xbsd_new_part(void) |
| 461 | { |
| 462 | off_t begin, end; |
| 463 | char mesg[256]; |
| 464 | int i; |
| 465 | |
| 466 | if (!xbsd_check_new_partition(&i)) |
| 467 | return; |
| 468 | |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 469 | #if !defined(__alpha__) && !defined(__powerpc__) && !defined(__hppa__) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 470 | begin = get_start_sect(xbsd_part); |
| 471 | end = begin + get_nr_sects(xbsd_part) - 1; |
| 472 | #else |
| 473 | begin = 0; |
| 474 | end = xbsd_dlabel.d_secperunit - 1; |
| 475 | #endif |
| 476 | |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 477 | snprintf(mesg, sizeof(mesg), "First %s", str_units(SINGULAR)); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 478 | begin = read_int(bsd_cround(begin), bsd_cround(begin), bsd_cround(end), |
| 479 | 0, mesg); |
| 480 | |
| 481 | if (display_in_cyl_units) |
| 482 | begin = (begin - 1) * xbsd_dlabel.d_secpercyl; |
| 483 | |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 484 | snprintf(mesg, sizeof(mesg), "Last %s or +size or +sizeM or +sizeK", |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 485 | str_units(SINGULAR)); |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 486 | end = read_int(bsd_cround(begin), bsd_cround(end), bsd_cround(end), |
| 487 | bsd_cround(begin), mesg); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 488 | |
| 489 | if (display_in_cyl_units) |
| 490 | end = end * xbsd_dlabel.d_secpercyl - 1; |
| 491 | |
| 492 | xbsd_dlabel.d_partitions[i].p_size = end - begin + 1; |
| 493 | xbsd_dlabel.d_partitions[i].p_offset = begin; |
| 494 | xbsd_dlabel.d_partitions[i].p_fstype = BSD_FS_UNUSED; |
| 495 | } |
| 496 | |
| 497 | static void |
| 498 | xbsd_print_disklabel(int show_all) |
| 499 | { |
| 500 | struct xbsd_disklabel *lp = &xbsd_dlabel; |
| 501 | struct xbsd_partition *pp; |
| 502 | int i, j; |
| 503 | |
| 504 | if (show_all) { |
Denis Vlasenko | 53354ac | 2008-06-07 15:10:29 +0000 | [diff] [blame] | 505 | static const int d_masks[] = { BSD_D_REMOVABLE, BSD_D_ECC, BSD_D_BADSECT }; |
| 506 | |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 507 | #if defined(__alpha__) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 508 | printf("# %s:\n", disk_device); |
| 509 | #else |
| 510 | printf("# %s:\n", partname(disk_device, xbsd_part_index+1, 0)); |
| 511 | #endif |
Denis Vlasenko | 80b8b39 | 2007-06-25 10:55:35 +0000 | [diff] [blame] | 512 | if ((unsigned) lp->d_type < ARRAY_SIZE(xbsd_dktypenames)-1) |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 513 | printf("type: %s\n", xbsd_dktypenames[lp->d_type]); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 514 | else |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 515 | printf("type: %d\n", lp->d_type); |
| 516 | printf("disk: %.*s\n", (int) sizeof(lp->d_typename), lp->d_typename); |
| 517 | printf("label: %.*s\n", (int) sizeof(lp->d_packname), lp->d_packname); |
Denis Vlasenko | 53354ac | 2008-06-07 15:10:29 +0000 | [diff] [blame] | 518 | printf("flags: "); |
Denis Vlasenko | f45c4f4 | 2008-06-16 04:09:25 +0000 | [diff] [blame] | 519 | print_flags_separated(d_masks, "removable\0""ecc\0""badsect\0", lp->d_flags, " "); |
Denis Vlasenko | 4daad90 | 2007-09-27 10:20:47 +0000 | [diff] [blame] | 520 | bb_putchar('\n'); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 521 | /* On various machines the fields of *lp are short/int/long */ |
| 522 | /* In order to avoid problems, we cast them all to long. */ |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 523 | printf("bytes/sector: %ld\n", (long) lp->d_secsize); |
| 524 | printf("sectors/track: %ld\n", (long) lp->d_nsectors); |
| 525 | printf("tracks/cylinder: %ld\n", (long) lp->d_ntracks); |
| 526 | printf("sectors/cylinder: %ld\n", (long) lp->d_secpercyl); |
| 527 | printf("cylinders: %ld\n", (long) lp->d_ncylinders); |
| 528 | printf("rpm: %d\n", lp->d_rpm); |
| 529 | printf("interleave: %d\n", lp->d_interleave); |
| 530 | printf("trackskew: %d\n", lp->d_trackskew); |
| 531 | printf("cylinderskew: %d\n", lp->d_cylskew); |
| 532 | printf("headswitch: %ld\t\t# milliseconds\n", |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 533 | (long) lp->d_headswitch); |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 534 | printf("track-to-track seek: %ld\t# milliseconds\n", |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 535 | (long) lp->d_trkseek); |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 536 | printf("drivedata: "); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 537 | for (i = NDDATA - 1; i >= 0; i--) |
| 538 | if (lp->d_drivedata[i]) |
| 539 | break; |
| 540 | if (i < 0) |
| 541 | i = 0; |
| 542 | for (j = 0; j <= i; j++) |
| 543 | printf("%ld ", (long) lp->d_drivedata[j]); |
| 544 | } |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 545 | printf("\n%d partitions:\n", lp->d_npartitions); |
| 546 | printf("# start end size fstype [fsize bsize cpg]\n"); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 547 | pp = lp->d_partitions; |
| 548 | for (i = 0; i < lp->d_npartitions; i++, pp++) { |
| 549 | if (pp->p_size) { |
| 550 | if (display_in_cyl_units && lp->d_secpercyl) { |
| 551 | printf(" %c: %8ld%c %8ld%c %8ld%c ", |
| 552 | 'a' + i, |
| 553 | (long) pp->p_offset / lp->d_secpercyl + 1, |
| 554 | (pp->p_offset % lp->d_secpercyl) ? '*' : ' ', |
| 555 | (long) (pp->p_offset + pp->p_size + lp->d_secpercyl - 1) / lp->d_secpercyl, |
| 556 | ((pp->p_offset + pp->p_size) % lp->d_secpercyl) ? '*' : ' ', |
| 557 | (long) pp->p_size / lp->d_secpercyl, |
| 558 | (pp->p_size % lp->d_secpercyl) ? '*' : ' ' |
| 559 | ); |
| 560 | } else { |
| 561 | printf(" %c: %8ld %8ld %8ld ", |
| 562 | 'a' + i, |
| 563 | (long) pp->p_offset, |
| 564 | (long) pp->p_offset + pp->p_size - 1, |
| 565 | (long) pp->p_size |
| 566 | ); |
| 567 | } |
| 568 | |
Denis Vlasenko | 80b8b39 | 2007-06-25 10:55:35 +0000 | [diff] [blame] | 569 | if ((unsigned) pp->p_fstype < ARRAY_SIZE(xbsd_fstypes)-1) |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 570 | printf("%8.8s", xbsd_fstypes[pp->p_fstype]); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 571 | else |
| 572 | printf("%8x", pp->p_fstype); |
| 573 | |
| 574 | switch (pp->p_fstype) { |
| 575 | case BSD_FS_UNUSED: |
| 576 | printf(" %5ld %5ld %5.5s ", |
| 577 | (long) pp->p_fsize, (long) pp->p_fsize * pp->p_frag, ""); |
| 578 | break; |
| 579 | case BSD_FS_BSDFFS: |
| 580 | printf(" %5ld %5ld %5d ", |
| 581 | (long) pp->p_fsize, (long) pp->p_fsize * pp->p_frag, pp->p_cpg); |
| 582 | break; |
| 583 | default: |
| 584 | printf("%22.22s", ""); |
| 585 | break; |
| 586 | } |
Denis Vlasenko | 4daad90 | 2007-09-27 10:20:47 +0000 | [diff] [blame] | 587 | bb_putchar('\n'); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 588 | } |
| 589 | } |
| 590 | } |
| 591 | |
| 592 | static void |
| 593 | xbsd_write_disklabel(void) |
| 594 | { |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 595 | #if defined(__alpha__) |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 596 | printf("Writing disklabel to %s\n", disk_device); |
| 597 | xbsd_writelabel(NULL); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 598 | #else |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 599 | printf("Writing disklabel to %s\n", |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 600 | partname(disk_device, xbsd_part_index + 1, 0)); |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 601 | xbsd_writelabel(xbsd_part); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 602 | #endif |
| 603 | reread_partition_table(0); /* no exit yet */ |
| 604 | } |
| 605 | |
| 606 | static int |
| 607 | xbsd_create_disklabel(void) |
| 608 | { |
| 609 | char c; |
| 610 | |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 611 | #if defined(__alpha__) |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 612 | printf("%s contains no disklabel\n", disk_device); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 613 | #else |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 614 | printf("%s contains no disklabel\n", |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 615 | partname(disk_device, xbsd_part_index + 1, 0)); |
| 616 | #endif |
| 617 | |
| 618 | while (1) { |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 619 | c = read_nonempty("Do you want to create a disklabel? (y/n) "); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 620 | if (c == 'y' || c == 'Y') { |
| 621 | if (xbsd_initlabel( |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 622 | #if defined(__alpha__) || defined(__powerpc__) || defined(__hppa__) || \ |
| 623 | defined(__s390__) || defined(__s390x__) |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 624 | NULL |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 625 | #else |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 626 | xbsd_part |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 627 | #endif |
Denis Vlasenko | 4437d19 | 2008-04-17 00:12:10 +0000 | [diff] [blame] | 628 | ) == 1) { |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 629 | xbsd_print_disklabel(1); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 630 | return 1; |
Denis Vlasenko | 4437d19 | 2008-04-17 00:12:10 +0000 | [diff] [blame] | 631 | } |
| 632 | return 0; |
| 633 | } |
| 634 | if (c == 'n') |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 635 | return 0; |
| 636 | } |
| 637 | } |
| 638 | |
| 639 | static int |
Denis Vlasenko | 06c0a71 | 2007-01-29 22:51:44 +0000 | [diff] [blame] | 640 | edit_int(int def, const char *mesg) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 641 | { |
Denis Vlasenko | 8e1c715 | 2007-01-22 07:21:38 +0000 | [diff] [blame] | 642 | mesg = xasprintf("%s (%d): ", mesg, def); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 643 | do { |
Denis Vlasenko | 8e1c715 | 2007-01-22 07:21:38 +0000 | [diff] [blame] | 644 | if (!read_line(mesg)) |
| 645 | goto ret; |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 646 | } while (!isdigit(*line_ptr)); |
Denis Vlasenko | 8e1c715 | 2007-01-22 07:21:38 +0000 | [diff] [blame] | 647 | def = atoi(line_ptr); |
| 648 | ret: |
Denis Vlasenko | 06c0a71 | 2007-01-29 22:51:44 +0000 | [diff] [blame] | 649 | free((char*)mesg); |
Denis Vlasenko | 8e1c715 | 2007-01-22 07:21:38 +0000 | [diff] [blame] | 650 | return def; |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 651 | } |
| 652 | |
| 653 | static void |
| 654 | xbsd_edit_disklabel(void) |
| 655 | { |
| 656 | struct xbsd_disklabel *d; |
| 657 | |
| 658 | d = &xbsd_dlabel; |
| 659 | |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 660 | #if defined(__alpha__) || defined(__ia64__) |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 661 | d->d_secsize = edit_int(d->d_secsize , "bytes/sector"); |
| 662 | d->d_nsectors = edit_int(d->d_nsectors , "sectors/track"); |
| 663 | d->d_ntracks = edit_int(d->d_ntracks , "tracks/cylinder"); |
| 664 | d->d_ncylinders = edit_int(d->d_ncylinders , "cylinders"); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 665 | #endif |
| 666 | |
Denis Vlasenko | 2870301 | 2006-12-19 20:32:02 +0000 | [diff] [blame] | 667 | /* d->d_secpercyl can be != d->d_nsectors * d->d_ntracks */ |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 668 | while (1) { |
Denis Vlasenko | 2870301 | 2006-12-19 20:32:02 +0000 | [diff] [blame] | 669 | d->d_secpercyl = edit_int(d->d_nsectors * d->d_ntracks, |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 670 | "sectors/cylinder"); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 671 | if (d->d_secpercyl <= d->d_nsectors * d->d_ntracks) |
| 672 | break; |
| 673 | |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 674 | printf("Must be <= sectors/track * tracks/cylinder (default)\n"); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 675 | } |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 676 | d->d_rpm = edit_int(d->d_rpm , "rpm"); |
| 677 | d->d_interleave = edit_int(d->d_interleave, "interleave"); |
| 678 | d->d_trackskew = edit_int(d->d_trackskew , "trackskew"); |
| 679 | d->d_cylskew = edit_int(d->d_cylskew , "cylinderskew"); |
| 680 | d->d_headswitch = edit_int(d->d_headswitch, "headswitch"); |
| 681 | d->d_trkseek = edit_int(d->d_trkseek , "track-to-track seek"); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 682 | |
| 683 | d->d_secperunit = d->d_secpercyl * d->d_ncylinders; |
| 684 | } |
| 685 | |
| 686 | static int |
Denis Vlasenko | 2870301 | 2006-12-19 20:32:02 +0000 | [diff] [blame] | 687 | xbsd_get_bootstrap(char *path, void *ptr, int size) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 688 | { |
| 689 | int fdb; |
| 690 | |
Denis Vlasenko | 2870301 | 2006-12-19 20:32:02 +0000 | [diff] [blame] | 691 | fdb = open(path, O_RDONLY); |
| 692 | if (fdb < 0) { |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 693 | perror(path); |
| 694 | return 0; |
| 695 | } |
| 696 | if (read(fdb, ptr, size) < 0) { |
| 697 | perror(path); |
| 698 | close(fdb); |
| 699 | return 0; |
| 700 | } |
| 701 | printf(" ... %s\n", path); |
| 702 | close(fdb); |
| 703 | return 1; |
| 704 | } |
| 705 | |
| 706 | static void |
| 707 | sync_disks(void) |
| 708 | { |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 709 | printf("Syncing disks\n"); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 710 | sync(); |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 711 | /* sleep(4); What? */ |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 712 | } |
| 713 | |
| 714 | static void |
| 715 | xbsd_write_bootstrap(void) |
| 716 | { |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 717 | char path[MAXPATHLEN]; |
Denis Vlasenko | 06c0a71 | 2007-01-29 22:51:44 +0000 | [diff] [blame] | 718 | const char *bootdir = BSD_LINUX_BOOTDIR; |
| 719 | const char *dkbasename; |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 720 | struct xbsd_disklabel dl; |
| 721 | char *d, *p, *e; |
| 722 | int sector; |
| 723 | |
| 724 | if (xbsd_dlabel.d_type == BSD_DTYPE_SCSI) |
| 725 | dkbasename = "sd"; |
| 726 | else |
| 727 | dkbasename = "wd"; |
| 728 | |
Denis Vlasenko | 8e1c715 | 2007-01-22 07:21:38 +0000 | [diff] [blame] | 729 | snprintf(path, sizeof(path), "Bootstrap: %sboot -> boot%s (%s): ", |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 730 | dkbasename, dkbasename, dkbasename); |
Denis Vlasenko | 8e1c715 | 2007-01-22 07:21:38 +0000 | [diff] [blame] | 731 | if (read_line(path)) { |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 732 | dkbasename = line_ptr; |
| 733 | } |
| 734 | snprintf(path, sizeof(path), "%s/%sboot", bootdir, dkbasename); |
| 735 | if (!xbsd_get_bootstrap(path, disklabelbuffer, (int) xbsd_dlabel.d_secsize)) |
| 736 | return; |
| 737 | |
| 738 | /* We need a backup of the disklabel (xbsd_dlabel might have changed). */ |
| 739 | d = &disklabelbuffer[BSD_LABELSECTOR * SECTOR_SIZE]; |
| 740 | memmove(&dl, d, sizeof(struct xbsd_disklabel)); |
| 741 | |
| 742 | /* The disklabel will be overwritten by 0's from bootxx anyway */ |
| 743 | memset(d, 0, sizeof(struct xbsd_disklabel)); |
| 744 | |
| 745 | snprintf(path, sizeof(path), "%s/boot%s", bootdir, dkbasename); |
Denis Vlasenko | 93f6aa6 | 2006-11-30 21:11:01 +0000 | [diff] [blame] | 746 | if (!xbsd_get_bootstrap(path, &disklabelbuffer[xbsd_dlabel.d_secsize], |
Denis Vlasenko | 2870301 | 2006-12-19 20:32:02 +0000 | [diff] [blame] | 747 | (int) xbsd_dlabel.d_bbsize - xbsd_dlabel.d_secsize)) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 748 | return; |
| 749 | |
| 750 | e = d + sizeof(struct xbsd_disklabel); |
| 751 | for (p = d; p < e; p++) |
| 752 | if (*p) { |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 753 | printf("Bootstrap overlaps with disk label!\n"); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 754 | exit(EXIT_FAILURE); |
| 755 | } |
| 756 | |
| 757 | memmove(d, &dl, sizeof(struct xbsd_disklabel)); |
| 758 | |
Denis Vlasenko | 2870301 | 2006-12-19 20:32:02 +0000 | [diff] [blame] | 759 | #if defined(__powerpc__) || defined(__hppa__) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 760 | sector = 0; |
Denis Vlasenko | 2870301 | 2006-12-19 20:32:02 +0000 | [diff] [blame] | 761 | #elif defined(__alpha__) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 762 | sector = 0; |
| 763 | alpha_bootblock_checksum(disklabelbuffer); |
| 764 | #else |
| 765 | sector = get_start_sect(xbsd_part); |
| 766 | #endif |
| 767 | |
Denis Vlasenko | 4437d19 | 2008-04-17 00:12:10 +0000 | [diff] [blame] | 768 | if (lseek(dev_fd, sector * SECTOR_SIZE, SEEK_SET) == -1) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 769 | fdisk_fatal(unable_to_seek); |
Denis Vlasenko | 4437d19 | 2008-04-17 00:12:10 +0000 | [diff] [blame] | 770 | if (BSD_BBSIZE != write(dev_fd, disklabelbuffer, BSD_BBSIZE)) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 771 | fdisk_fatal(unable_to_write); |
| 772 | |
Denis Vlasenko | 2870301 | 2006-12-19 20:32:02 +0000 | [diff] [blame] | 773 | #if defined(__alpha__) |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 774 | printf("Bootstrap installed on %s\n", disk_device); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 775 | #else |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 776 | printf("Bootstrap installed on %s\n", |
Denis Vlasenko | 2870301 | 2006-12-19 20:32:02 +0000 | [diff] [blame] | 777 | partname(disk_device, xbsd_part_index+1, 0)); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 778 | #endif |
| 779 | |
| 780 | sync_disks(); |
| 781 | } |
| 782 | |
| 783 | static void |
| 784 | xbsd_change_fstype(void) |
| 785 | { |
| 786 | int i; |
| 787 | |
| 788 | i = xbsd_get_part_index(xbsd_dlabel.d_npartitions); |
| 789 | xbsd_dlabel.d_partitions[i].p_fstype = read_hex(xbsd_fstypes); |
| 790 | } |
| 791 | |
| 792 | static int |
| 793 | xbsd_get_part_index(int max) |
| 794 | { |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 795 | char prompt[sizeof("Partition (a-%c): ") + 16]; |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 796 | char l; |
| 797 | |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 798 | snprintf(prompt, sizeof(prompt), "Partition (a-%c): ", 'a' + max - 1); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 799 | do |
| 800 | l = tolower(read_nonempty(prompt)); |
| 801 | while (l < 'a' || l > 'a' + max - 1); |
| 802 | return l - 'a'; |
| 803 | } |
| 804 | |
| 805 | static int |
| 806 | xbsd_check_new_partition(int *i) |
| 807 | { |
| 808 | /* room for more? various BSD flavours have different maxima */ |
| 809 | if (xbsd_dlabel.d_npartitions == BSD_MAXPARTITIONS) { |
| 810 | int t; |
| 811 | |
| 812 | for (t = 0; t < BSD_MAXPARTITIONS; t++) |
| 813 | if (xbsd_dlabel.d_partitions[t].p_size == 0) |
| 814 | break; |
| 815 | |
| 816 | if (t == BSD_MAXPARTITIONS) { |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 817 | printf("The maximum number of partitions has been created\n"); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 818 | return 0; |
| 819 | } |
| 820 | } |
| 821 | |
Denis Vlasenko | 2870301 | 2006-12-19 20:32:02 +0000 | [diff] [blame] | 822 | *i = xbsd_get_part_index(BSD_MAXPARTITIONS); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 823 | |
| 824 | if (*i >= xbsd_dlabel.d_npartitions) |
| 825 | xbsd_dlabel.d_npartitions = (*i) + 1; |
| 826 | |
| 827 | if (xbsd_dlabel.d_partitions[*i].p_size != 0) { |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 828 | printf("This partition already exists\n"); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 829 | return 0; |
| 830 | } |
| 831 | |
| 832 | return 1; |
| 833 | } |
| 834 | |
| 835 | static void |
| 836 | xbsd_list_types(void) |
| 837 | { |
| 838 | list_types(xbsd_fstypes); |
| 839 | } |
| 840 | |
Denis Vlasenko | 2870301 | 2006-12-19 20:32:02 +0000 | [diff] [blame] | 841 | static uint16_t |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 842 | xbsd_dkcksum(struct xbsd_disklabel *lp) |
| 843 | { |
Denis Vlasenko | 2870301 | 2006-12-19 20:32:02 +0000 | [diff] [blame] | 844 | uint16_t *start, *end; |
| 845 | uint16_t sum = 0; |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 846 | |
Denis Vlasenko | 2870301 | 2006-12-19 20:32:02 +0000 | [diff] [blame] | 847 | start = (uint16_t *) lp; |
| 848 | end = (uint16_t *) &lp->d_partitions[lp->d_npartitions]; |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 849 | while (start < end) |
| 850 | sum ^= *start++; |
| 851 | return sum; |
| 852 | } |
| 853 | |
| 854 | static int |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 855 | xbsd_initlabel(struct partition *p) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 856 | { |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 857 | struct xbsd_disklabel *d = &xbsd_dlabel; |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 858 | struct xbsd_partition *pp; |
| 859 | |
| 860 | get_geometry(); |
| 861 | memset(d, 0, sizeof(struct xbsd_disklabel)); |
| 862 | |
| 863 | d->d_magic = BSD_DISKMAGIC; |
| 864 | |
| 865 | if (strncmp(disk_device, "/dev/sd", 7) == 0) |
| 866 | d->d_type = BSD_DTYPE_SCSI; |
| 867 | else |
| 868 | d->d_type = BSD_DTYPE_ST506; |
| 869 | |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 870 | #if !defined(__alpha__) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 871 | d->d_flags = BSD_D_DOSPART; |
| 872 | #else |
| 873 | d->d_flags = 0; |
| 874 | #endif |
| 875 | d->d_secsize = SECTOR_SIZE; /* bytes/sector */ |
Denis Vlasenko | f77f369 | 2007-12-16 17:22:33 +0000 | [diff] [blame] | 876 | d->d_nsectors = g_sectors; /* sectors/track */ |
| 877 | d->d_ntracks = g_heads; /* tracks/cylinder (heads) */ |
| 878 | d->d_ncylinders = g_cylinders; |
| 879 | d->d_secpercyl = g_sectors * g_heads;/* sectors/cylinder */ |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 880 | if (d->d_secpercyl == 0) |
| 881 | d->d_secpercyl = 1; /* avoid segfaults */ |
| 882 | d->d_secperunit = d->d_secpercyl * d->d_ncylinders; |
| 883 | |
| 884 | d->d_rpm = 3600; |
| 885 | d->d_interleave = 1; |
| 886 | d->d_trackskew = 0; |
| 887 | d->d_cylskew = 0; |
| 888 | d->d_headswitch = 0; |
| 889 | d->d_trkseek = 0; |
| 890 | |
| 891 | d->d_magic2 = BSD_DISKMAGIC; |
| 892 | d->d_bbsize = BSD_BBSIZE; |
| 893 | d->d_sbsize = BSD_SBSIZE; |
| 894 | |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 895 | #if !defined(__alpha__) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 896 | d->d_npartitions = 4; |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 897 | pp = &d->d_partitions[2]; /* Partition C should be NetBSD partition */ |
| 898 | |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 899 | pp->p_offset = get_start_sect(p); |
| 900 | pp->p_size = get_nr_sects(p); |
| 901 | pp->p_fstype = BSD_FS_UNUSED; |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 902 | pp = &d->d_partitions[3]; /* Partition D should be whole disk */ |
| 903 | |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 904 | pp->p_offset = 0; |
| 905 | pp->p_size = d->d_secperunit; |
| 906 | pp->p_fstype = BSD_FS_UNUSED; |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 907 | #else |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 908 | d->d_npartitions = 3; |
| 909 | pp = &d->d_partitions[2]; /* Partition C should be |
| 910 | the whole disk */ |
| 911 | pp->p_offset = 0; |
| 912 | pp->p_size = d->d_secperunit; |
| 913 | pp->p_fstype = BSD_FS_UNUSED; |
| 914 | #endif |
| 915 | |
| 916 | return 1; |
| 917 | } |
| 918 | |
| 919 | /* |
| 920 | * Read a xbsd_disklabel from sector 0 or from the starting sector of p. |
| 921 | * If it has the right magic, return 1. |
| 922 | */ |
| 923 | static int |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 924 | xbsd_readlabel(struct partition *p) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 925 | { |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 926 | struct xbsd_disklabel *d; |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 927 | int t, sector; |
| 928 | |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 929 | if (!bsd_globals_ptr) |
| 930 | bsd_globals_ptr = xzalloc(sizeof(*bsd_globals_ptr)); |
| 931 | |
| 932 | d = &xbsd_dlabel; |
Denis Vlasenko | d547083 | 2007-01-03 02:58:54 +0000 | [diff] [blame] | 933 | |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 934 | /* p is used only to get the starting sector */ |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 935 | #if !defined(__alpha__) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 936 | sector = (p ? get_start_sect(p) : 0); |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 937 | #else |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 938 | sector = 0; |
| 939 | #endif |
| 940 | |
Denis Vlasenko | 4437d19 | 2008-04-17 00:12:10 +0000 | [diff] [blame] | 941 | if (lseek(dev_fd, sector * SECTOR_SIZE, SEEK_SET) == -1) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 942 | fdisk_fatal(unable_to_seek); |
Denis Vlasenko | 4437d19 | 2008-04-17 00:12:10 +0000 | [diff] [blame] | 943 | if (BSD_BBSIZE != read(dev_fd, disklabelbuffer, BSD_BBSIZE)) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 944 | fdisk_fatal(unable_to_read); |
| 945 | |
| 946 | memmove(d, &disklabelbuffer[BSD_LABELSECTOR * SECTOR_SIZE + BSD_LABELOFFSET], |
| 947 | sizeof(struct xbsd_disklabel)); |
| 948 | |
| 949 | if (d->d_magic != BSD_DISKMAGIC || d->d_magic2 != BSD_DISKMAGIC) |
| 950 | return 0; |
| 951 | |
| 952 | for (t = d->d_npartitions; t < BSD_MAXPARTITIONS; t++) { |
| 953 | d->d_partitions[t].p_size = 0; |
| 954 | d->d_partitions[t].p_offset = 0; |
| 955 | d->d_partitions[t].p_fstype = BSD_FS_UNUSED; |
| 956 | } |
| 957 | |
| 958 | if (d->d_npartitions > BSD_MAXPARTITIONS) |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 959 | printf("Warning: too many partitions (%d, maximum is %d)\n", |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 960 | d->d_npartitions, BSD_MAXPARTITIONS); |
| 961 | return 1; |
| 962 | } |
| 963 | |
| 964 | static int |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 965 | xbsd_writelabel(struct partition *p) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 966 | { |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 967 | struct xbsd_disklabel *d = &xbsd_dlabel; |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 968 | unsigned int sector; |
| 969 | |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 970 | #if !defined(__alpha__) && !defined(__powerpc__) && !defined(__hppa__) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 971 | sector = get_start_sect(p) + BSD_LABELSECTOR; |
| 972 | #else |
| 973 | sector = BSD_LABELSECTOR; |
| 974 | #endif |
| 975 | |
| 976 | d->d_checksum = 0; |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 977 | d->d_checksum = xbsd_dkcksum(d); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 978 | |
| 979 | /* This is necessary if we want to write the bootstrap later, |
| 980 | otherwise we'd write the old disklabel with the bootstrap. |
| 981 | */ |
| 982 | memmove(&disklabelbuffer[BSD_LABELSECTOR * SECTOR_SIZE + BSD_LABELOFFSET], |
| 983 | d, sizeof(struct xbsd_disklabel)); |
| 984 | |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 985 | #if defined(__alpha__) && BSD_LABELSECTOR == 0 |
Denis Vlasenko | 93f6aa6 | 2006-11-30 21:11:01 +0000 | [diff] [blame] | 986 | alpha_bootblock_checksum(disklabelbuffer); |
Denis Vlasenko | 4437d19 | 2008-04-17 00:12:10 +0000 | [diff] [blame] | 987 | if (lseek(dev_fd, 0, SEEK_SET) == -1) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 988 | fdisk_fatal(unable_to_seek); |
Denis Vlasenko | 4437d19 | 2008-04-17 00:12:10 +0000 | [diff] [blame] | 989 | if (BSD_BBSIZE != write(dev_fd, disklabelbuffer, BSD_BBSIZE)) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 990 | fdisk_fatal(unable_to_write); |
| 991 | #else |
Denis Vlasenko | 4437d19 | 2008-04-17 00:12:10 +0000 | [diff] [blame] | 992 | if (lseek(dev_fd, sector * SECTOR_SIZE + BSD_LABELOFFSET, SEEK_SET) == -1) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 993 | fdisk_fatal(unable_to_seek); |
Denis Vlasenko | 4437d19 | 2008-04-17 00:12:10 +0000 | [diff] [blame] | 994 | if (sizeof(struct xbsd_disklabel) != write(dev_fd, d, sizeof(struct xbsd_disklabel))) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 995 | fdisk_fatal(unable_to_write); |
| 996 | #endif |
| 997 | sync_disks(); |
| 998 | return 1; |
| 999 | } |
| 1000 | |
| 1001 | |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 1002 | #if !defined(__alpha__) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 1003 | static int |
| 1004 | xbsd_translate_fstype(int linux_type) |
| 1005 | { |
| 1006 | switch (linux_type) { |
| 1007 | case 0x01: /* DOS 12-bit FAT */ |
| 1008 | case 0x04: /* DOS 16-bit <32M */ |
| 1009 | case 0x06: /* DOS 16-bit >=32M */ |
| 1010 | case 0xe1: /* DOS access */ |
| 1011 | case 0xe3: /* DOS R/O */ |
| 1012 | case 0xf2: /* DOS secondary */ |
| 1013 | return BSD_FS_MSDOS; |
| 1014 | case 0x07: /* OS/2 HPFS */ |
| 1015 | return BSD_FS_HPFS; |
| 1016 | default: |
| 1017 | return BSD_FS_OTHER; |
| 1018 | } |
| 1019 | } |
| 1020 | |
| 1021 | static void |
| 1022 | xbsd_link_part(void) |
| 1023 | { |
| 1024 | int k, i; |
| 1025 | struct partition *p; |
| 1026 | |
Denis Vlasenko | f77f369 | 2007-12-16 17:22:33 +0000 | [diff] [blame] | 1027 | k = get_partition(1, g_partitions); |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 1028 | |
| 1029 | if (!xbsd_check_new_partition(&i)) |
| 1030 | return; |
| 1031 | |
| 1032 | p = get_part_table(k); |
| 1033 | |
| 1034 | xbsd_dlabel.d_partitions[i].p_size = get_nr_sects(p); |
| 1035 | xbsd_dlabel.d_partitions[i].p_offset = get_start_sect(p); |
| 1036 | xbsd_dlabel.d_partitions[i].p_fstype = xbsd_translate_fstype(p->sys_ind); |
| 1037 | } |
| 1038 | #endif |
| 1039 | |
Denis Vlasenko | 2a85676 | 2007-01-02 16:45:05 +0000 | [diff] [blame] | 1040 | #if defined(__alpha__) |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 1041 | static void |
| 1042 | alpha_bootblock_checksum(char *boot) |
| 1043 | { |
| 1044 | uint64_t *dp, sum; |
| 1045 | int i; |
| 1046 | |
| 1047 | dp = (uint64_t *)boot; |
| 1048 | sum = 0; |
| 1049 | for (i = 0; i < 63; i++) |
| 1050 | sum += dp[i]; |
| 1051 | dp[63] = sum; |
| 1052 | } |
| 1053 | #endif /* __alpha__ */ |
| 1054 | |
Denis Vlasenko | bd85207 | 2007-03-19 14:43:38 +0000 | [diff] [blame] | 1055 | /* Undefine 'global' tricks */ |
| 1056 | #undef disklabelbuffer |
| 1057 | #undef xbsd_dlabel |
| 1058 | |
Denis Vlasenko | 98ae216 | 2006-10-12 19:30:44 +0000 | [diff] [blame] | 1059 | #endif /* OSF_LABEL */ |