Changeset a188131 in mainline


Ignore:
Timestamp:
2025-04-09T19:05:44Z (5 days ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
master
Children:
3acb63b5, a78b0a0
Parents:
597fa24
Message:

Add UI to system installer

Location:
uspace
Files:
2 added
10 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/shutdown-dlg/shutdown-dlg.c

    r597fa24 ra188131  
    238238 *
    239239 * @param dialog Message dialog
    240  * @param arg Argument (ui_demo_t *)
     240 * @param arg Argument (shutdown_dlg_t *)
    241241 * @param earg Entry argument
    242242 */
    … …  
    254254 *
    255255 * @param dialog Message dialog
    256  * @param arg Argument (ui_demo_t *)
     256 * @param arg Argument (shutdown_dlg_t *)
    257257 */
    258258static void shutdown_confirm_bcancel(ui_select_dialog_t *dialog, void *arg)
    … …  
    267267 *
    268268 * @param dialog Message dialog
    269  * @param arg Argument (ui_demo_t *)
     269 * @param arg Argument (shutdown_dlg_t *)
    270270 */
    271271static void shutdown_confirm_close(ui_select_dialog_t *dialog, void *arg)
    … …  
    280280 *
    281281 * @param dialog Message dialog
    282  * @param arg Argument (ui_demo_t *)
     282 * @param arg Argument (shutdown_dlg_t *)
    283283 * @param bnum Button number
    284284 */
    … …  
    295295 *
    296296 * @param dialog Message dialog
    297  * @param arg Argument (ui_demo_t *)
     297 * @param arg Argument (shutdown_dlg_t *)
    298298 */
    299299static void shutdown_failed_msg_close(ui_msg_dialog_t *dialog, void *arg)
    … …  
    480480
    481481        ui_wnd_params_init(&params);
    482         params.caption = "Shut down background";
     482        params.caption = "Shutdown";
    483483        params.style &= ~ui_wds_decorated;
    484484        params.placement = ui_wnd_place_full_screen;
    485485        params.flags |= ui_wndf_topmost | ui_wndf_nofocus;
    486         /*
    487          * params.rect.p0.x = 0;
    488          * params.rect.p0.y = 0;
    489          * params.rect.p1.x = 1;
    490          * params.rect.p1.y = 1;
    491          */
    492486
    493487        rc = ui_window_create(sddlg.ui, &params, &sddlg.bgwindow);

  • uspace/app/shutdown-dlg/shutdown-dlg.h

    r597fa24 ra188131  
    2727 */
    2828
    29 /** @addtogroup hello
     29/** @addtogroup shutdown-dlg
    3030 * @{
    3131 */

  • uspace/app/sysinst/meson.build

    r597fa24 ra188131  
    11#
    2 # Copyright (c) 2014 Jiri Svoboda
     2# Copyright (c) 2025 Jiri Svoboda
    33# All rights reserved.
    44#
    … …  
    2727#
    2828
    29 deps = [ 'block', 'fdisk', 'futil', 'sif', 'system' ]
     29deps = [ 'block', 'fdisk', 'futil', 'sif', 'system', 'ui' ]
    3030src = files(
    3131        'rdimg.c',

  • uspace/app/sysinst/rdimg.c

    r597fa24 ra188131  
    3535#include <errno.h>
    3636#include <fibril.h>
     37#include <io/log.h>
    3738#include <stdio.h>
    3839#include <stdlib.h>
    … …  
    6061        rc = vol_get_parts(vol, &part_ids, &nparts);
    6162        if (rc != EOK) {
    62                 printf("Error getting list of volumes.\n");
     63                log_msg(LOG_DEFAULT, LVL_ERROR,
     64                    "Error getting list of volumes.");
    6365                goto out;
    6466        }
    … …  
    6769                rc = vol_part_info(vol, part_ids[i], &vinfo);
    6870                if (rc != EOK) {
    69                         printf("Error getting volume information.\n");
     71                        log_msg(LOG_DEFAULT, LVL_ERROR,
     72                            "Error getting volume information.");
    7073                        rc = EIO;
    7174                        goto out;
    … …  
    106109        int cnt;
    107110
    108         printf("rd_img_open: begin\n");
     111        log_msg(LOG_DEFAULT, LVL_NOTE, "rd_img_open: begin");
     112
    109113        rdpath = str_dup("/vol/" RD_LABEL);
    110114        if (rdpath == NULL) {
    … …  
    119123        }
    120124
    121         printf("rd_img_open: spawn file_bd\n");
     125        log_msg(LOG_DEFAULT, LVL_NOTE, "rd_img_open: spawn file_bd");
    122126        rc = task_spawnl(&id, &wait, FILE_BD, FILE_BD, imgpath, RD_SVC, NULL);
    123127        if (rc != EOK) {
    … …  
    126130        }
    127131
    128         printf("rd_img_open: wait for file_bd\n");
     132        log_msg(LOG_DEFAULT, LVL_NOTE, "rd_img_open: wait for file_bd");
    129133        rc = task_wait(&wait, &texit, &retval);
    130134        if (rc != EOK || texit != TASK_EXIT_NORMAL) {
    … …  
    134138
    135139        /* Wait for the RAM disk to become available */
    136         printf("rd_img_open: wait for RAM disk to be mounted\n");
     140        log_msg(LOG_DEFAULT, LVL_NOTE,
     141            "rd_img_open: wait for RAM disk to be mounted");
    137142        cnt = 10;
    138143        while (cnt > 0) {
    … …  
    146151
    147152        if (cnt == 0) {
    148                 printf("rd_img_open: ran out of time\n");
     153                log_msg(LOG_DEFAULT, LVL_ERROR, "rd_img_open: ran out of time");
    149154                rc = EIO;
    150155                goto error;
    … …  
    154159        *rimg = img;
    155160        *rpath = rdpath;
    156         printf("rd_img_open: success\n");
     161        log_msg(LOG_DEFAULT, LVL_NOTE, "rd_img_open: success");
    157162        return EOK;
    158163error:
    … …  
    173178        vol_t *vol = NULL;
    174179
    175         printf("rd_img_close: begin\n");
     180        log_msg(LOG_DEFAULT, LVL_NOTE, "rd_img_close: begin");
    176181
    177182        rc = vol_create(&vol);
    178183        if (rc != EOK) {
    179                 printf("Error opening volume management service.\n");
    180                 rc = EIO;
    181                 goto error;
    182         }
    183 
    184         printf("rd_img_close: Find RAM disk volume.\n");
     184                log_msg(LOG_DEFAULT, LVL_ERROR,
     185                    "Error opening volume management service.");
     186                rc = EIO;
     187                goto error;
     188        }
     189
     190        log_msg(LOG_DEFAULT, LVL_NOTE, "rd_img_close: Find RAM disk volume.");
    185191        rc = rd_img_part_by_label(vol, RD_LABEL, &rd_svcid);
    186192        if (rc != EOK) {
    187                 printf("Error getting RAM disk service ID.\n");
    188                 rc = EIO;
    189                 goto error;
    190         }
    191 
    192         printf("rd_img_close: eject RAM disk volume\n");
     193                log_msg(LOG_DEFAULT, LVL_ERROR,
     194                    "Error getting RAM disk service ID.");
     195                rc = EIO;
     196                goto error;
     197        }
     198
     199        log_msg(LOG_DEFAULT, LVL_NOTE, "rd_img_close: eject RAM disk volume");
    193200        rc = vol_part_eject(vol, rd_svcid, vef_none);
    194201        if (rc != EOK) {
    195                 printf("Error ejecting RAM disk volume.\n");
     202                log_msg(LOG_DEFAULT, LVL_ERROR,
     203                    "Error ejecting RAM disk volume.");
    196204                rc = EIO;
    197205                goto error;
    … …  
    202210        rc = task_kill(img->filebd_tid);
    203211        if (rc != EOK) {
    204                 printf("Error killing file_bd.\n");
     212                log_msg(LOG_DEFAULT, LVL_ERROR, "Error killing file_bd.");
    205213                rc = EIO;
    206214                goto error;
    … …  
    208216
    209217        free(img);
    210         printf("rd_img_close: success\n");
     218        log_msg(LOG_DEFAULT, LVL_NOTE, "rd_img_close: success");
    211219        return EOK;
    212220error:

  • uspace/app/sysinst/sysinst.c

    r597fa24 ra188131  
    4242#include <fdisk.h>
    4343#include <futil.h>
     44#include <gfx/render.h>
     45#include <io/log.h>
    4446#include <loc.h>
    4547#include <stdio.h>
    … …  
    4850#include <str_error.h>
    4951#include <system.h>
     52#include <ui/msgdialog.h>
     53#include <ui/ui.h>
     54#include <ui/window.h>
    5055#include <vfs/vfs.h>
    5156#include <vol.h>
    … …  
    5459#include "rdimg.h"
    5560#include "volume.h"
     61#include "sysinst.h"
     62
     63#define NAME "sysinst"
    5664
    5765/** Device to install to
    … …  
    96104};
    97105
    98 static bool restart = false;
    99 
    100106static fibril_mutex_t shutdown_lock;
    101107static fibril_condvar_t shutdown_cv;
    … …  
    110116        .shutdown_failed = sysinst_shutdown_failed
    111117};
     118
     119static void wnd_close(ui_window_t *, void *);
     120static errno_t bg_wnd_paint(ui_window_t *, void *);
     121
     122static ui_window_cb_t bg_window_cb = {
     123        .close = wnd_close,
     124        .paint = bg_wnd_paint
     125};
     126
     127static ui_window_cb_t progress_window_cb = {
     128        .close = wnd_close
     129};
     130
     131static void sysinst_confirm_button(ui_msg_dialog_t *, void *, unsigned);
     132static void sysinst_confirm_close(ui_msg_dialog_t *, void *);
     133
     134static ui_msg_dialog_cb_t sysinst_confirm_cb = {
     135        .button = sysinst_confirm_button,
     136        .close = sysinst_confirm_close
     137};
     138
     139static errno_t sysinst_restart_dlg_create(sysinst_t *);
     140static void sysinst_restart_dlg_button(ui_msg_dialog_t *, void *, unsigned);
     141static void sysinst_restart_dlg_close(ui_msg_dialog_t *, void *);
     142
     143static ui_msg_dialog_cb_t sysinst_restart_dlg_cb = {
     144        .button = sysinst_restart_dlg_button,
     145        .close = sysinst_restart_dlg_close
     146};
     147
     148static int sysinst_start(sysinst_t *);
     149static errno_t sysinst_restart(sysinst_t *);
     150static void sysinst_progress_destroy(sysinst_progress_t *);
     151static void sysinst_action(sysinst_t *, const char *);
     152static void sysinst_error(sysinst_t *, const char *);
     153static void sysinst_debug(sysinst_t *, const char *);
     154
     155static void sysinst_futil_copy_file(void *, const char *, const char *);
     156static void sysinst_futil_create_dir(void *, const char *);
     157
     158static futil_cb_t sysinst_futil_cb = {
     159        .copy_file = sysinst_futil_copy_file,
     160        .create_dir = sysinst_futil_create_dir
     161};
     162
     163static void sysinst_error_msg_button(ui_msg_dialog_t *, void *, unsigned);
     164static void sysinst_error_msg_close(ui_msg_dialog_t *, void *);
     165
     166static ui_msg_dialog_cb_t sysinst_error_msg_cb = {
     167        .button = sysinst_error_msg_button,
     168        .close = sysinst_error_msg_close
     169};
     170
     171/** Close window.
     172 *
     173 * @param window Window
     174 * @param arg Argument (sysinst_t *)
     175 */
     176static void wnd_close(ui_window_t *window, void *arg)
     177{
     178        (void)window;
     179        (void)arg;
     180}
     181
     182/** Paint background window.
     183 *
     184 * @param window Window
     185 * @param arg Argument (sysinst_t *)
     186 */
     187static errno_t bg_wnd_paint(ui_window_t *window, void *arg)
     188{
     189        sysinst_t *sysinst = (sysinst_t *)arg;
     190        gfx_rect_t app_rect;
     191        gfx_context_t *gc;
     192        errno_t rc;
     193
     194        gc = ui_window_get_gc(window);
     195
     196        rc = gfx_set_color(gc, sysinst->bg_color);
     197        if (rc != EOK)
     198                return rc;
     199
     200        ui_window_get_app_rect(window, &app_rect);
     201
     202        rc = gfx_fill_rect(gc, &app_rect);
     203        if (rc != EOK)
     204                return rc;
     205
     206        rc = gfx_update(gc);
     207        if (rc != EOK)
     208                return rc;
     209
     210        return EOK;
     211}
     212
     213/** Installation confirm dialog OK button press.
     214 *
     215 * @param dialog Message dialog
     216 * @param arg Argument (sysinst_t *)
     217 * @param btn Button number
     218 * @param earg Entry argument
     219 */
     220static void sysinst_confirm_button(ui_msg_dialog_t *dialog, void *arg,
     221    unsigned btn)
     222{
     223        sysinst_t *sysinst = (sysinst_t *) arg;
     224
     225        ui_msg_dialog_destroy(dialog);
     226
     227        switch (btn) {
     228        case 0:
     229                /* OK */
     230                sysinst_start(sysinst);
     231                break;
     232        default:
     233                /* Cancel */
     234                ui_quit(sysinst->ui);
     235                break;
     236        }
     237}
     238
     239/** Installation confirm dialog close request.
     240 *
     241 * @param dialog Message dialog
     242 * @param arg Argument (sysinst_t *)
     243 */
     244static void sysinst_confirm_close(ui_msg_dialog_t *dialog, void *arg)
     245{
     246        sysinst_t *sysinst = (sysinst_t *) arg;
     247
     248        ui_msg_dialog_destroy(dialog);
     249        ui_quit(sysinst->ui);
     250}
     251
     252/** Restart system dialog OK button press.
     253 *
     254 * @param dialog Message dialog
     255 * @param arg Argument (sysinst_t *)
     256 * @param btn Button number
     257 * @param earg Entry argument
     258 */
     259static void sysinst_restart_dlg_button(ui_msg_dialog_t *dialog, void *arg,
     260    unsigned btn)
     261{
     262        sysinst_t *sysinst = (sysinst_t *) arg;
     263
     264        ui_msg_dialog_destroy(dialog);
     265
     266        (void)sysinst;
     267
     268        switch (btn) {
     269        case 0:
     270                /* OK */
     271                (void)sysinst_restart(sysinst);
     272                break;
     273        default:
     274                /* Cancel */
     275                ui_quit(sysinst->ui);
     276                break;
     277        }
     278}
     279
     280/** Restat system dialog close request.
     281 *
     282 * @param dialog Message dialog
     283 * @param arg Argument (sysinst_t *)
     284 */
     285static void sysinst_restart_dlg_close(ui_msg_dialog_t *dialog, void *arg)
     286{
     287        sysinst_t *sysinst = (sysinst_t *) arg;
     288
     289        ui_msg_dialog_destroy(dialog);
     290        ui_quit(sysinst->ui);
     291}
     292
     293/** Installation error message dialog button press.
     294 *
     295 * @param dialog Message dialog
     296 * @param arg Argument (sysinst_t *)
     297 * @param bnum Button number
     298 */
     299static void sysinst_error_msg_button(ui_msg_dialog_t *dialog,
     300    void *arg, unsigned bnum)
     301{
     302        sysinst_t *sysinst = (sysinst_t *) arg;
     303
     304        ui_msg_dialog_destroy(dialog);
     305        ui_quit(sysinst->ui);
     306}
     307
     308/** Installation error message dialog close request.
     309 *
     310 * @param dialog Message dialog
     311 * @param arg Argument (shutdown_dlg_t *)
     312 */
     313static void sysinst_error_msg_close(ui_msg_dialog_t *dialog, void *arg)
     314{
     315        sysinst_t *sysinst = (sysinst_t *) arg;
     316
     317        ui_msg_dialog_destroy(dialog);
     318        ui_quit(sysinst->ui);
     319}
     320
     321/** Create error message dialog.
     322 *
     323 * @param sysinst System installer
     324 * @return EOK on success or an error code
     325 */
     326static errno_t sysinst_error_msg_create(sysinst_t *sysinst)
     327{
     328        ui_msg_dialog_params_t params;
     329        ui_msg_dialog_t *dialog;
     330        errno_t rc;
     331
     332        ui_msg_dialog_params_init(&params);
     333        params.caption = "Error";
     334        params.text = sysinst->errmsg;
     335        params.flags |= umdf_topmost | umdf_center;
     336
     337        rc = ui_msg_dialog_create(sysinst->ui, &params, &dialog);
     338        if (rc != EOK)
     339                return rc;
     340
     341        ui_msg_dialog_set_cb(dialog, &sysinst_error_msg_cb, (void *)sysinst);
     342
     343        return EOK;
     344}
     345
     346/** Called when futil is starting to copy a file.
     347 *
     348 * @param arg Argument (sysinst_t *)
     349 * @param src Source path
     350 * @param dest Destination path
     351 */
     352static void sysinst_futil_copy_file(void *arg, const char *src,
     353    const char *dest)
     354{
     355        sysinst_t *sysinst = (sysinst_t *)arg;
     356        char buf[128];
     357
     358        (void)src;
     359        snprintf(buf, sizeof(buf), "Copying %s.", dest);
     360        sysinst_action(sysinst, buf);
     361}
     362
     363/** Called when futil is about to create a directory.
     364 *
     365 * @param arg Argument (sysinst_t *)
     366 * @param dest Destination path
     367 */
     368static void sysinst_futil_create_dir(void *arg, const char *dest)
     369{
     370        sysinst_t *sysinst = (sysinst_t *)arg;
     371        char buf[128];
     372
     373        snprintf(buf, sizeof(buf), "Creating %s.", dest);
     374        sysinst_action(sysinst, buf);
     375}
    112376
    113377/** System shutdown complete.
    … …  
    162426/** Label the destination device.
    163427 *
     428 * @param sysinst System installer
    164429 * @param dev Disk device to label
    165430 * @param psvc_id Place to store service ID of the created partition
    … …  
    167432 * @return EOK on success or an error code
    168433 */
    169 static errno_t sysinst_label_dev(const char *dev, service_id_t *psvc_id)
     434static errno_t sysinst_label_dev(sysinst_t *sysinst, const char *dev,
     435    service_id_t *psvc_id)
    170436{
    171437        fdisk_t *fdisk;
    … …  
    178444        errno_t rc;
    179445
    180         printf("sysinst_label_dev(): get service ID '%s'\n", dev);
     446        sysinst_debug(sysinst, "sysinst_label_dev(): get service ID");
     447
    181448        rc = loc_service_get_id(dev, &sid, 0);
    182449        if (rc != EOK)
    183450                return rc;
    184451
    185         printf("sysinst_label_dev(): open device\n");
     452        sysinst_debug(sysinst, "sysinst_label_dev(): open device");
    186453
    187454        rc = fdisk_create(&fdisk);
    188455        if (rc != EOK) {
    189                 printf("Error initializing fdisk.\n");
     456                sysinst_error(sysinst, "Error initializing fdisk.");
    190457                return rc;
    191458        }
    … …  
    193460        rc = fdisk_dev_open(fdisk, sid, &fdev);
    194461        if (rc != EOK) {
    195                 printf("Error opening device.\n");
    196                 return rc;
    197         }
    198 
    199         printf("sysinst_label_dev(): create mount directory\n");
     462                sysinst_error(sysinst, "Error opening device.");
     463                return rc;
     464        }
     465
     466        sysinst_debug(sysinst, "sysinst_label_dev(): create mount directory");
    200467
    201468        rc = vfs_link_path(MOUNT_POINT, KIND_DIRECTORY, NULL);
    202         if (rc != EOK)
    203                 return rc;
    204 
    205         printf("sysinst_label_dev(): create label\n");
     469        if (rc != EOK) {
     470                sysinst_error(sysinst, "Error creating mount directory.");
     471                return rc;
     472        }
     473
     474        sysinst_debug(sysinst, "sysinst_label_dev(): create label");
    206475
    207476        rc = fdisk_label_create(fdev, lt_mbr);
    208477        if (rc != EOK) {
    209                 printf("Error creating label: %s.\n", str_error(rc));
    210                 return rc;
    211         }
    212 
    213         printf("sysinst_label_dev(): create partition\n");
     478                sysinst_error(sysinst, "Error creating label.");
     479                return rc;
     480        }
     481
     482        sysinst_debug(sysinst, "sysinst_label_dev(): create partition");
    214483
    215484        rc = fdisk_part_get_max_avail(fdev, spc_pri, &capa);
    216485        if (rc != EOK) {
    217                 printf("Error getting available capacity: %s.\n", str_error(rc));
     486                sysinst_error(sysinst,
     487                    "Error getting available capacity.");
    218488                return rc;
    219489        }
    … …  
    228498        rc = fdisk_part_create(fdev, &pspec, &part);
    229499        if (rc != EOK) {
    230                 printf("Error creating partition.\n");
     500                sysinst_error(sysinst, "Error creating partition.");
    231501                return rc;
    232502        }
    … …  
    234504        rc = fdisk_part_get_info(part, &pinfo);
    235505        if (rc != EOK) {
    236                 printf("Error getting partition information.\n");
    237                 return rc;
    238         }
    239 
    240         printf("sysinst_label_dev(): OK\n");
     506                sysinst_error(sysinst, "Error getting partition information.");
     507                return rc;
     508        }
     509
     510        sysinst_debug(sysinst, "sysinst_label_dev(): OK");
    241511        *psvc_id = pinfo.svc_id;
    242512        return EOK;
    … …  
    245515/** Set up system volume structure.
    246516 *
    247  * @return EOK on success or an error code
    248  */
    249 static errno_t sysinst_setup_sysvol(void)
     517 * @param sysinst System installer
     518 * @return EOK on success or an error code
     519 */
     520static errno_t sysinst_setup_sysvol(sysinst_t *sysinst)
    250521{
    251522        errno_t rc;
    … …  
    264535                rc = vfs_link_path(path, KIND_DIRECTORY, NULL);
    265536                if (rc != EOK) {
    266                         printf("Error creating directory '%s'.\n", path);
     537                        sysinst_error(sysinst, "Error creating directory.");
    267538                        goto error;
    268539                }
    … …  
    277548
    278549        /* Copy initial configuration files */
    279         rc = futil_rcopy_contents(CFG_FILES_SRC, CFG_FILES_DEST);
     550        rc = futil_rcopy_contents(sysinst->futil, CFG_FILES_SRC,
     551            CFG_FILES_DEST);
    280552        if (rc != EOK)
    281553                return rc;
    … …  
    292564 * @return EOK on success or an error code
    293565 */
    294 static errno_t sysinst_copy_boot_files(void)
    295 {
    296         errno_t rc;
    297 
    298         printf("sysinst_copy_boot_files(): copy bootloader files\n");
    299         rc = futil_rcopy_contents(BOOT_FILES_SRC, MOUNT_POINT);
    300         if (rc != EOK)
    301                 return rc;
    302 
    303         printf("sysinst_copy_boot_files(): OK\n");
     566static errno_t sysinst_copy_boot_files(sysinst_t *sysinst)
     567{
     568        errno_t rc;
     569
     570        log_msg(LOG_DEFAULT, LVL_NOTE,
     571            "sysinst_copy_boot_files(): copy bootloader files");
     572        rc = futil_rcopy_contents(sysinst->futil, BOOT_FILES_SRC, MOUNT_POINT);
     573        if (rc != EOK)
     574                return rc;
     575
     576        sysinst_debug(sysinst, "sysinst_copy_boot_files(): OK");
    304577        return EOK;
    305578}
    … …  
    307580/** Set up configuration in the initial RAM disk.
    308581 *
    309  * @return EOK on success or an error code
    310  */
    311 static errno_t sysinst_customize_initrd(void)
     582 * @param sysinst System installer
     583 * @return EOK on success or an error code
     584 */
     585static errno_t sysinst_customize_initrd(sysinst_t *sysinst)
    312586{
    313587        errno_t rc;
    … …  
    321595        rc = rd_img_open(MOUNT_POINT "/boot/initrd.img", &rdpath, &rd);
    322596        if (rc != EOK) {
    323                 printf("Error opening initial RAM disk image.\n");
     597                sysinst_error(sysinst, "Error opening initial RAM disk image.");
    324598                goto error;
    325599        }
    … …  
    331605        }
    332606
    333         printf("Configuring volume server.\n");
     607        sysinst_debug(sysinst, "Configuring volume server.");
     608
    334609        rc = vol_volumes_create(path, &volumes);
    335610        if (rc != EOK) {
    336                 printf("Error creating volume server configuration.\n");
     611                sysinst_error(sysinst,
     612                    "Error creating volume server configuration.");
    337613                rc = EIO;
    338614                goto error;
    339615        }
    340616
    341         printf("Configuring volume server: look up volume\n");
     617        sysinst_debug(sysinst, "Configuring volume server: look up volume");
    342618        rc = vol_volume_lookup_ref(volumes, INST_VOL_LABEL, &volume);
    343619        if (rc != EOK) {
    344                 printf("Error creating volume server configuration.\n");
     620                sysinst_error(sysinst,
     621                    "Error creating volume server configuration.");
    345622                rc = EIO;
    346623                goto error;
    347624        }
    348625
    349         printf("Configuring volume server: set mount point\n");
     626        sysinst_debug(sysinst, "Configuring volume server: set mount point");
    350627        rc = vol_volume_set_mountp(volume, INST_VOL_MP);
    351628        if (rc != EOK) {
    352                 printf("Error creating system partition configuration.\n");
     629                sysinst_error(sysinst,
     630                    "Error creating system partition configuration.");
    353631                rc = EIO;
    354632                goto error;
    … …  
    357635        rc = vol_volumes_sync(volumes);
    358636        if (rc != EOK) {
    359                 printf("Error saving volume confiuration.\n");
    360                 goto error;
    361         }
    362 
    363         printf("Configuring volume server: delete reference\n");
     637                sysinst_error(sysinst, "Error saving volume confiuration.");
     638                goto error;
     639        }
     640
     641        log_msg(LOG_DEFAULT, LVL_NOTE,
     642            "Configuring volume server: delete reference");
    364643        vol_volume_del_ref(volume);
    365644        volume = NULL;
    366         printf("Configuring volume server: destroy volumes object\n");
     645        log_msg(LOG_DEFAULT, LVL_NOTE,
     646            "Configuring volume server: destroy volumes object");
    367647        vol_volumes_destroy(volumes);
    368648        volumes = NULL;
    … …  
    370650        rc = rd_img_close(rd);
    371651        if (rc != EOK) {
    372                 printf("Error closing initial RAM disk image.\n");
     652                sysinst_error(sysinst, "Error closing initial RAM disk image.");
    373653                rc = EIO;
    374654                goto error;
    … …  
    413693 * Install Grub's boot blocks.
    414694 *
     695 * @param sysinst System installer
    415696 * @param devp Disk device
    416697 * @return EOK on success or an error code
    417698 */
    418 static errno_t sysinst_copy_boot_blocks(const char *devp)
     699static errno_t sysinst_copy_boot_blocks(sysinst_t *sysinst, const char *devp)
    419700{
    420701        void *boot_img;
    … …  
    430711        errno_t rc;
    431712
    432         printf("sysinst_copy_boot_blocks: Read boot block image.\n");
    433         rc = futil_get_file(BOOT_FILES_SRC "/boot/grub/i386-pc/boot.img",
     713        log_msg(LOG_DEFAULT, LVL_NOTE,
     714            "sysinst_copy_boot_blocks: Read boot block image.");
     715
     716        rc = futil_get_file(sysinst->futil,
     717            BOOT_FILES_SRC "/boot/grub/i386-pc/boot.img",
    434718            &boot_img, &boot_img_size);
    435719        if (rc != EOK || boot_img_size != 512)
    436720                return EIO;
    437721
    438         printf("sysinst_copy_boot_blocks: Read GRUB core image.\n");
    439         rc = futil_get_file(BOOT_FILES_SRC "/boot/grub/i386-pc/core.img",
     722        log_msg(LOG_DEFAULT, LVL_NOTE,
     723            "sysinst_copy_boot_blocks: Read GRUB core image.");
     724
     725        rc = futil_get_file(sysinst->futil,
     726            BOOT_FILES_SRC "/boot/grub/i386-pc/core.img",
    440727            &core_img, &core_img_size);
    441728        if (rc != EOK)
    442729                return EIO;
    443730
    444         printf("sysinst_copy_boot_blocks: get service ID.\n");
     731        log_msg(LOG_DEFAULT, LVL_NOTE,
     732            "sysinst_copy_boot_blocks: get service ID.");
     733
    445734        rc = loc_service_get_id(devp, &sid, 0);
    446735        if (rc != EOK)
    447736                return rc;
    448737
    449         printf("sysinst_copy_boot_blocks: block_init.\n");
     738        log_msg(LOG_DEFAULT, LVL_NOTE,
     739            "sysinst_copy_boot_blocks: block_init.");
     740
    450741        rc = block_init(sid);
    451742        if (rc != EOK)
    452743                return rc;
    453744
    454         printf("sysinst_copy_boot_blocks: get block size\n");
     745        log_msg(LOG_DEFAULT, LVL_NOTE,
     746            "sysinst_copy_boot_blocks: get block size");
     747
    455748        rc = block_get_bsize(sid, &bsize);
    456749        if (rc != EOK)
    … …  
    458751
    459752        if (bsize != 512) {
    460                 printf("Device block size != 512.\n");
     753                sysinst_error(sysinst, "Device block size != 512.");
    461754                return EIO;
    462755        }
    463756
    464         printf("sysinst_copy_boot_blocks: read boot block\n");
     757        log_msg(LOG_DEFAULT, LVL_NOTE,
     758            "sysinst_copy_boot_blocks: read boot block");
     759
    465760        rc = block_read_direct(sid, BOOT_BLOCK_IDX, 1, bbuf);
    466761        if (rc != EOK)
    … …  
    477772                --bl;
    478773                if ((void *)bl < core_img) {
    479                         printf("No block terminator in core image.\n");
     774                        sysinst_error(sysinst,
     775                            "No block terminator in core image.");
    480776                        return EIO;
    481777                }
    … …  
    491787        set_unaligned_u64le(bbuf + grub_boot_machine_kernel_sector, core_start);
    492788
    493         printf("sysinst_copy_boot_blocks: write boot block\n");
     789        log_msg(LOG_DEFAULT, LVL_NOTE,
     790            "sysinst_copy_boot_blocks: write boot block");
     791
    494792        rc = block_write_direct(sid, BOOT_BLOCK_IDX, 1, bbuf);
    495793        if (rc != EOK)
    496794                return EIO;
    497795
    498         printf("sysinst_copy_boot_blocks: write core blocks\n");
     796        log_msg(LOG_DEFAULT, LVL_NOTE,
     797            "sysinst_copy_boot_blocks: write core blocks");
     798
    499799        /* XXX Must pad last block with zeros */
    500800        rc = block_write_direct(sid, core_start, core_blocks, core_img);
    … …  
    502802                return EIO;
    503803
    504         printf("sysinst_copy_boot_blocks: OK.\n");
     804        log_msg(LOG_DEFAULT, LVL_NOTE,
     805            "sysinst_copy_boot_blocks: OK.");
     806
    505807        return EOK;
    506808}
    … …  
    508810/** Eject installation volume.
    509811 *
     812 * @param sysinst System installer
    510813 * @param psvc_id Partition service ID
    511  */
    512 static errno_t sysinst_eject_dev(service_id_t part_id)
     814 * @return EOK on success or an error code
     815 */
     816static errno_t sysinst_eject_dev(sysinst_t *sysinst, service_id_t part_id)
    513817{
    514818        vol_t *vol = NULL;
    … …  
    517821        rc = vol_create(&vol);
    518822        if (rc != EOK) {
    519                 printf("Error contacting volume service.\n");
     823                sysinst_error(sysinst, "Error contacting volume service.");
    520824                goto out;
    521825        }
    … …  
    523827        rc = vol_part_eject(vol, part_id, vef_physical);
    524828        if (rc != EOK) {
    525                 printf("Error ejecting volume.\n");
     829                sysinst_error(sysinst, "Error ejecting volume.");
    526830                goto out;
    527831        }
    … …  
    535839/** Restart the system.
    536840 *
    537  * @return EOK on success or an error code
    538  */
    539 static errno_t sysinst_restart(void)
     841 * @param sysinst System installer
     842 * @return EOK on success or an error code
     843 */
     844static errno_t sysinst_restart(sysinst_t *sysinst)
    540845{
    541846        errno_t rc;
    … …  
    549854        rc = system_open(SYSTEM_DEFAULT, &sysinst_system_cb, NULL, &system);
    550855        if (rc != EOK) {
    551                 printf("Failed opening system control service.\n");
     856                sysinst_error(sysinst,
     857                    "Failed opening system control service.");
    552858                return rc;
    553859        }
    … …  
    556862        if (rc != EOK) {
    557863                system_close(system);
    558                 printf("Failed requesting system restart.\n");
     864                sysinst_error(sysinst, "Failed requesting system restart.");
    559865                return rc;
    560866        }
    561867
    562868        fibril_mutex_lock(&shutdown_lock);
    563         printf("The system is shutting down...\n");
     869        sysinst_debug(sysinst, "The system is shutting down...");
     870
    564871        while (!shutdown_stopped)
    565872                fibril_condvar_wait(&shutdown_cv, &shutdown_lock);
    566873
    567874        if (shutdown_failed) {
    568                 printf("Shutdown failed.\n");
     875                sysinst_error(sysinst, "Shutdown failed.");
    569876                system_close(system);
    570877                return rc;
    571878        }
    572879
    573         printf("Shutdown complete. It is now safe to remove power.\n");
     880        log_msg(LOG_DEFAULT, LVL_NOTE,
     881            "Shutdown complete. It is now safe to remove power.");
    574882
    575883        /* Sleep forever */
    … …  
    586894/** Install system to a device.
    587895 *
     896 * @parma sysinst System installer
    588897 * @param dev Device to install to.
    589898 * @return EOK on success or an error code
    590899 */
    591 static errno_t sysinst_install(const char *dev)
     900static errno_t sysinst_install(sysinst_t *sysinst, const char *dev)
    592901{
    593902        errno_t rc;
    594903        service_id_t psvc_id;
    595904
    596         rc = sysinst_label_dev(dev, &psvc_id);
    597         if (rc != EOK)
    598                 return rc;
    599 
    600         printf("FS created and mounted. Creating system directory structure.\n");
    601         rc = sysinst_setup_sysvol();
    602         if (rc != EOK)
    603                 return rc;
    604 
    605         printf("Directories created. Copying boot files.\n");
    606         rc = sysinst_copy_boot_files();
    607         if (rc != EOK)
    608                 return rc;
    609 
    610         printf("Boot files done. Configuring the system.\n");
    611         rc = sysinst_customize_initrd();
    612         if (rc != EOK)
    613                 return rc;
    614 
    615         printf("Boot files done. Installing boot blocks.\n");
    616         rc = sysinst_copy_boot_blocks(dev);
    617         if (rc != EOK)
    618                 return rc;
    619 
    620         printf("Ejecting device.\n");
    621         rc = sysinst_eject_dev(psvc_id);
    622         if (rc != EOK)
    623                 return rc;
    624 
    625         rc = sysinst_restart();
    626         if (rc != EOK)
    627                 return rc;
    628 
    629         return EOK;
    630 }
    631 
    632 int main(int argc, char *argv[])
    633 {
     905        sysinst_action(sysinst, "Creating device label and file system.");
     906
     907        rc = sysinst_label_dev(sysinst, dev, &psvc_id);
     908        if (rc != EOK)
     909                return rc;
     910
     911        sysinst_action(sysinst, "Creating system directory structure.");
     912        rc = sysinst_setup_sysvol(sysinst);
     913        if (rc != EOK)
     914                return rc;
     915
     916        sysinst_action(sysinst, "Copying boot files.");
     917        rc = sysinst_copy_boot_files(sysinst);
     918        if (rc != EOK)
     919                return rc;
     920
     921        sysinst_action(sysinst, "Configuring the system.");
     922        rc = sysinst_customize_initrd(sysinst);
     923        if (rc != EOK)
     924                return rc;
     925
     926        sysinst_action(sysinst, "Installing boot blocks.");
     927        rc = sysinst_copy_boot_blocks(sysinst, dev);
     928        if (rc != EOK)
     929                return rc;
     930
     931        sysinst_action(sysinst, "Ejecting device.");
     932        rc = sysinst_eject_dev(sysinst, psvc_id);
     933        if (rc != EOK)
     934                return rc;
     935
     936        return EOK;
     937}
     938
     939/** Installation fibril.
     940 *
     941 * @param arg Argument (sysinst_t *)
     942 * @return EOK on success or an error code
     943 */
     944static errno_t sysinst_install_fibril(void *arg)
     945{
     946        sysinst_t *sysinst = (sysinst_t *)arg;
    634947        unsigned i;
    635948        errno_t rc;
    636949
    637         if (argc > 1 && str_cmp(argv[1], "-r") == 0)
    638                 restart = true;
     950        (void)sysinst;
    639951
    640952        i = 0;
    … …  
    647959
    648960        if (default_devs[i] == NULL) {
    649                 printf("Cannot determine installation device.\n");
     961                sysinst_error(sysinst, "Cannot determine installation device.");
     962                rc = ENOENT;
     963                goto error;
     964        }
     965
     966        rc = sysinst_install(sysinst, default_devs[i]);
     967        if (rc != EOK)
     968                goto error;
     969
     970        sysinst_progress_destroy(sysinst->progress);
     971        rc = sysinst_restart_dlg_create(sysinst);
     972        if (rc != EOK)
     973                goto error;
     974
     975        return EOK;
     976error:
     977        ui_lock(sysinst->ui);
     978        sysinst_progress_destroy(sysinst->progress);
     979        (void)sysinst_error_msg_create(sysinst);
     980        ui_unlock(sysinst->ui);
     981        return rc;
     982}
     983
     984/** Create installation progress window.
     985 *
     986 * @param sysinst System installer
     987 * @param rprogress Place to store pointer to new progress window
     988 * @return EOK on success or an error code
     989 */
     990static errno_t sysinst_progress_create(sysinst_t *sysinst,
     991    sysinst_progress_t **rprogress)
     992{
     993        ui_wnd_params_t params;
     994        ui_window_t *window = NULL;
     995        gfx_rect_t rect;
     996        gfx_rect_t arect;
     997        ui_resource_t *ui_res;
     998        sysinst_progress_t *progress;
     999        ui_fixed_t *fixed = NULL;
     1000        errno_t rc;
     1001
     1002        ui_wnd_params_init(&params);
     1003        params.caption = "System Installation";
     1004        params.style &= ~ui_wds_titlebar;
     1005        params.flags |= ui_wndf_topmost;
     1006        params.placement = ui_wnd_place_center;
     1007        if (ui_is_textmode(sysinst->ui)) {
     1008                params.rect.p0.x = 0;
     1009                params.rect.p0.y = 0;
     1010                params.rect.p1.x = 64;
     1011                params.rect.p1.y = 5;
     1012        } else {
     1013                params.rect.p0.x = 0;
     1014                params.rect.p0.y = 0;
     1015                params.rect.p1.x = 500;
     1016                params.rect.p1.y = 60;
     1017        }
     1018
     1019        progress = calloc(1, sizeof(sysinst_progress_t));
     1020        if (progress == NULL) {
     1021                rc = ENOMEM;
     1022                sysinst_error(sysinst, "Out of memory.");
     1023                goto error;
     1024        }
     1025
     1026        rc = ui_window_create(sysinst->ui, &params, &window);
     1027        if (rc != EOK) {
     1028                sysinst_error(sysinst, "Error creating window.");
     1029                goto error;
     1030        }
     1031
     1032        ui_window_set_cb(window, &progress_window_cb, (void *)sysinst);
     1033
     1034        ui_res = ui_window_get_res(window);
     1035
     1036        rc = ui_fixed_create(&fixed);
     1037        if (rc != EOK) {
     1038                sysinst_error(sysinst, "Error creating fixed layout.");
     1039                goto error;
     1040        }
     1041
     1042        rc = ui_label_create(ui_res, "Installing system. Please wait...",
     1043            &progress->label);
     1044        if (rc != EOK) {
     1045                sysinst_error(sysinst, "Error creating label.");
     1046                goto error;
     1047        }
     1048
     1049        ui_window_get_app_rect(window, &arect);
     1050
     1051        if (ui_is_textmode(sysinst->ui)) {
     1052                rect.p0.x = arect.p0.x;
     1053                rect.p0.y = arect.p0.y;
     1054                rect.p1.x = arect.p1.x;
     1055                rect.p1.y = 2;
     1056        } else {
     1057                rect.p0.x = arect.p0.x;
     1058                rect.p0.y = arect.p0.y;
     1059                rect.p1.x = arect.p1.x;
     1060                rect.p1.y = 30;
     1061        }
     1062        ui_label_set_rect(progress->label, &rect);
     1063        ui_label_set_halign(progress->label, gfx_halign_center);
     1064        ui_label_set_valign(progress->label, gfx_valign_center);
     1065
     1066        rc = ui_fixed_add(fixed, ui_label_ctl(progress->label));
     1067        if (rc != EOK) {
     1068                sysinst_error(sysinst, "Error adding control to layout.");
     1069                ui_label_destroy(progress->label);
     1070                progress->label = NULL;
     1071                goto error;
     1072        }
     1073
     1074        rc = ui_label_create(ui_res, "",
     1075            &progress->action);
     1076        if (rc != EOK) {
     1077                sysinst_error(sysinst, "Error creating label.");
     1078                goto error;
     1079        }
     1080
     1081        if (ui_is_textmode(sysinst->ui)) {
     1082                rect.p0.x = arect.p0.x;
     1083                rect.p0.y = 3;
     1084                rect.p1.x = arect.p1.x;
     1085                rect.p1.y = arect.p1.y;
     1086        } else {
     1087                rect.p0.x = arect.p0.x;
     1088                rect.p0.y = 30;
     1089                rect.p1.x = arect.p1.x;
     1090                rect.p1.y = arect.p1.y;
     1091        }
     1092        ui_label_set_rect(progress->action, &rect);
     1093        ui_label_set_halign(progress->action, gfx_halign_center);
     1094        ui_label_set_valign(progress->action, gfx_valign_center);
     1095
     1096        rc = ui_fixed_add(fixed, ui_label_ctl(progress->action));
     1097        if (rc != EOK) {
     1098                sysinst_error(sysinst, "Error adding control to layout.");
     1099                ui_label_destroy(progress->label);
     1100                progress->label = NULL;
     1101                goto error;
     1102        }
     1103
     1104        ui_window_add(window, ui_fixed_ctl(fixed));
     1105        fixed = NULL;
     1106
     1107        rc = ui_window_paint(window);
     1108        if (rc != EOK) {
     1109                sysinst_error(sysinst, "Error painting window.");
     1110                goto error;
     1111        }
     1112
     1113        progress->window = window;
     1114        progress->fixed = fixed;
     1115        *rprogress = progress;
     1116        return EOK;
     1117error:
     1118        if (progress != NULL && progress->fixed != NULL)
     1119                ui_fixed_destroy(progress->fixed);
     1120        if (window != NULL)
     1121                ui_window_destroy(window);
     1122        if (progress != NULL)
     1123                free(progress);
     1124        return rc;
     1125}
     1126
     1127/** Destroy installation progress window.
     1128 *
     1129 * @param sysinst System installer
     1130 * @param rprogress Place to store pointer to new progress window
     1131 * @return EOK on success or an error code
     1132 */
     1133static void sysinst_progress_destroy(sysinst_progress_t *progress)
     1134{
     1135        if (progress == NULL)
     1136                return;
     1137
     1138        ui_window_destroy(progress->window);
     1139        free(progress);
     1140}
     1141
     1142/** Set current action message.
     1143 *
     1144 * @param sysinst System installer
     1145 * @param action Action text
     1146 */
     1147static void sysinst_action(sysinst_t *sysinst, const char *action)
     1148{
     1149        if (sysinst->progress == NULL)
     1150                return;
     1151
     1152        ui_label_set_text(sysinst->progress->action, action);
     1153        ui_label_paint(sysinst->progress->action);
     1154        log_msg(LOG_DEFAULT, LVL_NOTE, "%s", action);
     1155}
     1156
     1157/** Set current error message.
     1158 *
     1159 * @param sysinst System installer
     1160 * @param errmsg Error message
     1161 */
     1162static void sysinst_error(sysinst_t *sysinst, const char *errmsg)
     1163{
     1164        str_cpy(sysinst->errmsg, sizeof(sysinst->errmsg), errmsg);
     1165        log_msg(LOG_DEFAULT, LVL_ERROR, errmsg);
     1166}
     1167
     1168/** Log a debug message.
     1169 *
     1170 * @param sysinst System installer
     1171 * @param errmsg Error message
     1172 */
     1173static void sysinst_debug(sysinst_t *sysinst, const char *msg)
     1174{
     1175        log_msg(LOG_DEFAULT, LVL_ERROR, msg);
     1176}
     1177
     1178/** Start system installation.
     1179 *
     1180 * @param sysinst System installer
     1181 * @return EOK on success or an error code
     1182 */
     1183static int sysinst_start(sysinst_t *sysinst)
     1184{
     1185        errno_t rc;
     1186        fid_t fid;
     1187
     1188        rc = sysinst_progress_create(sysinst, &sysinst->progress);
     1189        if (rc != EOK)
     1190                return rc;
     1191
     1192        fid = fibril_create(sysinst_install_fibril, (void *)sysinst);
     1193        if (fid == 0) {
     1194                sysinst_error(sysinst, "Out of memory.");
     1195                return ENOMEM;
     1196        }
     1197
     1198        fibril_add_ready(fid);
     1199        return EOK;
     1200}
     1201
     1202/** Create installation confirmation dialog.
     1203 *
     1204 * @param sysinst System installer
     1205 * @return EOK on success or an error code
     1206 */
     1207static errno_t sysinst_confirm_create(sysinst_t *sysinst)
     1208{
     1209        ui_msg_dialog_params_t params;
     1210        ui_msg_dialog_t *dialog;
     1211        errno_t rc;
     1212
     1213        ui_msg_dialog_params_init(&params);
     1214        params.caption = "System installation";
     1215        params.text = "This will install HelenOS to your computer. Continue?";
     1216        params.choice = umdc_ok_cancel;
     1217        params.flags |= umdf_topmost | umdf_center;
     1218
     1219        rc = ui_msg_dialog_create(sysinst->ui, &params, &dialog);
     1220        if (rc != EOK)
     1221                return rc;
     1222
     1223        ui_msg_dialog_set_cb(dialog, &sysinst_confirm_cb, sysinst);
     1224        return EOK;
     1225}
     1226
     1227/** Create restart dialog.
     1228 *
     1229 * @param sysinst System installer
     1230 * @return EOK on success or an error code
     1231 */
     1232static errno_t sysinst_restart_dlg_create(sysinst_t *sysinst)
     1233{
     1234        ui_msg_dialog_params_t params;
     1235        ui_msg_dialog_t *dialog;
     1236        errno_t rc;
     1237
     1238        ui_msg_dialog_params_init(&params);
     1239        params.caption = "Restart System";
     1240        params.text = "Installation complete. Restart the system?";
     1241        params.choice = umdc_ok_cancel;
     1242        params.flags |= umdf_topmost | umdf_center;
     1243
     1244        rc = ui_msg_dialog_create(sysinst->ui, &params, &dialog);
     1245        if (rc != EOK)
     1246                return rc;
     1247
     1248        ui_msg_dialog_set_cb(dialog, &sysinst_restart_dlg_cb, sysinst);
     1249        return EOK;
     1250}
     1251
     1252/** Run system installer on display.
     1253 *
     1254 * @param display_spec Display specification
     1255 * @return EOK on success or an error code
     1256 */
     1257static errno_t sysinst_run(const char *display_spec)
     1258{
     1259        ui_t *ui = NULL;
     1260        sysinst_t *sysinst;
     1261        ui_wnd_params_t params;
     1262        errno_t rc;
     1263
     1264        sysinst = calloc(1, sizeof(sysinst_t));
     1265        if (sysinst == NULL)
     1266                return ENOMEM;
     1267
     1268        rc = futil_create(&sysinst_futil_cb, (void *)sysinst, &sysinst->futil);
     1269        if (rc != EOK) {
     1270                printf("Out of memory.\n");
     1271                goto error;
     1272        }
     1273
     1274        rc = ui_create(display_spec, &ui);
     1275        if (rc != EOK) {
     1276                printf("Error creating UI on display %s.\n", display_spec);
     1277                goto error;
     1278        }
     1279
     1280        sysinst->ui = ui;
     1281
     1282        ui_wnd_params_init(&params);
     1283        params.caption = "System Installation";
     1284        params.style &= ~ui_wds_decorated;
     1285        params.placement = ui_wnd_place_full_screen;
     1286        params.flags |= ui_wndf_topmost | ui_wndf_nofocus;
     1287
     1288        rc = ui_window_create(sysinst->ui, &params, &sysinst->bgwindow);
     1289        if (rc != EOK) {
     1290                printf("Error creating window.\n");
     1291                goto error;
     1292        }
     1293
     1294        ui_window_set_cb(sysinst->bgwindow, &bg_window_cb, (void *)sysinst);
     1295
     1296        if (ui_is_textmode(sysinst->ui)) {
     1297                rc = gfx_color_new_ega(0x17, &sysinst->bg_color);
     1298                if (rc != EOK) {
     1299                        printf("Error allocating color.\n");
     1300                        goto error;
     1301                }
     1302        } else {
     1303                rc = gfx_color_new_rgb_i16(0x8000, 0xc800, 0xffff, &sysinst->bg_color);
     1304                if (rc != EOK) {
     1305                        printf("Error allocating color.\n");
     1306                        goto error;
     1307                }
     1308        }
     1309
     1310        rc = ui_window_paint(sysinst->bgwindow);
     1311        if (rc != EOK) {
     1312                printf("Error painting window.\n");
     1313                goto error;
     1314        }
     1315
     1316        (void)sysinst_confirm_create(sysinst);
     1317
     1318        ui_run(ui);
     1319
     1320        if (sysinst->bgwindow != NULL)
     1321                ui_window_destroy(sysinst->bgwindow);
     1322        if (sysinst->system != NULL)
     1323                system_close(sysinst->system);
     1324        gfx_color_delete(sysinst->bg_color);
     1325        ui_destroy(ui);
     1326        free(sysinst);
     1327        return EOK;
     1328error:
     1329        if (sysinst->futil != NULL)
     1330                futil_destroy(sysinst->futil);
     1331        if (sysinst->system != NULL)
     1332                system_close(sysinst->system);
     1333        if (sysinst->bg_color != NULL)
     1334                gfx_color_delete(sysinst->bg_color);
     1335        if (sysinst->bgwindow != NULL)
     1336                ui_window_destroy(sysinst->bgwindow);
     1337        if (ui != NULL)
     1338                ui_destroy(ui);
     1339        free(sysinst);
     1340        return rc;
     1341}
     1342
     1343static void print_syntax(void)
     1344{
     1345        printf("Syntax: " NAME " [-d <display-spec>]\n");
     1346}
     1347
     1348int main(int argc, char *argv[])
     1349{
     1350        const char *display_spec = UI_ANY_DEFAULT;
     1351        errno_t rc;
     1352        int i;
     1353
     1354        i = 1;
     1355        while (i < argc && argv[i][0] == '-') {
     1356                if (str_cmp(argv[i], "-d") == 0) {
     1357                        ++i;
     1358                        if (i >= argc) {
     1359                                printf("Argument missing.\n");
     1360                                print_syntax();
     1361                                return 1;
     1362                        }
     1363
     1364                        display_spec = argv[i++];
     1365                } else {
     1366                        printf("Invalid option '%s'.\n", argv[i]);
     1367                        print_syntax();
     1368                        return 1;
     1369                }
     1370        }
     1371
     1372        if (i < argc) {
     1373                print_syntax();
    6501374                return 1;
    6511375        }
    6521376
    653         return sysinst_install(default_devs[i]);
     1377        if (log_init(NAME) != EOK) {
     1378                printf(NAME ": Failed to initialize logging.\n");
     1379                return 1;
     1380        }
     1381
     1382        rc = sysinst_run(display_spec);
     1383        if (rc != EOK)
     1384                return 1;
     1385
     1386        return 0;
    6541387}
    6551388

  • uspace/app/taskbar/taskbar.sif

    r597fa24 ra188131  
    3333<entry caption="~F~disk Disk Editor" cmd="/app/fdisk" terminal="y">
    3434</entry>
     35<entry caption="Insta~l~l HelenOS to Disk" cmd="/app/sysinst -d %d" terminal="n">
     36</entry>
    3537<entry separator="y">
    3638</entry>

  • uspace/lib/futil/include/futil.h

    r597fa24 ra188131  
    11/*
    2  * Copyright (c) 2024 Jiri Svoboda
     2 * Copyright (c) 2025 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3838#define FUTIL_H
    3939
     40#include <errno.h>
    4041#include <stddef.h>
     42#include "types/futil.h"
    4143
    42 extern errno_t futil_copy_file(const char *, const char *);
    43 extern errno_t futil_rcopy_contents(const char *, const char *);
    44 extern errno_t futil_get_file(const char *, void **, size_t *);
     44extern errno_t futil_create(futil_cb_t *, void *, futil_t **);
     45extern void futil_destroy(futil_t *);
     46extern errno_t futil_copy_file(futil_t *, const char *, const char *);
     47extern errno_t futil_rcopy_contents(futil_t *, const char *, const char *);
     48extern errno_t futil_get_file(futil_t *, const char *, void **, size_t *);
    4549
    4650#endif

  • uspace/lib/futil/src/futil.c

    r597fa24 ra188131  
    11/*
    2  * Copyright (c) 2024 Jiri Svoboda
     2 * Copyright (c) 2025 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    4747static char buf[BUF_SIZE];
    4848
     49/** Create file utility instance.
     50 *
     51 * @param cb Callback functions
     52 * @param arg Argument to callback functions
     53 * @param rfutil Place to store pointer to new file utility instance
     54 * @return EOK on succcess, ENOMEM if out of memory.
     55 */
     56errno_t futil_create(futil_cb_t *cb, void *arg, futil_t **rfutil)
     57{
     58        futil_t *futil;
     59
     60        futil = calloc(1, sizeof(futil_t));
     61        if (futil == NULL)
     62                return ENOMEM;
     63
     64        futil->cb = cb;
     65        futil->cb_arg = arg;
     66        *rfutil = futil;
     67        return EOK;
     68}
     69
     70/** Destroy file utility instance.
     71 *
     72 * @param futil File utility instance
     73 */
     74void futil_destroy(futil_t *futil)
     75{
     76        free(futil);
     77}
     78
    4979/** Copy file.
    5080 *
     81 * @param futil File utility instance
    5182 * @param srcp Source path
    5283 * @param dstp Destination path
    … …  
    5485 * @return EOK on success, EIO on I/O error
    5586 */
    56 errno_t futil_copy_file(const char *srcp, const char *destp)
     87errno_t futil_copy_file(futil_t *futil, const char *srcp, const char *destp)
    5788{
    5889        int sf, df;
    … …  
    6192        aoff64_t posr = 0, posw = 0;
    6293
    63         printf("Copy '%s' to '%s'.\n", srcp, destp);
     94        if (futil->cb != NULL && futil->cb->copy_file != NULL)
     95                futil->cb->copy_file(futil->cb_arg, srcp, destp);
    6496
    6597        rc = vfs_lookup_open(srcp, WALK_REGULAR, MODE_READ, &sf);
    … …  
    99131/** Copy contents of srcdir (recursively) into destdir.
    100132 *
     133 * @param futil File utility instance
    101134 * @param srcdir Source directory
    102135 * @param destdir Destination directory
    … …  
    104137 * @return EOK on success, ENOMEM if out of memory, EIO on I/O error
    105138 */
    106 errno_t futil_rcopy_contents(const char *srcdir, const char *destdir)
     139errno_t futil_rcopy_contents(futil_t *futil, const char *srcdir,
     140    const char *destdir)
    107141{
    108142        DIR *dir;
    … …  
    128162
    129163                if (s.is_file) {
    130                         rc = futil_copy_file(srcp, destp);
     164                        rc = futil_copy_file(futil, srcp, destp);
    131165                        if (rc != EOK)
    132166                                return EIO;
    133167                } else if (s.is_directory) {
    134                         printf("Create directory '%s'\n", destp);
     168                        if (futil->cb != NULL && futil->cb->create_dir != NULL)
     169                                futil->cb->create_dir(futil->cb_arg, destp);
    135170                        rc = vfs_link_path(destp, KIND_DIRECTORY, NULL);
    136171                        if (rc != EOK)
    137172                                return EIO;
    138                         rc = futil_rcopy_contents(srcp, destp);
     173                        rc = futil_rcopy_contents(futil, srcp, destp);
    139174                        if (rc != EOK)
    140175                                return EIO;
    … …  
    151186/** Return file contents as a heap-allocated block of bytes.
    152187 *
     188 * @param futil File utility instance
    153189 * @param srcp File path
    154190 * @param rdata Place to store pointer to data
    … …  
    158194 *         I/O error, ENOMEM if out of memory
    159195 */
    160 errno_t futil_get_file(const char *srcp, void **rdata, size_t *rsize)
     196errno_t futil_get_file(futil_t *futil, const char *srcp, void **rdata,
     197    size_t *rsize)
    161198{
    162199        int sf;

  • uspace/lib/ui/src/msgdialog.c

    r597fa24 ra188131  
    11/*
    2  * Copyright (c) 2024 Jiri Svoboda
     2 * Copyright (c) 2025 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    125125                wparams.rect.p0.x = 0;
    126126                wparams.rect.p0.y = 0;
    127                 wparams.rect.p1.x = 400;
     127                wparams.rect.p1.x = 440;
    128128                wparams.rect.p1.y = 110;
    129129        }
    … …  
    154154                rect.p0.x = 10;
    155155                rect.p0.y = 35;
    156                 rect.p1.x = 390;
     156                rect.p1.x = 430;
    157157                rect.p1.y = 50;
    158158        }

  • uspace/srv/system/system.c

    r597fa24 ra188131  
    328328        size_t nparts;
    329329        bool sv_mounted;
     330        futil_t *futil = NULL;
    330331        size_t i;
    331332        errno_t rc;
    … …  
    380381
    381382                /* Copy initial configuration files */
    382                 rc = futil_rcopy_contents("/cfg", "/w/cfg");
     383                rc = futil_create(NULL, NULL, &futil);
    383384                if (rc != EOK)
    384385                        goto error;
     386
     387                rc = futil_rcopy_contents(futil, "/cfg", "/w/cfg");
     388                if (rc != EOK)
     389                        goto error;
     390
     391                futil_destroy(futil);
     392                futil = NULL;
    385393        } else {
    386394                printf("%s: System volume is configured.\n", NAME);
    … …  
    429437        if (part_ids != NULL)
    430438                free(part_ids);
     439        if (futil != NULL)
     440                futil_destroy(futil);
    431441
    432442        return rc;
Note: See TracChangeset for help on using the changeset viewer.