Changes in uspace/app/sysinst/sysinst.c [9b95b964:2c21595] in mainline

File:

• uspace/app/sysinst/sysinst.c (modified) (23 diffs)

uspace/app/sysinst/sysinst.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2024 Jiri Svoboda
+ * Copyright (c) 2026 Jiri Svoboda
  * All rights reserved.
  *
@@ -41 +41 @@
 #include <errno.h>
 #include <fdisk.h>
+#include <fmgt.h>
+#include <gfx/render.h>
+#include <io/log.h>
 #include <loc.h>
 #include <stdio.h>
@@ -46 +49 @@
 #include <str.h>
 #include <str_error.h>
+#include <system.h>
+#include <ui/msgdialog.h>
+#include <ui/ui.h>
+#include <ui/window.h>
 #include <vfs/vfs.h>
 #include <vol.h>
 
-#include "futil.h"
 #include "grub.h"
 #include "rdimg.h"
 #include "volume.h"
+#include "sysinst.h"
+
+#define NAME "sysinst"
 
 /** Device to install to
@@ -63 +72 @@
  */
 #define DEFAULT_DEV_0 "devices/\\hw\\sys\\00:01.1\\c0d0"
-#define DEFAULT_DEV_1 "devices/\\hw\\sys\\00:01.0\\ata1\\c0d0"
+#define DEFAULT_DEV_1 "devices/\\hw\\sys\\ide1\\c0d0"
+#define DEFAULT_DEV_2 "devices/\\hw\\sys\\00:01.0\\ide1\\c0d0"
 //#define DEFAULT_DEV "devices/\\hw\\pci0\\00:01.2\\uhci_rh\\usb01_a1\\mass-storage0\\l0"
+/** Index of partition which we must install to (hardwired in load.cfg) */
+#define INST_PART_IDX 1
+/* File system type cannot be changed without modifying core.img */
+#define INST_FSTYPE fs_ext4
 /** Volume label for the new file system */
 #define INST_VOL_LABEL "HelenOS"
@@ -77 +91 @@
 #define CD_MOUNT_POINT "/vol/" CD_VOL_LABEL
 
-#define BOOT_FILES_SRC CD_MOUNT_POINT
+#define BOOT_FILES_SRC CD_MOUNT_POINT "/boot"
 #define BOOT_BLOCK_IDX 0 /* MBR */
+
+#define CFG_FILES_SRC "/cfg"
+#define CFG_FILES_DEST MOUNT_POINT
 
 static const char *default_devs[] = {
         DEFAULT_DEV_0,
         DEFAULT_DEV_1,
+        DEFAULT_DEV_2,
         NULL
 };
@@ -92 +110 @@
 };
 
