/src/util-linux/libfdisk/src/partition.c

Source

#include "c.h"
#include "strutils.h"

#ifdef HAVE_LIBBLKID
# include <blkid.h>
#endif

#include "fdiskP.h"

/**
 * SECTION: partition
 * @title: Partition
 * @short_description: generic label independent partition abstraction
 *
 * The fdisk_partition provides label independent abstraction. The partitions
 * are not directly connected with partition table (label) data. Any change to
 * fdisk_partition does not affects in-memory or on-disk label data.
 *
 * The fdisk_partition is possible to use as a template for
 * fdisk_add_partition() or fdisk_set_partition() operations.
 */

static void init_partition(struct fdisk_partition *pa)
{
  FDISK_INIT_UNDEF(pa->size);
  FDISK_INIT_UNDEF(pa->start);
  FDISK_INIT_UNDEF(pa->partno);
  FDISK_INIT_UNDEF(pa->parent_partno);
  FDISK_INIT_UNDEF(pa->boot);

  INIT_LIST_HEAD(&pa->parts);
}

/**
 * fdisk_new_partition:
 *
 * Returns: new instance.
 */
struct fdisk_partition *fdisk_new_partition(void)
{
  struct fdisk_partition *pa = calloc(1, sizeof(*pa));
  if (!pa)
    return NULL;

  pa->refcount = 1;
  init_partition(pa);
  DBG(PART, ul_debugobj(pa, "alloc"));
  return pa;
}

/**
 * fdisk_reset_partition:
 * @pa: partition
 *
 * Resets partition content.
 */
void fdisk_reset_partition(struct fdisk_partition *pa)
{
  int ref;

  if (!pa)
    return;

  DBG(PART, ul_debugobj(pa, "reset"));
  ref = pa->refcount;

  fdisk_unref_parttype(pa->type);
  free(pa->name);
  free(pa->uuid);
  free(pa->attrs);
  free(pa->fstype);
  free(pa->fsuuid);
  free(pa->fslabel);
  free(pa->start_chs);
  free(pa->end_chs);

  memset(pa, 0, sizeof(*pa));
  pa->refcount = ref;

  init_partition(pa);
}

static struct fdisk_partition *__copy_partition(struct fdisk_partition *o)
{
  struct fdisk_partition *n = fdisk_new_partition();
  int rc;

  if (!n)
    return NULL;

  memcpy(n, o, sizeof(*n));

  /* do not copy reference to lists, etc.*/
  n->refcount = 1;
  INIT_LIST_HEAD(&n->parts);

  if (n->type)
    fdisk_ref_parttype(n->type);

  /* note that strdup_between_structs() deallocates destination pointer,
   * so make sure it's NULL as we call memcpy() before ... */
  n->name = NULL;
  rc = strdup_between_structs(n, o, name);

  n->uuid = NULL;
  if (!rc)
    rc = strdup_between_structs(n, o, uuid);
  n->attrs = NULL;
  if (!rc)
    rc = strdup_between_structs(n, o, attrs);
  n->fstype = NULL;
  if (!rc)
    rc = strdup_between_structs(n, o, fstype);
  n->fsuuid = NULL;
  if (!rc)
    rc = strdup_between_structs(n, o, fsuuid);
  n->fslabel = NULL;
  if (!rc)
    rc = strdup_between_structs(n, o, fslabel);
  n->start_chs = NULL;
  if (!rc)
    rc = strdup_between_structs(n, o, start_chs);
  n->end_chs = NULL;
  if (!rc)
    rc = strdup_between_structs(n, o, end_chs);

  if (rc) {
    fdisk_unref_partition(n);
    n = NULL;
  }
  return n;
}

/**
 * fdisk_ref_partition:
 * @pa: partition pointer
 *
 * Increments reference counter.
 */
void fdisk_ref_partition(struct fdisk_partition *pa)
{
  if (pa)
    pa->refcount++;
}

/**
 * fdisk_unref_partition:
 * @pa: partition pointer
 *
 * Decrements reference counter, on zero the @pa is automatically
 * deallocated.
 */
void fdisk_unref_partition(struct fdisk_partition *pa)
{
  if (!pa)
    return;

  pa->refcount--;
  if (pa->refcount <= 0) {
    list_del(&pa->parts);
    fdisk_reset_partition(pa);
    DBG(PART, ul_debugobj(pa, "free"));
    free(pa);
  }
}

/**
 * fdisk_partition_set_start:
 * @pa: partition
 * @off: offset in sectors, maximal is UINT64_MAX-1
 *
 * Note that zero is valid offset too. Use fdisk_partition_unset_start() to
 * undefine the offset.
 *
 * Returns: 0 on success, <0 on error.
 */
int fdisk_partition_set_start(struct fdisk_partition *pa, fdisk_sector_t off)
{
  if (!pa)
    return -EINVAL;
  if (FDISK_IS_UNDEF(off))
    return -ERANGE;
  pa->start = off;
  pa->fs_probed = 0;
  return 0;
}

/**
 * fdisk_partition_unset_start:
 * @pa: partition
 *
 * Sets the size as undefined. See fdisk_partition_has_start().
 *
 * Returns: 0 on success, <0 on error.
 */
int fdisk_partition_unset_start(struct fdisk_partition *pa)
{
  if (!pa)
    return -EINVAL;
  FDISK_INIT_UNDEF(pa->start);
  pa->fs_probed = 0;
  return 0;
}

/**
 * fdisk_partition_get_start:
 * @pa: partition
 *
 * The zero is also valid offset. The function may return random undefined
 * value when start offset is undefined (for example after
 * fdisk_partition_unset_start()). Always use fdisk_partition_has_start() to be
 * sure that you work with valid numbers.
 *
 * Returns: start offset in sectors
 */
fdisk_sector_t fdisk_partition_get_start(struct fdisk_partition *pa)
{
  return pa->start;
}

/**
 * fdisk_partition_has_start:
 * @pa: partition
 *
 * Returns: 1 or 0
 */
int fdisk_partition_has_start(struct fdisk_partition *pa)
{
  return pa && !FDISK_IS_UNDEF(pa->start);
}


/**
 * fdisk_partition_cmp_start:
 * @a: partition
 * @b: partition
 *
 * Compares partitions according to start offset, See fdisk_table_sort_partitions().
 *
 * Return: 0 if the same, <0 if @b greater, >0 if @a greater.
 */
int fdisk_partition_cmp_start(struct fdisk_partition *a,
            struct fdisk_partition *b)
{
  int no_a = FDISK_IS_UNDEF(a->start),
      no_b = FDISK_IS_UNDEF(b->start);

