Changeset 6d0fc11 in mainline for uspace/srv/bd/hr/hr.c


Ignore:
Timestamp:
2025-03-30T19:38:58Z (4 months ago)
Author:
Miroslav Cimerman <mc@…>
Children:
baa4929
Parents:
746e636
Message:

hr: style: align structures, function prototypes

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/bd/hr/hr.c

    r746e636 r6d0fc11  
    5858#include "var.h"
    5959
     60static void hr_assemble_srv(ipc_call_t *);
     61static void hr_auto_assemble_srv(ipc_call_t *);
     62static void hr_stop_srv(ipc_call_t *);
     63static void hr_add_hotspare_srv(ipc_call_t *);
     64static void hr_print_status_srv(ipc_call_t *);
     65static void hr_ctl_conn(ipc_call_t *, void *);
     66static void hr_client_conn(ipc_call_t *, void *);
     67
    6068loc_srv_t *hr_srv;
    6169list_t hr_volumes;
     
    6371
    6472static service_id_t ctl_sid;
    65 
    66 static void hr_auto_assemble_srv(ipc_call_t *icall)
    67 {
    68         HR_DEBUG("%s()", __func__);
    69 
    70         errno_t rc;
    71         size_t size;
    72         size_t assembled_cnt = 0;
    73         ipc_call_t call;
    74 
    75         if (!async_data_read_receive(&call, &size)) {
    76                 async_answer_0(icall, EREFUSED);
    77                 return;
    78         }
    79 
    80         if (size != sizeof(size_t)) {
    81                 async_answer_0(&call, EINVAL);
    82                 async_answer_0(icall, EINVAL);
    83                 return;
    84         }
    85 
    86         rc = hr_util_try_assemble(NULL, &assembled_cnt);
    87         if (rc != EOK)
    88                 goto error;
    89 
    90         rc = async_data_read_finalize(&call, &assembled_cnt, size);
    91         if (rc != EOK)
    92                 goto error;
    93 
    94         async_answer_0(icall, EOK);
    95         return;
    96 error:
    97         async_answer_0(&call, rc);
    98         async_answer_0(icall, rc);
    99 }
    100 
    101 static void hr_assemble_srv(ipc_call_t *icall)
    102 {
    103         HR_DEBUG("%s()", __func__);
    104 
    105         errno_t rc;
    106         size_t size, assembled_cnt;
    107         hr_config_t *cfg;
    108         ipc_call_t call;
    109 
    110         if (!async_data_write_receive(&call, &size)) {
    111                 async_answer_0(&call, EREFUSED);
    112                 async_answer_0(icall, EREFUSED);
    113                 return;
    114         }
    115 
    116         if (size != sizeof(hr_config_t)) {
    117                 async_answer_0(&call, EINVAL);
    118                 async_answer_0(icall, EINVAL);
    119                 return;
    120         }
    121 
    122         cfg = calloc(1, sizeof(hr_config_t));
    123         if (cfg == NULL) {
    124                 async_answer_0(&call, ENOMEM);
    125                 async_answer_0(icall, ENOMEM);
    126                 return;
    127         }
    128 
    129         rc = async_data_write_finalize(&call, cfg, size);
    130         if (rc != EOK)
    131                 goto error;
    132 
    133         if (!async_data_read_receive(&call, &size)) {
    134                 async_answer_0(icall, EREFUSED);
    135                 return;
    136         }
    137 
    138         if (size != sizeof(size_t)) {
    139                 async_answer_0(icall, EINVAL);
    140                 return;
    141         }
    142 
    143         rc = hr_util_try_assemble(cfg, &assembled_cnt);
    144         if (rc != EOK)
    145                 goto error;
    146 
    147         rc = async_data_read_finalize(&call, &assembled_cnt, size);
    148         if (rc != EOK)
    149                 goto error;
    150 
    151         free(cfg);
    152         async_answer_0(icall, EOK);
    153         return;
    154 error:
    155         free(cfg);
    156         async_answer_0(&call, rc);
    157         async_answer_0(icall, rc);
    158 }
    15973
    16074static void hr_create_srv(ipc_call_t *icall)
     
    264178        free(cfg);
    265179        hr_destroy_vol_struct(new_volume);
     180        async_answer_0(icall, rc);
     181}
     182
     183static void hr_assemble_srv(ipc_call_t *icall)
     184{
     185        HR_DEBUG("%s()", __func__);
     186
     187        errno_t rc;
     188        size_t size, assembled_cnt;
     189        hr_config_t *cfg;
     190        ipc_call_t call;
     191
     192        if (!async_data_write_receive(&call, &size)) {
     193                async_answer_0(&call, EREFUSED);
     194                async_answer_0(icall, EREFUSED);
     195                return;
     196        }
     197
     198        if (size != sizeof(hr_config_t)) {
     199                async_answer_0(&call, EINVAL);
     200                async_answer_0(icall, EINVAL);
     201                return;
     202        }
     203
     204        cfg = calloc(1, sizeof(hr_config_t));
     205        if (cfg == NULL) {
     206                async_answer_0(&call, ENOMEM);
     207                async_answer_0(icall, ENOMEM);
     208                return;
     209        }
     210
     211        rc = async_data_write_finalize(&call, cfg, size);
     212        if (rc != EOK)
     213                goto error;
     214
     215        if (!async_data_read_receive(&call, &size)) {
     216                async_answer_0(icall, EREFUSED);
     217                return;
     218        }
     219
     220        if (size != sizeof(size_t)) {
     221                async_answer_0(icall, EINVAL);
     222                return;
     223        }
     224
     225        rc = hr_util_try_assemble(cfg, &assembled_cnt);
     226        if (rc != EOK)
     227                goto error;
     228
     229        rc = async_data_read_finalize(&call, &assembled_cnt, size);
     230        if (rc != EOK)
     231                goto error;
     232
     233        free(cfg);
     234        async_answer_0(icall, EOK);
     235        return;
     236error:
     237        free(cfg);
     238        async_answer_0(&call, rc);
     239        async_answer_0(icall, rc);
     240}
     241
     242static void hr_auto_assemble_srv(ipc_call_t *icall)
     243{
     244        HR_DEBUG("%s()", __func__);
     245
     246        errno_t rc;
     247        size_t size;
     248        size_t assembled_cnt = 0;
     249        ipc_call_t call;
     250
     251        if (!async_data_read_receive(&call, &size)) {
     252                async_answer_0(icall, EREFUSED);
     253                return;
     254        }
     255
     256        if (size != sizeof(size_t)) {
     257                async_answer_0(&call, EINVAL);
     258                async_answer_0(icall, EINVAL);
     259                return;
     260        }
     261
     262        rc = hr_util_try_assemble(NULL, &assembled_cnt);
     263        if (rc != EOK)
     264                goto error;
     265
     266        rc = async_data_read_finalize(&call, &assembled_cnt, size);
     267        if (rc != EOK)
     268                goto error;
     269
     270        async_answer_0(icall, EOK);
     271        return;
     272error:
     273        async_answer_0(&call, rc);
    266274        async_answer_0(icall, rc);
    267275}
Note: See TracChangeset for help on using the changeset viewer.