+static fibril_mutex_t shutdown_lock;
+static fibril_condvar_t shutdown_cv;
+static bool shutdown_stopped;
+static bool shutdown_failed;
+
+static void sysinst_shutdown_complete(void *);
+static void sysinst_shutdown_failed(void *);
+
+static system_cb_t sysinst_system_cb = {
+        .shutdown_complete = sysinst_shutdown_complete,
+        .shutdown_failed = sysinst_shutdown_failed
+};
+
+static void wnd_close(ui_window_t *, void *);
+static errno_t bg_wnd_paint(ui_window_t *, void *);
+
+static ui_window_cb_t bg_window_cb = {
+        .close = wnd_close,
+        .paint = bg_wnd_paint
+};
+
+static ui_window_cb_t progress_window_cb = {
+        .close = wnd_close
+};
+
+static void sysinst_confirm_button(ui_msg_dialog_t *, void *, unsigned);
+static void sysinst_confirm_close(ui_msg_dialog_t *, void *);
+
+static ui_msg_dialog_cb_t sysinst_confirm_cb = {
+        .button = sysinst_confirm_button,
+        .close = sysinst_confirm_close
+};
+
+static void sysinst_upgrade_confirm_button(ui_msg_dialog_t *, void *, unsigned);
+static void sysinst_upgrade_confirm_close(ui_msg_dialog_t *, void *);
+
+static ui_msg_dialog_cb_t sysinst_upgrade_confirm_cb = {
+        .button = sysinst_upgrade_confirm_button,
+        .close = sysinst_upgrade_confirm_close
+};
+
+static errno_t sysinst_restart_dlg_create(sysinst_t *);
+static void sysinst_restart_dlg_button(ui_msg_dialog_t *, void *, unsigned);
+static void sysinst_restart_dlg_close(ui_msg_dialog_t *, void *);
+
+static ui_msg_dialog_cb_t sysinst_restart_dlg_cb = {
+        .button = sysinst_restart_dlg_button,
+        .close = sysinst_restart_dlg_close
+};
+
+static int sysinst_start(sysinst_t *);
+static errno_t sysinst_restart(sysinst_t *);
+static void sysinst_progress_destroy(sysinst_progress_t *);
+static void sysinst_progress(sysinst_t *, const char *);
+static void sysinst_action(sysinst_t *, const char *);
+static void sysinst_error(sysinst_t *, const char *);
+static void sysinst_debug(sysinst_t *, const char *);
+
+static fmgt_exists_action_t sysinst_fmgt_exists_query(void *, fmgt_exists_t *);
+static void sysinst_fmgt_action(void *, fmgt_action_t, const char *,
+    const char *);
+static void sysinst_fmgt_progress(void *, fmgt_progress_t *);
+static errno_t sysinst_eject_dev(sysinst_t *, service_id_t);
+static errno_t sysinst_eject_phys_by_mp(sysinst_t *, const char *);
+static errno_t sysinst_upgrade_confirm_create(sysinst_t *);
+
+static fmgt_cb_t sysinst_fmgt_cb = {
+        .exists_query = sysinst_fmgt_exists_query,
+        .action = sysinst_fmgt_action,
+        .progress = sysinst_fmgt_progress
+};
+
+static void sysinst_error_msg_button(ui_msg_dialog_t *, void *, unsigned);
+static void sysinst_error_msg_close(ui_msg_dialog_t *, void *);
+
+static ui_msg_dialog_cb_t sysinst_error_msg_cb = {
+        .button = sysinst_error_msg_button,
+        .close = sysinst_error_msg_close
+};
+
+/** Close window.
+ *
+ * @param window Window
+ * @param arg Argument (sysinst_t *)
+ */
+static void wnd_close(ui_window_t *window, void *arg)
+{
+        (void)window;
+        (void)arg;
+}
+
+/** Paint background window.
+ *
+ * @param window Window
+ * @param arg Argument (sysinst_t *)
+ */
+static errno_t bg_wnd_paint(ui_window_t *window, void *arg)
+{
+        sysinst_t *sysinst = (sysinst_t *)arg;
+        gfx_rect_t app_rect;
+        gfx_context_t *gc;
+        errno_t rc;
+
+        gc = ui_window_get_gc(window);
+
+        rc = gfx_set_color(gc, sysinst->bg_color);
+        if (rc != EOK)
+                return rc;
+
+        ui_window_get_app_rect(window, &app_rect);
+
+        rc = gfx_fill_rect(gc, &app_rect);
+        if (rc != EOK)
+                return rc;
+
+        rc = gfx_update(gc);
+        if (rc != EOK)
+                return rc;
+
+        return EOK;
+}
+
+/** Installation confirm dialog OK button press.
+ *
+ * @param dialog Message dialog
+ * @param arg Argument (sysinst_t *)
+ * @param btn Button number
+ * @param earg Entry argument
+ */
+static void sysinst_confirm_button(ui_msg_dialog_t *dialog, void *arg,
+    unsigned btn)
+{
+        sysinst_t *sysinst = (sysinst_t *) arg;
+
+        ui_msg_dialog_destroy(dialog);
+
+        switch (btn) {
+        case 0:
+                /* OK */
+                sysinst_start(sysinst);
+                break;
+        default:
+                /* Cancel */
+                ui_quit(sysinst->ui);
+                break;
+        }
+}
+
+/** Installation confirm dialog close request.
+ *
+ * @param dialog Message dialog
+ * @param arg Argument (sysinst_t *)
+ */
+static void sysinst_confirm_close(ui_msg_dialog_t *dialog, void *arg)
+{
+        sysinst_t *sysinst = (sysinst_t *) arg;
+
+        ui_msg_dialog_destroy(dialog);
+        ui_quit(sysinst->ui);
+}
+
+/** Upgrade confirm dialog OK button press.
+ *
+ * @param dialog Message dialog
+ * @param arg Argument (sysinst_t *)
+ * @param btn Button number
+ * @param earg Entry argument
+ */
+static void sysinst_upgrade_confirm_button(ui_msg_dialog_t *dialog, void *arg,
+    unsigned btn)
+{
+        sysinst_t *sysinst = (sysinst_t *) arg;
+
+        ui_msg_dialog_destroy(dialog);
+
+        switch (btn) {
+        case 0:
+                /* OK */
+                fibril_mutex_lock(&sysinst->responded_lock);
+                sysinst->responded = true;
+                sysinst->quit = false;
+                fibril_mutex_unlock(&sysinst->responded_lock);
+                fibril_condvar_signal(&sysinst->responded_cv);
+                break;
+        default:
+                /* Cancel */
+                fibril_mutex_lock(&sysinst->responded_lock);
+                sysinst->responded = true;
+                sysinst->quit = true;
+                fibril_mutex_unlock(&sysinst->responded_lock);
+                fibril_condvar_signal(&sysinst->responded_cv);
+                break;
+        }
+}
+
+/** Upgrade confirm dialog close request.
+ *
+ * @param dialog Message dialog
+ * @param arg Argument (sysinst_t *)
+ */
+static void sysinst_upgrade_confirm_close(ui_msg_dialog_t *dialog, void *arg)
+{
+        sysinst_t *sysinst = (sysinst_t *) arg;
+
+        ui_msg_dialog_destroy(dialog);
+        ui_quit(sysinst->ui);
+}
+
+/** Restart system dialog OK button press.
+ *
+ * @param dialog Message dialog
+ * @param arg Argument (sysinst_t *)
+ * @param btn Button number
+ * @param earg Entry argument
+ */
+static void sysinst_restart_dlg_button(ui_msg_dialog_t *dialog, void *arg,
+    unsigned btn)
+{
+        sysinst_t *sysinst = (sysinst_t *) arg;
+
+        ui_msg_dialog_destroy(dialog);
+
+        (void)sysinst;
+
+        switch (btn) {
+        case 0:
+                /* OK */
+                sysinst_action(sysinst, "Ejecting installation media.");
+                (void)sysinst_eject_phys_by_mp(sysinst, CD_MOUNT_POINT);
+                (void)sysinst_restart(sysinst);
+                break;
+        default:
+                /* Cancel */
+                ui_quit(sysinst->ui);
+                break;
+        }
+}
+
+/** Restat system dialog close request.
+ *
+ * @param dialog Message dialog
+ * @param arg Argument (sysinst_t *)
+ */
+static void sysinst_restart_dlg_close(ui_msg_dialog_t *dialog, void *arg)
+{
+        sysinst_t *sysinst = (sysinst_t *) arg;
+
+        ui_msg_dialog_destroy(dialog);
+        ui_quit(sysinst->ui);
+}
+
+/** Installation error message dialog button press.
+ *
+ * @param dialog Message dialog
+ * @param arg Argument (sysinst_t *)
+ * @param bnum Button number
+ */
+static void sysinst_error_msg_button(ui_msg_dialog_t *dialog,
+    void *arg, unsigned bnum)
+{
+        sysinst_t *sysinst = (sysinst_t *) arg;
+
+        ui_msg_dialog_destroy(dialog);
+        ui_quit(sysinst->ui);
+}
+
+/** Installation error message dialog close request.
+ *
+ * @param dialog Message dialog
+ * @param arg Argument (shutdown_dlg_t *)
+ */
+static void sysinst_error_msg_close(ui_msg_dialog_t *dialog, void *arg)
+{
+        sysinst_t *sysinst = (sysinst_t *) arg;
+
+        ui_msg_dialog_destroy(dialog);
+        ui_quit(sysinst->ui);
+}
+
+/** Create error message dialog.
+ *
+ * @param sysinst System installer
+ * @return EOK on success or an error code
+ */
+static errno_t sysinst_error_msg_create(sysinst_t *sysinst)
+{
+        ui_msg_dialog_params_t params;
+        ui_msg_dialog_t *dialog;
+        errno_t rc;
+
+        ui_msg_dialog_params_init(&params);
+        params.caption = "Error";
+        params.text = sysinst->errmsg;
+        params.flags |= umdf_topmost | umdf_center;
+
+        rc = ui_msg_dialog_create(sysinst->ui, &params, &dialog);
+        if (rc != EOK)
+                return rc;
+
+        ui_msg_dialog_set_cb(dialog, &sysinst_error_msg_cb, (void *)sysinst);
+
+        return EOK;
+}
+
+/** Called when fmgt hits an existing file while copying.
+ *
+ * @param arg Argument (sysinst_t *)
+ * @param exists Information about existing file
+ * @return Existing file recovery action
+ */
+fmgt_exists_action_t sysinst_fmgt_exists_query(void *arg, fmgt_exists_t *exists)
+{
+        sysinst_t *sysinst = (sysinst_t *)arg;
+
+        (void)sysinst;
+        (void)exists->fname;
+
+        sysinst_action(sysinst, exists->fname);
+
+        /*
+         * Before starting fmgt operation, the caller would specify
+         * whether to overwrite existing files.
+         */
+        if (sysinst->overwrite)
+                return fmgt_exr_overwrite;
+        else
+                return fmgt_exr_skip;
+}
+
+/** Called when fmgt is starting to perform action on a file.
+ *
+ * @param arg Argument (sysinst_t *)
+ * @param action Action being performed
+ * @param src Source or only path
+ * @param dest Destination path or @c NULL
+ */
+static void sysinst_fmgt_action(void *arg, fmgt_action_t action,
+    const char *src, const char *dest)
+{
+        sysinst_t *sysinst = (sysinst_t *)arg;
+        char buf[128];
+
+        (void)src;
+
+        switch (action) {
+        case fmgt_ac_create:
+                snprintf(buf, sizeof(buf), "Creating %s.", src);
+                sysinst_action(sysinst, buf);
+                break;
+        case fmgt_ac_copy:
+                snprintf(buf, sizeof(buf), "Copying %s.", dest);
+                sysinst_action(sysinst, buf);
+                break;
+        default:
+                break;
+        }
+}
+
+/** Called by fmgt to update on progress.
+ *
+ * @param arg Argument (sysinst_t *)
+ * @param src Source path
+ * @param dest Destination path
+ */
+static void sysinst_fmgt_progress(void *arg, fmgt_progress_t *progress)
+{
+        sysinst_t *sysinst = (sysinst_t *)arg;
+        char buf[128];
+
+        snprintf(buf, sizeof(buf), "Copied %s files, %s; "
+            "current file: %s done.", progress->total_procf,
+            progress->total_procb, progress->curf_percent);
+        sysinst_progress(sysinst, buf);
+}
+
+/** System shutdown complete.
+ *
+ * @param arg Argument (shutdown_t *)
+ */
+static void sysinst_shutdown_complete(void *arg)
+{
+        (void)arg;
+
+        fibril_mutex_lock(&shutdown_lock);
+        shutdown_stopped = true;
+        shutdown_failed = false;
+        fibril_condvar_broadcast(&shutdown_cv);
+        fibril_mutex_unlock(&shutdown_lock);
+}
+
+/** System shutdown failed.
+ *
+ * @param arg Argument (not used)
+ */
+static void sysinst_shutdown_failed(void *arg)
+{
+        (void)arg;
+
+        fibril_mutex_lock(&shutdown_lock);
+        shutdown_stopped = true;
+        shutdown_failed = true;
+        fibril_condvar_broadcast(&shutdown_cv);
+        fibril_mutex_unlock(&shutdown_lock);
+}
+
 /** Check the if the destination device exists.
  *
@@ -111 +534 @@
 }
 
-/** Label the destination device.
- *
- * @param dev Disk device to label
- * @param psvc_id Place to store service ID of the created partition
- *
- * @return EOK on success or an error code
- */
-static errno_t sysinst_label_dev(const char *dev, service_id_t *psvc_id)
-{
-        fdisk_t *fdisk;
-        fdisk_dev_t *fdev;
+/** Find existing OS partition.
+ *
+ * @param sysinst System installer
+ * @param fdev Destination device
+ * @param rpart Place to store pointer to partition
+ *
+ * @return EOK on success or an error code
+ */
+static errno_t sysinst_existing_os_part_find(sysinst_t *sysinst,
+    fdisk_dev_t *fdev, fdisk_part_t **rpart)
+{
+        fdisk_part_t *part;
+        fdisk_part_info_t pinfo;
+        errno_t rc;
+
+        sysinst_debug(sysinst, "sysinst_existing_os_part_find(): walk partitions");
+
+        part = fdisk_part_first(fdev);
+        while (part != NULL) {
+                rc = fdisk_part_get_info(part, &pinfo);
+                if (rc != EOK) {
+                        sysinst_error(sysinst,
+                            "Error getting partition information.");
+                        goto error;
+                }
+
+                if (pinfo.index == INST_PART_IDX && pinfo.pkind == lpk_primary)
+                        break;
+
+                part = fdisk_part_next(part);
+        }
+
+        /* Partition with index INST_PART_IDX not found? */
+        if (part == NULL)
+                return ENOENT;
+
+        /* Correct file system type? */
+        if (pinfo.fstype != INST_FSTYPE) {
+                /* Not a usable existing partition. */
+                return ENOENT;
+        }
+
+        sysinst_debug(sysinst, "sysinst_existing_os_part_find(): OK");
+        sysinst->psvc_id = pinfo.svc_id;
+        *rpart = part;
+        return EOK;
+error:
+        return rc;
+}
+
+/** Create installation partition.
+ *
+ * @param sysinst System installer
+ * @param fdev Destination device
+ *
+ * @return EOK on success or an error code
+ */
+static errno_t sysinst_inst_part_create(sysinst_t *sysinst, fdisk_dev_t *fdev)
+{
         fdisk_part_t *part;
         fdisk_part_spec_t pspec;
         fdisk_part_info_t pinfo;
         capa_spec_t capa;
-        service_id_t sid;
-        errno_t rc;
-
-        printf("sysinst_label_dev(): get service ID '%s'\n", dev);
-        rc = loc_service_get_id(dev, &sid, 0);
-        if (rc != EOK)
-                return rc;
-
-        printf("sysinst_label_dev(): open device\n");
-
-        rc = fdisk_create(&fdisk);
-        if (rc != EOK) {
-                printf("Error initializing fdisk.\n");
-                return rc;
-        }
-
-        rc = fdisk_dev_open(fdisk, sid, &fdev);
-        if (rc != EOK) {
-                printf("Error opening device.\n");
-                return rc;
-        }
-
-        printf("sysinst_label_dev(): create mount directory\n");
-
-        rc = vfs_link_path(MOUNT_POINT, KIND_DIRECTORY, NULL);
-        if (rc != EOK)
-                return rc;
-
-        printf("sysinst_label_dev(): create label\n");
-
-        rc = fdisk_label_create(fdev, lt_mbr);
-        if (rc != EOK) {
-                printf("Error creating label: %s.\n", str_error(rc));
-                return rc;
-        }
-
-        printf("sysinst_label_dev(): create partition\n");
+        errno_t rc;
+
+        sysinst_debug(sysinst, "sysinst_inst_part_create(): get maximum available block");
 
         rc = fdisk_part_get_max_avail(fdev, spc_pri, &capa);
         if (rc != EOK) {
-                printf("Error getting available capacity: %s.\n", str_error(rc));
-                return rc;
+                sysinst_error(sysinst,
+                    "Error getting available capacity.");
+                goto error;
         }
 
@@ -173 +611 @@
         pspec.capacity = capa;
         pspec.pkind = lpk_primary;
-        pspec.fstype = fs_ext4; /* Cannot be changed without modifying core.img */
+        pspec.fstype = INST_FSTYPE; /* Cannot be changed without modifying core.img */
         pspec.mountp = MOUNT_POINT;
+        pspec.index = INST_PART_IDX; /* Cannot be changed without modifying core.img */
         pspec.label = INST_VOL_LABEL;
 
         rc = fdisk_part_create(fdev, &pspec, &part);
         if (rc != EOK) {
-                printf("Error creating partition.\n");
+                sysinst_error(sysinst, "Error creating partition.");
+                goto error;
+        }
+
+        rc = fdisk_part_get_info(part, &pinfo);
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error getting partition information.");
+                goto error;
+        }
+
+        sysinst_debug(sysinst, "sysinst_inst_part_create(): OK");
+        sysinst->psvc_id = pinfo.svc_id;
+        return EOK;
+error:
+        return rc;
+}
+
+/** Label and mount the destination device.
+ *
+ * @param sysinst System installer
+ * @param dev Disk device to label
+ *
+ * @return EOK on success or an error code
+ */
+static errno_t sysinst_label_dev(sysinst_t *sysinst, const char *dev)
+{
+        fdisk_t *fdisk = NULL;
+        fdisk_dev_t *fdev = NULL;
+        fdisk_part_t *part;
+        fdisk_label_info_t linfo;
+        bool create_label = false;
+        bool dir_created = false;
+        bool label_created = false;
+        service_id_t sid;
+        errno_t rc;
+
+        sysinst_debug(sysinst, "sysinst_label_dev(): get service ID");
+
+        rc = loc_service_get_id(dev, &sid, 0);
+        if (rc != EOK)
+                goto error;
+
+        sysinst_debug(sysinst, "sysinst_label_dev(): open device");
+
+        rc = fdisk_create(&fdisk);
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error initializing fdisk.");
+                goto error;
+        }
+
+        rc = fdisk_dev_open(fdisk, sid, &fdev);
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error opening device.");
+                goto error;
+        }
+
+        sysinst_debug(sysinst, "sysinst_label_dev(): create mount directory");
+
+        rc = vfs_link_path(MOUNT_POINT, KIND_DIRECTORY, NULL);
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error creating mount directory.");
+                goto error;
+        }
+
+        dir_created = true;
+
+        sysinst_debug(sysinst, "sysinst_label_dev(): create label");
+
+        rc = fdisk_label_get_info(fdev, &linfo);
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error analyzing device.");
+                goto error;
+        }
+
+        switch (linfo.ltype) {
+        case lt_none:
+                /* need to create label */
+                create_label = true;
+                break;
+        case lt_mbr:
+                /* MBR label already present */
+                break;
+        default:
+                /* a different type of label already present */
+                sysinst_error(sysinst, "Disk contains unusable label.");
+                goto error;
+        }
+
+        /* Need to create label? */
+        if (create_label) {
+                rc = fdisk_label_create(fdev, lt_mbr);
+                if (rc != EOK) {
+                        sysinst_error(sysinst, "Error creating label.");
+                        goto error;
+                }
+        }
+
+        label_created = true;
+
+        sysinst_debug(sysinst, "sysinst_label_dev(): create partition");
+
+        /* Existing OS partition? */
+        rc = sysinst_existing_os_part_find(sysinst, fdev, &part);
+        if (rc == EOK) {
+                /* Open dialog to confirm that user wants to upgrade. */
+                rc = sysinst_upgrade_confirm_create(sysinst);
+                if (rc != EOK) {
+                        sysinst_error(sysinst, "Cannot create window.");
+                        goto error;
+                }
+
+                fibril_mutex_lock(&sysinst->responded_lock);
+                while (!sysinst->responded)
+                        fibril_condvar_wait(&sysinst->responded_cv,
+                            &sysinst->responded_lock);
+                fibril_mutex_unlock(&sysinst->responded_lock);
+
+                /* User decided not to upgrade existing installation? */
+                if (sysinst->quit) {
+                        (void)vfs_unlink_path(MOUNT_POINT);
+                        return EOK;
+                }
+
+                /* Set mount point for installation partition. */
+                rc = fdisk_part_set_mountp(part, MOUNT_POINT);
+                if (rc != EOK) {
+                        sysinst_error(sysinst, "Cannot mount installation "
+                            "partition.");
+                        goto error;
+                }
+
+                /* performing OS upgrade */
+                sysinst->oper = sio_upgrade;
+                if (sysinst->progress != NULL) {
+                        (void)ui_label_set_text(sysinst->progress->label,
+                            "Upgrading system. Please wait...");
+                        (void)ui_label_paint(sysinst->progress->label);
+                        (void)ui_window_set_caption(sysinst->bgwindow,
+                            "System Upgrade");
+                }
+        } else {
+                /* Create installation partition. */
+                rc = sysinst_inst_part_create(sysinst, fdev);
+                if (rc != EOK)
+                        goto error;
+
+                /* performing initial OS installation */
+                sysinst->oper = sio_install;
+        }
+
+        return EOK;
+error:
+        if (label_created)
+                fdisk_label_destroy(fdev);
+        if (dir_created)
+                (void)vfs_unlink_path(MOUNT_POINT);
+        if (fdev != NULL)
+                fdisk_dev_close(fdev);
+        if (fdisk != NULL)
+                fdisk_destroy(fdisk);
+        return rc;
+}
+
+/** Finish/unmount destination device.
+ *
+ * @param sysinst System installer
+ *
+ * @return EOK on success or an error code
+ */
+static errno_t sysinst_finish_dev(sysinst_t *sysinst)
+{
+        errno_t rc;
+
+        sysinst_debug(sysinst, "sysinst_finish_dev(): eject target volume");
+        rc = sysinst_eject_dev(sysinst, sysinst->psvc_id);
+        if (rc != EOK)
                 return rc;
-        }
-
-        rc = fdisk_part_get_info(part, &pinfo);
-        if (rc != EOK) {
-                printf("Error getting partition information.\n");
-                return rc;
-        }
-
-        printf("sysinst_label_dev(): OK\n");
-        *psvc_id = pinfo.svc_id;
+
+        sysinst_debug(sysinst, "sysinst_finish_dev(): "
+            "deleting mount directory");
+        (void)vfs_unlink_path(MOUNT_POINT);
+
         return EOK;
 }