  if (no_a && no_b)
    return 0;
  if (no_a)
    return -1;
  if (no_b)
    return 1;

  return cmp_numbers(a->start, b->start);
}

/**
 * fdisk_partition_start_follow_default
 * @pa: partition
 * @enable: 0|1
 *
 * When @pa is used as a template for fdisk_add_partition(), it follows the driver's default for
 * the beginning of the partition. For DOS, it is the first usable space, while for GPT, it is
 * the first sector of the largest area.
 *
 * Returns: 0 on success, <0 on error.
 */
int fdisk_partition_start_follow_default(struct fdisk_partition *pa, int enable)
{
  if (!pa)
    return -EINVAL;
  pa->start_follow_default = enable ? 1 : 0;
  return 0;
}

/**
 * fdisk_partition_start_is_default:
 * @pa: partition
 *
 * See fdisk_partition_start_follow_default().
 *
 * Returns: 1 if the partition follows default
 */
int fdisk_partition_start_is_default(struct fdisk_partition *pa)
{
  assert(pa);
  return pa->start_follow_default;
}

/**
 * fdisk_partition_set_size:
 * @pa: partition
 * @sz: size in sectors, maximal is UIN64_MAX-1
 *
 * Note that zero is valid size too. Use fdisk_partition_unset_size() to
 * undefine the size.
 *
 * Returns: 0 on success, <0 on error.
 */
int fdisk_partition_set_size(struct fdisk_partition *pa, fdisk_sector_t sz)
{
  if (!pa)
    return -EINVAL;
  if (FDISK_IS_UNDEF(sz))
    return -ERANGE;
  pa->size = sz;
  pa->fs_probed = 0;
  return 0;
}

/**
 * fdisk_partition_unset_size:
 * @pa: partition
 *
 * Sets the size as undefined. See fdisk_partition_has_size().
 *
 * Returns: 0 on success, <0 on error.
 */
int fdisk_partition_unset_size(struct fdisk_partition *pa)
{
  if (!pa)
    return -EINVAL;
  FDISK_INIT_UNDEF(pa->size);
  pa->fs_probed = 0;
  return 0;
}

/**
 * fdisk_partition_get_size:
 * @pa: partition
 *
 * The zero is also valid size. The function may return random undefined
 * value when size is undefined (for example after fdisk_partition_unset_size()).
 * Always use fdisk_partition_has_size() to be sure that you work with valid
 * numbers.
 *
 * Returns: size offset in sectors
 */
fdisk_sector_t fdisk_partition_get_size(struct fdisk_partition *pa)
{
  return pa->size;
}

/**
 * fdisk_partition_has_size:
 * @pa: partition
 *
 * Returns: 1 or 0
 */
int fdisk_partition_has_size(struct fdisk_partition *pa)
{
  return pa && !FDISK_IS_UNDEF(pa->size);
}

/**
 * fdisk_partition_size_explicit:
 * @pa: partition
 * @enable: 0|1
 *
 * By default libfdisk aligns the size when add the new partition (by
 * fdisk_add_partition()). If you want to disable this functionality use
 * @enable = 1.
 *
 * Returns: 0 on success, <0 on error.
 */
int fdisk_partition_size_explicit(struct fdisk_partition *pa, int enable)
{
  if (!pa)
    return -EINVAL;
  pa->size_explicit = enable ? 1 : 0;
  return 0;
}

/**
 * fdisk_partition_set_partno:
 * @pa: partition
 * @num: partition number (0 is the first partition, maximal is SIZE_MAX-1)
 *
 * Note that zero is valid partno too. Use fdisk_partition_unset_partno() to
 * undefine the partno.
 *
 * Returns: 0 on success, <0 on error.
 */
int fdisk_partition_set_partno(struct fdisk_partition *pa, size_t num)
{
  if (!pa)
    return -EINVAL;
  if (FDISK_IS_UNDEF(num))
    return -ERANGE;
  pa->partno = num;
  return 0;
}

/**
 * fdisk_partition_unset_partno:
 * @pa: partition
 *
 * Sets the partno as undefined. See fdisk_partition_has_partno().
 *
 * Returns: 0 on success, <0 on error.
 */
int fdisk_partition_unset_partno(struct fdisk_partition *pa)
{
  if (!pa)
    return -EINVAL;
  FDISK_INIT_UNDEF(pa->partno);
  return 0;
}

/**
 * fdisk_partition_get_partno:
 * @pa: partition
 *
 * The zero is also valid partition number. The function may return random
 * value when partno is undefined (for example after fdisk_partition_unset_partno()).
 * Always use fdisk_partition_has_partno() to be sure that you work with valid
 * numbers.
 *
 * Returns: partition number (0 is the first partition)
 */
size_t fdisk_partition_get_partno(struct fdisk_partition *pa)
{
  return pa->partno;
}

/**
 * fdisk_partition_has_partno:
 * @pa: partition
 *
 * Returns: 1 or 0
 */
int fdisk_partition_has_partno(struct fdisk_partition *pa)
{
  return pa && !FDISK_IS_UNDEF(pa->partno);
}


/**
 * fdisk_partition_cmp_partno:
 * @a: partition
 * @b: partition
 *
 * Compares partitions according to partition number See fdisk_table_sort_partitions().
 *
 * Return: 0 if the same, <0 if @b greater, >0 if @a greater.
 */
int fdisk_partition_cmp_partno(struct fdisk_partition *a,
             struct fdisk_partition *b)
{
  return a->partno - b->partno;
}

/**
 * fdisk_partition_partno_follow_default
 * @pa: partition
 * @enable: 0|1
 *
 * When @pa used as a template for fdisk_add_partition() when force label driver
 * to add a new partition to the default (next) position.
 *
 * Returns: 0 on success, <0 on error.
 */
int fdisk_partition_partno_follow_default(struct fdisk_partition *pa, int enable)
{
  if (!pa)
    return -EINVAL;
  pa->partno_follow_default = enable ? 1 : 0;
  return 0;
}

/**
 * fdisk_partition_set_type:
 * @pa: partition
 * @type: partition type
 *
 * Sets partition type.
 *
 * Returns: 0 on success, <0 on error.
 */
int fdisk_partition_set_type(struct fdisk_partition *pa,
           struct fdisk_parttype *type)
{
  if (!pa)
    return -EINVAL;

  fdisk_ref_parttype(type);
  fdisk_unref_parttype(pa->type);
  pa->type = type;

  return 0;
}

/**
 * fdisk_partition_get_type:
 * @pa: partition
 *
 * Returns: pointer to partition type.
 */
