distrib/utils/sysinst/arch/x68k/md.c

   1 /*      $NetBSD: md.c,v 1.37 2009/09/19 14:57:30 abs Exp $ */
   2
   3 /*
   4  * Copyright 1997 Piermont Information Systems Inc.
   5  * All rights reserved.
   6  *
   7  * Based on code written by Philip A. Nelson for Piermont Information
   8  * Systems Inc.  Modified by Minoura Makoto for x68k.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. All advertising materials mentioning features or use of this software
  19  *    must display the following acknowledgement:
  20  *      This product includes software developed for the NetBSD Project by
  21  *      Piermont Information Systems Inc.
  22  * 4. The name of Piermont Information Systems Inc. may not be used to endorse
  23  *    or promote products derived from this software without specific prior
  24  *    written permission.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY PIERMONT INFORMATION SYSTEMS INC. ``AS IS''
  27  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29  * ARE DISCLAIMED. IN NO EVENT SHALL PIERMONT INFORMATION SYSTEMS INC. BE
  30  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  36  * THE POSSIBILITY OF SUCH DAMAGE.
  37  */
  38
  39 /* md.c -- x68k machine specific routines */
  40 /* This file is in close sync with pmax, sparc, and vax md.c */
  41
  42 #include <stdio.h>
  43 #include <unistd.h>
  44 #include <sys/disklabel.h>
  45 #include <sys/ioctl.h>
  46 #include <sys/param.h>
  47 #include <util.h>
  48
  49 #include "defs.h"
  50 #include "md.h"
  51 #include "msg_defs.h"
  52 #include "menu_defs.h"
  53
  54 #ifdef notyet
  55 #undef NDOSPART 8
  56 #define NDOSPART 16
  57 typedef struct parttab {
  58         struct dos_partition dosparts[NDOSPART];
  59 } parttab;
  60
  61 parttab md_disklabel;
  62 int md_freepart;
  63 int md_nfreepart;
  64 #endif /* notyet */
  65
  66 int md_need_newdisk = 0;
  67
  68 /* prototypes */
  69 static int md_newdisk(void);
  70
  71 void
  72 md_init(void)
  73 {
  74 }
  75
  76 void
  77 md_init_set_status(int minimal)
  78 {
  79         (void)minimal;
  80 }
  81
  82 int
  83 md_get_info(void)
  84 {
  85         char buf[1024];
  86         int fd;
  87         char dev_name[100];
  88         struct disklabel disklabel;
  89
  90         snprintf(dev_name, 100, "/dev/r%sc", diskdev);
  91
  92         fd = open(dev_name, O_RDONLY, 0);
  93         if (fd < 0) {
  94                 if (logging)
  95                         (void)fprintf(logfp, "Can't open %s\n", dev_name);
  96                 endwin();
  97                 fprintf(stderr, "Can't open %s\n", dev_name);
  98                 exit(1);
  99         }
 100         if (ioctl(fd, DIOCGDINFO, &disklabel) == -1) {
 101                 if (logging)
 102                         (void)fprintf(logfp, "Can't read disklabel on %s.\n",
 103                                 dev_name);
 104                 endwin();
 105                 fprintf(stderr, "Can't read disklabel on %s.\n", dev_name);
 106                 close(fd);
 107                 exit(1);
 108         }
 109         if (disklabel.d_secsize != 512) {
 110                 endwin();
 111                 fprintf(stderr, "Non-512byte/sector disk is not supported.\n");
 112                 close(fd);
 113                 exit(1);
 114         }
 115
 116         dlcyl = disklabel.d_ncylinders;
 117         dlhead = disklabel.d_ntracks;
 118         dlsec = disklabel.d_nsectors;
 119         sectorsize = disklabel.d_secsize;
 120         dlcylsize = disklabel.d_secpercyl;
 121         dlsize = dlcyl*dlhead*dlsec;
 122
 123         if (read(fd, buf, 1024) < 0) {
 124                 endwin();
 125                 fprintf(stderr, "Can't read %s\n", dev_name);
 126                 close(fd);
 127                 exit(1);
 128         }
 129         if (memcmp(buf, "X68SCSI1", 8) != 0)
 130                 md_need_newdisk = 1;
 131 #ifdef notyet
 132         else
 133                 if (read(fd, md_disklabel, sizeof(md_disklabel)) < 0) {
 134                         endwin();
 135                         fprintf(stderr, "Can't read %s\n", dev_name);
 136                         close(fd);
 137                         exit(1);
 138                 }
 139 #endif
 140         /* preserve first 64 sectors for system. */
 141         ptstart = 64;
 142
 143         /* preserve existing partitions? */
 144
 145         close(fd);
 146
 147         return 1;
 148 }
 149
 150 /*
 151  * md back-end code for menu-driven BSD disklabel editor.
 152  */
 153 int
 154 md_make_bsd_partitions(void)
 155 {
 156         return(make_bsd_partitions());
 157 }
 158
 159 /*
 160  * any additional partition validation
 161  */
 162 int
 163 md_check_partitions(void)
 164 {
 165         /* X68k partitions must be in order of the range. */
 166         int part, last = PART_A-1;
 167         uint32_t start = 0;
 168
 169         for (part = PART_A; part < 8; part++) {
 170                 if (part == PART_C)
 171                         continue;
 172                 if (last >= PART_A && bsdlabel[part].pi_size > 0) {
 173                         msg_display(MSG_emptypart, part+'a');
 174                         process_menu(MENU_ok, NULL);
 175                         return 0;
 176                 }
 177                 if (bsdlabel[part].pi_size == 0) {
 178                         if (last < PART_A)
 179                                 last = part;
 180                 } else {
 181                         if (start >= bsdlabel[part].pi_offset) {
 182                                 msg_display(MSG_ordering, part+'a');
 183                                 process_menu(MENU_yesno, NULL);
 184                                 if (yesno)
 185                                         return 0;
 186                         }
 187                         start = bsdlabel[part].pi_offset;
 188                 }
 189         }
 190
 191         return 1;
 192 }
 193
 194 #ifdef notyet
 195 static int
 196 md_check_partitions(void)
 197 {
 198         int i, j;
 199         int preserve;
 200
 201         /* check existing BSD partitions. */
 202         for (i = 0; i < NDOSPART; i++) {
 203                 if (md_disklabel.dosparts[i].dp_size == 0)
 204                         break;
 205                 if (memcmp(md_disklabel.dosparts[i].dp_typename, "Human68k", 8)) {
 206                         msg_display(MSG_existing);
 207                         process_menu(MENU_noyes);
 208                         preserve = yesno;
 209                         break;
 210                 }
 211         }
 212         emptylabel(bsdlabel);
 213         bsdlabel[C].pi_fstype = FS_UNUSED;
 214         bsdlabel[C].pi_offset = 0;
 215         bsdlabel[C].pi_size = dlsize;
 216         for (i = 0, j = A; i < NDOSPART;) {
 217                 if (j == C) {
 218                         j++;
 219                         continue;
 220                 }
 221                 if (!preserve &&
 222                     memcmp(md_disklabel.dosparts[i].dp_typename,
 223                             "Human68k", 8)) {
 224                         /* discard it. */
 225                         i++;
 226                         continue;
 227                 }
 228                 bsdlabel[j].pi_fstype = (i == 1) ? FS_SWAP : FS_BSDFFS;
 229                 bsdlabel[j].pi_offset = md_disklabel.dosparts[i].dp_start*2;
 230                 bsdlabel[j].pi_size = md_disklabel.dosparts[i].dp_size*2;
 231                 i++;
 232                 j++;
 233         }
 234         if (j > 6) {
 235                 msg_display(MSG_nofreepart, diskdev);
 236                 return 0;
 237         }
 238         md_nfreepart = 8 - j;
 239
 240         /* check for free space */
 241         fsptsize = bsdlabel[A].pi_offset - 64;
 242         if (fptsize <= 0) {     /* XXX: should not be 0; minfsdb?  */
 243                 msg_display(MSG_notfirst, diskdev);
 244                 process_menu(MENU_ok);
 245                 exit(1);
 246         }
 247
 248         /* Partitions should be preserved in md_make_bsdpartitions() */
 249 }
 250 #endif /* notyet */
 251
 252 /*
 253  * hook called before writing new disklabel.
 254  */
 255 int
 256 md_pre_disklabel(void)
 257 {
 258         if (md_need_newdisk)
 259                 md_newdisk ();
 260         return 0;
 261 }
 262
 263 /*
 264  * hook called after writing disklabel to new target disk.
 265  */
 266 int
 267 md_post_disklabel(void)
 268 {
 269         if (get_ramsize() < 6)
 270                 set_swap(diskdev, bsdlabel);
 271         return 0;
 272 }
 273
 274 /*
 275  * hook called after upgrade() or install() has finished setting
 276  * up the target disk but immediately before the user is given the
 277  * ``disks are now set up'' message.
 278  *
 279  * On the x68k, we use this opportunity to install the boot blocks.
 280  */
 281 int
 282 md_post_newfs(void)
 283 {
 284         /* boot blocks ... */
 285         msg_display(MSG_dobootblks, diskdev);
 286         cp_to_target("/usr/mdec/boot", "/boot");
 287         if (run_program(RUN_DISPLAY | RUN_NO_CLEAR,
 288             "/usr/mdec/installboot.new /usr/mdec/sdboot_ufs /dev/r%sa",
 289             diskdev))
 290                 process_menu(MENU_ok,
 291                         deconst("Warning: disk is probably not bootable"));
 292         return 0;
 293 }
 294
 295 int
 296 md_post_extract(void)
 297 {
 298         return 0;
 299 }
 300
 301 void
 302 md_cleanup_install(void)
 303 {
 304 #ifdef notyet                   /* sed is too large for ramdisk */
 305         enable_rc_conf();
 306 #endif
 307 }
 308
 309 int
 310 md_pre_update(void)
 311 {
 312         if (get_ramsize() < 6)
 313                 set_swap(diskdev, NULL);
 314         return 1;
 315 }
 316
 317 /* Upgrade support */
 318 int
 319 md_update(void)
 320 {
 321         md_post_newfs();
 322         return 1;
 323 }
 324
 325 static int
 326 md_newdisk(void)
 327 {
 328         msg_display(MSG_newdisk, diskdev, diskdev);
 329
 330         return run_program(RUN_FATAL|RUN_DISPLAY,
 331             "/usr/mdec/newdisk -v %s", diskdev);
 332 }
 333