@@ -196 +805 @@
 /** Set up system volume structure.
  *
- * @return EOK on success or an error code
- */
-static errno_t sysinst_setup_sysvol(void)
+ * @param sysinst System installer
+ * @return EOK on success or an error code
+ */
+static errno_t sysinst_setup_sysvol(sysinst_t *sysinst)
 {
         errno_t rc;
         char *path = NULL;
         const char **cp;
+        fmgt_flist_t *flist = NULL;
         int rv;
 
@@ -214 +825 @@
 
                 rc = vfs_link_path(path, KIND_DIRECTORY, NULL);
-                if (rc != EOK) {
-                        printf("Error creating directory '%s'.\n", path);
+                if (rc != EOK && rc != EEXIST) {
+                        sysinst_error(sysinst, "Error creating directory.");
                         goto error;
                 }
@@ -227 +838 @@
         path = NULL;
 
+        /* Copy initial configuration files */
+
+        log_msg(LOG_DEFAULT, LVL_NOTE,
+            "sysinst_copy_boot_files(): copy initial configuration files");
+
+        rc = fmgt_flist_create(&flist);
+        if (rc != EOK)
+                goto error;
+
+        rc = fmgt_flist_append(flist, CFG_FILES_SRC);
+        if (rc != EOK)
+                goto error;
+
+        /* Do not overwrite configuration files. */
+        sysinst->overwrite = false;
+        rc = fmgt_copy(sysinst->fmgt, flist, CFG_FILES_DEST);
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error copying initial configuration "
+                    "files.");
+                goto error;
+        }
+
+        fmgt_flist_destroy(flist);
+        log_msg(LOG_DEFAULT, LVL_NOTE,
+            "sysinst_copy_boot_files(): copy initial configuration files OK");
         return EOK;
 error:
+        if (flist != NULL)
+                fmgt_flist_destroy(flist);
         if (path != NULL)
                 free(path);
@@ -238 +876 @@
  * @return EOK on success or an error code
  */
-static errno_t sysinst_copy_boot_files(void)
-{
-        errno_t rc;
-
-        printf("sysinst_copy_boot_files(): copy bootloader files\n");
-        rc = futil_rcopy_contents(BOOT_FILES_SRC, MOUNT_POINT);
-        if (rc != EOK)
-                return rc;
-
-        printf("sysinst_copy_boot_files(): OK\n");
+static errno_t sysinst_copy_boot_files(sysinst_t *sysinst)
+{
+        fmgt_flist_t *flist = NULL;
+        errno_t rc;
+
+        log_msg(LOG_DEFAULT, LVL_NOTE,
+            "sysinst_copy_boot_files(): copy bootloader files");
+        rc = fmgt_flist_create(&flist);
+        if (rc != EOK)
+                goto error;
+
+        rc = fmgt_flist_append(flist, BOOT_FILES_SRC);
+        if (rc != EOK)
+                goto error;
+
+        /* Overwrite boot files with new ones during upgrade. */
+        sysinst->overwrite = true;
+        rc = fmgt_copy(sysinst->fmgt, flist, MOUNT_POINT);
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error copying bootloader "
+                    "files.");
+                goto error;
+        }
+
+        fmgt_flist_destroy(flist);
+        sysinst_debug(sysinst, "sysinst_copy_boot_files(): OK");
         return EOK;
+error:
+        if (flist != NULL)
+                fmgt_flist_destroy(flist);
+        return rc;
 }
 
 /** Set up configuration in the initial RAM disk.
  *
- * @return EOK on success or an error code
- */
-static errno_t sysinst_customize_initrd(void)
+ * @param sysinst System installer
+ * @return EOK on success or an error code
+ */
+static errno_t sysinst_customize_initrd(sysinst_t *sysinst)
 {
         errno_t rc;
@@ -267 +926 @@
         rc = rd_img_open(MOUNT_POINT "/boot/initrd.img", &rdpath, &rd);
         if (rc != EOK) {
-                printf("Error opening initial RAM disk image.\n");
-                goto error;
-        }
-
-        rv = asprintf(&path, "%s%s", rdpath, "/cfg/volsrv.sif");
+                sysinst_error(sysinst, "Error opening initial RAM disk image.");
+                goto error;
+        }
+
+        rv = asprintf(&path, "%s%s", rdpath, "/cfg/initvol.sif");
         if (rv < 0) {
                 rc = ENOMEM;
@@ -277 +936 @@
         }
 
-        printf("Configuring volume server.\n");
+        sysinst_debug(sysinst, "Configuring volume server.");
+
         rc = vol_volumes_create(path, &volumes);
         if (rc != EOK) {
-                printf("Error creating volume server configuration.\n");
+                sysinst_error(sysinst,
+                    "Error creating volume server configuration.");
                 rc = EIO;
                 goto error;
         }
 