struct fdisk_parttype *fdisk_partition_get_type(struct fdisk_partition *pa)
{
  return pa ? pa->type : NULL;
}

/**
 * fdisk_partition_set_name:
 * @pa: partition
 * @name: partition name
 *
 * Returns: 0 on success, <0 on error.
 */
int fdisk_partition_set_name(struct fdisk_partition *pa, const char *name)
{
  if (!pa)
    return -EINVAL;
  return strdup_to_struct_member(pa, name, name);
}

/**
 * fdisk_partition_get_name:
 * @pa: partition
 *
 * Returns: partition name
 */
const char *fdisk_partition_get_name(struct fdisk_partition *pa)
{
  return pa ? pa->name : NULL;
}

/**
 * fdisk_partition_set_uuid:
 * @pa: partition
 * @uuid: UUID of the partition
 *
 * Returns: 0 on success, <0 on error.
 */
int fdisk_partition_set_uuid(struct fdisk_partition *pa, const char *uuid)
{
  if (!pa)
    return -EINVAL;
  return strdup_to_struct_member(pa, uuid, uuid);
}

/**
 * fdisk_partition_has_end:
 * @pa: partition
 *
 * Returns: 1 if the partition has defined last sector
 */
int fdisk_partition_has_end(struct fdisk_partition *pa)
{
  return pa && !FDISK_IS_UNDEF(pa->start) && !FDISK_IS_UNDEF(pa->size);
}

/**
 * fdisk_partition_get_end:
 * @pa: partition
 *
 * This function may returns absolute non-sense, always check
 * fdisk_partition_has_end().
 *
 * Note that partition end is defined by fdisk_partition_set_start() and
 * fdisk_partition_set_size().
 *
 * Returns: last partition sector LBA.
 */
fdisk_sector_t fdisk_partition_get_end(struct fdisk_partition *pa)
{
  return pa->start + pa->size - (pa->size == 0 ? 0 : 1);
}

/**
 * fdisk_partition_end_follow_default
 * @pa: partition
 * @enable: 0|1
 *
 * When @pa used as a template for fdisk_add_partition() when force label
 * driver to use all the possible space for the new partition.
 *
 * Returns: 0 on success, <0 on error.
 */
int fdisk_partition_end_follow_default(struct fdisk_partition *pa, int enable)
{
  if (!pa)
    return -EINVAL;
  pa->end_follow_default = enable ? 1 : 0;
  return 0;
}

/**
 * fdisk_partition_end_is_default:
 * @pa: partition
 *
 * Returns: 1 if the partition follows default
 */
int fdisk_partition_end_is_default(struct fdisk_partition *pa)
{
  assert(pa);
  return pa->end_follow_default;
}

/**
 * fdisk_partition_get_uuid:
 * @pa: partition
 *
 * Returns: partition UUID as string
 */
const char *fdisk_partition_get_uuid(struct fdisk_partition *pa)
{
  return pa ? pa->uuid : NULL;
}

/**
 * fdisk_partition_get_attrs:
 * @pa: partition
 *
 * Returns: partition attributes in string format
 */
const char *fdisk_partition_get_attrs(struct fdisk_partition *pa)
{
  return pa ? pa->attrs : NULL;
}

/**
 * fdisk_partition_set_attrs:
 * @pa: partition
 * @attrs: attributes
 *
 * Sets @attrs to @pa.
 *
 * Return: 0 on success, <0 on error.
 */
int fdisk_partition_set_attrs(struct fdisk_partition *pa, const char *attrs)
{
  if (!pa)
    return -EINVAL;
  return strdup_to_struct_member(pa, attrs, attrs);
}

/**
 * fdisk_partition_is_nested:
 * @pa: partition
 *
 * Returns: 1 if the partition is nested (e.g. MBR logical partition)
 */
int fdisk_partition_is_nested(struct fdisk_partition *pa)
{
  return pa && !FDISK_IS_UNDEF(pa->parent_partno);
}

/**
 * fdisk_partition_is_container:
 * @pa: partition
 *
 * Returns: 1 if the partition is container (e.g. MBR extended partition)
 */
int fdisk_partition_is_container(struct fdisk_partition *pa)
{
  return pa && pa->container;
}

/**
 * fdisk_partition_get_parent:
 * @pa: partition
 * @parent: parent parno
 *
 * Returns: returns devno of the parent
 */
int fdisk_partition_get_parent(struct fdisk_partition *pa, size_t *parent)
{
  if (pa && parent)
    *parent = pa->parent_partno;
  else
    return -EINVAL;
  return 0;
}

/**
 * fdisk_partition_is_used:
 * @pa: partition
 *
 * Returns: 1 if the partition points to some area
 */
int fdisk_partition_is_used(struct fdisk_partition *pa)
{
  return pa && pa->used;
}

/**
 * fdisk_partition_is_bootable:
 * @pa: partition
 *
 * Returns: 1 if the partition has enabled boot flag
 */
int fdisk_partition_is_bootable(struct fdisk_partition *pa)
{
  return pa && pa->boot == 1;
}

/**
 * fdisk_partition_is_freespace:
 * @pa: partition
 *
 * Returns: 1 if @pa points to freespace
 */
int fdisk_partition_is_freespace(struct fdisk_partition *pa)
{
  return pa && pa->freespace;
}

/**
 * fdisk_partition_is_wholedisk:
 * @pa: partition
 *
 * Returns: 1 if the partition is special whole-disk (e.g. SUN) partition
 */
int fdisk_partition_is_wholedisk(struct fdisk_partition *pa)
{
  return pa && pa->wholedisk;
}

/**
 * fdisk_partition_next_partno:
 * @pa: partition
 * @cxt: context
 * @n: returns partition number
 *
 * If @pa specified and partno-follow-default (see fdisk_partition_partno_follow_default())
 * enabled then returns next expected partno or -ERANGE on error.
 *
 * If @pa is NULL, or @pa does not specify any semantic for the next partno
 * then use Ask API to ask user for the next partno. In this case returns 1 if
 * no free partition available. If fdisk dialogs are disabled then returns -EINVAL.
 *
 * Returns: 0 on success, <0 on error, or 1 for non-free partno by Ask API.
 */
