uspace/lib/fdisk/src/fdisk.c

   1 /*
   2  * Copyright (c) 2015 Jiri Svoboda
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  * - Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in the
  13  *   documentation and/or other materials provided with the distribution.
  14  * - The name of the author may not be used to endorse or promote products
  15  *   derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /** @addtogroup libfdisk
  30  * @{
  31  */
  32 /**
  33  * @file Disk management library.
  34  */
  35
  36 #include <adt/list.h>
  37 #include <capa.h>
  38 #include <errno.h>
  39 #include <fdisk.h>
  40 #include <loc.h>
  41 #include <macros.h>
  42 #include <mem.h>
  43 #include <stdlib.h>
  44 #include <str.h>
  45 #include <vbd.h>
  46 #include <vol.h>
  47
  48 static errno_t fdisk_dev_add_parts(fdisk_dev_t *);
  49 static void fdisk_dev_remove_parts(fdisk_dev_t *);
  50 static errno_t fdisk_part_spec_prepare(fdisk_dev_t *, fdisk_part_spec_t *,
  51     vbd_part_spec_t *);
  52 static void fdisk_pri_part_insert_lists(fdisk_dev_t *, fdisk_part_t *);
  53 static void fdisk_log_part_insert_lists(fdisk_dev_t *, fdisk_part_t *);
  54 static errno_t fdisk_update_dev_info(fdisk_dev_t *);
  55 static uint64_t fdisk_ba_align_up(fdisk_dev_t *, uint64_t);
  56 static uint64_t fdisk_ba_align_down(fdisk_dev_t *, uint64_t);
  57 static errno_t fdisk_part_get_max_free_range(fdisk_dev_t *, fdisk_spc_t, aoff64_t *,
  58     aoff64_t *);
  59 static void fdisk_free_range_first(fdisk_dev_t *, fdisk_spc_t, fdisk_free_range_t *);
  60 static bool fdisk_free_range_next(fdisk_free_range_t *);
  61 static bool fdisk_free_range_get(fdisk_free_range_t *, aoff64_t *, aoff64_t *);
  62
  63 static void fdisk_dev_info_delete(fdisk_dev_info_t *info)
  64 {
  65         if (info == NULL)
  66                 return;
  67
  68         free(info->svcname);
  69         free(info);
  70 }
  71
  72 errno_t fdisk_create(fdisk_t **rfdisk)
  73 {
  74         fdisk_t *fdisk = NULL;
  75         errno_t rc;
  76
  77         fdisk = calloc(1, sizeof(fdisk_t));
  78         if (fdisk == NULL) {
  79                 rc = ENOMEM;
  80                 goto error;
  81         }
  82
  83         rc = vol_create(&fdisk->vol);
  84         if (rc != EOK) {
  85                 rc = EIO;
  86                 goto error;
  87         }
  88
  89         rc = vbd_create(&fdisk->vbd);
  90         if (rc != EOK) {
  91                 rc = EIO;
  92                 goto error;
  93         }
  94
  95         *rfdisk = fdisk;
  96         return EOK;
  97 error:
  98         fdisk_destroy(fdisk);
  99
 100         return rc;
 101 }
 102
 103 void fdisk_destroy(fdisk_t *fdisk)
 104 {
 105         if (fdisk == NULL)
 106                 return;
 107
 108         vol_destroy(fdisk->vol);
 109         vbd_destroy(fdisk->vbd);
 110         free(fdisk);
 111 }
 112
 113 errno_t fdisk_dev_list_get(fdisk_t *fdisk, fdisk_dev_list_t **rdevlist)
 114 {
 115         fdisk_dev_list_t *devlist = NULL;
 116         fdisk_dev_info_t *info;
 117         service_id_t *svcs = NULL;
 118         size_t count, i;
 119         errno_t rc;
 120
 121         devlist = calloc(1, sizeof(fdisk_dev_list_t));
 122         if (devlist == NULL)
 123                 return ENOMEM;
 124
 125         devlist->fdisk = fdisk;
 126         list_initialize(&devlist->devinfos);
 127
 128         rc = vbd_get_disks(fdisk->vbd, &svcs, &count);
 129         if (rc != EOK) {
 130                 rc = EIO;
 131                 goto error;
 132         }
 133
 134         for (i = 0; i < count; i++) {
 135                 info = calloc(1, sizeof(fdisk_dev_info_t));
 136                 if (info == NULL) {
 137                         rc = ENOMEM;
 138                         goto error;
 139                 }
 140
 141                 info->svcid = svcs[i];
 142                 info->devlist = devlist;
 143                 list_append(&info->ldevlist, &devlist->devinfos);
 144         }
 145
 146         *rdevlist = devlist;
 147         free(svcs);
 148         return EOK;
 149 error:
 150         free(svcs);
 151         fdisk_dev_list_free(devlist);
 152         return rc;
 153 }
 154
 155 void fdisk_dev_list_free(fdisk_dev_list_t *devlist)
 156 {
 157         fdisk_dev_info_t *info;
 158
 159         if (devlist == NULL)
 160                 return;
 161
 162         while (!list_empty(&devlist->devinfos)) {
 163                 info = list_get_instance(list_first(
 164                     &devlist->devinfos), fdisk_dev_info_t,
 165                     ldevlist);
 166
 167                 list_remove(&info->ldevlist);
 168                 fdisk_dev_info_delete(info);
 169         }
 170
 171         free(devlist);
 172 }
 173
 174 fdisk_dev_info_t *fdisk_dev_first(fdisk_dev_list_t *devlist)
 175 {
 176         if (list_empty(&devlist->devinfos))
 177                 return NULL;
 178
 179         return list_get_instance(list_first(&devlist->devinfos),
 180             fdisk_dev_info_t, ldevlist);
 181 }
 182
 183 fdisk_dev_info_t *fdisk_dev_next(fdisk_dev_info_t *devinfo)
 184 {
 185         link_t *lnext;
 186
 187         lnext = list_next(&devinfo->ldevlist,
 188             &devinfo->devlist->devinfos);
 189         if (lnext == NULL)
 190                 return NULL;
 191
 192         return list_get_instance(lnext, fdisk_dev_info_t,
 193             ldevlist);
 194 }
 195
 196 void fdisk_dev_info_get_svcid(fdisk_dev_info_t *info, service_id_t *rsid)
 197 {
 198         *rsid = info->svcid;
 199 }
 200
 201 errno_t fdisk_dev_info_get_svcname(fdisk_dev_info_t *info, char **rname)
 202 {
 203         char *name;
 204         errno_t rc;
 205
 206         if (info->svcname == NULL) {
 207                 rc = loc_service_get_name(info->svcid,
 208                     &info->svcname);
 209                 if (rc != EOK)
 210                         return rc;
 211         }
 212
 213         name = str_dup(info->svcname);
 214         if (name == NULL)
 215                 return ENOMEM;
 216
 217         *rname = name;
 218         return EOK;
 219 }
 220
 221 errno_t fdisk_dev_info_capacity(fdisk_dev_info_t *info, capa_spec_t *capa)
 222 {
 223         vbd_disk_info_t vinfo;
 224         errno_t rc;
 225
 226         rc = vbd_disk_info(info->devlist->fdisk->vbd, info->svcid, &vinfo);
 227         if (rc != EOK)
 228                 return EIO;
 229
 230         capa_from_blocks(vinfo.nblocks, vinfo.block_size, capa);
 231         return EOK;
 232 }
 233
 234 /** Add partition to our inventory. */
 235 static errno_t fdisk_part_add(fdisk_dev_t *dev, vbd_part_id_t partid,
 236     fdisk_part_t **rpart)
 237 {
 238         fdisk_part_t *part;
 239         vbd_part_info_t pinfo;
 240         vol_part_info_t vpinfo;
 241         errno_t rc;
 242
 243         part = calloc(1, sizeof(fdisk_part_t));
 244         if (part == NULL)
 245                 return ENOMEM;
 246
 247         rc = vbd_part_get_info(dev->fdisk->vbd, partid, &pinfo);
 248         if (rc != EOK) {
 249                 rc = EIO;
 250                 goto error;
 251         }
 252
 253         if (pinfo.svc_id != 0) {
 254                 /*
 255                  * Normally vol service discovers the partition asynchronously.
 256                  * Here we need to make sure the partition is already known to it.
 257                  */
 258                 rc = vol_part_add(dev->fdisk->vol, pinfo.svc_id);
 259                 if (rc != EOK && rc != EEXIST) {
 260                         rc = EIO;
 261                         goto error;
 262                 }
 263
 264                 rc = vol_part_info(dev->fdisk->vol, pinfo.svc_id, &vpinfo);
 265                 if (rc != EOK) {
 266                         rc = EIO;
 267                         goto error;
 268                 }
 269
 270                 part->pcnt = vpinfo.pcnt;
 271                 part->fstype = vpinfo.fstype;
 272                 part->label = str_dup(vpinfo.label);
 273         }
 274
 275         part->dev = dev;
 276         part->index = pinfo.index;
 277         part->block0 = pinfo.block0;
 278         part->nblocks = pinfo.nblocks;
 279         part->pkind = pinfo.pkind;
 280         part->svc_id = pinfo.svc_id;
 281
 282         switch (part->pkind) {
 283         case lpk_primary:
 284         case lpk_extended:
 285                 fdisk_pri_part_insert_lists(dev, part);
 286                 break;
 287         case lpk_logical:
 288                 fdisk_log_part_insert_lists(dev, part);
 289                 break;
 290         }
 291
 292         list_append(&part->lparts, &dev->parts);
 293
 294         if (part->pkind == lpk_extended)
 295                 dev->ext_part = part;
 296
 297         capa_from_blocks(part->nblocks, dev->dinfo.block_size,
 298             &part->capacity);
 299         part->part_id = partid;
 300
 301         if (rpart != NULL)
 302                 *rpart = part;
 303         return EOK;
 304 error:
 305         if (part != NULL)
 306                 free(part->label);
 307         free(part);
 308         return rc;
 309 }
 310
 311 /** Remove partition from our inventory. */
 312 static void fdisk_part_remove(fdisk_part_t *part)
 313 {
 314         list_remove(&part->lparts);
 315         if (link_used(&part->lpri_ba))
 316                 list_remove(&part->lpri_ba);
 317         if (link_used(&part->lpri_idx))
 318                 list_remove(&part->lpri_idx);
 319         if (link_used(&part->llog_ba))
 320                 list_remove(&part->llog_ba);
 321
 322         free(part->label);
 323         free(part);
 324 }
 325
 326 static void fdisk_pri_part_insert_lists(fdisk_dev_t *dev, fdisk_part_t *part)
 327 {
 328         link_t *link;
 329         fdisk_part_t *p;
 330
 331         /* Insert to list by block address */
 332         link = list_first(&dev->pri_ba);
 333         while (link != NULL) {
 334                 p = list_get_instance(link, fdisk_part_t, lpri_ba);
 335                 if (p->block0 > part->block0) {
 336                         list_insert_before(&part->lpri_ba, &p->lpri_ba);
 337                         break;
 338                 }
 339
 340                 link = list_next(link, &dev->pri_ba);
 341         }
 342
 343         if (link == NULL)
 344                 list_append(&part->lpri_ba, &dev->pri_ba);
 345
 346         /* Insert to list by index */
 347         link = list_first(&dev->pri_idx);
 348         while (link != NULL) {
 349                 p = list_get_instance(link, fdisk_part_t, lpri_idx);
 350                 if (p->index > part->index) {
 351                         list_insert_before(&part->lpri_idx, &p->lpri_idx);
 352                         break;
 353                 }
 354
 355                 link = list_next(link, &dev->pri_idx);
 356         }
 357
 358         if (link == NULL)
 359                 list_append(&part->lpri_idx, &dev->pri_idx);
 360 }
 361
 362 static void fdisk_log_part_insert_lists(fdisk_dev_t *dev, fdisk_part_t *part)
 363 {
 364         link_t *link;
 365         fdisk_part_t *p;
 366
 367         /* Insert to list by block address */
 368         link = list_first(&dev->log_ba);
 369         while (link != NULL) {
 370                 p = list_get_instance(link, fdisk_part_t, llog_ba);
 371                 if (p->block0 > part->block0) {
 372                         list_insert_before(&part->llog_ba, &p->llog_ba);
 373                         break;
 374                 }
 375
 376                 link = list_next(link, &dev->log_ba);
 377         }
 378
 379         if (link == NULL)
 380                 list_append(&part->llog_ba, &dev->log_ba);
 381 }
 382
 383 static errno_t fdisk_dev_add_parts(fdisk_dev_t *dev)
 384 {
 385         service_id_t *psids = NULL;
 386         size_t nparts, i;
 387         errno_t rc;
 388
 389         rc = fdisk_update_dev_info(dev);
 390         if (rc != EOK) {
 391                 rc = EIO;
 392                 goto error;
 393         }
 394
 395         rc = vbd_label_get_parts(dev->fdisk->vbd, dev->sid, &psids, &nparts);
 396         if (rc != EOK) {
 397                 rc = EIO;
 398                 goto error;
 399         }
 400
 401         for (i = 0; i < nparts; i++) {
 402                 rc = fdisk_part_add(dev, psids[i], NULL);
 403                 if (rc != EOK) {
 404                         goto error;
 405                 }
 406         }
 407
 408         free(psids);
 409         return EOK;
 410 error:
 411         fdisk_dev_remove_parts(dev);
 412         return rc;
 413 }
 414
 415 static void fdisk_dev_remove_parts(fdisk_dev_t *dev)
 416 {
 417         fdisk_part_t *part;
 418
 419         part = fdisk_part_first(dev);
 420         while (part != NULL) {
 421                 fdisk_part_remove(part);
 422                 part = fdisk_part_first(dev);
 423         }
 424 }
 425
 426 errno_t fdisk_dev_open(fdisk_t *fdisk, service_id_t sid, fdisk_dev_t **rdev)
 427 {
 428         fdisk_dev_t *dev = NULL;
 429         service_id_t *psids = NULL;
 430         size_t nparts, i;
 431         errno_t rc;
 432
 433         dev = calloc(1, sizeof(fdisk_dev_t));
 434         if (dev == NULL)
 435                 return ENOMEM;
 436
 437         dev->fdisk = fdisk;
 438         dev->sid = sid;
 439         list_initialize(&dev->parts);
 440         list_initialize(&dev->pri_idx);
 441         list_initialize(&dev->pri_ba);
 442         list_initialize(&dev->log_ba);
 443
 444         rc = fdisk_update_dev_info(dev);
 445         if (rc != EOK) {
 446                 rc = EIO;
 447                 goto error;
 448         }
 449
 450         rc = vbd_label_get_parts(fdisk->vbd, sid, &psids, &nparts);
 451         if (rc != EOK) {
 452                 rc = EIO;
 453                 goto error;
 454         }
 455
 456         for (i = 0; i < nparts; i++) {
 457                 rc = fdisk_part_add(dev, psids[i], NULL);
 458                 if (rc != EOK) {
 459                         goto error;
 460                 }
 461         }
 462
 463         free(psids);
 464         *rdev = dev;
 465         return EOK;
 466 error:
 467         fdisk_dev_close(dev);
 468         return rc;
 469 }
 470
 471 void fdisk_dev_close(fdisk_dev_t *dev)
 472 {
 473         if (dev == NULL)
 474                 return;
 475
 476         fdisk_dev_remove_parts(dev);
 477         free(dev);
 478 }
 479
 480 /** Erase contents of unlabeled disk. */
 481 errno_t fdisk_dev_erase(fdisk_dev_t *dev)
 482 {
 483         fdisk_part_t *part;
 484         errno_t rc;
 485
 486         if (dev->dinfo.ltype != lt_none)
 487                 return EINVAL;
 488
 489         part = fdisk_part_first(dev);
 490         assert(part != NULL);
 491         if (part->pcnt == vpc_empty)
 492                 return EINVAL;
 493
 494         rc = vol_part_empty(dev->fdisk->vol, part->svc_id);
 495         if (rc != EOK) {
 496                 return rc;
 497         }
 498
 499         part->pcnt = vpc_empty;
 500         return EOK;
 501 }
 502
 503 void fdisk_dev_get_flags(fdisk_dev_t *dev, fdisk_dev_flags_t *rflags)
 504 {
 505         fdisk_dev_flags_t flags;
 506         fdisk_part_t *part;
 507
 508         flags = 0;
 509
 510         /* fdf_can_create_label */
 511         if (dev->dinfo.ltype == lt_none) {
 512                 part = fdisk_part_first(dev);
 513                 assert(part != NULL);
 514                 if (part->pcnt == vpc_empty)
 515                         flags |= fdf_can_create_label;
 516                 else
 517                         flags |= fdf_can_erase_dev;
 518         } else {
 519                 flags |= fdf_can_delete_label;
 520         }
 521
 522         *rflags = flags;
 523 }
 524
 525 errno_t fdisk_dev_get_svcname(fdisk_dev_t *dev, char **rname)
 526 {
 527         char *name;
 528         errno_t rc;
 529
 530         rc = loc_service_get_name(dev->sid, &name);
 531         if (rc != EOK)
 532                 return rc;
 533
 534         *rname = name;
 535         return EOK;
 536 }
 537
 538 errno_t fdisk_dev_capacity(fdisk_dev_t *dev, capa_spec_t *capa)
 539 {
 540         capa_from_blocks(dev->dinfo.nblocks, dev->dinfo.block_size, capa);
 541         return EOK;
 542 }
 543
 544 errno_t fdisk_label_get_info(fdisk_dev_t *dev, fdisk_label_info_t *info)
 545 {
 546         vbd_disk_info_t vinfo;
 547         uint64_t b0, nb;
 548         uint64_t hdrb;
 549         errno_t rc;
 550
 551         rc = vbd_disk_info(dev->fdisk->vbd, dev->sid, &vinfo);
 552         if (rc != EOK) {
 553                 rc = EIO;
 554                 goto error;
 555         }
 556
 557         info->ltype = vinfo.ltype;
 558         info->flags = vinfo.flags;
 559
 560         if ((info->flags & lf_can_create_pri) != 0 ||
 561             (info->flags & lf_can_create_ext) != 0) {
 562                 /* Verify there is enough space to create partition */
 563
 564                 rc = fdisk_part_get_max_free_range(dev, spc_pri, &b0, &nb);
 565                 if (rc != EOK)
 566                         info->flags &= ~(lf_can_create_pri | lf_can_create_ext);
 567         }
 568
 569         if ((info->flags & lf_can_create_log) != 0) {
 570                 /* Verify there is enough space to create logical partition */
 571                 hdrb = max(1, dev->align);
 572                 rc = fdisk_part_get_max_free_range(dev, spc_log, &b0, &nb);
 573                 if (rc != EOK || nb <= hdrb)
 574                         info->flags &= ~lf_can_create_log;
 575         }
 576
 577         return EOK;
 578 error:
 579         return rc;
 580 }
 581
 582 errno_t fdisk_label_create(fdisk_dev_t *dev, label_type_t ltype)
 583 {
 584         fdisk_part_t *part;
 585         errno_t rc;
 586
 587         /* Disk must not contain a label. */
 588         if (dev->dinfo.ltype != lt_none)
 589                 return EEXIST;
 590
 591         /* Dummy partition spanning entire disk must be considered empty */
 592         part = fdisk_part_first(dev);
 593         assert(part != NULL);
 594         if (part->pcnt != vpc_empty)
 595                 return EEXIST;
 596
 597         /* Remove dummy partition */
 598         fdisk_dev_remove_parts(dev);
 599
 600         rc = vbd_label_create(dev->fdisk->vbd, dev->sid, ltype);
 601         if (rc != EOK) {
 602                 /* Re-add dummy partition */
 603                 (void) fdisk_dev_add_parts(dev);
 604                 return rc;
 605         }
 606
 607         rc = fdisk_update_dev_info(dev);
 608         if (rc != EOK)
 609                 return rc;
 610
 611         return EOK;
 612 }
 613
 614 errno_t fdisk_label_destroy(fdisk_dev_t *dev)
 615 {
 616         fdisk_part_t *part;
 617         fdisk_dev_flags_t dflags;
 618         errno_t rc;
 619
 620         part = fdisk_part_first(dev);
 621         while (part != NULL) {
 622                 rc = fdisk_part_destroy(part);
 623                 if (rc != EOK)
 624                         return EIO;
 625                 part = fdisk_part_first(dev);
 626         }
 627
 628         rc = vbd_label_delete(dev->fdisk->vbd, dev->sid);
 629         if (rc != EOK)
 630                 return EIO;
 631
 632         rc = fdisk_dev_add_parts(dev);
 633         if (rc != EOK)
 634                 return rc;
 635
 636         /* Make sure device is considered empty */
 637         fdisk_dev_get_flags(dev, &dflags);
 638         if ((dflags & fdf_can_erase_dev) != 0) {
 639                 rc = fdisk_dev_erase(dev);
 640                 if (rc != EOK)
 641                         return rc;
 642         }
 643
 644         return EOK;
 645 }
 646
 647 fdisk_part_t *fdisk_part_first(fdisk_dev_t *dev)
 648 {
 649         link_t *link;
 650
 651         link = list_first(&dev->parts);
 652         if (link == NULL)
 653                 return NULL;
 654
 655         return list_get_instance(link, fdisk_part_t, lparts);
 656 }
 657
 658 fdisk_part_t *fdisk_part_next(fdisk_part_t *part)
 659 {
 660         link_t *link;
 661
 662         link = list_next(&part->lparts, &part->dev->parts);
 663         if (link == NULL)
 664                 return NULL;
 665
 666         return list_get_instance(link, fdisk_part_t, lparts);
 667 }
 668
 669 errno_t fdisk_part_get_info(fdisk_part_t *part, fdisk_part_info_t *info)
 670 {
 671         info->capacity = part->capacity;
 672         info->pcnt = part->pcnt;
 673         info->fstype = part->fstype;
 674         info->pkind = part->pkind;
 675         info->label = part->label;
 676         info->svc_id = part->svc_id;
 677         return EOK;
 678 }
 679
 680 /** Get size of largest free block. */
 681 errno_t fdisk_part_get_max_avail(fdisk_dev_t *dev, fdisk_spc_t spc,
 682     capa_spec_t *capa)
 683 {
 684         errno_t rc;
 685         uint64_t b0;
 686         uint64_t nb;
 687         aoff64_t hdrb;
 688
 689         rc = fdisk_part_get_max_free_range(dev, spc, &b0, &nb);
 690         if (rc != EOK)
 691                 return rc;
 692
 693         /* For logical partitions we need to subtract header size */
 694         if (spc == spc_log) {
 695                 hdrb = max(1, dev->align);
 696                 if (nb <= hdrb)
 697                         return ENOSPC;
 698                 nb -= hdrb;
 699         }
 700
 701         capa_from_blocks(nb, dev->dinfo.block_size, capa);
 702         return EOK;
 703 }
 704
 705 /** Get total free space capacity. */
 706 errno_t fdisk_part_get_tot_avail(fdisk_dev_t *dev, fdisk_spc_t spc,
 707     capa_spec_t *capa)
 708 {
 709         fdisk_free_range_t fr;
 710         uint64_t hdrb;
 711         uint64_t b0;
 712         uint64_t nb;
 713         uint64_t totb;
 714
 715         if (spc == spc_log)
 716                 hdrb = max(1, dev->align);
 717         else
 718                 hdrb = 0;
 719
 720         totb = 0;
 721         fdisk_free_range_first(dev, spc, &fr);
 722         do {
 723                 if (fdisk_free_range_get(&fr, &b0, &nb)) {
 724                         if (nb > hdrb)
 725                                 totb += nb - hdrb;
 726                 }
 727         } while (fdisk_free_range_next(&fr));
 728
 729         capa_from_blocks(totb, dev->dinfo.block_size, capa);
 730         return EOK;
 731 }
 732
 733 /** Create partition.
 734  *
 735  * Create new partition based on a specification.
 736  *
 737  * @param dev Fdisk device
 738  * @param pspec Partition specification
 739  * @param rpart Place to store pointer to new partition
 740  *
 741  * @return EOK on success or error code
 742  */
 743 errno_t fdisk_part_create(fdisk_dev_t *dev, fdisk_part_spec_t *pspec,
 744     fdisk_part_t **rpart)
 745 {
 746         fdisk_part_t *part = NULL;
 747         vbd_part_spec_t vpspec;
 748         vbd_part_id_t partid = 0;
 749         vol_part_info_t vpinfo;
 750         const char *label;
 751         const char *mountp;
 752         errno_t rc;
 753
 754         label = pspec->label != NULL ? pspec->label : "";
 755         mountp = pspec->mountp != NULL ? pspec->mountp : "";
 756
 757         rc = fdisk_part_spec_prepare(dev, pspec, &vpspec);
 758         if (rc != EOK) {
 759                 rc = EIO;
 760                 goto error;
 761         }
 762
 763         rc = vbd_part_create(dev->fdisk->vbd, dev->sid, &vpspec, &partid);
 764         if (rc != EOK) {
 765                 rc = EIO;
 766                 goto error;
 767         }
 768
 769         rc = fdisk_part_add(dev, partid, &part);
 770         if (rc != EOK) {
 771                 rc = EIO;
 772                 goto error;
 773         }
 774
 775         if (part->svc_id != 0) {
 776                 rc = vol_part_mkfs(dev->fdisk->vol, part->svc_id, pspec->fstype,
 777                     label, mountp);
 778                 if (rc != EOK && rc != ENOTSUP) {
 779                         rc = EIO;
 780                         goto error;
 781                 }
 782
 783                 /* Get the real label value */
 784                 rc = vol_part_info(dev->fdisk->vol, part->svc_id, &vpinfo);
 785                 if (rc != EOK) {
 786                         rc = EIO;
 787                         goto error;
 788                 }
 789
 790                 part->pcnt = vpinfo.pcnt;
 791                 part->fstype = vpinfo.fstype;
 792                 part->label = str_dup(vpinfo.label);
 793
 794                 if (part->label == NULL) {
 795                         rc = EIO;
 796                         goto error;
 797                 }
 798         }
 799
 800         if (rpart != NULL)
 801                 *rpart = part;
 802         return EOK;
 803 error:
 804         /* Try rolling back */
 805         if (part != NULL)
 806                 fdisk_part_remove(part);
 807         if (partid != 0)
 808                 (void) vbd_part_delete(dev->fdisk->vbd, partid);
 809         return rc;
 810 }
 811
 812 errno_t fdisk_part_destroy(fdisk_part_t *part)
 813 {
 814         errno_t rc;
 815
 816         rc = vbd_part_delete(part->dev->fdisk->vbd, part->part_id);
 817         if (rc != EOK)
 818                 return EIO;
 819
 820         fdisk_part_remove(part);
 821         return EOK;
 822 }
 823
 824 /** Set partition mount point.
 825  *
 826  * @param part Fdisk partition
 827  * @param mountp Mount point
 828  *
 829  * @return EOK on success or error code
 830  */
 831 errno_t fdisk_part_set_mountp(fdisk_part_t *part, const char *mountp)
 832 {
 833         return vol_part_set_mountp(part->dev->fdisk->vol,
 834             part->svc_id, mountp);
 835 }
 836
 837 void fdisk_pspec_init(fdisk_part_spec_t *pspec)
 838 {
 839         memset(pspec, 0, sizeof(fdisk_part_spec_t));
 840 }
 841
 842 /** Get free partition index. */
 843 static errno_t fdisk_part_get_free_idx(fdisk_dev_t *dev, int *rindex)
 844 {
 845         link_t *link;
 846         fdisk_part_t *part;
 847         int nidx;
 848
 849         link = list_first(&dev->pri_idx);
 850         nidx = 1;
 851         while (link != NULL) {
 852                 part = list_get_instance(link, fdisk_part_t, lpri_idx);
 853                 if (part->index > nidx)
 854                         break;
 855                 nidx = part->index + 1;
 856                 link = list_next(link, &dev->pri_idx);
 857         }
 858
 859         if (nidx > 4 /* XXXX actual number of slots*/) {
 860                 return ELIMIT;
 861         }
 862
 863         *rindex = nidx;
 864         return EOK;
 865 }
 866
 867 /** Get free range of blocks.
 868  *
 869  * Get free range of blocks of at least the specified size (first fit).
 870  */
 871 static errno_t fdisk_part_get_free_range(fdisk_dev_t *dev, aoff64_t nblocks,
 872     fdisk_spc_t spc, aoff64_t *rblock0, aoff64_t *rnblocks)
 873 {
 874         fdisk_free_range_t fr;
 875         uint64_t b0;
 876         uint64_t nb;
 877
 878         fdisk_free_range_first(dev, spc, &fr);
 879         do {
 880                 if (fdisk_free_range_get(&fr, &b0, &nb)) {
 881                         if (nb >= nblocks) {
 882                                 *rblock0 = b0;
 883                                 *rnblocks = nb;
 884                                 return EOK;
 885                         }
 886                 }
 887         } while (fdisk_free_range_next(&fr));
 888
 889         /* No conforming free range found */
 890         return ENOSPC;
 891 }
 892
 893 /** Get largest free range of blocks.
 894  *
 895  * Get free range of blocks of the maximum size.
 896  */
 897 static errno_t fdisk_part_get_max_free_range(fdisk_dev_t *dev, fdisk_spc_t spc,
 898     aoff64_t *rblock0, aoff64_t *rnblocks)
 899 {
 900         fdisk_free_range_t fr;
 901         uint64_t b0;
 902         uint64_t nb;
 903         uint64_t best_b0;
 904         uint64_t best_nb;
 905
 906         best_b0 = best_nb = 0;
 907         fdisk_free_range_first(dev, spc, &fr);
 908         do {
 909                 if (fdisk_free_range_get(&fr, &b0, &nb)) {
 910                         if (nb > best_nb) {
 911                                 best_b0 = b0;
 912                                 best_nb = nb;
 913                         }
 914                 }
 915         } while (fdisk_free_range_next(&fr));
 916
 917         if (best_nb == 0)
 918                 return ENOSPC;
 919
 920         *rblock0 = best_b0;
 921         *rnblocks = best_nb;
 922         return EOK;
 923 }
 924
 925 /** Prepare new partition specification for VBD. */
 926 static errno_t fdisk_part_spec_prepare(fdisk_dev_t *dev, fdisk_part_spec_t *pspec,
 927     vbd_part_spec_t *vpspec)
 928 {
 929         aoff64_t nom_blocks;
 930         aoff64_t min_blocks;
 931         aoff64_t max_blocks;
 932         aoff64_t act_blocks;
 933         aoff64_t fblock0;
 934         aoff64_t fnblocks;
 935         aoff64_t hdrb;
 936         label_pcnt_t pcnt;
 937         fdisk_spc_t spc;
 938         int index;
 939         errno_t rc;
 940
 941         rc = capa_to_blocks(&pspec->capacity, cv_nom, dev->dinfo.block_size,
 942             &nom_blocks);
 943         if (rc != EOK)
 944                 return rc;
 945
 946         rc = capa_to_blocks(&pspec->capacity, cv_min, dev->dinfo.block_size,
 947             &min_blocks);
 948         if (rc != EOK)
 949                 return rc;
 950
 951         rc = capa_to_blocks(&pspec->capacity, cv_max, dev->dinfo.block_size,
 952             &max_blocks);
 953         if (rc != EOK)
 954                 return rc;
 955
 956         nom_blocks = fdisk_ba_align_up(dev, nom_blocks);
 957         min_blocks = fdisk_ba_align_up(dev, min_blocks);
 958         max_blocks = fdisk_ba_align_up(dev, max_blocks);
 959
 960         pcnt = LPC_LIMIT;
 961
 962         switch (pspec->fstype) {
 963         case fs_exfat:
 964                 pcnt = lpc_exfat;
 965                 break;
 966         case fs_fat:
 967                 pcnt = lpc_fat32; /* XXX Detect FAT12/16 vs FAT32 */
 968                 break;
 969         case fs_minix:
 970                 pcnt = lpc_minix;
 971                 break;
 972         case fs_ext4:
 973                 pcnt = lpc_ext4;
 974                 break;
 975         case fs_cdfs:
 976                 return EINVAL; /* You cannot create an ISO partition */
 977         }
 978
 979         if (pcnt == LPC_LIMIT)
 980                 return EINVAL;
 981
 982         if (pspec->pkind == lpk_logical) {
 983                 hdrb = max(1, dev->align);
 984                 spc = spc_log;
 985         } else {
 986                 hdrb = 0;
 987                 spc = spc_pri;
 988         }
 989
 990         rc = fdisk_part_get_free_range(dev, hdrb + nom_blocks, spc,
 991             &fblock0, &fnblocks);
 992
 993         if (rc == EOK) {
 994                 /*
 995                  * If the size of the free range would still give the same capacity
 996                  * when rounded, allocate entire range. Otherwise allocate exactly
 997                  * what we were asked for.
 998                  */
 999                 if (fnblocks <= max_blocks) {
1000                         act_blocks = fnblocks;
1001                 } else {
1002                         act_blocks = hdrb + nom_blocks;
1003                 }
1004         } else {
1005                 assert(rc == ENOSPC);
1006
1007                 /*
1008                  * There is no free range that can contain exactly the requested
1009                  * capacity. Try to allocate at least such number of blocks
1010                  * that would still fullfill the request within the limits
1011                  * of the precision with witch the capacity was specified
1012                  * (i.e. when rounded up).
1013                  */
1014                 rc = fdisk_part_get_free_range(dev, hdrb + min_blocks, spc,
1015                     &fblock0, &fnblocks);
1016                 if (rc != EOK)
1017                         return rc;
1018
1019                 assert(fnblocks < hdrb + nom_blocks);
1020                 act_blocks = fnblocks;
1021         }
1022
1023         if (pspec->pkind != lpk_logical) {
1024                 rc = fdisk_part_get_free_idx(dev, &index);
1025                 if (rc != EOK)
1026                         return EIO;
1027         } else {
1028                 index = 0;
1029         }
1030
1031         memset(vpspec, 0, sizeof(vbd_part_spec_t));
1032         vpspec->index = index;
1033         vpspec->hdr_blocks = hdrb;
1034         vpspec->block0 = fblock0 + hdrb;
1035         vpspec->nblocks = act_blocks - hdrb;
1036         vpspec->pkind = pspec->pkind;
1037
1038         if (pspec->pkind != lpk_extended) {
1039                 rc = vbd_suggest_ptype(dev->fdisk->vbd, dev->sid, pcnt,
1040                     &vpspec->ptype);
1041                 if (rc != EOK)
1042                         return EIO;
1043         }
1044
1045         return EOK;
1046 }
1047
1048 static errno_t fdisk_update_dev_info(fdisk_dev_t *dev)
1049 {
1050         errno_t rc;
1051         size_t align_bytes;
1052         uint64_t avail_cap;
1053
1054         rc = vbd_disk_info(dev->fdisk->vbd, dev->sid, &dev->dinfo);
1055         if (rc != EOK)
1056                 return EIO;
1057
1058         /* Capacity available for partition in bytes */
1059         avail_cap = dev->dinfo.anblocks * dev->dinfo.block_size;
1060
1061         /* Determine optimum alignment */
1062         align_bytes = 1024 * 1024; /* 1 MiB */
1063         while (align_bytes > 1 && avail_cap / align_bytes < 256) {
1064                 align_bytes = align_bytes / 16;
1065         }
1066
1067         dev->align = align_bytes / dev->dinfo.block_size;
1068         if (dev->align < 1)
1069                 dev->align = 1;
1070         return EOK;
1071 }
1072
1073 static uint64_t fdisk_ba_align_up(fdisk_dev_t *dev, uint64_t ba)
1074 {
1075         return ((ba + dev->align - 1) / dev->align) * dev->align;
1076 }
1077
1078 static uint64_t fdisk_ba_align_down(fdisk_dev_t *dev, uint64_t ba)
1079 {
1080         return ba - (ba % dev->align);
1081 }
1082
1083 static void fdisk_free_range_first(fdisk_dev_t *dev, fdisk_spc_t spc,
1084     fdisk_free_range_t *fr)
1085 {
1086         link_t *link;
1087
1088         fr->dev = dev;
1089         fr->spc = spc;
1090
1091         if (fr->spc == spc_pri) {
1092                 /* Primary partitions */
1093                 fr->b0 = fdisk_ba_align_up(fr->dev, fr->dev->dinfo.ablock0);
1094
1095                 link = list_first(&dev->pri_ba);
1096                 if (link != NULL)
1097                         fr->npart = list_get_instance(link, fdisk_part_t, lpri_ba);
1098                 else
1099                         fr->npart = NULL;
1100         } else { /* fr->spc == spc_log */
1101                 /* Logical partitions */
1102                 fr->b0 = fdisk_ba_align_up(fr->dev, fr->dev->ext_part->block0);
1103
1104                 link = list_first(&dev->log_ba);
1105                 if (link != NULL)
1106                         fr->npart = list_get_instance(link, fdisk_part_t, llog_ba);
1107                 else
1108                         fr->npart = NULL;
1109         }
1110 }
1111
1112 static bool fdisk_free_range_next(fdisk_free_range_t *fr)
1113 {
1114         link_t *link;
1115
1116         if (fr->npart == NULL)
1117                 return false;
1118
1119         fr->b0 = fdisk_ba_align_up(fr->dev, fr->npart->block0 +
1120             fr->npart->nblocks);
1121
1122         if (fr->spc == spc_pri) {
1123                 /* Primary partitions */
1124                 link = list_next(&fr->npart->lpri_ba, &fr->dev->pri_ba);
1125                 if (link != NULL)
1126                         fr->npart = list_get_instance(link, fdisk_part_t, lpri_ba);
1127                 else
1128                         fr->npart = NULL;
1129         } else { /* fr->spc == spc_log */
1130                 /* Logical partitions */
1131                 link = list_next(&fr->npart->llog_ba, &fr->dev->log_ba);
1132                 if (link != NULL)
1133                         fr->npart = list_get_instance(link, fdisk_part_t, llog_ba);
1134                 else
1135                         fr->npart = NULL;
1136         }
1137
1138         return true;
1139 }
1140
1141 static bool fdisk_free_range_get(fdisk_free_range_t *fr,
1142     aoff64_t *b0, aoff64_t *nb)
1143 {
1144         aoff64_t b1;
1145
1146         if (fr->npart != NULL) {
1147                 b1 = fdisk_ba_align_down(fr->dev, fr->npart->block0);
1148         } else {
1149                 if (fr->spc == spc_pri) {
1150                         b1 = fdisk_ba_align_down(fr->dev,
1151                             fr->dev->dinfo.ablock0 + fr->dev->dinfo.anblocks);
1152                 } else { /* fr->spc == spc_log */
1153                         b1 = fdisk_ba_align_down(fr->dev,
1154                             fr->dev->ext_part->block0 + fr->dev->ext_part->nblocks);
1155                 }
1156         }
1157
1158         if (b1 < fr->b0)
1159                 return false;
1160
1161         *b0 = fr->b0;
1162         *nb = b1 - fr->b0;
1163
1164         return true;
1165 }
1166
1167 /** Get volume label support. */
1168 errno_t fdisk_get_vollabel_support(fdisk_dev_t *dev, vol_fstype_t fstype,
1169     vol_label_supp_t *vlsupp)
1170 {
1171         return vol_part_get_lsupp(dev->fdisk->vol, fstype, vlsupp);
1172 }
1173
1174 /** @}
1175  */