Changeset e0bbecb in mainline for uspace/lib/device/src/hr.c


Ignore:
Timestamp:
2025-06-09T20:01:03Z (6 weeks ago)
Author:
Miroslav Cimerman <mc@…>
Children:
e2a8fd2
Parents:
431b513
Message:

hr: move state printing to hrctl

One IPC call is for short volume states printing
and other one for specific volume detailed info
printing.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/device/src/hr.c

    r431b513 re0bbecb  
    209209}
    210210
    211 static errno_t print_vol_info(size_t index, hr_vol_info_t *vol_info)
    212 {
    213         errno_t rc;
    214         size_t i;
    215         char *devname;
    216         hr_extent_t *ext;
    217 
    218         printf("--- vol %zu ---\n", index);
    219 
    220         printf("svc_id: %" PRIun "\n", vol_info->svc_id);
    221 
    222         rc = loc_service_get_name(vol_info->svc_id, &devname);
    223         if (rc != EOK)
    224                 return rc;
    225         printf("devname: %s\n", devname);
    226 
    227         printf("state: %s\n", hr_get_vol_state_str(vol_info->state));
    228 
    229         printf("level: %d\n", vol_info->level);
    230         if (vol_info->level == HR_LVL_4 || vol_info->level == HR_LVL_5) {
    231                 printf("layout: %s\n",
    232                     hr_get_layout_str(vol_info->layout));
    233         }
    234         if (vol_info->level == HR_LVL_0 || vol_info->level == HR_LVL_4) {
    235                 if (vol_info->strip_size / 1024 < 1)
    236                         printf("strip size in bytes: %" PRIu32 "\n",
    237                             vol_info->strip_size);
    238                 else
    239                         printf("strip size: %" PRIu32 "K\n",
    240                             vol_info->strip_size / 1024);
    241         }
    242         printf("size in bytes: %" PRIu64 "MiB\n",
    243             vol_info->nblocks * vol_info->bsize / 1024 / 1024);
    244         printf("size in blocks: %" PRIu64 "\n", vol_info->nblocks);
    245         printf("block size: %zu\n", vol_info->bsize);
    246 
    247         if (vol_info->level == HR_LVL_4)
    248                 printf("extents: [P] [state] [index] [devname]\n");
    249         else
    250                 printf("extents: [state] [index] [devname]\n");
    251         for (i = 0; i < vol_info->extent_no; i++) {
    252                 ext = &vol_info->extents[i];
    253                 if (ext->state == HR_EXT_MISSING || ext->state == HR_EXT_NONE) {
    254                         devname = (char *) "MISSING-devname";
    255                 } else {
    256                         rc = loc_service_get_name(ext->svc_id, &devname);
    257                         if (rc != EOK) {
    258                                 printf("loc_service_get_name() failed, skipping...\n");
    259                                 continue;
    260                         }
    261                 }
    262                 if (vol_info->level == HR_LVL_4) {
    263                         if ((i == 0 && vol_info->layout == HR_RLQ_RAID4_0) ||
    264                             (i == vol_info->extent_no - 1 &&
    265                             vol_info->layout == HR_RLQ_RAID4_N))
    266                                 printf("          P   %s    %zu       %s\n", hr_get_ext_state_str(ext->state), i, devname);
    267                         else
    268                                 printf("              %s    %zu       %s\n", hr_get_ext_state_str(ext->state), i, devname);
    269                 } else {
    270                         printf("          %s    %zu       %s\n", hr_get_ext_state_str(ext->state), i, devname);
    271                 }
    272         }
    273 
    274         if (vol_info->hotspare_no == 0)
    275                 return EOK;
    276 
    277         printf("hotspares: [state] [index] [devname]\n");
    278         for (i = 0; i < vol_info->hotspare_no; i++) {
    279                 ext = &vol_info->hotspares[i];
    280                 if (ext->state == HR_EXT_MISSING) {
    281                         devname = (char *) "MISSING-devname";
    282                 } else {
    283                         rc = loc_service_get_name(ext->svc_id, &devname);
    284                         if (rc != EOK)
    285                                 return rc;
    286                 }
    287                 printf("            %s   %zu     %s\n",
    288                     hr_get_ext_state_str(ext->state), i, devname);
    289         }
    290 
    291         return EOK;
    292 }
    293 
    294211/** Stop/deactivate volume.
    295212 *
     
    408325}
    409326
    410 /** Print state of volumes.
    411  *
    412  * @param hr    Server session
    413  *
    414  * @return EOK on success or an error code
    415  */
    416 errno_t hr_print_state(hr_t *hr)
     327/** Get state of volumes.
     328 *
     329 * @param hr            Server session
     330 * @param rpairs        Place to store pointer to (service id, vol state) pairs
     331 * @param rcnt          Place to store pair count
     332 *
     333 * @return EOK on success or an error code
     334 */
     335errno_t hr_get_vol_states(hr_t *hr, hr_pair_vol_state_t **rpairs, size_t *rcnt)
    417336{
    418337        errno_t rc, retval;
    419338        async_exch_t *exch;
    420339        aid_t req;
    421         size_t size, i;
    422         hr_vol_info_t *vols = NULL;
    423 
    424         exch = async_exchange_begin(hr->sess);
    425         if (exch == NULL) {
    426                 rc = EINVAL;
    427                 goto error;
    428         }
    429 
    430         req = async_send_0(exch, HR_STATUS, NULL);
    431         rc = async_data_read_start(exch, &size, sizeof(size_t));
    432         if (rc != EOK) {
    433                 async_exchange_end(exch);
    434                 async_forget(req);
    435                 return rc;
    436         }
    437 
    438         vols = calloc(size, sizeof(hr_vol_info_t));
    439         if (vols == NULL) {
     340        size_t cnt, i;
     341        hr_pair_vol_state_t *pairs = NULL;
     342
     343        exch = async_exchange_begin(hr->sess);
     344        if (exch == NULL) {
     345                rc = EINVAL;
     346                goto error;
     347        }
     348
     349        req = async_send_0(exch, HR_GET_VOL_STATES, NULL);
     350        rc = async_data_read_start(exch, &cnt, sizeof(size_t));
     351        if (rc != EOK) {
     352                async_exchange_end(exch);
     353                async_forget(req);
     354                return rc;
     355        }
     356
     357        pairs = calloc(cnt, sizeof(*pairs));
     358        if (pairs == NULL) {
    440359                async_exchange_end(exch);
    441360                async_forget(req);
     
    443362        }
    444363
    445         for (i = 0; i < size; i++) {
    446                 rc = async_data_read_start(exch, &vols[i],
    447                     sizeof(hr_vol_info_t));
     364        for (i = 0; i < cnt; i++) {
     365                rc = async_data_read_start(exch, &pairs[i], sizeof(*pairs));
    448366                if (rc != EOK) {
    449367                        async_exchange_end(exch);
     
    460378        }
    461379
    462         if (size == 0) {
    463                 printf("no active volumes\n");
    464                 goto error;
    465         }
    466 
    467         for (i = 0; i < size; i++) {
    468                 rc = print_vol_info(i, &vols[i]);
    469                 if (rc != EOK)
    470                         goto error;
    471         }
    472 
    473 error:
    474         if (vols != NULL)
    475                 free(vols);
     380        if (rpairs != NULL)
     381                *rpairs = pairs;
     382        if (rcnt != NULL)
     383                *rcnt = cnt;
     384        return EOK;
     385
     386error:
     387        if (pairs != NULL)
     388                free(pairs);
     389        return rc;
     390}
     391
     392/** Get volume info.
     393 *
     394 * @param hr            Server session
     395 * @param svc_id        Service id of volume
     396 * @param rinfo         Place to store volume info
     397 *
     398 * @return EOK on success or an error code
     399 */
     400errno_t hr_get_vol_info(hr_t *hr, service_id_t svc_id, hr_vol_info_t *rinfo)
     401{
     402        errno_t rc, retval;
     403        async_exch_t *exch;
     404        aid_t req;
     405
     406        exch = async_exchange_begin(hr->sess);
     407        if (exch == NULL) {
     408                rc = EINVAL;
     409                goto error;
     410        }
     411
     412        req = async_send_0(exch, HR_GET_VOL_INFO, NULL);
     413        rc = async_data_write_start(exch, &svc_id, sizeof(svc_id));
     414        if (rc != EOK) {
     415                async_exchange_end(exch);
     416                async_forget(req);
     417                return rc;
     418        }
     419
     420        rc = async_data_read_start(exch, rinfo, sizeof(*rinfo));
     421        async_exchange_end(exch);
     422        if (rc != EOK) {
     423                async_forget(req);
     424                goto error;
     425        }
     426
     427        async_wait_for(req, &retval);
     428        if (retval != EOK) {
     429                rc = retval;
     430                goto error;
     431        }
     432
     433error:
    476434        return rc;
    477435}
     
    555513}
    556514
     515/** Get volume level string.
     516 *
     517 * @param level Levelvalue
     518 *
     519 * @return Level string
     520 */
     521const char *hr_get_level_str(hr_level_t level)
     522{
     523        switch (level) {
     524        case HR_LVL_0:
     525                return "stripe (RAID 0)";
     526        case HR_LVL_1:
     527                return "mirror (RAID 1)";
     528        case HR_LVL_4:
     529                return "dedicated parity (RAID 4)";
     530        case HR_LVL_5:
     531                return "distributed parity (RAID 5)";
     532        default:
     533                return "Invalid RAID level";
     534        }
     535}
     536
    557537/** Get volume metadata type string.
    558538 *
Note: See TracChangeset for help on using the changeset viewer.