int fdisk_partition_next_partno(
    struct fdisk_partition *pa,
    struct fdisk_context *cxt,
    size_t *n)
{
  if (!cxt || !n)
    return -EINVAL;

  if (pa && pa->partno_follow_default) {
    size_t i;

    DBG(PART, ul_debugobj(pa, "next partno (follow default)"));

    for (i = 0; i < cxt->label->nparts_max; i++) {
      if (!fdisk_is_partition_used(cxt, i)) {
        *n = i;
        return 0;
      }
    }
    return -ERANGE;

  }

  if (pa && fdisk_partition_has_partno(pa)) {

    DBG(PART, ul_debugobj(pa, "next partno (specified=%zu)", pa->partno));

    if (pa->partno >= cxt->label->nparts_max ||
        fdisk_is_partition_used(cxt, pa->partno))
      return -ERANGE;
    *n = pa->partno;
    return 0;

  }

  if (fdisk_has_dialogs(cxt))
    return fdisk_ask_partnum(cxt, n, 1);

  return -EINVAL;
}

static int probe_partition_content(struct fdisk_context *cxt, struct fdisk_partition *pa)
{
  int rc = 1; /* nothing */

  DBG(PART, ul_debugobj(pa, "start probe #%zu partition [cxt %p] >>>", pa->partno, cxt));

  /* zeroize the current setting */
  strdup_to_struct_member(pa, fstype, NULL);
  strdup_to_struct_member(pa, fsuuid, NULL);
  strdup_to_struct_member(pa, fslabel, NULL);

  if (!fdisk_partition_has_start(pa) ||
      !fdisk_partition_has_size(pa))
    goto done;

#ifdef HAVE_LIBBLKID
  else {
    uintmax_t start, size;

    blkid_probe pr = blkid_new_probe();
    if (!pr)
      goto done;

    DBG(PART, ul_debugobj(pa, "blkid prober: %p", pr));

    blkid_probe_enable_superblocks(pr, 1);
    blkid_probe_set_superblocks_flags(pr,
        BLKID_SUBLKS_MAGIC |
        BLKID_SUBLKS_TYPE |
        BLKID_SUBLKS_LABEL |
        BLKID_SUBLKS_UUID |
        BLKID_SUBLKS_BADCSUM);

    start = fdisk_partition_get_start(pa) * fdisk_get_sector_size(cxt);
    size = fdisk_partition_get_size(pa) * fdisk_get_sector_size(cxt);

    if (blkid_probe_set_device(pr, cxt->dev_fd, start, size) == 0
        && blkid_do_fullprobe(pr) == 0) {

      const char *data;
      rc = 0;

      if (!blkid_probe_lookup_value(pr, "TYPE",  &data, NULL))
        rc = strdup_to_struct_member(pa, fstype, data);

      if (!rc && !blkid_probe_lookup_value(pr, "LABEL", &data, NULL))
        rc = strdup_to_struct_member(pa, fslabel, data);

      if (!rc && !blkid_probe_lookup_value(pr, "UUID",  &data, NULL))
        rc = strdup_to_struct_member(pa, fsuuid, data);
    }

    blkid_free_probe(pr);
    pa->fs_probed = 1;
  }
#endif /* HAVE_LIBBLKID */

done:
  DBG(PART, ul_debugobj(pa, "<<< end probe #%zu partition[cxt %p, rc=%d]", pa->partno, cxt, rc));
  return rc;
}

/**
 * fdisk_partition_to_string:
 * @pa: partition
 * @cxt: context
 * @id: field (FDISK_FIELD_*)
 * @data: returns string with allocated data
 *
 * Returns info about partition converted to printable string.
 *
 * For example
 * <informalexample>
 *   <programlisting>
 *      struct fdisk_partition *pa;
 *
 *      fdisk_get_partition(cxt, 0, &pa);
 *  fdisk_partition_to_string(pa, FDISK_FIELD_UUID, &data);
 *  printf("first partition uuid: %s\n", data);
 *  free(data);
 *  fdisk_unref_partition(pa);
 *   </programlisting>
 * </informalexample>
 *
 * returns UUID for the first partition.
 *
 * Returns: 0 on success, otherwise, a corresponding error.
 */
int fdisk_partition_to_string(struct fdisk_partition *pa,
            struct fdisk_context *cxt,
            int id,
            char **data)
{
  char *p = NULL;
  int rc = 0;
  uint64_t x;

  if (!pa || !cxt || !data)
    return -EINVAL;

  switch (id) {
  case FDISK_FIELD_DEVICE:
    if (pa->freespace)
      p = strdup(_("Free space"));
    else if (fdisk_partition_has_partno(pa) && cxt->dev_path) {
      if (cxt->label->flags & FDISK_LABEL_FL_INCHARS_PARTNO)
        rc = asprintf(&p, "%c", (int) pa->partno + 'a');
      else
        p = fdisk_partname(cxt->dev_path, pa->partno + 1);
    }
    break;
  case FDISK_FIELD_BOOT:
    p = fdisk_partition_is_bootable(pa) ? strdup("*") : NULL;
    break;
  case FDISK_FIELD_START:
    if (fdisk_partition_has_start(pa)) {
      x = fdisk_cround(cxt, pa->start);
      rc = pa->start_post ?
        asprintf(&p, "%"PRIu64"%c", x, pa->start_post) :
        asprintf(&p, "%"PRIu64, x);
    }
    break;
  case FDISK_FIELD_END:
    if (fdisk_partition_has_end(pa)) {
      x = fdisk_cround(cxt, fdisk_partition_get_end(pa));
      rc = pa->end_post ?
          asprintf(&p, "%"PRIu64"%c", x, pa->end_post) :
          asprintf(&p, "%"PRIu64, x);
    }
    break;
  case FDISK_FIELD_SIZE:
    if (fdisk_partition_has_size(pa)) {
      uint64_t sz = pa->size * cxt->sector_size;

      switch (cxt->sizeunit) {
      case FDISK_SIZEUNIT_BYTES:
        rc = asprintf(&p, "%"PRIu64"", sz);
        break;
      case FDISK_SIZEUNIT_HUMAN:
        if (fdisk_is_details(cxt))
          rc = pa->size_post ?
              asprintf(&p, "%"PRIu64"%c", sz, pa->size_post) :
              asprintf(&p, "%"PRIu64, sz);
        else {
          p = size_to_human_string(SIZE_SUFFIX_1LETTER, sz);
          if (!p)
            rc = -ENOMEM;
        }
        break;
      }
    }
    break;
  case FDISK_FIELD_CYLINDERS:
  {
    uintmax_t sz = fdisk_partition_has_size(pa) ? pa->size : 0;
    if (sz)
      /* Why we need to cast that to uintmax_t? */
      rc = asprintf(&p, "%ju", (uintmax_t)(sz / (cxt->geom.heads * cxt->geom.sectors)) + 1);
    break;
  }
  case FDISK_FIELD_SECTORS:
    rc = asprintf(&p, "%ju",
      fdisk_partition_has_size(pa) ? (uintmax_t) pa->size : 0);
    break;
  case FDISK_FIELD_BSIZE:
    rc = asprintf(&p, "%"PRIu64, pa->bsize);
    break;
  case FDISK_FIELD_FSIZE:
    rc = asprintf(&p, "%"PRIu64, pa->fsize);
    break;
  case FDISK_FIELD_CPG:
    rc = asprintf(&p, "%"PRIu64, pa->cpg);
    break;
  case FDISK_FIELD_TYPE:
    p = pa->type && pa->type->name ? strdup(_(pa->type->name)) : NULL;
    break;
  case FDISK_FIELD_TYPEID:
    if (pa->type && fdisk_parttype_get_string(pa->type))
      rc = asprintf(&p, "%s", fdisk_parttype_get_string(pa->type));
    else if (pa->type)
      rc = asprintf(&p, "%x", fdisk_parttype_get_code(pa->type));
    break;
  case FDISK_FIELD_UUID:
    p = pa->uuid && *pa->uuid? strdup(pa->uuid) : NULL;
    break;
  case FDISK_FIELD_NAME:
    p = pa->name && *pa->name ? strdup(pa->name) : NULL;
    break;
  case FDISK_FIELD_ATTR:
    p = pa->attrs && *pa->attrs ? strdup(pa->attrs) : NULL;
    break;
  case FDISK_FIELD_SADDR:
    p = pa->start_chs && *pa->start_chs ? strdup(pa->start_chs) : NULL;
    break;
  case FDISK_FIELD_EADDR:
    p = pa->end_chs && *pa->end_chs? strdup(pa->end_chs) : NULL;
    break;
  case FDISK_FIELD_FSUUID:
    if (pa->fs_probed || probe_partition_content(cxt, pa) == 0)
      p = pa->fsuuid && *pa->fsuuid ? strdup(pa->fsuuid) : NULL;
    break;
  case FDISK_FIELD_FSLABEL:
    if (pa->fs_probed || probe_partition_content(cxt, pa) == 0)
      p = pa->fslabel && *pa->fslabel ? strdup(pa->fslabel) : NULL;
    break;
  case FDISK_FIELD_FSTYPE:
    if (pa->fs_probed || probe_partition_content(cxt, pa) == 0)
      p = pa->fstype && *pa->fstype ? strdup(pa->fstype) : NULL;
    break;
  default:
    return -EINVAL;
  }

  if (rc < 0) {
    rc = -ENOMEM;
    free(p);
    p = NULL;

  } else if (rc > 0)
    rc = 0;

  *data = p;

  return rc;
}


