usr.sbin/installer/dfuibe_installer/fn_install.c

   1 /*
   2  * Copyright (c)2004,2015 The DragonFly Project.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  *   Redistributions of source code must retain the above copyright
   9  *   notice, this list of conditions and the following disclaimer.
  10  *
  11  *   Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in
  13  *   the documentation and/or other materials provided with the
  14  *   distribution.
  15  *
  16  *   Neither the name of the DragonFly Project nor the names of its
  17  *   contributors may be used to endorse or promote products derived
  18  *   from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  23  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  24  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  25  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  26  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  27  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  29  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  31  * OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 /*
  35  * fn_install.c
  36  * Installer Function : Install OS Files.
  37  * $Id: fn_install.c,v 1.74 2006/04/18 19:43:48 joerg Exp $
  38  */
  39
  40 #include <libgen.h>
  41 #include <string.h>
  42
  43 #define SOURCES_CONF_FILE "usr/share/installer/sources.conf"
  44
  45 #ifdef ENABLE_NLS
  46 #include <libintl.h>
  47 #define _(String) gettext (String)
  48 #else
  49 #define _(String) (String)
  50 #endif
  51
  52 #include "libaura/mem.h"
  53 #include "libaura/buffer.h"
  54 #include "libaura/fspred.h"
  55
  56 #include "libdfui/dfui.h"
  57 #include "libdfui/system.h"
  58
  59 #include "libinstaller/commands.h"
  60 #include "libinstaller/confed.h"
  61 #include "libinstaller/diskutil.h"
  62 #include "libinstaller/functions.h"
  63 #include "libinstaller/uiutil.h"
  64
  65 #include "flow.h"
  66 #include "pathnames.h"
  67 #include "fn.h"
  68
  69 /*
  70  * NOTE: Even though /var/run doesn't need to be backed up, nearly all
  71  *       services depend on it so it is best to leave it on the root.
  72  */
  73 static const char *nullfs_mountpt[] = {
  74         "/usr/obj", "/var/crash", "/var/cache",
  75         "/var/spool", "/var/log", "/var/tmp",
  76         NULL };
  77 static const char *nullfs_mountname[] = {
  78         "/build/usr.obj", "/build/var.crash", "/build/var.cache",
  79         "/build/var.spool", "/build/var.log", "/build/var.tmp",
  80         NULL };
  81
  82 static void
  83 handle_altfs(struct i_fn_args *a, struct commands *cmds)
  84 {
  85         int i;
  86
  87         /*
  88          * Create directories for null mounts if not specified as a partition.
  89          * (null mounts are from /build)
  90          */
  91         for (i = 0; nullfs_mountpt[i]; ++i) {
  92                 if (subpartition_find(storage_get_selected_slice(a->s), "%s", nullfs_mountpt[i]) != NULL)
  93                         continue;
  94
  95                 /*
  96                  * Create directory infrastructure for null-mount if
  97                  * necessary, then issue the null mount(s).
  98                  */
  99                 command_add(cmds, "%s%s -p %smnt%s",
 100                             a->os_root, cmd_name(a, "MKDIR"),
 101                             a->os_root, nullfs_mountname[i]);
 102                 command_add(cmds, "%s%s -p %smnt%s",
 103                             a->os_root, cmd_name(a, "MKDIR"),
 104                             a->os_root, nullfs_mountpt[i]);
 105                 command_add(cmds, "%s%s %smnt%s %smnt%s",
 106                     a->os_root, cmd_name(a, "MOUNT_NULL"),
 107                     a->os_root, nullfs_mountname[i],
 108                     a->os_root, nullfs_mountpt[i]);
 109         }
 110
 111         /*
 112          * Create directory for /tmp and tmpfs mount if not specified as
 113          * a partition.
 114          */
 115         if (subpartition_find(storage_get_selected_slice(a->s), "%s", "/tmp") == NULL) {
 116                 command_add(cmds, "%s%s -p %smnt/tmp",
 117                             a->os_root, cmd_name(a, "MKDIR"), a->os_root);
 118                 command_add(cmds, "%s%s 1777 %smnt/tmp",
 119                             a->os_root, cmd_name(a, "CHMOD"), a->os_root);
 120                 command_add(cmds, "%s%s dummy %smnt/tmp",
 121                             a->os_root, cmd_name(a, "MOUNT_TMPFS"), a->os_root);
 122         }
 123 }
 124
 125 static void
 126 unmount_altfs(struct i_fn_args *a __unused, struct commands *cmds __unused)
 127 {
 128         return;
 129 #if 0
 130         int i;
 131
 132         /*
 133          * Unmount null mounts
 134          */
 135         i = sizeof(nullfs_mountpt) / sizeof(nullfs_mountpt[0]) - 1;
 136         while (i >= 0) {
 137                 if (subpartition_find(storage_get_selected_slice(a->s), "%s", nullfs_mountpt[i]) != NULL)
 138                         continue;
 139
 140                 /*
 141                  * Create directory infrastructure for null-mount if
 142                  * necessary, then issue the null mount(s).
 143                  */
 144                 command_add(cmds, "%s%s %smnt%s",
 145                             a->os_root, cmd_name(a, "UMOUNT"),
 146                             a->os_root, nullfs_mountpt[i]);
 147                 --i;
 148         }
 149
 150         /*
 151          * Unmount tmpfs mounts
 152          */
 153         if (subpartition_find(storage_get_selected_slice(a->s), "%s", "/tmp") == NULL) {
 154                 command_add(cmds, "%s%s -p %smnt%s",
 155                             a->os_root, cmd_name(a, "UMOUNT"),
 156                             a->os_root, "/tmp");
 157         }
 158 #endif
 159 }
 160
 161 /*
 162  * fn_install_os: actually put DragonFly on a disk.
 163  */
 164 void
 165 fn_install_os(struct i_fn_args *a)
 166 {
 167         struct subpartition *sp, *spnext;
 168         struct commands *cmds;
 169         struct command *cmd;
 170         int i, seen_it, prefix, j, needcrypt;
 171         FILE *sources_conf;
 172         char line[256];
 173         char cp_src[64][256];
 174         char file_path[256];
 175         char *string;
 176         int lines = 0;
 177         int nfsidx;
 178
 179         /*
 180          * Read SOURCES_CONF_FILE and populate our copy sources.
 181          */
 182         snprintf(file_path, 256, "%s%s", a->os_root, SOURCES_CONF_FILE);
 183         sources_conf = fopen(file_path, "r");
 184         i_log(a, "Reading %s", file_path);
 185         while(fgets(line, 256, sources_conf) != NULL && lines < 63) {
 186                 if(strlen(line)>0)
 187                         line[strlen(line)-1] = '\0';
 188                 strlcpy(cp_src[lines], line, 256);
 189                 i_log(a,"Adding %s to copy source table.", cp_src[lines]);
 190                 lines++;
 191         }
 192         i_log(a,"Added %i total items to copy source table.", lines);
 193         strcpy(cp_src[lines], "");
 194         fclose(sources_conf);
 195
 196         cmds = commands_new();
 197
 198         /*
 199          * If swap isn't mounted yet, mount it.
 200          */
 201         if (measure_activated_swap(a) == 0) {
 202                 for (sp = slice_subpartition_first(storage_get_selected_slice(a->s));
 203                     sp != NULL; sp = subpartition_next(sp)) {
 204                         if (!subpartition_is_swap(sp))
 205                                 continue;
 206                         command_add(cmds, "%s%s /dev/%s",
 207                             a->os_root,
 208                             cmd_name(a, "SWAPON"),
 209                             subpartition_is_encrypted(sp) ?
 210                             "mapper/swap" : subpartition_get_device_name(sp));
 211                 }
 212         }
 213
 214         /*
 215          * Unmount anything already mounted on /mnt.
 216          */
 217         unmount_altfs(a, cmds);
 218         unmount_all_under(a, cmds, "%smnt", a->os_root);
 219
 220         /* Check if crypto support is needed */
 221         needcrypt = 0;
 222         for (sp = slice_subpartition_first(storage_get_selected_slice(a->s));
 223              sp != NULL; sp = subpartition_next(sp)) {
 224                 if (subpartition_is_encrypted(sp)) {
 225                         needcrypt = 1;
 226                         break;
 227                 }
 228         }
 229
 230         for (sp = slice_subpartition_first(storage_get_selected_slice(a->s));
 231              sp != NULL; sp = subpartition_next(sp)) {
 232                 if (strcmp(subpartition_get_mountpoint(sp), "/") == 0 ||
 233                     strcmp(subpartition_get_mountpoint(sp), "/build") == 0) {
 234                         /* make sure mountpoint directory exists */
 235                         command_add(cmds, "%s%s -p %smnt%s",
 236                                     a->os_root, cmd_name(a, "MKDIR"),
 237                                     a->os_root,
 238                                     subpartition_get_mountpoint(sp));
 239                         if (use_hammer == 1) {
 240                                 command_add(cmds, "%s%s /dev/%s %smnt%s",
 241                                     a->os_root, cmd_name(a, "MOUNT_HAMMER"),
 242                                     (subpartition_is_encrypted(sp) ?
 243                                      fn_mapper_name(subpartition_get_device_name(sp), 0) : subpartition_get_device_name(sp)),
 244                                     a->os_root,
 245                                     subpartition_get_mountpoint(sp));
 246                         } else {
 247                                 command_add(cmds, "%s%s /dev/%s %smnt%s",
 248                                     a->os_root, cmd_name(a, "MOUNT"),
 249                                     subpartition_is_encrypted(sp) ?
 250                                      fn_mapper_name(subpartition_get_device_name(sp), 0) : subpartition_get_device_name(sp),
 251                                     a->os_root,
 252                                     subpartition_get_mountpoint(sp));
 253                         }
 254                 }
 255         }
 256
 257         /*
 258          * Create mount points and mount subpartitions on them.
 259          */
 260         for (sp = slice_subpartition_first(storage_get_selected_slice(a->s));
 261              sp != NULL; sp = subpartition_next(sp)) {
 262                 if (subpartition_is_swap(sp)) {
 263                         /*
 264                          * Set this subpartition as the dump device.
 265                          */
 266                         command_add(cmds, "%s%s -v /dev/%s",
 267                             a->os_root, cmd_name(a, "DUMPON"),
 268                             subpartition_is_encrypted(sp) ?
 269                             "mapper/swap" : subpartition_get_device_name(sp));
 270
 271                         asprintf(&string, "/dev/%s",
 272                             subpartition_is_encrypted(sp) ?
 273                             "mapper/swap" : subpartition_get_device_name(sp));
 274                         config_var_set(rc_conf, "dumpdev", string);
 275                         free(string);
 276                         continue;
 277                 }
 278
 279                 /*
 280                  * mount everything except / and /build (which have already
 281                  * been mounted).  This should also get /boot.
 282                  */
 283                 if (strcmp(subpartition_get_mountpoint(sp), "/") != 0 &&
 284                     strcmp(subpartition_get_mountpoint(sp), "/build") != 0) {
 285                         /* make sure mountpoint directory exists */
 286                         command_add(cmds, "%s%s -p %smnt%s",
 287                             a->os_root, cmd_name(a, "MKDIR"),
 288                             a->os_root,
 289                             subpartition_get_mountpoint(sp));
 290                         /* Don't mount it if it's TMPFS-backed. */
 291                         if (subpartition_is_tmpfsbacked(sp))
 292                                 continue;
 293                         if (subpartition_is_encrypted(sp)) {
 294                                 command_add(cmds, "%s%s /dev/%s %smnt%s",
 295                                     a->os_root, cmd_name(a, "MOUNT"),
 296                                     fn_mapper_name(subpartition_get_device_name(sp), 0),
 297                                     a->os_root,
 298                                     subpartition_get_mountpoint(sp));
 299                         } else {
 300                                 command_add(cmds, "%s%s /dev/%s %smnt%s",
 301                                     a->os_root, cmd_name(a, "MOUNT"),
 302                                     subpartition_get_device_name(sp),
 303                                     a->os_root,
 304                                     subpartition_get_mountpoint(sp));
 305                         }
 306                 }
 307         }
 308
 309         /*
 310          * Take care of tmpfs and null-mounts from /build
 311          */
 312         handle_altfs(a, cmds);
 313
 314         /*
 315          * Actually copy files now.
 316          */
 317         for (i = 0; cp_src[i] != NULL && cp_src[i][0] != '\0'; i++) {
 318                 char *src, *dest, *dn, *tmp_dest;
 319
 320                 dest = cp_src[i];
 321
 322                 /*
 323                  * If dest would be on an TMPFS-backed
 324                  * mountpoint, don't bother copying it.
 325                  */
 326                 sp = subpartition_of(storage_get_selected_slice(a->s),
 327                                      "%s%s", a->os_root, &dest[1]);
 328                 if (sp != NULL && subpartition_is_tmpfsbacked(sp)) {
 329                         continue;
 330                 }
 331
 332                 /*
 333                  * Create intermediate directories, if needed.
 334                  */
 335                 tmp_dest = aura_strdup(dest);
 336                 dn = dirname(tmp_dest);
 337                 if (is_dir("%s%s", a->os_root, &dn[1]) &&
 338                     !is_dir("%smnt%s", a->os_root, dn)) {
 339                         command_add(cmds, "%s%s -p %smnt%s",
 340                             a->os_root, cmd_name(a, "MKDIR"),
 341                             a->os_root, dn);
 342                 }
 343                 aura_free(tmp_dest, "directory name");
 344
 345                 /*
 346                  * If a directory by the same name but with the suffix
 347                  * ".hdd" exists on the installation media, cpdup that
 348                  * instead.  This is particularly useful with /etc, which
 349                  * may have significantly different behaviour on the
 350                  * live CD compared to a standard HDD boot.
 351                  */
 352                 if (is_dir("%s%s.hdd", a->os_root, &dest[1]))
 353                         asprintf(&src, "%s.hdd", &dest[1]);
 354                 else
 355                         asprintf(&src, "%s", &dest[1]);
 356
 357                 /*
 358                  * Cpdup the chosen file or directory onto the HDD.
 359                  * if it exists on the source.
 360                  */
 361                 if (is_dir("%s%s", a->os_root, src) ||
 362                     is_file("%s%s", a->os_root, src)) {
 363                         cmd = command_add(cmds, "%s%s %s%s %smnt%s",
 364                             a->os_root, cmd_name(a, "CPDUP"),
 365                             a->os_root, src,
 366                             a->os_root, dest);
 367                         command_set_log_mode(cmd, COMMAND_LOG_QUIET);
 368                 }
 369         }
 370
 371         /*
 372          * Now, because cpdup does not cross mount points,
 373          * we must copy anything that the user might've made a
 374          * seperate mount point for (e.g. /usr/libdata/lint.)
 375          */
 376         nfsidx = 0;
 377         sp = NULL;
 378         spnext = slice_subpartition_first(storage_get_selected_slice(a->s));
 379
 380         for (;;) {
 381                 const char *mountpt;
 382
 383                 /*
 384                  * Iterate nullfs mounts and then partitions
 385                  */
 386                 if (nullfs_mountpt[nfsidx]) {
 387                         mountpt = nullfs_mountpt[nfsidx];
 388                         ++nfsidx;
 389                 } else {
 390                         sp = spnext;
 391                         if (sp == NULL)
 392                                 break;
 393                         spnext = subpartition_next(sp);
 394                         mountpt = subpartition_get_mountpoint(sp);
 395                 }
 396
 397                 /*
 398                  * If the subpartition is a swap subpartition or an
 399                  * TMPFS-backed mountpoint, don't try to copy anything
 400                  * into it.
 401                  */
 402                 if (sp) {
 403                         if (subpartition_is_swap(sp) ||
 404                             subpartition_is_tmpfsbacked(sp)) {
 405                                 continue;
 406                         }
 407                 }
 408
 409                 /*
 410                  * If the mountpoint doesn't even exist on the installation
 411                  * medium, don't try to copy anything from it!  We assume
 412                  * it's an empty subpartition for the user's needs.
 413                  */
 414                 if (!is_dir("%s%s", a->os_root, mountpt + 1))
 415                         continue;
 416
 417                 /*
 418                  * Don't bother copying the mountpoint IF:
 419                  * - we've already said to copy it, or something besides it
 420                  *   (it's a prefix of something in cp_src); or
 421                  * - we haven't said to copy it
 422                  *   (nothing in cp_src is a prefix of it.)
 423                  */
 424                 seen_it = 0;
 425                 prefix = 0;
 426                 for (i = 0; cp_src[i] != NULL && cp_src[i][0] != '\0'; i++) {
 427                         if (strncmp(mountpt, cp_src[i],
 428                             strlen(mountpt)) == 0) {
 429                                 seen_it = 1;
 430                                 break;
 431                         }
 432                         if (strncmp(cp_src[i], mountpt, strlen(cp_src[i])) == 0) {
 433                                 prefix = 1;
 434                         }
 435                 }
 436                 if (seen_it || !prefix)
 437                         continue;
 438
 439                 /*
 440                  * Otherwise, cpdup the subpartition.
 441                  *
 442                  * XXX check for .hdd-extended source dirs here, too,
 443                  * eventually - but for now, /etc.hdd will never be
 444                  * the kind of tricky sub-mount-within-a-mount-point
 445                  * that this part of the code is meant to handle.
 446                  */
 447                 cmd = command_add(cmds, "%s%s %s%s %smnt%s",
 448                         a->os_root, cmd_name(a, "CPDUP"),
 449                         a->os_root, mountpt + 1,
 450                         a->os_root, mountpt);
 451                 command_set_log_mode(cmd, COMMAND_LOG_QUIET);
 452         }
 453
 454         /*
 455          * Ensure /var has all directories it needs.
 456          */
 457         command_add(cmds, "%s%s -deU -f %setc/mtree/BSD.var.dist -p %smnt/var",
 458             a->os_root, cmd_name(a, "MTREE"), a->os_root, a->os_root);
 459
 460         /*
 461          * Create symlinks.
 462          */
 463
 464         /* Take care of /sys. */
 465         command_add(cmds, "%s%s -s usr/src/sys %smnt/sys",
 466             a->os_root, cmd_name(a, "LN"), a->os_root);
 467
 468         /*
 469          * Make sure /home exists (goes on root mount otherwise).
 470          */
 471         command_add(cmds, "%s%s -p %smnt/home",
 472                     a->os_root, cmd_name(a, "MKDIR"), a->os_root);
 473
 474         /*
 475          * XXX check for other possible combinations too?
 476          */
 477
 478         /*
 479          * Clean up.  In case some file didn't make it, use rm -f
 480          */
 481         command_add(cmds, "%s%s -f %smnt/boot/loader.conf",
 482             a->os_root, cmd_name(a, "RM"), a->os_root);
 483         command_add(cmds, "%s%s -f %smnt/tmp/install.log",
 484             a->os_root, cmd_name(a, "RM"), a->os_root);
 485         command_add(cmds, "%s%s -f %smnt/tmp/t[12]",
 486             a->os_root, cmd_name(a, "RM"), a->os_root);
 487         command_add(cmds, "%s%s -f %smnt/tmp/test_in",
 488             a->os_root, cmd_name(a, "RM"), a->os_root);
 489         command_add(cmds, "%s%s -f %smnt/tmp/test_out",
 490             a->os_root, cmd_name(a, "RM"), a->os_root);
 491
 492         /*
 493          * Copy pristine versions over any files we might have installed.
 494          * This allows the resulting file tree to be customized.
 495          */
 496         for (i = 0; cp_src[i] != NULL && cp_src[i][0] != '\0'; i++) {
 497                 char *src, *dest, *dn, *tmp_dest;
 498
 499                 src = cp_src[i];
 500                 dest = cp_src[i];
 501
 502                 /*
 503                  * Get the directory that the desired thing to
 504                  * copy resides in.
 505                  */
 506                 tmp_dest = aura_strdup(dest);
 507                 dn = dirname(tmp_dest);
 508
 509                 /*
 510                  * If this dir doesn't exist in PRISTINE_DIR
 511                  * on the install media, just skip it.
 512                  */
 513                 if (!is_dir("%s%s%s", a->os_root, PRISTINE_DIR, dn)) {
 514                         aura_free(tmp_dest, _("directory name"));
 515                         continue;
 516                 }
 517
 518                 /*
 519                  * Create intermediate directories, if needed.
 520                  */
 521                 if (!is_dir("%smnt%s", a->os_root, dn)) {
 522                         command_add(cmds, "%s%s -p %smnt%s",
 523                             a->os_root, cmd_name(a, "MKDIR"),
 524                             a->os_root, dn);
 525                 }
 526                 aura_free(tmp_dest, "directory name");
 527
 528                 /*
 529                  * Cpdup the chosen file or directory onto the HDD.
 530                  */
 531                 cmd = command_add(cmds, "%s%s %s%s %smnt%s",
 532                     a->os_root, cmd_name(a, "CPDUP"),
 533                     a->os_root, src,
 534                     a->os_root, dest);
 535
 536                 cmd = command_add(cmds,
 537                     "%s%s %s%s%s %smnt%s",
 538                     a->os_root, cmd_name(a, "CPDUP"),
 539                     a->os_root, PRISTINE_DIR, src,
 540                     a->os_root, dest);
 541                 command_set_log_mode(cmd, COMMAND_LOG_QUIET);
 542         }
 543
 544         /*
 545          * Rebuild the user database, to get rid of any extra users
 546          * from the LiveCD that aren't supposed to be installed
 547          * (copying a pristine master.passwd isn't enough.)
 548          */
 549         command_add(cmds, "%s%s -p -d %smnt/etc %smnt/etc/master.passwd",
 550             a->os_root, cmd_name(a, "PWD_MKDB"), a->os_root, a->os_root);
 551
 552         /*
 553          * Create missing directories for special mounts.
 554          */
 555         command_add(cmds, "%s%s %smnt/proc",
 556             a->os_root, cmd_name(a, "MKDIR"), a->os_root);
 557         command_add(cmds, "%s%s %smnt/dev",
 558             a->os_root, cmd_name(a, "MKDIR"), a->os_root);
 559         command_add(cmds, "%s%s %smnt/mnt",
 560             a->os_root, cmd_name(a, "MKDIR"), a->os_root);
 561
 562         /* Write new fstab. */
 563         command_add(cmds, "%s%s '%s' >%smnt/etc/fstab",
 564             a->os_root, cmd_name(a, "ECHO"),
 565             "# Device\t\tMountpoint\tFStype\tOptions\t\tDump\tPass#",
 566             a->os_root);
 567
 568         for (sp = slice_subpartition_first(storage_get_selected_slice(a->s));
 569              sp != NULL; sp = subpartition_next(sp)) {
 570                 if (strcmp(subpartition_get_mountpoint(sp), "swap") == 0) {
 571                         command_add(cmds, "%s%s '/dev/%s\t\tnone\t\tswap\tsw\t\t0\t0' >>%smnt/etc/fstab",
 572                             a->os_root, cmd_name(a, "ECHO"),
 573                             subpartition_is_encrypted(sp) ?
 574                             "mapper/swap" : subpartition_get_device_name(sp),
 575                             a->os_root);
 576                         if (subpartition_is_encrypted(sp)) {
 577                                 command_add(cmds,
 578                                     "%s%s 'swap\t/dev/%s\tnone\tnone' >>%smnt/etc/crypttab",
 579                                     a->os_root, cmd_name(a, "ECHO"),
 580                                     subpartition_get_device_name(sp),
 581                                     a->os_root);
 582                         }
 583                 } else {
 584                         const char *fsname;
 585                         int order;
 586
 587                         /*
 588                          * fs type (/boot is always ufs)
 589                          */
 590                         if (strcmp(subpartition_get_mountpoint(sp), "/boot") == 0)
 591                                 fsname = "ufs";
 592                         else if (use_hammer)
 593                                 fsname = "hammer";
 594                         else
 595                                 fsname = "ufs";
 596
 597                         if (strcmp(subpartition_get_mountpoint(sp), "/") == 0)
 598                                 order = 1;
 599                         else
 600                                 order = 2;
 601
 602                         /*
 603                          * Adjust loader.conf for root partition
 604                          */
 605                         if (strcmp(subpartition_get_mountpoint(sp), "/") == 0) {
 606                                 if (subpartition_is_encrypted(sp)) {
 607                                         command_add(cmds,
 608                                             "%s%s 'vfs.root.mountfrom=\"ufs:md0s0\"' >>%smnt/boot/loader.conf",
 609                                             a->os_root, cmd_name(a, "ECHO"),
 610                                             a->os_root);
 611                                         command_add(cmds,
 612                                             "%s%s 'vfs.root.realroot=\"crypt:%s:%s:%s\"' >>%smnt/boot/loader.conf",
 613                                             a->os_root, cmd_name(a, "ECHO"),
 614                                             fsname,
 615                                             subpartition_get_device_name(sp),
 616                                             fn_mapper_name(subpartition_get_device_name(sp), -1),
 617                                             a->os_root);
 618                                 } else {
 619                                         command_add(cmds,
 620                                             "%s%s 'vfs.root.mountfrom=\"%s:%s\"' >>%smnt/boot/loader.conf",
 621                                             a->os_root, cmd_name(a, "ECHO"),
 622                                             fsname,
 623                                             subpartition_get_device_name(sp),
 624                                             a->os_root);
 625                                 }
 626                         }
 627                         if (subpartition_is_tmpfsbacked(sp)) {
 628                                 command_add(cmds, "%s%s 'tmpfs\t\t\t%s\t\ttmpfs\trw,-s%luM\t1\t1' >>%smnt/etc/fstab",
 629                                     a->os_root, cmd_name(a, "ECHO"),
 630                                     subpartition_get_mountpoint(sp),
 631                                     subpartition_get_capacity(sp),
 632                                     a->os_root);
 633                         } else if (subpartition_is_encrypted(sp)) {
 634                                 command_add(cmds, "%s%s '%s\t/dev/%s\tnone\tnone' >>%smnt/etc/crypttab",
 635                                     a->os_root, cmd_name(a, "ECHO"),
 636                                     fn_mapper_name(subpartition_get_device_name(sp), -1),
 637                                     subpartition_get_device_name(sp),
 638                                     a->os_root);
 639                                 command_add(cmds, "%s%s '/dev/%s\t\t%s\t\t%s\trw\t\t2\t2' >>%smnt/etc/fstab",
 640                                     a->os_root, cmd_name(a, "ECHO"),
 641                                     fn_mapper_name(subpartition_get_device_name(sp), 0),
 642                                     subpartition_get_mountpoint(sp),
 643                                     fsname,
 644                                     a->os_root);
 645                         } else {
 646                                 command_add(cmds, "%s%s '/dev/%s\t\t%s\t\t%s\trw\t\t%d\t%d' >>%smnt/etc/fstab",
 647                                     a->os_root, cmd_name(a, "ECHO"),
 648                                     subpartition_get_device_name(sp),
 649                                     subpartition_get_mountpoint(sp),
 650                                     fsname,
 651                                     order, order,
 652                                     a->os_root);
 653                         }
 654                 }
 655         }
 656
 657         /*
 658          * Take care of NULL mounts from /build for things like /var/crash
 659          * and /usr/obj if not specified as a discrete partition.
 660          */
 661         for (j = 0; nullfs_mountpt[j] != NULL; j++) {
 662                 if (subpartition_find(storage_get_selected_slice(a->s),
 663                                       "%s", nullfs_mountpt[j]) != NULL) {
 664                         continue;
 665                 }
 666                 command_add(cmds,
 667                     "%s%s '%s\t%s\t\tnull\trw\t\t0\t0' >>%smnt/etc/fstab",
 668                     a->os_root, cmd_name(a, "ECHO"),
 669                     nullfs_mountname[j],
 670                     nullfs_mountpt[j],
 671                     a->os_root);
 672         }
 673
 674         /*
 675          * Take care of /tmp as a tmpfs filesystem
 676          */
 677         if (subpartition_find(storage_get_selected_slice(a->s), "/tmp") == NULL) {
 678                 command_add(cmds,
 679                     "%s%s 'tmpfs\t/tmp\t\ttmpfs\trw\t\t0\t0' >>%smnt/etc/fstab",
 680                     a->os_root, cmd_name(a, "ECHO"), a->os_root);
 681         }
 682
 683         /*
 684          * Take care of /proc
 685          */
 686         command_add(cmds, "%s%s '%s' >>%smnt/etc/fstab",
 687             a->os_root, cmd_name(a, "ECHO"),
 688             "proc\t\t\t/proc\t\tprocfs\trw\t\t0\t0",
 689             a->os_root);
 690
 691         /* Backup the disklabel and the log. */
 692         command_add(cmds, "%s%s %s > %smnt/etc/disklabel.%s",
 693             a->os_root, cmd_name(a, "DISKLABEL64"),
 694             slice_get_device_name(storage_get_selected_slice(a->s)),
 695             a->os_root,
 696             slice_get_device_name(storage_get_selected_slice(a->s)));
 697
 698 #if 0
 699         /* 'chflags nohistory' as needed */
 700         for (j = 0; pfs_mountpt[j] != NULL; j++)
 701                 if (pfs_nohistory[j] == 1)
 702                         command_add(cmds, "%s%s -R nohistory %smnt%s",
 703                             a->os_root, cmd_name(a, "CHFLAGS"),
 704                             a->os_root, pfs_mountpt[j]);
 705 #endif
 706
 707         /* Do some preparation if encrypted partitions were configured */
 708         if (needcrypt) {
 709                 command_add(cmds,
 710                     "%s%s 'dm_load=\"yes\"' >>%smnt/boot/loader.conf",
 711                     a->os_root, cmd_name(a, "ECHO"),
 712                     a->os_root);
 713                 command_add(cmds,
 714                     "%s%s 'dm_target_crypt_load=\"yes\"' >>%smnt/boot/loader.conf",
 715                     a->os_root, cmd_name(a, "ECHO"),
 716                     a->os_root);
 717                 command_add(cmds,
 718                     "%s%s 'initrd.img_load=\"YES\"' >>%smnt/boot/loader.conf",
 719                     a->os_root, cmd_name(a, "ECHO"),
 720                     a->os_root);
 721                 command_add(cmds,
 722                     "%s%s 'initrd.img_type=\"md_image\"' >>%smnt/boot/loader.conf",
 723                     a->os_root, cmd_name(a, "ECHO"),
 724                     a->os_root);
 725         }
 726
 727         /* Customize stuff here */
 728         if(is_file("%susr/local/bin/after_installation_routines.sh", a->os_root)) {
 729                 command_add(cmds, "%susr/local/bin/after_installation_routines.sh",
 730                     a->os_root);
 731         }
 732
 733         /* Save the installation log. */
 734         command_add(cmds, "%s%s %sinstall.log %smnt/var/log/install.log",
 735             a->os_root, cmd_name(a, "CP"),
 736             a->tmp, a->os_root);
 737         command_add(cmds, "%s%s 600 %smnt/var/log/install.log",
 738             a->os_root, cmd_name(a, "CHMOD"), a->os_root);
 739
 740         /*
 741          * Do it!
 742          */
 743         /* commands_preview(a->c, cmds); */
 744         if (!commands_execute(a, cmds)) {
 745                 inform(a->c, _("%s was not fully installed."), OPERATING_SYSTEM_NAME);
 746                 a->result = 0;
 747         } else {
 748                 a->result = 1;
 749         }
 750         commands_free(cmds);
 751         cmds = commands_new();
 752
 753         if (a->result) {
 754                 config_vars_write(rc_conf, CONFIG_TYPE_SH, "%smnt/etc/rc.conf",
 755                     a->os_root);
 756                 config_vars_free(rc_conf);
 757                 rc_conf = config_vars_new();
 758         }
 759
 760         /*
 761          * Unmount everything we mounted on /mnt.  This is done in a seperate
 762          * command chain, so that partitions are unmounted, even if an error
 763          * occurs in one of the preceding commands, or it is cancelled.
 764          */
 765         unmount_altfs(a, cmds);
 766         unmount_all_under(a, cmds, "%smnt", a->os_root);
 767
 768         /*
 769          * Once everything is unmounted, if the install went successfully,
 770          * make sure once and for all that the disklabel is bootable.
 771          */
 772         if (a->result)
 773                 command_add(cmds, "%s%s -B %s",
 774                     a->os_root, cmd_name(a, "DISKLABEL64"),
 775                     slice_get_device_name(storage_get_selected_slice(a->s)));
 776
 777         if (!commands_execute(a, cmds))
 778                 inform(a->c, _("Warning: subpartitions were not correctly unmounted."));
 779
 780         commands_free(cmds);
 781
 782         /*
 783          * Finally, remove all swap and any mappings.
 784          */
 785         if (swapoff_all(a) == NULL)
 786                 inform(a->c, _("Warning: swap could not be turned off."));
 787         if (remove_all_mappings(a) == NULL)
 788                 inform(a->c, _("Warning: mappings could not be removed."));
 789 }
 790
 791 /*
 792  * /dev/mapper/
 793  *
 794  * (result is persistant until next call)
 795  */
 796 const char *
 797 fn_mapper_name(const char *mountpt, int withdev)
 798 {
 799         const char *src;
 800         static char *save;
 801
 802         src = strrchr(mountpt, '/');
 803         if (src == NULL || src[1] == 0)
 804                 src = "root";
 805         else
 806                 ++src;
 807
 808         if (save)
 809                 free(save);
 810         switch(withdev) {
 811         case -1:
 812                 asprintf(&save, "%s", src);
 813                 break;
 814         case 0:
 815                 asprintf(&save, "mapper/%s", src);
 816                 break;
 817         case 1:
 818         default:
 819                 asprintf(&save, "/dev/mapper/%s", src);
 820                 break;
 821         }
 822         return save;
 823 }