-        printf("Configuring volume server: look up volume\n");
+        sysinst_debug(sysinst, "Configuring volume server: look up volume");
         rc = vol_volume_lookup_ref(volumes, INST_VOL_LABEL, &volume);
         if (rc != EOK) {
-                printf("Error creating volume server configuration.\n");
+                sysinst_error(sysinst,
+                    "Error creating volume server configuration.");
                 rc = EIO;
                 goto error;
         }
 
-        printf("Configuring volume server: set mount point\n");
+        sysinst_debug(sysinst, "Configuring volume server: set mount point");
         rc = vol_volume_set_mountp(volume, INST_VOL_MP);
         if (rc != EOK) {
-                printf("Error creating system partition configuration.\n");
+                sysinst_error(sysinst,
+                    "Error creating system partition configuration.");
                 rc = EIO;
                 goto error;
         }
 
-        printf("Configuring volume server: delete reference\n");
+        rc = vol_volumes_sync(volumes);
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error saving volume confiuration.");
+                goto error;
+        }
+
+        log_msg(LOG_DEFAULT, LVL_NOTE,
+            "Configuring volume server: delete reference");
         vol_volume_del_ref(volume);
         volume = NULL;
-        printf("Configuring volume server: destroy volumes object\n");
+        log_msg(LOG_DEFAULT, LVL_NOTE,
+            "Configuring volume server: destroy volumes object");
         vol_volumes_destroy(volumes);
         volumes = NULL;
@@ -310 +981 @@
         rc = rd_img_close(rd);
         if (rc != EOK) {
-                printf("Error closing initial RAM disk image.\n");
+                sysinst_error(sysinst, "Error closing initial RAM disk image.");
                 rc = EIO;
                 goto error;
@@ -349 +1020 @@
 }
 
+/** Return file contents as a heap-allocated block of bytes.
+ *
+ * @param srcp File path
+ * @param rdata Place to store pointer to data
+ * @param rsize Place to store size of data
+ *
+ * @return EOK on success, ENOENT if failed to open file, EIO on other
+ *         I/O error, ENOMEM if out of memory
+ */
+static errno_t sysinst_get_file(const char *srcp, void **rdata, size_t *rsize)
+{
+        int sf;
+        size_t nr;
+        errno_t rc;
+        size_t fsize;
+        char *data;
+        vfs_stat_t st;
+
+        rc = vfs_lookup_open(srcp, WALK_REGULAR, MODE_READ, &sf);
+        if (rc != EOK)
+                return ENOENT;
+
+        if (vfs_stat(sf, &st) != EOK) {
+                vfs_put(sf);
+                return EIO;
+        }
+
+        fsize = st.size;
+
+        data = calloc(fsize, 1);
+        if (data == NULL) {
+                vfs_put(sf);
+                return ENOMEM;
+        }
+
+        rc = vfs_read(sf, (aoff64_t []) { 0 }, data, fsize, &nr);
+        if (rc != EOK || nr != fsize) {
+                vfs_put(sf);
+                free(data);
+                return EIO;
+        }
+
+        (void) vfs_put(sf);
+        *rdata = data;
+        *rsize = fsize;
+
+        return EOK;
+}
+
 /** Copy boot blocks.
  *
  * Install Grub's boot blocks.
  *
+ * @param sysinst System installer
  * @param devp Disk device
  * @return EOK on success or an error code
  */
-static errno_t sysinst_copy_boot_blocks(const char *devp)
+static errno_t sysinst_copy_boot_blocks(sysinst_t *sysinst, const char *devp)
 {
         void *boot_img;
@@ -370 +1091 @@
         errno_t rc;
 
-        printf("sysinst_copy_boot_blocks: Read boot block image.\n");
-        rc = futil_get_file(BOOT_FILES_SRC "/boot/grub/i386-pc/boot.img",
+        log_msg(LOG_DEFAULT, LVL_NOTE,
+            "sysinst_copy_boot_blocks: Read boot block image.");
+
+        rc = sysinst_get_file(BOOT_FILES_SRC "/grub/i386-pc/boot.img",
             &boot_img, &boot_img_size);
-        if (rc != EOK || boot_img_size != 512)
+        if (rc != EOK || boot_img_size != 512) {
+                sysinst_error(sysinst, "Error reading boot block image.");
                 return EIO;
-
-        printf("sysinst_copy_boot_blocks: Read GRUB core image.\n");
-        rc = futil_get_file(BOOT_FILES_SRC "/boot/grub/i386-pc/core.img",
+        }
+
+        log_msg(LOG_DEFAULT, LVL_NOTE,
+            "sysinst_copy_boot_blocks: Read GRUB core image.");
+
+        rc = sysinst_get_file(BOOT_FILES_SRC "/grub/i386-pc/core.img",
             &core_img, &core_img_size);
-        if (rc != EOK)
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error reading GRUB core image.");
                 return EIO;
-
-        printf("sysinst_copy_boot_blocks: get service ID.\n");
+        }
+
+        log_msg(LOG_DEFAULT, LVL_NOTE,
+            "sysinst_copy_boot_blocks: get service ID.");
+
         rc = loc_service_get_id(devp, &sid, 0);
         if (rc != EOK)
                 return rc;
 
-        printf("sysinst_copy_boot_blocks: block_init.\n");
+        log_msg(LOG_DEFAULT, LVL_NOTE,
+            "sysinst_copy_boot_blocks: block_init.");
+
         rc = block_init(sid);
-        if (rc != EOK)
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error opening block device.");
                 return rc;
-
-        printf("sysinst_copy_boot_blocks: get block size\n");
+        }
+
+        log_msg(LOG_DEFAULT, LVL_NOTE,
+            "sysinst_copy_boot_blocks: get block size");
+
         rc = block_get_bsize(sid, &bsize);
-        if (rc != EOK)
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error getting block size.");
                 return rc;
+        }
 
         if (bsize != 512) {
-                printf("Device block size != 512.\n");
+                sysinst_error(sysinst, "Device block size != 512.");
                 return EIO;
         }
 
-        printf("sysinst_copy_boot_blocks: read boot block\n");
+        log_msg(LOG_DEFAULT, LVL_NOTE,
+            "sysinst_copy_boot_blocks: read boot block");
+
         rc = block_read_direct(sid, BOOT_BLOCK_IDX, 1, bbuf);
-        if (rc != EOK)
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error reading boot block.");
                 return EIO;
+        }
 
         core_start = 16;
@@ -417 +1160 @@
                 --bl;
                 if ((void *)bl < core_img) {
-                        printf("No block terminator in core image.\n");
+                        sysinst_error(sysinst,
+                            "No block terminator in core image.");
                         return EIO;
                 }
@@ -431 +1175 @@
         set_unaligned_u64le(bbuf + grub_boot_machine_kernel_sector, core_start);
 
-        printf("sysinst_copy_boot_blocks: write boot block\n");
+        log_msg(LOG_DEFAULT, LVL_NOTE,
+            "sysinst_copy_boot_blocks: write boot block");
+
         rc = block_write_direct(sid, BOOT_BLOCK_IDX, 1, bbuf);
-        if (rc != EOK)
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error writing boot block.");
                 return EIO;
-
-        printf("sysinst_copy_boot_blocks: write core blocks\n");
+        }
+
+        log_msg(LOG_DEFAULT, LVL_NOTE,
+            "sysinst_copy_boot_blocks: write core blocks");
+
         /* XXX Must pad last block with zeros */
         rc = block_write_direct(sid, core_start, core_blocks, core_img);
-        if (rc != EOK)
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error writing GRUB core blocks.");
                 return EIO;
-
-        printf("sysinst_copy_boot_blocks: OK.\n");
+        }
+
+        log_msg(LOG_DEFAULT, LVL_NOTE,
+            "sysinst_copy_boot_blocks: OK.");
+
         return EOK;
 }