/**
 * fdisk_get_partition:
 * @cxt: context
 * @partno: partition number (0 is the first partition)
 * @pa: returns data about partition
 *
 * Reads disklabel and fills in @pa with data about partition @n.
 *
 * Note that partno may address unused partition and then this function does
 * not fill anything to @pa.  See fdisk_is_partition_used(). If @pa points to
 * NULL then the function allocates a newly allocated fdisk_partition struct,
 * use fdisk_unref_partition() to deallocate.
 *
 * Returns: 0 on success, otherwise, a corresponding error.
 */
int fdisk_get_partition(struct fdisk_context *cxt, size_t partno,
      struct fdisk_partition **pa)
{
  int rc;
  struct fdisk_partition *np = NULL;

  if (!cxt || !cxt->label || !pa)
    return -EINVAL;
  if (!cxt->label->op->get_part)
    return -ENOSYS;
  if (!fdisk_is_partition_used(cxt, partno))
    return -EINVAL;

  if (!*pa) {
    np = *pa = fdisk_new_partition();
    if (!*pa)
      return -ENOMEM;
  } else
    fdisk_reset_partition(*pa);

  (*pa)->partno = partno;
  rc = cxt->label->op->get_part(cxt, partno, *pa);

  if (rc) {
    if (np) {
      fdisk_unref_partition(np);
      *pa = NULL;
    } else
      fdisk_reset_partition(*pa);
  } else
    (*pa)->size_explicit = 1;
  return rc;
}

static struct fdisk_partition *area_by_offset(
      struct fdisk_table *tb,
      struct fdisk_partition *cur,
      fdisk_sector_t off)
{
  struct fdisk_partition *pa = NULL;
  struct fdisk_iter itr;

  fdisk_reset_iter(&itr, FDISK_ITER_FORWARD);

  while (fdisk_table_next_partition(tb, &itr, &pa) == 0) {
    if (!fdisk_partition_has_start(pa) || !fdisk_partition_has_size(pa))
      continue;
    if (fdisk_partition_is_nested(cur) &&
        pa->parent_partno != cur->parent_partno)
      continue;
    if (off >= pa->start && off < pa->start + pa->size)
      return pa;
  }

  return NULL;
}

static int resize_get_first_possible(
      struct fdisk_table *tb,
      struct fdisk_partition *cur,
      fdisk_sector_t *start)
{
  struct fdisk_partition *pa = NULL, *first = NULL;
  struct fdisk_iter itr;

  fdisk_reset_iter(&itr, FDISK_ITER_FORWARD);

  *start = 0;
  DBG(TAB, ul_debugobj(tb, "checking first possible before start=%ju", (uintmax_t) cur->start));


  while (fdisk_table_next_partition(tb, &itr, &pa) == 0) {

    if (pa->start > cur->start || pa == cur)
      break;

    DBG(TAB, ul_debugobj(tb, " checking entry %p [partno=%zu start=%ju, end=%ju, size=%ju%s%s%s]",
      pa,
      fdisk_partition_get_partno(pa),
      (uintmax_t) fdisk_partition_get_start(pa),
      (uintmax_t) fdisk_partition_get_end(pa),
      (uintmax_t) fdisk_partition_get_size(pa),
      fdisk_partition_is_freespace(pa) ? " freespace" : "",
      fdisk_partition_is_nested(pa)    ? " nested"    : "",
      fdisk_partition_is_container(pa) ? " container" : ""));


    if (!fdisk_partition_is_freespace(pa)) {
      DBG(TAB, ul_debugobj(tb, "  ignored (no freespace)"));
      first = NULL;
      continue;
    }
    if (!fdisk_partition_has_start(pa) || !fdisk_partition_has_size(pa)) {
      DBG(TAB, ul_debugobj(tb, "  ignored (no start/size)"));
      first = NULL;
      continue;
    }
    /* The current is nested, free space has to be nested within the same parent */
    if (fdisk_partition_is_nested(cur)
        && pa->parent_partno != cur->parent_partno) {
      DBG(TAB, ul_debugobj(tb, "  ignore (nested required)"));
      first = NULL;
      continue;
    }
    if (pa->start + pa->size <= cur->start) {
      first = pa;
      DBG(TAB, ul_debugobj(tb, "  entry usable"));
    }
  }

  if (first)
    *start = first->start;
  else
    DBG(PART, ul_debugobj(cur, "resize: nothing usable before %ju", (uintmax_t) cur->start));

  return first ? 0 : -1;
}

