Changes in / [25e03b3:cbaf408] in mainline


Ignore:
Location:
uspace
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/sysinst/sysinst.c

    r25e03b3 rcbaf408  
    158158static void sysinst_futil_create_dir(void *, const char *);
    159159static errno_t sysinst_eject_dev(sysinst_t *, service_id_t);
    160 static errno_t sysinst_eject_phys_by_mp(sysinst_t *, const char *);
    161160
    162161static futil_cb_t sysinst_futil_cb = {
     
    273272        case 0:
    274273                /* OK */
    275                 sysinst_action(sysinst, "Ejecting installation media.");
    276                 (void)sysinst_eject_phys_by_mp(sysinst, CD_MOUNT_POINT);
    277274                (void)sysinst_restart(sysinst);
    278275                break;
     
    595592        rc = futil_rcopy_contents(sysinst->futil, CFG_FILES_SRC,
    596593            CFG_FILES_DEST);
    597         if (rc != EOK) {
    598                 sysinst_error(sysinst, "Error copying initial configuration "
    599                     "files.");
    600                 return rc;
    601         }
     594        if (rc != EOK)
     595                return rc;
    602596
    603597        return EOK;
     
    619613            "sysinst_copy_boot_files(): copy bootloader files");
    620614        rc = futil_rcopy_contents(sysinst->futil, BOOT_FILES_SRC, MOUNT_POINT);
    621         if (rc != EOK) {
    622                 sysinst_error(sysinst, "Error copying bootloader "
    623                     "files.");
    624                 return rc;
    625         }
     615        if (rc != EOK)
     616                return rc;
    626617
    627618        sysinst_debug(sysinst, "sysinst_copy_boot_files(): OK");
     
    900891        errno_t rc;
    901892
    902         log_msg(LOG_DEFAULT, LVL_NOTE,
    903             "sysinst_eject_phys_by_mp(%s)", path);
    904 
    905893        rc = vol_create(&vol);
    906894        if (rc != EOK) {
     
    946934        shutdown_failed = false;
    947935
    948         sysinst_action(sysinst, "Restarting the system.");
    949 
    950936        rc = system_open(SYSTEM_DEFAULT, &sysinst_system_cb, NULL, &system);
    951937        if (rc != EOK) {
     
    997983{
    998984        errno_t rc;
    999         bool clean_dev = false;
    1000985
    1001986        sysinst_action(sysinst, "Creating device label and file system.");
     
    1003988        rc = sysinst_label_dev(sysinst, dev);
    1004989        if (rc != EOK)
    1005                 goto error;
    1006 
    1007         clean_dev = true;
     990                return rc;
    1008991
    1009992        sysinst_action(sysinst, "Creating system directory structure.");
    1010993        rc = sysinst_setup_sysvol(sysinst);
    1011994        if (rc != EOK)
    1012                 goto error;
     995                return rc;
    1013996
    1014997        sysinst_action(sysinst, "Copying boot files.");
    1015998        rc = sysinst_copy_boot_files(sysinst);
    1016999        if (rc != EOK)
    1017                 goto error;
     1000                return rc;
    10181001
    10191002        sysinst_action(sysinst, "Configuring the system.");
    10201003        rc = sysinst_customize_initrd(sysinst);
    10211004        if (rc != EOK)
    1022                 goto error;
     1005                return rc;
    10231006
    10241007        sysinst_action(sysinst, "Finishing system volume.");
    10251008        rc = sysinst_finish_dev(sysinst);
    10261009        if (rc != EOK)
    1027                 goto error;
    1028 
    1029         clean_dev = false;
     1010                return rc;
    10301011
    10311012        sysinst_action(sysinst, "Installing boot blocks.");
     
    10341015                return rc;
    10351016
    1036         return EOK;
    1037 error:
    1038         if (clean_dev)
    1039                 (void)sysinst_finish_dev(sysinst);
    1040         return rc;
     1017        sysinst_action(sysinst, "Ejecting installation media.");
     1018        rc = sysinst_eject_phys_by_mp(sysinst, CD_MOUNT_POINT);
     1019        if (rc != EOK)
     1020                return rc;
     1021
     1022        return EOK;
    10411023}
    10421024
     
    10731055
    10741056        sysinst_progress_destroy(sysinst->progress);
    1075         sysinst->progress = NULL;
    1076 
    10771057        rc = sysinst_restart_dlg_create(sysinst);
    10781058        if (rc != EOK)
     
    12531233static void sysinst_action(sysinst_t *sysinst, const char *action)
    12541234{
    1255         log_msg(LOG_DEFAULT, LVL_NOTE, "%s", action);
    1256 
    12571235        if (sysinst->progress == NULL)
    12581236                return;
     
    12601238        ui_label_set_text(sysinst->progress->action, action);
    12611239        ui_label_paint(sysinst->progress->action);
     1240        log_msg(LOG_DEFAULT, LVL_NOTE, "%s", action);
    12621241}
    12631242
  • uspace/drv/block/ahci/ahci.c

    r25e03b3 rcbaf408  
    11/*
    2  * Copyright (c) 2025 Jiri Svoboda
    32 * Copyright (c) 2012 Petr Jerman
    43 * All rights reserved.
     
    10761075        }
    10771076
    1078         fun = sata->fun;
    10791077        ddf_fun_set_ops(fun, &ahci_ops);
    10801078
  • uspace/drv/hid/usbhid/mouse/mousedev.c

    r25e03b3 rcbaf408  
    11/*
    2  * Copyright (c) 2025 Jiri Svoboda
    32 * Copyright (c) 2011 Lubos Slovak, Vojtech Horky
    43 * Copyright (c) 2018 Ondrej Hlavaty
     
    167166        assert(mouse_dev != NULL);
    168167
    169         if (mouse_dev->mouse_sess == NULL)
    170                 return;
     168        if (mouse_dev->mouse_sess == NULL) {
     169                usb_log_warning(NAME " No console session.");
     170                return;
     171        }
    171172
    172173        const usb_hid_report_field_t *move_x = get_mouse_axis_move_field(
  • uspace/lib/drv/generic/remote_ahci.c

    r25e03b3 rcbaf408  
    11/*
    2  * Copyright (c) 2025 Jiri Svoboda
    32 * Copyright (c) 2012 Petr Jerman
    43 * All rights reserved.
     
    153152            IPC_M_AHCI_READ_BLOCKS, HI(blocknum),  LO(blocknum), count, NULL);
    154153
    155         errno_t rc = async_data_read_start(exch, buf, count * 512);
     154        async_share_out_start(exch, buf, AS_AREA_READ | AS_AREA_WRITE);
     155
    156156        async_exchange_end(exch);
    157         if (rc != EOK) {
    158                 async_forget(req);
    159                 return rc;
    160         }
    161 
    162         errno_t retval;
    163         async_wait_for(req, &retval);
    164         return retval;
     157
     158        errno_t rc;
     159        async_wait_for(req, &rc);
     160
     161        return rc;
    165162}
    166163
     
    175172            IPC_M_AHCI_WRITE_BLOCKS, HI(blocknum),  LO(blocknum), count, NULL);
    176173
    177         errno_t rc = async_data_write_start(exch, buf, count * 512);
     174        async_share_out_start(exch, buf, AS_AREA_READ | AS_AREA_WRITE);
     175
    178176        async_exchange_end(exch);
    179177
    180         if (rc != EOK) {
    181                 async_forget(req);
    182                 return rc;
    183         }
    184 
    185         errno_t retval;
    186         async_wait_for(req, &retval);
    187         return retval;
     178        errno_t rc;
     179        async_wait_for(req, &rc);
     180
     181        return rc;
    188182}
    189183
     
    290284        }
    291285
    292         ipc_call_t rcall;
    293         size_t size;
    294         if (!async_data_read_receive(&rcall, &size)) {
    295                 async_answer_0(&rcall, EINVAL);
    296                 async_answer_0(call, EINVAL);
    297                 return;
    298         }
    299 
    300         void *buf = malloc(size);
    301         if (buf == NULL) {
    302                 async_answer_0(&rcall, ENOMEM);
    303                 async_answer_0(call, ENOMEM);
    304                 return;
    305         }
    306 
    307         uint64_t blocknum =
     286        ipc_call_t data;
     287        size_t maxblock_size;
     288        unsigned int flags;
     289        async_share_out_receive(&data, &maxblock_size, &flags);
     290
     291        void *buf;
     292        async_share_out_finalize(&data, &buf);
     293
     294        const uint64_t blocknum =
    308295            (((uint64_t) (DEV_IPC_GET_ARG1(*call))) << 32) |
    309296            (((uint64_t) (DEV_IPC_GET_ARG2(*call))) & 0xffffffff);
    310         size_t cnt = (size_t) DEV_IPC_GET_ARG3(*call);
    311 
    312         errno_t rc = ahci_iface->read_blocks(fun, blocknum, cnt, buf);
    313         if (rc != EOK) {
    314                 async_answer_0(&rcall, ENOMEM);
    315                 async_answer_0(call, ENOMEM);
    316                 free(buf);
    317                 return;
    318         }
    319 
    320         async_data_read_finalize(&rcall, buf, size);
    321 
    322         free(buf);
    323         async_answer_0(call, EOK);
     297        const size_t cnt = (size_t) DEV_IPC_GET_ARG3(*call);
     298
     299        const errno_t ret = ahci_iface->read_blocks(fun, blocknum, cnt, buf);
     300
     301        async_answer_0(call, ret);
    324302}
    325303
     
    328306        const ahci_iface_t *ahci_iface = (ahci_iface_t *) iface;
    329307
    330         if (ahci_iface->write_blocks == NULL) {
    331                 async_answer_0(call, ENOTSUP);
    332                 return;
    333         }
    334 
    335         void *data;
    336         size_t dsize;
    337         errno_t rc = async_data_write_accept(&data, false, 0, 0, 0, &dsize);
    338         if (rc != EOK) {
    339                 async_answer_0(call, rc);
    340                 return;
    341         }
    342 
    343         uint64_t blocknum =
     308        if (ahci_iface->read_blocks == NULL) {
     309                async_answer_0(call, ENOTSUP);
     310                return;
     311        }
     312
     313        ipc_call_t data;
     314        size_t maxblock_size;
     315        unsigned int flags;
     316        async_share_out_receive(&data, &maxblock_size, &flags);
     317
     318        void *buf;
     319        async_share_out_finalize(&data, &buf);
     320
     321        const uint64_t blocknum =
    344322            (((uint64_t)(DEV_IPC_GET_ARG1(*call))) << 32) |
    345323            (((uint64_t)(DEV_IPC_GET_ARG2(*call))) & 0xffffffff);
    346         size_t cnt = (size_t) DEV_IPC_GET_ARG3(*call);
    347 
    348         if (dsize != cnt * 512) {
    349                 async_answer_0(call, EINVAL);
    350                 return;
    351         }
    352 
    353         rc = ahci_iface->write_blocks(fun, blocknum, cnt, data);
    354         free(data);
    355         async_answer_0(call, rc);
     324        const size_t cnt = (size_t) DEV_IPC_GET_ARG3(*call);
     325
     326        const errno_t ret = ahci_iface->write_blocks(fun, blocknum, cnt, buf);
     327
     328        async_answer_0(call, ret);
    356329}
    357330
Note: See TracChangeset for help on using the changeset viewer.