@@ -448 +1202 @@
 /** Eject installation volume.
  *
- * @param psvc_id Partition service ID
- */
-static errno_t sysinst_eject_dev(service_id_t part_id)
+ * @param sysinst System installer
+ * @param part_id Partition service ID
+ * @return EOK on success or an error code
+ */
+static errno_t sysinst_eject_dev(sysinst_t *sysinst, service_id_t part_id)
 {
         vol_t *vol = NULL;
@@ -457 +1213 @@
         rc = vol_create(&vol);
         if (rc != EOK) {
-                printf("Error contacting volume service.\n");
+                sysinst_error(sysinst, "Error contacting volume service.");
                 goto out;
         }
 
-        rc = vol_part_eject(vol, part_id);
-        if (rc != EOK) {
-                printf("Error ejecting volume.\n");
+        rc = vol_part_eject(vol, part_id, vef_none);
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error ejecting volume.");
                 goto out;
         }
@@ -473 +1229 @@
 }
 
+/** Physically eject volume by mount point.
+ *
+ * @param sysinst System installer
+ * @param path Mount point
+ * @return EOK on success or an error code
+ */
+static errno_t sysinst_eject_phys_by_mp(sysinst_t *sysinst, const char *path)
+{
+        vol_t *vol = NULL;
+        sysarg_t part_id;
+        errno_t rc;
+
+        log_msg(LOG_DEFAULT, LVL_NOTE,
+            "sysinst_eject_phys_by_mp(%s)", path);
+
+        rc = vol_create(&vol);
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error contacting volume service.");
+                goto out;
+        }
+
+        log_msg(LOG_DEFAULT, LVL_NOTE, "vol_part_by_mp: mp='%s'\n",
+            path);
+        rc = vol_part_by_mp(vol, path, &part_id);
+        if (rc != EOK) {
+                sysinst_error(sysinst,
+                    "Error finding installation media mount point.");
+                goto out;
+        }
+
+        log_msg(LOG_DEFAULT, LVL_NOTE, "eject svc_id %lu", (unsigned long)part_id);
+        rc = vol_part_eject(vol, part_id, vef_physical);
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error ejecting volume.");
+                goto out;
+        }
+
+        rc = EOK;
+out:
+        vol_destroy(vol);
+        return rc;
+}
+
+/** Restart the system.
+ *
+ * @param sysinst System installer
+ * @return EOK on success or an error code
+ */
+static errno_t sysinst_restart(sysinst_t *sysinst)
+{
+        errno_t rc;
+        system_t *system;
+
+        fibril_mutex_initialize(&shutdown_lock);
+        fibril_condvar_initialize(&shutdown_cv);
+        shutdown_stopped = false;
+        shutdown_failed = false;
+
+        sysinst_action(sysinst, "Restarting the system.");
+
+        rc = system_open(SYSTEM_DEFAULT, &sysinst_system_cb, NULL, &system);
+        if (rc != EOK) {
+                sysinst_error(sysinst,
+                    "Failed opening system control service.");
+                return rc;
+        }
+
+        rc = system_restart(system);
+        if (rc != EOK) {
+                system_close(system);
+                sysinst_error(sysinst, "Failed requesting system restart.");
+                return rc;
+        }
+
+        fibril_mutex_lock(&shutdown_lock);
+        sysinst_debug(sysinst, "The system is shutting down...");
+
+        while (!shutdown_stopped)
+                fibril_condvar_wait(&shutdown_cv, &shutdown_lock);
+
+        if (shutdown_failed) {
+                sysinst_error(sysinst, "Shutdown failed.");
+                system_close(system);
+                return rc;
+        }
+
+        log_msg(LOG_DEFAULT, LVL_NOTE,
+            "Shutdown complete. It is now safe to remove power.");
+
+        /* Sleep forever */
+        while (true)
+                fibril_condvar_wait(&shutdown_cv, &shutdown_lock);
+
+        fibril_mutex_unlock(&shutdown_lock);
+
+        system_close(system);
+        return 0;
+
+}
+
 /** Install system to a device.
  *
+ * @parma sysinst System installer
  * @param dev Device to install to.
  * @return EOK on success or an error code
  */