/*
 * Verify that area addressed by @start is freespace or the @cur[rent]
 * partition and continue to the next table entries until it's freespace, and
 * counts size of all this space.
 *
 * This is core of the partition start offset move operation. We can move the
 * start within the current partition to another free space. It's
 * forbidden to move start of the partition to another already defined
 * partition.
 */
static int resize_get_last_possible(
      struct fdisk_table *tb,
      struct fdisk_partition *cur,
      fdisk_sector_t start,
      fdisk_sector_t *maxsz)
{
  struct fdisk_partition *pa = NULL, *last = NULL;
  struct fdisk_iter itr;

  fdisk_reset_iter(&itr, FDISK_ITER_FORWARD);

  *maxsz = 0;
  DBG(TAB, ul_debugobj(tb, "checking last possible for start=%ju", (uintmax_t) start));


  while (fdisk_table_next_partition(tb, &itr, &pa) == 0) {

    DBG(TAB, ul_debugobj(tb, " checking entry %p [partno=%zu start=%ju, end=%ju, size=%ju%s%s%s]",
      pa,
      fdisk_partition_get_partno(pa),
      (uintmax_t) fdisk_partition_get_start(pa),
      (uintmax_t) fdisk_partition_get_end(pa),
      (uintmax_t) fdisk_partition_get_size(pa),
      fdisk_partition_is_freespace(pa) ? " freespace" : "",
      fdisk_partition_is_nested(pa)    ? " nested"    : "",
      fdisk_partition_is_container(pa) ? " container" : ""));

    if (!fdisk_partition_has_start(pa) ||
        !fdisk_partition_has_size(pa) ||
        (fdisk_partition_is_container(pa) && pa != cur)) {
      DBG(TAB, ul_debugobj(tb, "  ignored (no start/size or container)"));
      continue;
    }

    if (fdisk_partition_is_nested(pa)
        && fdisk_partition_is_container(cur)
        && pa->parent_partno == cur->partno) {
      DBG(TAB, ul_debugobj(tb, "  ignore (nested child of the current partition)"));
      continue;
    }

    /* The current is nested, free space has to be nested within the same parent */
    if (fdisk_partition_is_nested(cur)
        && pa->parent_partno != cur->parent_partno) {
      DBG(TAB, ul_debugobj(tb, "  ignore (nested required)"));
      continue;
    }

    if (!last) {
      if (start >= pa->start &&  start < pa->start + pa->size) {
        if (fdisk_partition_is_freespace(pa) || pa == cur) {
          DBG(TAB, ul_debugobj(tb, "  accepted as last"));
          last = pa;
        } else {
          DBG(TAB, ul_debugobj(tb, "  failed to set last"));
          break;
        }


        *maxsz = pa->size - (start - pa->start);
        DBG(TAB, ul_debugobj(tb, "  new max=%ju", (uintmax_t) *maxsz));
      }
    } else if (!fdisk_partition_is_freespace(pa) && pa != cur) {
      DBG(TAB, ul_debugobj(tb, "  no free space behind current"));
      break;
    } else {
      last = pa;
      *maxsz = pa->size - (start - pa->start);
      DBG(TAB, ul_debugobj(tb, "  new max=%ju (last updated)", (uintmax_t) *maxsz));
    }
  }

  if (last)
    DBG(PART, ul_debugobj(cur, "resize: max size=%ju", (uintmax_t) *maxsz));
  else
    DBG(PART, ul_debugobj(cur, "resize: nothing usable after %ju", (uintmax_t) start));

  return last ? 0 : -1;
}

/*
 * Uses template @tpl to recount start and size change of the partition @res. The
 * @tpl->size and @tpl->start are interpreted as relative to the current setting.
 */
static int recount_resize(
      struct fdisk_context *cxt, size_t partno,
      struct fdisk_partition *res, struct fdisk_partition *tpl)
{
  fdisk_sector_t start, size, xsize;
  struct fdisk_partition *cur = NULL;
  struct fdisk_table *tb = NULL;
  int rc;

  DBG(PART, ul_debugobj(tpl, ">>> resize requested"));

  FDISK_INIT_UNDEF(start);
  FDISK_INIT_UNDEF(size);

  rc = fdisk_get_partitions(cxt, &tb);
  if (!rc) {
    /* For resize we do not follow grain to detect free-space, but
     * we support to resize with very small granulation. */
    unsigned long org = cxt->grain;

    cxt->grain = cxt->sector_size;
    rc = fdisk_get_freespaces(cxt, &tb);
    cxt->grain = org;
  }
  if (rc) {
    fdisk_unref_table(tb);
    return rc;
  }

  fdisk_table_sort_partitions(tb, fdisk_partition_cmp_start);

  DBG(PART, ul_debugobj(tpl, "resize partition partno=%zu in table:", partno));
  ON_DBG(PART, fdisk_debug_print_table(tb));

  cur = fdisk_table_get_partition_by_partno(tb, partno);
  if (!cur) {
    fdisk_unref_table(tb);
    return -EINVAL;
  }

  /* 1a) set new start - change relative to the current on-disk setting */
  if (tpl->movestart && fdisk_partition_has_start(tpl)) {
    start = fdisk_partition_get_start(cur);
    if (tpl->movestart == FDISK_MOVE_DOWN) {
      if (fdisk_partition_get_start(tpl) > start)
        goto erange;
      start -= fdisk_partition_get_start(tpl);
    } else
      start += fdisk_partition_get_start(tpl);

    DBG(PART, ul_debugobj(tpl, "resize: moving start %s relative, new start: %ju",
        tpl->movestart == FDISK_MOVE_DOWN  ? "DOWN" : "UP", (uintmax_t)start));

  /* 1b) set new start - try freespace before the current partition */
  } else if (tpl->movestart == FDISK_MOVE_DOWN) {

    if (resize_get_first_possible(tb, cur, &start) != 0)
      goto erange;

    DBG(PART, ul_debugobj(tpl, "resize: moving start DOWN (first possible), new start: %ju",
        (uintmax_t)start));

  /* 1c) set new start - absolute number */
  } else if (fdisk_partition_has_start(tpl)) {
    start = fdisk_partition_get_start(tpl);
    DBG(PART, ul_debugobj(tpl, "resize: moving start to absolute offset: %ju",
                          (uintmax_t)start));
  }

