f2ffead7694ff5681976b551020a4f5260fbcbba
[dragonfly.git] / contrib / bsdinstaller-1.1.6 / src / backend / installer / fn_install.c
1 /*
2  * Copyright (c)2004 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/local/share/dfuibe_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 static const char *pfs_mountpt[8] = {"/var", "/tmp", "/usr", "/home",
70         "/usr/obj", "/var/crash", "/var/tmp", NULL};
71
72 static const int pfs_nohistory[8] = {0, 0, 0, 0, 1, 1, 1};
73
74 static void
75 handle_pfs(struct i_fn_args *a, struct commands *cmds)
76 {
77         int j;
78
79         /*
80          * Create PFS root directory.
81          */
82         command_add(cmds, "%s%s -p %smnt/pfs",
83             a->os_root, cmd_name(a, "MKDIR"),
84             a->os_root);
85
86         for (j = 0; pfs_mountpt[j] != NULL; j++) {
87                 /*
88                  * We have a PFS for a subdirectory, e.g. /var/crash, so we
89                  * need to create /pfs/var.crash
90                  */
91                 if (rindex(pfs_mountpt[j]+1, '/') != NULL) {
92                         command_add(cmds, "%s%s pfs-master %smnt/pfs%s.%s",
93                             a->os_root, cmd_name(a, "HAMMER"),
94                             a->os_root, dirname(pfs_mountpt[j]),
95                             basename(pfs_mountpt[j]));
96                         command_add(cmds, "%s%s -p %smnt%s",
97                             a->os_root, cmd_name(a, "MKDIR"),
98                             a->os_root, pfs_mountpt[j]);
99                         command_add(cmds, "%s%s %smnt/pfs%s.%s %smnt%s",
100                             a->os_root, cmd_name(a, "MOUNT_NULL"),
101                             a->os_root, dirname(pfs_mountpt[j]),
102                             basename(pfs_mountpt[j]),
103                             a->os_root, pfs_mountpt[j]);
104                         if (pfs_nohistory[j] == 1)
105                                 command_add(cmds, "%s%s nohistory %smnt%s",
106                                     a->os_root, cmd_name(a, "CHFLAGS"),
107                                     a->os_root, pfs_mountpt[j]);
108                 }
109                 else {
110                         command_add(cmds, "%s%s pfs-master %smnt/pfs%s",
111                             a->os_root, cmd_name(a, "HAMMER"),
112                             a->os_root, pfs_mountpt[j]);
113                         command_add(cmds, "%s%s -p %smnt%s",
114                             a->os_root, cmd_name(a, "MKDIR"),
115                             a->os_root, pfs_mountpt[j]);
116                         command_add(cmds, "%s%s %smnt/pfs%s %smnt%s",
117                             a->os_root, cmd_name(a, "MOUNT_NULL"),
118                             a->os_root, pfs_mountpt[j],
119                             a->os_root, pfs_mountpt[j]);
120                 }
121         }
122 }
123
124 /*
125  * fn_install_os: actually put DragonFly on a disk.
126  */
127 void
128 fn_install_os(struct i_fn_args *a)
129 {
130         struct subpartition *sp;
131         struct commands *cmds;
132         struct command *cmd;
133         int i, seen_it, prefix, j;
134         FILE *sources_conf;
135         char line[256];
136         char cp_src[64][256];
137         char file_path[256];
138         int lines = 0;
139         long mfsbacked_size;
140
141         /* 
142          * If SOURCES_CONF_FILE exists, lets read in and 
143          * populate our copy sources.   If it does not exist
144          * simply set the list by hand.
145          */
146         if (!is_file("%s%s", a->os_root, SOURCES_CONF_FILE)) {
147                 i_log(a, "Using internal copy sources table.");
148                 strcpy(cp_src[0],"/COPYRIGHT");
149                 strcpy(cp_src[1],"/var");
150                 strcpy(cp_src[2],"/bin");
151                 strcpy(cp_src[3],"/boot");
152                 strcpy(cp_src[4],"/cdrom");
153                 strcpy(cp_src[5],"/dev");
154                 strcpy(cp_src[6],"/etc");
155                 strcpy(cp_src[7],"/libexec");
156                 strcpy(cp_src[8],"/lib");
157                 strcpy(cp_src[9],"/kernel");
158                 strcpy(cp_src[10],"/modules");
159                 strcpy(cp_src[11],"/root");
160                 strcpy(cp_src[12],"/sbin");
161                 strcpy(cp_src[13],"/sys");
162                 strcpy(cp_src[14],"/tmp");
163                 strcpy(cp_src[15],"/usr/bin");
164                 strcpy(cp_src[16],"/usr/games");
165                 strcpy(cp_src[17],"/usr/include");
166                 strcpy(cp_src[18],"/usr/lib");
167                 strcpy(cp_src[19],"/usr/local");
168                 strcpy(cp_src[20],"/usr/local/OpenOffice.org1.1.3");
169                 strcpy(cp_src[21],"/usr/X11R6");
170                 strcpy(cp_src[22],"/usr/libdata");
171                 strcpy(cp_src[23],"/usr/libexec");
172                 strcpy(cp_src[24],"/usr/obj");
173                 strcpy(cp_src[25],"/usr/sbin");
174                 strcpy(cp_src[26],"/usr/share");
175                 strcpy(cp_src[27],"/usr/src");
176                 strcpy(cp_src[28],"");
177         } else {
178                 snprintf(file_path, 256, "%s%s", a->os_root, SOURCES_CONF_FILE);
179                 sources_conf = fopen(file_path, "r");
180                 i_log(a, "Reading %s%s", a->os_root, SOURCES_CONF_FILE);
181                 while(fgets(line, 256, sources_conf) != NULL && lines < 63) {
182                         if(strlen(line)>0)
183                                 line[strlen(line)-1] = '\0';
184                         strlcpy(cp_src[lines], line, 256);
185                         i_log(a,"Adding %s to copy source table.", cp_src[lines]);
186                         lines++;
187                 }
188                 i_log(a,"Added %i total items to copy source table.", lines);
189                 strcpy(cp_src[lines], "");
190                 fclose(sources_conf);
191         }
192
193         cmds = commands_new();
194
195         /*
196          * If swap isn't mounted yet, mount it.
197          */
198         if (measure_activated_swap(a) == 0) {
199                 for (sp = slice_subpartition_first(storage_get_selected_slice(a->s));
200                     sp != NULL; sp = subpartition_next(sp)) {
201                         if (!subpartition_is_swap(sp))
202                                 continue;
203                         command_add(cmds, "%s%s %sdev/%s",
204                             a->os_root,
205                             cmd_name(a, "SWAPON"),
206                             a->os_root,
207                             subpartition_get_device_name(sp));
208                 }
209         }
210
211         /*
212          * Unmount anything already mounted on /mnt.
213          */
214         unmount_all_under(a, cmds, "%smnt", a->os_root);
215
216         for (sp = slice_subpartition_first(storage_get_selected_slice(a->s));
217              sp != NULL; sp = subpartition_next(sp)) {
218                 if (strcmp(subpartition_get_mountpoint(sp), "/") == 0) {
219                         command_add(cmds, "%s%s -p %smnt%s",
220                             a->os_root, cmd_name(a, "MKDIR"),
221                             a->os_root, subpartition_get_mountpoint(sp));
222                         if (use_hammer == 1) {
223                                 command_add(cmds, "%s%s %sdev/%s %smnt%s",
224                                     a->os_root, cmd_name(a, "MOUNT_HAMMER"),
225                                     a->os_root,
226                                     subpartition_get_device_name(sp),
227                                     a->os_root,
228                                     subpartition_get_mountpoint(sp));
229                         } else {
230                                 command_add(cmds, "%s%s %sdev/%s %smnt%s",
231                                     a->os_root, cmd_name(a, "MOUNT"),
232                                     a->os_root,
233                                     subpartition_get_device_name(sp),
234                                     a->os_root,
235                                     subpartition_get_mountpoint(sp));
236                         }
237                 }
238         }
239
240         /*
241          * Create mount points and mount subpartitions on them.
242          */
243         for (sp = slice_subpartition_first(storage_get_selected_slice(a->s));
244              sp != NULL; sp = subpartition_next(sp)) {
245                 if (subpartition_is_swap(sp)) {
246                         /*
247                          * Set this subpartition as the dump device.
248                          */
249 #ifdef AUTOMATICALLY_ENABLE_CRASH_DUMPS
250                         if (subpartition_get_capacity(sp) < storage_get_memsize(a->s))
251                                 continue;
252
253                         command_add(cmds, "%s%s -v %sdev/%s",
254                             a->os_root, cmd_name(a, "DUMPON"),
255                             a->os_root,
256                             subpartition_get_device_name(sp));
257
258                         asprintf(&string, "/dev/%s",
259                             subpartition_get_device_name(sp));
260                         config_var_set(rc_conf, "dumpdev", string);
261                         free(string);
262                         config_var_set(rc_conf, "dumpdir", "/var/crash");
263 #endif
264                         continue;
265                 }
266         
267
268                 /*
269                  * Don't mount it if it's MFS-backed.
270                  */
271
272                 if (subpartition_is_mfsbacked(sp)) {
273                         continue;
274                 }
275                 if (use_hammer == 0) {
276                         /* / is already mounted */
277                         if (strcmp(subpartition_get_mountpoint(sp), "/") != 0) {
278                                 command_add(cmds, "%s%s -p %smnt%s",
279                                     a->os_root, cmd_name(a, "MKDIR"),
280                                     a->os_root,
281                                     subpartition_get_mountpoint(sp));
282                                 command_add(cmds, "%s%s %sdev/%s %smnt%s",
283                                     a->os_root, cmd_name(a, "MOUNT"),
284                                     a->os_root,
285                                     subpartition_get_device_name(sp),
286                                     a->os_root,
287                                     subpartition_get_mountpoint(sp));
288                         }
289                 }
290         }
291
292         /*
293          * Take care of HAMMER PFS.
294          */
295         if (use_hammer == 1)
296                 handle_pfs(a, cmds);
297
298         /*
299          * Actually copy files now.
300          */
301
302         for (i = 0; cp_src[i] != NULL && cp_src[i][0] != '\0'; i++) {
303                 char *src, *dest, *dn, *tmp_dest;
304
305                 dest = cp_src[i];
306
307                 /*
308                  * If dest would be on an MFS-backed
309                  * mountpoint, don't bother copying it.
310                  */
311                 sp = subpartition_of(storage_get_selected_slice(a->s),
312                                      "%s%s", a->os_root, &dest[1]);
313                 if (sp != NULL && subpartition_is_mfsbacked(sp)) {
314                         continue;
315                 }
316
317                 /*
318                  * Create intermediate directories, if needed.
319                  */
320                 tmp_dest = aura_strdup(dest);
321                 dn = dirname(tmp_dest);
322                 if (is_dir("%s%s", a->os_root, &dn[1]) &&
323                     !is_dir("%smnt%s", a->os_root, dn)) {
324                         command_add(cmds, "%s%s -p %smnt%s",
325                             a->os_root, cmd_name(a, "MKDIR"),
326                             a->os_root, dn);
327                 }
328                 aura_free(tmp_dest, "directory name");
329
330                 /*
331                  * If a directory by the same name but with the suffix
332                  * ".hdd" exists on the installation media, cpdup that
333                  * instead.  This is particularly useful with /etc, which
334                  * may have significantly different behaviour on the
335                  * live CD compared to a standard HDD boot.
336                  */
337                 if (is_dir("%s%s.hdd", a->os_root, &dest[1]))
338                         asprintf(&src, "%s.hdd", &dest[1]);
339                 else
340                         asprintf(&src, "%s", &dest[1]);
341
342                 if (is_dir("%s%s", a->os_root, src) || is_file("%s%s", a->os_root, src)) {
343                         /*
344                          * Cpdup the chosen file or directory onto the HDD.
345                          * if it exists on the source.
346                          */
347                         cmd = command_add(cmds, "%s%s %s%s %smnt%s",
348                             a->os_root, cmd_name(a, "CPDUP"),
349                             a->os_root, src,
350                             a->os_root, dest);
351                         command_set_log_mode(cmd, COMMAND_LOG_QUIET);
352                 }
353         }
354
355         /*
356          * Now, because cpdup does not cross mount points,
357          * we must copy anything that the user might've made a
358          * seperate mount point for (e.g. /usr/libdata/lint.)
359          */
360         for (sp = slice_subpartition_first(storage_get_selected_slice(a->s));
361              sp != NULL; sp = subpartition_next(sp)) {
362                 /*
363                  * If the subpartition is a swap subpartition or an
364                  * MFS-backed mountpoint, don't try to copy anything
365                  * into it.
366                  */
367                 if (subpartition_is_swap(sp) || subpartition_is_mfsbacked(sp))
368                         continue;
369
370                 /*
371                  * If the mountpoint doesn't even exist on the installation
372                  * medium, don't try to copy anything from it!  We assume
373                  * it's an empty subpartition for the user's needs.
374                  */
375                 if (!is_dir("%s%s", a->os_root, &subpartition_get_mountpoint(sp)[1]))
376                         continue;
377
378                 /*
379                  * Don't bother copying the mountpoint IF:
380                  * - we've already said to copy it, or something besides it
381                  *   (it's a prefix of something in cp_src); or
382                  * - we haven't said to copy it
383                  *   (nothing in cp_src is a prefix of it.)
384                  */
385                 seen_it = 0;
386                 prefix = 0;
387                 for (i = 0; cp_src[i] != NULL && cp_src[i][0] != '\0'; i++) {
388                         if (strncmp(subpartition_get_mountpoint(sp), cp_src[i],
389                             strlen(subpartition_get_mountpoint(sp))) == 0) {
390                                 seen_it = 1;
391                                 break;
392                         }
393                         if (strncmp(cp_src[i], subpartition_get_mountpoint(sp),
394                             strlen(cp_src[i])) == 0) {
395                                 prefix = 1;
396                         }
397                 }
398                 if (seen_it || !prefix)
399                         continue;
400
401                 /*
402                  * Otherwise, cpdup the subpartition.
403                  *
404                  * XXX check for .hdd-extended source dirs here, too,
405                  * eventually - but for now, /etc.hdd will never be
406                  * the kind of tricky sub-mount-within-a-mount-point
407                  * that this part of the code is meant to handle.
408                  */
409                 cmd = command_add(cmds, "%s%s %s%s %smnt%s",
410                     a->os_root, cmd_name(a, "CPDUP"),
411                     a->os_root, &subpartition_get_mountpoint(sp)[1],
412                     a->os_root, subpartition_get_mountpoint(sp));
413                 command_set_log_mode(cmd, COMMAND_LOG_QUIET);
414         }
415         
416         /*
417          * Create symlinks.
418          */
419
420         /*
421          * If the user has both /var and /tmp subparitions,
422          * symlink /var/tmp to /tmp.
423          */
424         if (subpartition_find(storage_get_selected_slice(a->s), "/tmp") != NULL &&
425             subpartition_find(storage_get_selected_slice(a->s), "/var") != NULL) {
426                 command_add(cmds, "%s%s 1777 %smnt/tmp",
427                     a->os_root, cmd_name(a, "CHMOD"), a->os_root);
428                 command_add(cmds, "%s%s -rf %smnt/var/tmp",
429                     a->os_root, cmd_name(a, "RM"), a->os_root);
430                 command_add(cmds, "%s%s -s /tmp %smnt/var/tmp",
431                     a->os_root, cmd_name(a, "LN"), a->os_root);
432         }
433
434         /*
435          * If the user has /var, but no /tmp,
436          * symlink /tmp to /var/tmp.
437          */
438         if (subpartition_find(storage_get_selected_slice(a->s), "/tmp") == NULL &&
439             subpartition_find(storage_get_selected_slice(a->s), "/var") != NULL) {
440                 command_add(cmds, "%s%s -rf %smnt/tmp",
441                     a->os_root, cmd_name(a, "RM"), a->os_root);
442                 command_add(cmds, "%s%s -s /var/tmp %smnt/tmp",
443                     a->os_root, cmd_name(a, "LN"), a->os_root);
444         }
445
446         /*
447          * If the user has /usr, but no /home,
448          * symlink /home to /usr/home.
449          */
450         if (subpartition_find(storage_get_selected_slice(a->s), "/home") == NULL &&
451             subpartition_find(storage_get_selected_slice(a->s), "/usr") != NULL) {
452                 command_add(cmds, "%s%s -rf %smnt/home",
453                     a->os_root, cmd_name(a, "RM"), a->os_root);
454                 command_add(cmds, "%s%s %smnt/usr/home",
455                     a->os_root, cmd_name(a, "MKDIR"), a->os_root);
456                 command_add(cmds, "%s%s -s /usr/home %smnt/home",
457                     a->os_root, cmd_name(a, "LN"), a->os_root);
458         }
459
460         /*
461          * XXX check for other possible combinations too?
462          */
463
464         /*
465          * Clean up.  In case some file didn't make it, use rm -f
466          */
467 #ifdef __DragonFly__
468         command_add(cmds, "%s%s -f %smnt/boot/loader.conf",
469             a->os_root, cmd_name(a, "RM"), a->os_root);
470 #endif
471         command_add(cmds, "%s%s -f %smnt/tmp/install.log",
472             a->os_root, cmd_name(a, "RM"), a->os_root);
473
474         /*
475          * Copy pristine versions over any files we might have installed.
476          * This allows the resulting file tree to be customized.
477          */
478         for (i = 0; cp_src[i] != NULL && cp_src[i][0] != '\0'; i++) {
479                 char *src, *dest, *dn, *tmp_dest;
480
481                 src = cp_src[i];
482                 dest = cp_src[i];
483
484                 /*
485                  * Get the directory that the desired thing to
486                  * copy resides in.
487                  */
488                 tmp_dest = aura_strdup(dest);
489                 dn = dirname(tmp_dest);
490
491                 /*
492                  * If this dir doesn't exist in PRISTINE_DIR
493                  * on the install media, just skip it.
494                  */
495                 if (!is_dir("%s%s%s", a->os_root, PRISTINE_DIR, dn)) {
496                         aura_free(tmp_dest, _("directory name"));
497                         continue;
498                 }
499
500                 /*
501                  * Create intermediate directories, if needed.
502                  */
503                 if (!is_dir("%smnt%s", a->os_root, dn)) {
504                         command_add(cmds, "%s%s -p %smnt%s",
505                             a->os_root, cmd_name(a, "MKDIR"),
506                             a->os_root, dn);
507                 }
508                 aura_free(tmp_dest, "directory name");
509
510                 /*
511                  * Cpdup the chosen file or directory onto the HDD.
512                  */
513                 cmd = command_add(cmds, "%s%s %s%s %smnt%s",
514                     a->os_root, cmd_name(a, "CPDUP"),
515                     a->os_root, src,
516                     a->os_root, dest);
517
518                 cmd = command_add(cmds,
519                     "%s%s %s%s%s %smnt%s",
520                     a->os_root, cmd_name(a, "CPDUP"),
521                     a->os_root, PRISTINE_DIR, src,
522                     a->os_root, dest);
523                 command_set_log_mode(cmd, COMMAND_LOG_QUIET);
524         }
525
526         /*
527          * Rebuild the user database, to get rid of any extra users
528          * from the LiveCD that aren't supposed to be installed
529          * (copying a pristine master.passwd isn't enough.)
530          */
531         command_add(cmds, "%s%s -p -d %smnt/etc %smnt/etc/master.passwd",
532             a->os_root, cmd_name(a, "PWD_MKDB"), a->os_root, a->os_root);
533
534         /* Create missing directories. */
535         command_add(cmds, "%s%s %smnt/proc",
536             a->os_root, cmd_name(a, "MKDIR"), a->os_root);
537         command_add(cmds, "%s%s %smnt/mnt",
538             a->os_root, cmd_name(a, "MKDIR"), a->os_root);
539
540         /* Write new fstab. */
541
542         command_add(cmds, "%s%s '%s' >%smnt/etc/fstab",
543             a->os_root, cmd_name(a, "ECHO"),
544             "# Device\t\tMountpoint\tFStype\tOptions\t\tDump\tPass#",
545             a->os_root);
546
547         for (sp = slice_subpartition_first(storage_get_selected_slice(a->s));
548              sp != NULL; sp = subpartition_next(sp)) {
549                 if (strcmp(subpartition_get_mountpoint(sp), "swap") == 0) {
550                         command_add(cmds, "%s%s '/dev/%s\t\tnone\t\tswap\tsw\t\t0\t0' >>%smnt/etc/fstab",
551                             a->os_root, cmd_name(a, "ECHO"),
552                             subpartition_get_device_name(sp),
553                             a->os_root);
554                 } else if (use_hammer == 0) {
555                         if (strcmp(subpartition_get_mountpoint(sp), "/") == 0) {
556                                 command_add(cmds, "%s%s '/dev/%s\t\t%s\t\tufs\trw\t\t1\t1' >>%smnt/etc/fstab",
557                                     a->os_root, cmd_name(a, "ECHO"),
558                                     subpartition_get_device_name(sp),
559                                     subpartition_get_mountpoint(sp),
560                                     a->os_root);
561                         } else if (subpartition_is_mfsbacked(sp)) {
562                                 mfsbacked_size = slice_get_capacity(storage_get_selected_slice(a->s)) * 2048;
563                                 command_add(cmds, "%s%s 'swap\t\t%s\t\t\tmfs\trw,-s%ld\t\t1\t1' >>%smnt/etc/fstab",
564                                         a->os_root, cmd_name(a, "ECHO"),
565                                         subpartition_get_mountpoint(sp),
566                                         mfsbacked_size,
567                                         a->os_root);
568                         } else {
569                                 command_add(cmds, "%s%s '/dev/%s\t\t%s\t\tufs\trw\t\t2\t2' >>%smnt/etc/fstab",
570                                     a->os_root, cmd_name(a, "ECHO"),
571                                     subpartition_get_device_name(sp),
572                                     subpartition_get_mountpoint(sp),
573                                     a->os_root);
574                         }
575                 } else {
576                         if (strcmp(subpartition_get_mountpoint(sp), "/") == 0) {
577                                 command_add(cmds, "%s%s '/dev/%s\t\t%s\t\thammer\trw\t\t1\t1' >>%smnt/etc/fstab",
578                                     a->os_root, cmd_name(a, "ECHO"),
579                                     subpartition_get_device_name(sp),
580                                     subpartition_get_mountpoint(sp),
581                                     a->os_root);
582                         } else if (strcmp(subpartition_get_mountpoint(sp), "/boot") == 0) {
583                                 command_add(cmds, "%s%s '/dev/%s\t\t%s\t\tufs\trw\t\t1\t1' >>%smnt/etc/fstab",
584                                     a->os_root, cmd_name(a, "ECHO"),
585                                     subpartition_get_device_name(sp),
586                                     subpartition_get_mountpoint(sp),
587                                     a->os_root);
588                         }
589                 }
590         }
591
592         /*
593          * Take care of HAMMER PFS null mounts.
594          */
595         if (use_hammer == 1) {
596                 for (j = 0; pfs_mountpt[j] != NULL; j++) {
597                         if (rindex(pfs_mountpt[j]+1, '/') != NULL)
598                                 command_add(cmds, "%s%s '/pfs%s.%s\t%s\t\tnull\trw\t\t0\t0' >>%smnt/etc/fstab",
599                                     a->os_root, cmd_name(a, "ECHO"),
600                                     dirname(pfs_mountpt[j]),
601                                     basename(pfs_mountpt[j]),
602                                     pfs_mountpt[j],
603                                     a->os_root);
604                         else
605                                 command_add(cmds, "%s%s '/pfs%s\t\t%s\t\tnull\trw\t\t0\t0' >>%smnt/etc/fstab",
606                                     a->os_root, cmd_name(a, "ECHO"),
607                                     pfs_mountpt[j],
608                                     pfs_mountpt[j],
609                                     a->os_root);
610                 }
611         }
612
613         command_add(cmds, "%s%s '%s' >>%smnt/etc/fstab",
614             a->os_root, cmd_name(a, "ECHO"),
615             "proc\t\t\t/proc\t\tprocfs\trw\t\t0\t0",
616             a->os_root);
617
618         /* Backup the disklabel and the log. */
619         if (use_hammer == 0) {
620                 command_add(cmds, "%s%s %s > %smnt/etc/disklabel.%s",
621                     a->os_root, cmd_name(a, "DISKLABEL"),
622                     slice_get_device_name(storage_get_selected_slice(a->s)),
623                     a->os_root,
624                     slice_get_device_name(storage_get_selected_slice(a->s)));
625         } else {
626                 command_add(cmds, "%s%s %s > %smnt/etc/disklabel.%s",
627                     a->os_root, cmd_name(a, "DISKLABEL64"),
628                     slice_get_device_name(storage_get_selected_slice(a->s)),
629                     a->os_root,
630                     slice_get_device_name(storage_get_selected_slice(a->s)));
631         }
632
633         command_add(cmds, "%s%s %sinstall.log %smnt/var/log/install.log",
634             a->os_root, cmd_name(a, "CP"),
635             a->tmp, a->os_root);
636         command_add(cmds, "%s%s 600 %smnt/var/log/install.log",
637             a->os_root, cmd_name(a, "CHMOD"), a->os_root);
638
639         /* Customize stuff here */
640         if(is_file("%susr/local/bin/after_installation_routines.sh")) {
641                 command_add(cmds, "%susr/local/bin/after_installation_routines.sh",
642                 a->os_root, _("Running after installation custom routines..."));
643         }
644
645         /*
646          * Do it!
647          */
648         /* commands_preview(cmds); */
649         if (!commands_execute(a, cmds)) {
650                 inform(a->c, _("%s was not fully installed."), OPERATING_SYSTEM_NAME);
651                 a->result = 0;
652         } else {
653                 a->result = 1;
654         }
655         commands_free(cmds);
656
657         /*
658          * Unmount everything we mounted on /mnt.  This is done in a seperate
659          * command chain, so that partitions are unmounted, even if an error
660          * occurs in one of the preceding commands, or it is cancelled.
661          */
662         cmds = commands_new();
663         unmount_all_under(a, cmds, "%smnt", a->os_root);
664
665         /*
666          * Once everything is unmounted, if the install went successfully,
667          * make sure once and for all that the disklabel is bootable.
668          */
669         if (a->result) {
670                 if (use_hammer == 0) {
671                         command_add(cmds, "%s%s -B %s",
672                             a->os_root, cmd_name(a, "DISKLABEL"),
673                             slice_get_device_name(storage_get_selected_slice(a->s)));
674                 } else {
675                         command_add(cmds, "%s%s -B %s",
676                             a->os_root, cmd_name(a, "DISKLABEL64"),
677                             slice_get_device_name(storage_get_selected_slice(a->s)));
678                 }
679         }
680
681         if (!commands_execute(a, cmds))
682                 inform(a->c, _("Warning: subpartitions were not correctly unmounted."));
683
684         commands_free(cmds);
685 }
686