-static errno_t sysinst_install(const char *dev)
-{
-        errno_t rc;
-        service_id_t psvc_id;
-
-        rc = sysinst_label_dev(dev, &psvc_id);
+static errno_t sysinst_install(sysinst_t *sysinst, const char *dev)
+{
+        errno_t rc;
+        bool clean_dev = false;
+
+        sysinst_action(sysinst, "Creating device label and file system.");
+
+        rc = sysinst_label_dev(sysinst, dev);
+        if (rc != EOK)
+                goto error;
+        if (sysinst->quit)
+                return EOK;
+
+        clean_dev = true;
+
+        sysinst_action(sysinst, "Creating system directory structure.");
+        rc = sysinst_setup_sysvol(sysinst);
+        if (rc != EOK)
+                goto error;
+
+        sysinst_action(sysinst, "Copying boot files.");
+        rc = sysinst_copy_boot_files(sysinst);
+        if (rc != EOK)
+                goto error;
+
+        sysinst_action(sysinst, "Configuring the system.");
+        rc = sysinst_customize_initrd(sysinst);
+        if (rc != EOK)
+                goto error;
+
+        sysinst_action(sysinst, "Finishing system volume.");
+        rc = sysinst_finish_dev(sysinst);
+        if (rc != EOK)
+                goto error;
+
+        clean_dev = false;
+
+        sysinst_action(sysinst, "Installing boot blocks.");
+        rc = sysinst_copy_boot_blocks(sysinst, dev);
         if (rc != EOK)
                 return rc;
 
-        printf("FS created and mounted. Creating system directory structure.\n");
-        rc = sysinst_setup_sysvol();
-        if (rc != EOK)
-                return rc;
-
-        printf("Directories created. Copying boot files.\n");
-        rc = sysinst_copy_boot_files();
-        if (rc != EOK)
-                return rc;
-
-        printf("Boot files done. Configuring the system.\n");
-        rc = sysinst_customize_initrd();
-        if (rc != EOK)
-                return rc;
-
-        printf("Boot files done. Installing boot blocks.\n");
-        rc = sysinst_copy_boot_blocks(dev);
-        if (rc != EOK)
-                return rc;
-
-        printf("Ejecting device.\n");
-        rc = sysinst_eject_dev(psvc_id);
-        if (rc != EOK)
-                return rc;
-
         return EOK;
-}
-
-int main(int argc, char *argv[])
-{
+error:
+        if (clean_dev)
+                (void)sysinst_finish_dev(sysinst);
+        return rc;
+}
+
+/** Installation fibril.
+ *
+ * @param arg Argument (sysinst_t *)
+ * @return EOK on success or an error code
+ */
+static errno_t sysinst_install_fibril(void *arg)
+{
+        sysinst_t *sysinst = (sysinst_t *)arg;
         unsigned i;
         errno_t rc;
+
+        (void)sysinst;
 
         i = 0;
@@ -525 +1402 @@
                 if (rc == EOK)
                         break;
+                ++i;
         }
 
         if (default_devs[i] == NULL) {
-                printf("Cannot determine installation device.\n");
+                sysinst_error(sysinst, "Cannot determine installation device.");
+                rc = ENOENT;
+                goto error;
+        }
+
+        rc = sysinst_install(sysinst, default_devs[i]);
+        if (rc != EOK)
+                goto error;
+
+        sysinst_progress_destroy(sysinst->progress);
+        sysinst->progress = NULL;
+
+        /* User decided not to upgrade system? */
+        if (sysinst->quit) {
+                ui_quit(sysinst->ui);
+                return EOK;
+        }
+
+        rc = sysinst_restart_dlg_create(sysinst);
+        if (rc != EOK)
+                goto error;
+
+        return EOK;
+error:
+        ui_lock(sysinst->ui);
+        sysinst_progress_destroy(sysinst->progress);
+        (void)sysinst_error_msg_create(sysinst);
+        ui_unlock(sysinst->ui);
+        return rc;
+}
+
+/** Create installation progress window.
+ *
+ * @param sysinst System installer
+ * @param rprogress Place to store pointer to new progress window
+ * @return EOK on success or an error code
+ */
+static errno_t sysinst_progress_create(sysinst_t *sysinst,
+    sysinst_progress_t **rprogress)
+{
+        ui_wnd_params_t params;
+        ui_window_t *window = NULL;
+        gfx_rect_t rect;
+        gfx_rect_t arect;
+        ui_resource_t *ui_res;
+        sysinst_progress_t *progress;
+        ui_fixed_t *fixed = NULL;
+        errno_t rc;
+
+        ui_wnd_params_init(&params);
+        params.caption = "System Installation";
+        params.style &= ~ui_wds_titlebar;
+        params.flags |= ui_wndf_topmost;
+        params.placement = ui_wnd_place_center;
+        if (ui_is_textmode(sysinst->ui)) {
+                params.rect.p0.x = 0;
+                params.rect.p0.y = 0;
+                params.rect.p1.x = 64;
+                params.rect.p1.y = 7;
+        } else {
+                params.rect.p0.x = 0;
+                params.rect.p0.y = 0;
+                params.rect.p1.x = 500;
+                params.rect.p1.y = 90;
+        }
+
+        progress = calloc(1, sizeof(sysinst_progress_t));
+        if (progress == NULL) {
+                rc = ENOMEM;
+                sysinst_error(sysinst, "Out of memory.");
+                goto error;
+        }
+
+        rc = ui_window_create(sysinst->ui, &params, &window);
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error creating window.");
+                goto error;
+        }
+
+        ui_window_set_cb(window, &progress_window_cb, (void *)sysinst);
+
+        ui_res = ui_window_get_res(window);
+
+        rc = ui_fixed_create(&fixed);
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error creating fixed layout.");
+                goto error;
+        }
+
+        /* Installing/upgrading system line */
+        rc = ui_label_create(ui_res, "Installing system. Please wait...",
+            &progress->label);
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error creating label.");
+                goto error;
+        }
+
+        ui_window_get_app_rect(window, &arect);
+
+        if (ui_is_textmode(sysinst->ui)) {
+                rect.p0.x = arect.p0.x;
+                rect.p0.y = arect.p0.y;
+                rect.p1.x = arect.p1.x;
+                rect.p1.y = 2;
+        } else {
+                rect.p0.x = arect.p0.x;
+                rect.p0.y = arect.p0.y;
+                rect.p1.x = arect.p1.x;
+                rect.p1.y = 30;
+        }
+        ui_label_set_rect(progress->label, &rect);
+        ui_label_set_halign(progress->label, gfx_halign_center);
+        ui_label_set_valign(progress->label, gfx_valign_center);
+
+        rc = ui_fixed_add(fixed, ui_label_ctl(progress->label));
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error adding control to layout.");
+                ui_label_destroy(progress->label);
+                progress->label = NULL;
+                goto error;
+        }
+
+        /* Action line */
+        rc = ui_label_create(ui_res, "",
+            &progress->action);
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error creating label.");
+                goto error;
+        }
+
+        if (ui_is_textmode(sysinst->ui)) {
+                rect.p0.x = arect.p0.x;
+                rect.p0.y = 3;
+                rect.p1.x = arect.p1.x;
+                rect.p1.y = 4;
+        } else {
+                rect.p0.x = arect.p0.x;
+                rect.p0.y = 40;
+                rect.p1.x = arect.p1.x;
+                rect.p1.y = 60;
+        }
+        ui_label_set_rect(progress->action, &rect);
+        ui_label_set_halign(progress->action, gfx_halign_center);
+        ui_label_set_valign(progress->action, gfx_valign_top);
+
+        rc = ui_fixed_add(fixed, ui_label_ctl(progress->action));
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error adding control to layout.");
+                ui_label_destroy(progress->label);
+                progress->label = NULL;
+                goto error;
+        }
+
+        /* Progress line */
+        rc = ui_label_create(ui_res, "",
+            &progress->progress);
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error creating label.");
+                goto error;
+        }
+
+        if (ui_is_textmode(sysinst->ui)) {
+                rect.p0.x = arect.p0.x;
+                rect.p0.y = 5;
+                rect.p1.x = arect.p1.x;
+                rect.p1.y = arect.p1.y;
+        } else {
+                rect.p0.x = arect.p0.x;
+                rect.p0.y = 70;
+                rect.p1.x = arect.p1.x;
+                rect.p1.y = arect.p1.y;
+        }
+        ui_label_set_rect(progress->progress, &rect);
+        ui_label_set_halign(progress->progress, gfx_halign_center);
+        ui_label_set_valign(progress->progress, gfx_valign_top);
+
+        rc = ui_fixed_add(fixed, ui_label_ctl(progress->progress));
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error adding control to layout.");
+                ui_label_destroy(progress->label);
+                progress->label = NULL;
+                goto error;
+        }
+
+        ui_window_add(window, ui_fixed_ctl(fixed));
+        fixed = NULL;
+
+        rc = ui_window_paint(window);
+        if (rc != EOK) {
+                sysinst_error(sysinst, "Error painting window.");
+                goto error;
+        }
+
+        progress->window = window;
+        progress->fixed = fixed;
+        *rprogress = progress;
+        return EOK;
+error:
+        if (progress != NULL && progress->fixed != NULL)
+                ui_fixed_destroy(progress->fixed);
+        if (window != NULL)
+                ui_window_destroy(window);
+        if (progress != NULL)
+                free(progress);
+        return rc;
+}
+
+/** Destroy installation progress window.
+ *
+ * @param sysinst System installer
+ * @param rprogress Place to store pointer to new progress window
+ * @return EOK on success or an error code
+ */
+static void sysinst_progress_destroy(sysinst_progress_t *progress)
+{
+        if (progress == NULL)
+                return;
+
+        ui_window_destroy(progress->window);
+        free(progress);
+}
+
+/** Set current progress message.
+ *
+ * @param sysinst System installer
+ * @param progress Progress text
+ */
+static void sysinst_progress(sysinst_t *sysinst, const char *progress)
+{
+        log_msg(LOG_DEFAULT, LVL_NOTE, "%s", progress);
+
+        if (sysinst->progress == NULL)
+                return;
+
+        ui_label_set_text(sysinst->progress->progress, progress);
+        ui_label_paint(sysinst->progress->progress);
+}
+
+/** Set current action message.
+ *
+ * @param sysinst System installer
+ * @param action Action text
+ */
+static void sysinst_action(sysinst_t *sysinst, const char *action)
+{
+        log_msg(LOG_DEFAULT, LVL_NOTE, "%s", action);
+
+        if (sysinst->progress == NULL)
+                return;
+
+        ui_label_set_text(sysinst->progress->action, action);
+        ui_label_paint(sysinst->progress->action);
+}
+
+/** Set current error message.
+ *
+ * @param sysinst System installer
+ * @param errmsg Error message
+ */
+static void sysinst_error(sysinst_t *sysinst, const char *errmsg)
+{
+        str_cpy(sysinst->errmsg, sizeof(sysinst->errmsg), errmsg);
+        log_msg(LOG_DEFAULT, LVL_ERROR, errmsg);
+}
+
+/** Log a debug message.
+ *
+ * @param sysinst System installer
+ * @param errmsg Error message
+ */
+static void sysinst_debug(sysinst_t *sysinst, const char *msg)
+{
+        log_msg(LOG_DEFAULT, LVL_ERROR, msg);
+}
+
+/** Start system installation.
+ *
+ * @param sysinst System installer
+ * @return EOK on success or an error code
+ */
+static int sysinst_start(sysinst_t *sysinst)
+{
+        errno_t rc;
+        fid_t fid;
+
+        rc = sysinst_progress_create(sysinst, &sysinst->progress);
+        if (rc != EOK)
+                return rc;
+
+        fid = fibril_create(sysinst_install_fibril, (void *)sysinst);
+        if (fid == 0) {
+                sysinst_error(sysinst, "Out of memory.");
+                return ENOMEM;
+        }
+
+        fibril_add_ready(fid);
+        return EOK;
+}
+
+/** Create installation confirmation dialog.
+ *
+ * @param sysinst System installer
+ * @return EOK on success or an error code
+ */
+static errno_t sysinst_confirm_create(sysinst_t *sysinst)
+{
+        ui_msg_dialog_params_t params;
+        ui_msg_dialog_t *dialog;
+        errno_t rc;
+
+        ui_msg_dialog_params_init(&params);
+        params.caption = "System installation";
+        params.text = "This will install HelenOS to your computer. Continue?";
+        params.choice = umdc_ok_cancel;
+        params.flags |= umdf_topmost | umdf_center;
+
+        rc = ui_msg_dialog_create(sysinst->ui, &params, &dialog);
+        if (rc != EOK)
+                return rc;
+
+        ui_msg_dialog_set_cb(dialog, &sysinst_confirm_cb, sysinst);
+        return EOK;
+}
+
+/** Create upgrade confirmation dialog.
+ *
+ * @param sysinst System installer
+ * @return EOK on success or an error code
+ */
+static errno_t sysinst_upgrade_confirm_create(sysinst_t *sysinst)
+{
+        ui_msg_dialog_params_t params;
+        ui_msg_dialog_t *dialog;
+        errno_t rc;
+
+        ui_msg_dialog_params_init(&params);
+        params.caption = "System upgrade";
+        params.text = "Existing installation found. "
+            "Do you want to upgrade it?";
+        params.choice = umdc_ok_cancel;
+        params.flags |= umdf_topmost | umdf_center;
+
+        rc = ui_msg_dialog_create(sysinst->ui, &params, &dialog);
+        if (rc != EOK)
+                return rc;
+
+        ui_msg_dialog_set_cb(dialog, &sysinst_upgrade_confirm_cb, sysinst);
+        return EOK;
+}
+
+/** Create restart dialog.
+ *
+ * @param sysinst System installer
+ * @return EOK on success or an error code
+ */
+static errno_t sysinst_restart_dlg_create(sysinst_t *sysinst)
+{
+        ui_msg_dialog_params_t params;
+        ui_msg_dialog_t *dialog;
+        errno_t rc;
+
+        ui_msg_dialog_params_init(&params);
+        params.caption = "Restart System";
+
+        if (sysinst->oper == sio_install)
+                params.text = "Installation complete. Restart the system?";
+        else
+                params.text = "Upgrade complete. Restart the system?";
+
+        params.choice = umdc_ok_cancel;
+        params.flags |= umdf_topmost | umdf_center;
+
+        rc = ui_msg_dialog_create(sysinst->ui, &params, &dialog);
+        if (rc != EOK)
+                return rc;
+
+        ui_msg_dialog_set_cb(dialog, &sysinst_restart_dlg_cb, sysinst);
+        return EOK;
+}
+
+/** Run system installer on display.
+ *
+ * @param display_spec Display specification
+ * @return EOK on success or an error code
+ */
+static errno_t sysinst_run(const char *display_spec)
+{
+        ui_t *ui = NULL;
+        sysinst_t *sysinst;
+        ui_wnd_params_t params;
+        errno_t rc;
+
+        sysinst = calloc(1, sizeof(sysinst_t));
+        if (sysinst == NULL)
+                return ENOMEM;
+
+        fibril_condvar_initialize(&sysinst->responded_cv);
+        fibril_mutex_initialize(&sysinst->responded_lock);
+
+        rc = fmgt_create(&sysinst->fmgt);
+        if (rc != EOK) {
+                printf("Out of memory.\n");
+                goto error;
+        }
+
+        fmgt_set_cb(sysinst->fmgt, &sysinst_fmgt_cb, (void *)sysinst);
+        fmgt_set_init_update(sysinst->fmgt, true);
+
+        rc = ui_create(display_spec, &ui);
+        if (rc != EOK) {
+                printf("Error creating UI on display %s.\n", display_spec);
+                goto error;
+        }
+
+        sysinst->ui = ui;
+
+        ui_wnd_params_init(&params);
+        params.caption = "System Installation";
+        params.style &= ~ui_wds_decorated;
+        params.placement = ui_wnd_place_full_screen;
+        params.flags |= ui_wndf_topmost | ui_wndf_nofocus;
+
+        rc = ui_window_create(sysinst->ui, &params, &sysinst->bgwindow);
+        if (rc != EOK) {
+                printf("Error creating window.\n");
+                goto error;
+        }
+
+        ui_window_set_cb(sysinst->bgwindow, &bg_window_cb, (void *)sysinst);
+
+        if (ui_is_textmode(sysinst->ui)) {
+                rc = gfx_color_new_ega(0x17, &sysinst->bg_color);
+                if (rc != EOK) {
+                        printf("Error allocating color.\n");
+                        goto error;
+                }
+        } else {
+                rc = gfx_color_new_rgb_i16(0x8000, 0xc800, 0xffff, &sysinst->bg_color);
+                if (rc != EOK) {
+                        printf("Error allocating color.\n");
+                        goto error;
+                }
+        }
+
+        rc = ui_window_paint(sysinst->bgwindow);
+        if (rc != EOK) {
+                printf("Error painting window.\n");
+                goto error;
+        }
+
+        rc = sysinst_confirm_create(sysinst);
+        if (rc != EOK) {
+                printf("Error creating window.\n");
+                goto error;
+        }
+
+        ui_run(ui);
+
+        if (sysinst->bgwindow != NULL)
+                ui_window_destroy(sysinst->bgwindow);
+        if (sysinst->system != NULL)
+                system_close(sysinst->system);
+        gfx_color_delete(sysinst->bg_color);
+        ui_destroy(ui);
+        free(sysinst);
+        return EOK;
+error:
+        if (sysinst->fmgt != NULL)
+                fmgt_destroy(sysinst->fmgt);
+        if (sysinst->system != NULL)
+                system_close(sysinst->system);
+        if (sysinst->bg_color != NULL)
+                gfx_color_delete(sysinst->bg_color);
+        if (sysinst->bgwindow != NULL)
+                ui_window_destroy(sysinst->bgwindow);
+        if (ui != NULL)
+                ui_destroy(ui);
+        free(sysinst);
+        return rc;
+}
+
+static void print_syntax(void)
+{
+        printf("Syntax: " NAME " [-d <display-spec>]\n");
+}
+
+int main(int argc, char *argv[])
+{
+        const char *display_spec = UI_ANY_DEFAULT;
+        errno_t rc;
+        int i;
+
+        i = 1;
+        while (i < argc && argv[i][0] == '-') {
+                if (str_cmp(argv[i], "-d") == 0) {
+                        ++i;
+                        if (i >= argc) {
+                                printf("Argument missing.\n");
+                                print_syntax();
+                                return 1;
+                        }
+
+                        display_spec = argv[i++];
+                } else {
+                        printf("Invalid option '%s'.\n", argv[i]);
+                        print_syntax();
+                        return 1;
+                }
+        }
+
+        if (i < argc) {
+                print_syntax();
                 return 1;
         }
 
-        return sysinst_install(default_devs[i]);
+        if (log_init(NAME) != EOK) {
+                printf(NAME ": Failed to initialize logging.\n");
+                return 1;
+        }
+
+        rc = sysinst_run(display_spec);
+        if (rc != EOK)
+                return 1;
+
+        return 0;
 }