  /* 2) verify that start is within the current partition or any freespace area */
  if (!FDISK_IS_UNDEF(start)) {
    struct fdisk_partition *area = area_by_offset(tb, cur, start);

    if (area == cur)
      DBG(PART, ul_debugobj(tpl, "resize: start points to the current partition"));
    else if (area && fdisk_partition_is_freespace(area))
      DBG(PART, ul_debugobj(tpl, "resize: start points to freespace"));
    else if (!area && start >= cxt->first_lba && start < cxt->first_lba + (cxt->grain / cxt->sector_size))
      DBG(PART, ul_debugobj(tpl, "resize: start points before first partition"));
    else {
      DBG(PART, ul_debugobj(tpl, "resize: start verification failed"));
      goto erange;
    }
  } else {
    /* no change, start points to the current partition */
    DBG(PART, ul_debugobj(tpl, "resize: start unchanged"));
    start = fdisk_partition_get_start(cur);
  }

  /* 3a) set new size -- reduce */
  if (tpl->resize == FDISK_RESIZE_REDUCE && fdisk_partition_has_size(tpl)) {
    DBG(PART, ul_debugobj(tpl, "resize: reduce"));
    size = fdisk_partition_get_size(cur);
    if (fdisk_partition_get_size(tpl) > size)
      goto erange;
    size -= fdisk_partition_get_size(tpl);

  /* 3b) set new size -- enlarge */
  } else if (tpl->resize == FDISK_RESIZE_ENLARGE && fdisk_partition_has_size(tpl)) {
    DBG(PART, ul_debugobj(tpl, "resize: enlarge"));
    size = fdisk_partition_get_size(cur);
    size += fdisk_partition_get_size(tpl);

  /* 3c) set new size -- no size specified, enlarge to all freespace */
  } else if (tpl->resize == FDISK_RESIZE_ENLARGE) {
    DBG(PART, ul_debugobj(tpl, "resize: enlarge to all possible"));
    if (resize_get_last_possible(tb, cur, start, &size))
      goto erange;

  /* 3d) set new size -- absolute number */
  } else if (fdisk_partition_has_size(tpl)) {
    DBG(PART, ul_debugobj(tpl, "resize: new absolute size"));
    size = fdisk_partition_get_size(tpl);
  }

  /* 4) verify that size is within the current partition or next free space */
  xsize = !FDISK_IS_UNDEF(size) ? size : fdisk_partition_get_size(cur);

  if (fdisk_partition_has_size(cur)) {
    fdisk_sector_t maxsz;

    if (resize_get_last_possible(tb, cur, start, &maxsz))
      goto erange;
    DBG(PART, ul_debugobj(tpl, "resize: size=%ju, max=%ju",
          (uintmax_t) xsize, (uintmax_t) maxsz));
    if (xsize > maxsz)
      goto erange;
  }

  if (FDISK_IS_UNDEF(size)) {
    DBG(PART, ul_debugobj(tpl, "resize: size unchanged (undefined)"));
  }


  DBG(PART, ul_debugobj(tpl, "<<< resize: SUCCESS: start %ju->%ju; size %ju->%ju",
      (uintmax_t) fdisk_partition_get_start(cur), (uintmax_t) start,
      (uintmax_t) fdisk_partition_get_size(cur), (uintmax_t) size));
  res->start = start;
  res->size = size;
  fdisk_unref_table(tb);
  return 0;
erange:
  DBG(PART, ul_debugobj(tpl, "<<< resize: FAILED"));
  fdisk_warnx(cxt, _("Failed to resize partition #%zu."), partno + 1);
  fdisk_unref_table(tb);
  return -ERANGE;

}

/**
 * fdisk_set_partition:
 * @cxt: context
 * @partno: partition number (0 is the first partition)
 * @pa: new partition setting
 *
 * Modifies disklabel according to setting with in @pa.
 *
 * Returns: 0 on success, <0 on error.
 */
int fdisk_set_partition(struct fdisk_context *cxt, size_t partno,
      struct fdisk_partition *pa)
{
  struct fdisk_partition *xpa = pa, *tmp = NULL;
  int rc, wipe = 0;

  if (!cxt || !cxt->label || !pa)
    return -EINVAL;
  if (!cxt->label->op->set_part)
    return -ENOSYS;

  pa->fs_probed = 0;

  if (!fdisk_is_partition_used(cxt, partno)) {
    pa->partno = partno;
    return fdisk_add_partition(cxt, pa, NULL);
  }

  if (pa->resize || pa->movestart
      || fdisk_partition_has_start(pa) || fdisk_partition_has_size(pa)) {
    xpa = __copy_partition(pa);
    if (!xpa) {
      rc = -ENOMEM;
      goto done;
    }
    xpa->movestart = 0;
    xpa->resize = 0;
    FDISK_INIT_UNDEF(xpa->size);
    FDISK_INIT_UNDEF(xpa->start);

    rc = recount_resize(cxt, partno, xpa, pa);
    if (rc)
      goto done;
  }

  DBG(CXT, ul_debugobj(cxt, "setting partition %zu %p (start=%ju, end=%ju, size=%ju)",
        partno, xpa,
        (uintmax_t) fdisk_partition_get_start(xpa),
        (uintmax_t) fdisk_partition_get_end(xpa),
        (uintmax_t) fdisk_partition_get_size(xpa)));

  /* disable wipe for old offset/size setting */
  if (fdisk_get_partition(cxt, partno, &tmp) == 0 && tmp) {
    wipe = fdisk_set_wipe_area(cxt, fdisk_partition_get_start(tmp),
            fdisk_partition_get_size(tmp), FALSE);
    fdisk_unref_partition(tmp);
  }

  /* call label driver */
  rc = cxt->label->op->set_part(cxt, partno, xpa);

  /* enable wipe for new offset/size */
  if (!rc && wipe)
    fdisk_wipe_partition(cxt, partno, TRUE);
done:
  DBG(CXT, ul_debugobj(cxt, "set_partition() rc=%d", rc));
  if (xpa != pa)
    fdisk_unref_partition(xpa);
  return rc;
}

/**
 * fdisk_wipe_partition:
 * @cxt: fdisk context
 * @partno: partition number
 * @enable: 0 or 1
 *
 * Enable/disable filesystems/RAIDs wiping in area defined by partition start and size.
 *
 * Returns: <0 in case of error, 0 on success
 * Since: 2.29
 */
int fdisk_wipe_partition(struct fdisk_context *cxt, size_t partno, int enable)
{
  struct fdisk_partition *pa = NULL;
  int rc;

  rc = fdisk_get_partition(cxt, partno, &pa);
  if (rc)
    return rc;

  rc = fdisk_set_wipe_area(cxt, fdisk_partition_get_start(pa),
              fdisk_partition_get_size(pa), enable);
  fdisk_unref_partition(pa);
  return rc < 0 ? rc : 0;
}

/**
 * fdisk_partition_has_wipe:
 * @cxt: fdisk context
 * @pa: partition
 *
 * Since: 2.30
 *
 * Returns: 1 if the area specified by @pa will be wiped by write command, or 0.
 */
int fdisk_partition_has_wipe(struct fdisk_context *cxt, struct fdisk_partition *pa)
{
  return fdisk_has_wipe_area(cxt, fdisk_partition_get_start(pa),
          fdisk_partition_get_size(pa));
}


/**
 * fdisk_add_partition:
 * @cxt: fdisk context
 * @pa: template for the partition (or NULL)
 * @partno: NULL or returns new partition number
 *
 * If @pa is not specified or any @pa item is missing the libfdisk will ask by
 * fdisk_ask_ API.
 *
 * The @pa template is important for non-interactive partitioning,
 * especially for MBR where is necessary to differentiate between
 * primary/logical; this is done by start offset or/and partno.
 * The rules for MBR:
 *
 *   A) template specifies start within extended partition: add logical
 *   B) template specifies start out of extended partition: add primary
 *   C) template specifies start (or default), partno < 4: add primary
 *   D) template specifies default start, partno >= 4: add logical
 *
 * otherwise MBR driver uses Ask-API to get missing information.
 *
 * Adds a new partition to disklabel.
 *
 * Returns: 0 on success, <0 on error.
 */
int fdisk_add_partition(struct fdisk_context *cxt,
      struct fdisk_partition *pa,
      size_t *partno)
{
  int rc;

  if (!cxt || !cxt->label)
    return -EINVAL;
  if (!cxt->label->op->add_part)
    return -ENOSYS;
  if (fdisk_missing_geometry(cxt))
    return -EINVAL;

  if (pa) {
    pa->fs_probed = 0;
    DBG(CXT, ul_debugobj(cxt, "adding new partition %p", pa));
    if (fdisk_partition_has_start(pa))
      DBG(CXT, ul_debugobj(cxt, "     start: %ju", (uintmax_t) fdisk_partition_get_start(pa)));
    if (fdisk_partition_has_end(pa))
      DBG(CXT, ul_debugobj(cxt, "       end: %ju", (uintmax_t) fdisk_partition_get_end(pa)));
    if (fdisk_partition_has_size(pa))
      DBG(CXT, ul_debugobj(cxt, "      size: %ju", (uintmax_t) fdisk_partition_get_size(pa)));

    DBG(CXT, ul_debugobj(cxt,         "  defaults: start=%s, end=%s, partno=%s",
          pa->start_follow_default ? "yes" : "no",
          pa->end_follow_default ? "yes" : "no",
          pa->partno_follow_default ? "yes" : "no"));
  } else
    DBG(CXT, ul_debugobj(cxt, "adding partition"));

  rc = cxt->label->op->add_part(cxt, pa, partno);

  DBG(CXT, ul_debugobj(cxt, "add partition done (rc=%d)", rc));
  return rc;
}

/**
 * fdisk_delete_partition:
 * @cxt: fdisk context
 * @partno: partition number to delete (0 is the first partition)
 *
 * Deletes a @partno partition from disklabel.
 *
 * Returns: 0 on success, <0 on error
 */
int fdisk_delete_partition(struct fdisk_context *cxt, size_t partno)
{
  if (!cxt || !cxt->label)
    return -EINVAL;
  if (!cxt->label->op->del_part)
    return -ENOSYS;

  fdisk_wipe_partition(cxt, partno, 0);

  DBG(CXT, ul_debugobj(cxt, "deleting %s partition number %zd",
        cxt->label->name, partno));
  return cxt->label->op->del_part(cxt, partno);
}

/**
 * fdisk_delete_all_partitions:
 * @cxt: fdisk context
 *
 * Delete all used partitions from disklabel.
 *
 * Returns: 0 on success, otherwise, a corresponding error.
 */
int fdisk_delete_all_partitions(struct fdisk_context *cxt)
{
  size_t i;
  int rc = 0;

  if (!cxt || !cxt->label)
    return -EINVAL;

  for (i = 0; i < cxt->label->nparts_max; i++) {

    if (!fdisk_is_partition_used(cxt, i))
      continue;
    rc = fdisk_delete_partition(cxt, i);
    if (rc)
      break;
  }

  return rc;
}

/**
 * fdisk_is_partition_used:
 * @cxt: context
 * @n: partition number (0 is the first partition)
 *
 * Check if the partition number @n is used by partition table. This function
 * does not check if the device is used (e.g. mounted) by system!
 *
 * This is faster than fdisk_get_partition() + fdisk_partition_is_used().
 *
 * Returns: 0 or 1
 */
int fdisk_is_partition_used(struct fdisk_context *cxt, size_t n)
{
  if (!cxt || !cxt->label)
    return -EINVAL;
  if (!cxt->label->op->part_is_used)
    return -ENOSYS;

  return cxt->label->op->part_is_used(cxt, n);
}


/**
 * fdisk_partition_max_size:
 * @cxt: context
 * @n: partition number (0 is the first partition)
 * @maxsz: returns maximum size of partition
 *
 * Find maximum size the partition can be resized to.
 * Takes into account free space between this partition and the next one.
 *
 * Returns: 0 on success, <0 on error.
 */
int fdisk_partition_get_max_size(struct fdisk_context *cxt, size_t n,
         fdisk_sector_t *maxsz)
{
  struct fdisk_partition *cur = NULL;
  struct fdisk_table *tb = NULL;
  int rc;

  rc = fdisk_get_partitions(cxt, &tb);
  if (rc)
    goto out;

  rc = fdisk_get_freespaces(cxt, &tb);
  if (rc)
    goto out;

  rc = fdisk_table_sort_partitions(tb, fdisk_partition_cmp_start);
  if (rc)
    goto out;

  cur = fdisk_table_get_partition_by_partno(tb, n);
  if (!cur)
    goto einval;

  if (!fdisk_partition_has_start(cur))
    goto einval;

  if (resize_get_last_possible(tb, cur,
             fdisk_partition_get_start(cur), maxsz))
    goto einval;

out:
  fdisk_unref_partition(cur);
  fdisk_unref_table(tb);

  return rc;

einval:
  rc = -EINVAL;
  goto out;
}

Coverage Report

Created: 2025-11-11 06:33