自学教程：C++ udev_settle函数代码示例

intdo_part_set_name (const char *device, int partnum, const char *name){  int r;  CLEANUP_FREE char *err = NULL;  if (partnum <= 0) {    reply_with_error ("partition number must be >= 1");    return -1;  }  char partstr[16];  snprintf (partstr, sizeof partstr, "%d", partnum);  udev_settle ();  r = commandf (NULL, &err, COMMAND_FLAG_FOLD_STDOUT_ON_STDERR,                "parted", "-s", "--", device, "name", partstr, name, NULL);  if (r == -1) {    reply_with_error ("parted: %s: %s", device, err);    return -1;  }  udev_settle ();  return 0;}

intdo_part_init (const char *device, const char *parttype){  int r;  CLEANUP_FREE char *err = NULL;  parttype = check_parttype (parttype);  if (!parttype) {    reply_with_error ("unknown partition type: common choices are /"gpt/" and /"msdos/"");    return -1;  }  udev_settle ();  r = commandf (NULL, &err, COMMAND_FLAG_FOLD_STDOUT_ON_STDERR,                "parted", "-s", "--", device, "mklabel", parttype, NULL);  if (r == -1) {    reply_with_error ("parted: %s: %s", device, err);    return -1;  }  udev_settle ();  return 0;}

static char *print_partition_table (const char *device, bool add_m_option){  char *out;  CLEANUP_FREE char *err = NULL;  int r;  udev_settle ();  if (add_m_option)    r = command (&out, &err, "parted", "-m", "-s", "--", device,                 "unit", "b",                 "print", NULL);  else    r = command (&out, &err, "parted", "-s", "--", device,                 "unit", "b",                 "print", NULL);  udev_settle ();  if (r == -1) {    int errcode = 0;    /* Translate "unrecognised disk label" into an errno code. */    if (err && strstr (err, "unrecognised disk label") != NULL)      errcode = EINVAL;    reply_with_error_errno (errcode, "parted print: %s: %s", device, err);    free (out);    return NULL;  }  return out;}

intdo_part_set_mbr_id (const char *device, int partnum, int idbyte){  if (partnum <= 0) {    reply_with_error ("partition number must be >= 1");    return -1;  }  char partnum_str[16];  snprintf (partnum_str, sizeof partnum_str, "%d", partnum);  char idbyte_str[16];  snprintf (idbyte_str, sizeof partnum_str, "%x", idbyte); /* NB: hex */  CLEANUP_FREE char *err = NULL;  int r;  udev_settle ();  r = command (NULL, &err, str_sfdisk,               "--change-id", device, partnum_str, idbyte_str, NULL);  if (r == -1) {    reply_with_error ("sfdisk --change-id: %s", err);    return -1;  }  udev_settle ();  return 0;}

intdo_part_resize (const char *device, int partnum, int64_t endsect){  int r;  CLEANUP_FREE char *err = NULL;  char endstr[32];  char partnum_str[16];  if (partnum <= 0) {    reply_with_error ("partition number must be >= 1");    return -1;  }  snprintf (partnum_str, sizeof partnum_str, "%d", partnum);  snprintf (endstr, sizeof endstr, "%" PRIi64 "s", endsect);  udev_settle ();  r = commandf (NULL, &err, COMMAND_FLAG_FOLD_STDOUT_ON_STDERR,                "parted", "-s", "--", device, "resizepart", partnum_str,                endstr, NULL);  if (r == -1) {    reply_with_error ("parted: %s: %s:", device, err);    return -1;  }  udev_settle();  return 0;}

/* Currently we use sfdisk for getting and setting the ID byte.  In * future, extend parted to provide this functionality.  As a result * of using sfdisk, this won't work for non-MBR-style partitions, but * that limitation is noted in the documentation and we can extend it * later without breaking the ABI. */intdo_part_get_mbr_id (const char *device, int partnum){  if (partnum <= 0) {    reply_with_error ("partition number must be >= 1");    return -1;  }  char partnum_str[16];  snprintf (partnum_str, sizeof partnum_str, "%d", partnum);  CLEANUP_FREE char *out = NULL, *err = NULL;  int r;  udev_settle ();  r = command (&out, &err, str_sfdisk, "--print-id", device, partnum_str, NULL);  if (r == -1) {    reply_with_error ("sfdisk --print-id: %s", err);    return -1;  }  udev_settle ();  /* It's printed in hex ... */  int id;  if (sscanf (out, "%x", &id) != 1) {    reply_with_error ("sfdisk --print-id: cannot parse output: %s", out);    return -1;  }  return id;}

intdo_part_set_bootable (const char *device, int partnum, int bootable){  int r;  char *err;  if (partnum <= 0) {    reply_with_error ("partition number must be >= 1");    return -1;  }  char partstr[16];  snprintf (partstr, sizeof partstr, "%d", partnum);  udev_settle ();  r = commandf (NULL, &err, COMMAND_FLAG_FOLD_STDOUT_ON_STDERR,                "parted", "-s", "--",                device, "set", partstr, "boot", bootable ? "on" : "off", NULL);  if (r == -1) {    reply_with_error ("parted: %s: %s", device, err);    free (err);    return -1;  }  free (err);  udev_settle ();  return 0;}

intdo_part_set_mbr_id (const char *device, int partnum, int idbyte){  if (partnum <= 0) {    reply_with_error ("partition number must be >= 1");    return -1;  }  const char *param = test_sfdisk_has_part_type () ? "--part-type" : "--change-id";  char partnum_str[16];  snprintf (partnum_str, sizeof partnum_str, "%d", partnum);  char idbyte_str[16];  /* NB: hex */  snprintf (idbyte_str, sizeof partnum_str, "%x", (unsigned) idbyte);  CLEANUP_FREE char *err = NULL;  int r;  udev_settle ();  r = command (NULL, &err, "sfdisk",               param, device, partnum_str, idbyte_str, NULL);  if (r == -1) {    reply_with_error ("sfdisk %s: %s", param, err);    return -1;  }  udev_settle ();  return 0;}

intdo_part_add (const char *device, const char *prlogex,             int64_t startsect, int64_t endsect){  int r;  char *err;  char startstr[32];  char endstr[32];  /* Check and translate prlogex. */  if (STREQ (prlogex, "primary") ||      STREQ (prlogex, "logical") ||      STREQ (prlogex, "extended"))    ;  else if (STREQ (prlogex, "p"))    prlogex = "primary";  else if (STREQ (prlogex, "l"))    prlogex = "logical";  else if (STREQ (prlogex, "e"))    prlogex = "extended";  else {    reply_with_error ("unknown partition type: %s: this should be /"primary/", /"logical/" or /"extended/"", prlogex);    return -1;  }  if (startsect < 0) {    reply_with_error ("startsect cannot be negative");    return -1;  }  /* but endsect can be negative */  snprintf (startstr, sizeof startstr, "%" PRIi64 "s", startsect);  snprintf (endstr, sizeof endstr, "%" PRIi64 "s", endsect);  udev_settle ();  /* XXX Bug: If the partition table type (which we don't know in this   * function) is GPT, then this parted command sets the _partition   * name_ to prlogex, eg. "primary".  I would essentially describe   * this as a bug in the parted mkpart command.   */  r = commandf (NULL, &err, COMMAND_FLAG_FOLD_STDOUT_ON_STDERR,                "parted", "-s", "--",                device, "mkpart", prlogex, startstr, endstr, NULL);  if (r == -1) {    reply_with_error ("parted: %s: %s", device, err);    free (err);    return -1;  }  free (err);  udev_settle ();  return 0;}

intdo_lvcreate_free (const char *logvol, const char *volgroup, int percent){  CLEANUP_FREE char *err = NULL;  int r;  if (percent < 0 || percent > 100) {    reply_with_error ("percentage must be [0..100] (was %d)", percent);    return -1;  }  char size[64];  snprintf (size, sizeof size, "%d%%FREE", percent);  r = command (NULL, &err,               str_lvm, "lvcreate",               "-l", size, "-n", logvol, volgroup, NULL);  if (r == -1) {    reply_with_error ("%s", err);    return -1;  }  udev_settle ();  return 0;}

intdo_luks_close (const char *device){  /* Must be /dev/mapper/... */  if (! STRPREFIX (device, "/dev/mapper/")) {    reply_with_error ("luks_close: you must call this on the /dev/mapper device created by luks_open");    return -1;  }  const char *mapname = &device[12];  char *err;  int r = command (NULL, &err, str_cryptsetup, "luksClose", mapname, NULL);  if (r == -1) {    reply_with_error ("%s", err);    free (err);    return -1;  }  free (err);  udev_settle ();  return 0;}

intdo_vg_activate (int activate, char *const *volgroups){  int r, i, argc;  CLEANUP_FREE char *err = NULL;  CLEANUP_FREE const char **argv = NULL;  argc = count_strings (volgroups) + 4;  argv = malloc (sizeof (char *) * (argc+1));  if (argv == NULL) {    reply_with_perror ("malloc");    return -1;  }  argv[0] = str_lvm;  argv[1] = "vgchange";  argv[2] = "-a";  argv[3] = activate ? "y" : "n";  for (i = 4; i < argc+1; ++i)    argv[i] = volgroups[i-4];  r = commandv (NULL, &err, (const char * const*) argv);  if (r == -1) {    reply_with_error ("vgchange: %s", err);    return -1;  }  udev_settle ();  return 0;}

intdo_vgcreate (const char *volgroup, char *const *physvols){  char *err;  int r, argc, i;  const char **argv;  argc = count_strings (physvols) + 3;  argv = malloc (sizeof (char *) * (argc + 1));  if (argv == NULL) {    reply_with_perror ("malloc");    return -1;  }  argv[0] = "lvm";  argv[1] = "vgcreate";  argv[2] = volgroup;  for (i = 3; i <= argc; ++i)    argv[i] = physvols[i-3];  r = commandv (NULL, &err, (const char * const*) argv);  if (r == -1) {    reply_with_error ("%s", err);    free (err);    free (argv);    return -1;  }  free (err);  free (argv);  udev_settle ();  return 0;}

intdo_part_disk (const char *device, const char *parttype){  parttype = check_parttype (parttype);  if (!parttype) {    reply_with_error ("unknown partition type: common choices are /"gpt/" and /"msdos/"");    return -1;  }  /* Align all partitions created this way to 128 sectors, and leave   * the last 128 sectors at the end of the disk free.  This wastes   * 64K+64K = 128K on 512-byte sector disks.  The rationale is:   *   * - aligned operations are faster   * - absolute minimum recommended alignment is 64K (1M would be better)   * - GPT requires at least 34 sectors at the end of the disk.   */  const char *startstr = "128s";  const char *endstr = "-128s";  RUN_PARTED (return -1,              device,              "mklabel", parttype,              /* See comment about about the parted mkpart command. */              "mkpart", STREQ (parttype, "gpt") ? "p1" : "primary",              startstr, endstr, NULL);  udev_settle ();  return 0;}

static intpwrite_fd (int fd, const char *content, size_t size, int64_t offset,           const char *display_path, int settle){  ssize_t r;  r = pwrite (fd, content, size, offset);  if (r == -1) {    reply_with_perror ("pwrite: %s", display_path);    close (fd);    return -1;  }  if (close (fd) == -1) {    reply_with_perror ("close: %s", display_path);    return -1;  }  /* When you call close on any block device, udev kicks off a rule   * which runs blkid to reexamine the device.  We need to wait for   * this rule to finish running since it holds the device open and   * can cause other operations to fail, notably BLKRRPART.  'settle'   * flag is only set on block devices.   *   * XXX We should be smarter about when we do this or should get rid   * of the udev rules since we don't use blkid in cached mode.   */  if (settle)    udev_settle ();  return r;}

intdo_vgcreate (const char *volgroup, char *const *physvols){  int r, argc, i;  CLEANUP_FREE char *err = NULL;  CLEANUP_FREE const char **argv = NULL;  argc = count_strings (physvols) + 3;  argv = malloc (sizeof (char *) * (argc + 1));  if (argv == NULL) {    reply_with_perror ("malloc");    return -1;  }  argv[0] = str_lvm;  argv[1] = "vgcreate";  argv[2] = volgroup;  for (i = 3; i < argc+1; ++i)    argv[i] = physvols[i-3];  r = commandv (NULL, &err, (const char * const*) argv);  if (r == -1) {    reply_with_error ("%s", err);    return -1;  }  udev_settle ();  return 0;}

intdo_part_disk (const char *device, const char *parttype){  int r;  char *err;  parttype = check_parttype (parttype);  if (!parttype) {    reply_with_error ("unknown partition type: common choices are /"gpt/" and /"msdos/"");    return -1;  }  /* Align all partitions created this way to 128 sectors, and leave   * the last 128 sectors at the end of the disk free.  This wastes   * 64K+64K = 128K on 512-byte sector disks.  The rationale is:   *   * - aligned operations are faster   * - absolute minimum recommended alignment is 64K (1M would be better)   * - GPT requires at least 34 sectors* at the end of the disk.   *   *   *=except for 4k sector disks, where only 6 sectors are required   */  const char *startstr = "128s";  const char *endstr = "-128s";  udev_settle ();  r = commandf (NULL, &err, COMMAND_FLAG_FOLD_STDOUT_ON_STDERR,                "parted", "-s", "--",                device,                "mklabel", parttype,                /* See comment about about the parted mkpart command. */                "mkpart", STREQ (parttype, "gpt") ? "p1" : "primary",                startstr, endstr, NULL);  if (r == -1) {    reply_with_error ("parted: %s: %s", device, err);    free (err);    return -1;  }  free (err);  udev_settle ();  return 0;}

intdo_part_init (const char *device, const char *parttype){  parttype = check_parttype (parttype);  if (!parttype) {    reply_with_error ("unknown partition type: common choices are /"gpt/" and /"msdos/"");    return -1;  }  RUN_PARTED (return -1, device, "mklabel", parttype, NULL);  udev_settle ();  return 0;}

static intluks_open (const char *device, const char *key, const char *mapname,           int readonly){  /* Sanity check: /dev/mapper/mapname must not exist already.  Note   * that the device-mapper control device (/dev/mapper/control) is   * always there, so you can't ever have mapname == "control".   */  size_t len = strlen (mapname);  char devmapper[len+32];  snprintf (devmapper, len+32, "/dev/mapper/%s", mapname);  if (access (devmapper, F_OK) == 0) {    reply_with_error ("%s: device already exists", devmapper);    return -1;  }  char *tempfile = write_key_to_temp (key);  if (!tempfile)    return -1;  const char *argv[MAX_ARGS];  size_t i = 0;  ADD_ARG (argv, i, str_cryptsetup);  ADD_ARG (argv, i, "-d");  ADD_ARG (argv, i, tempfile);  if (readonly) ADD_ARG (argv, i, "--readonly");  ADD_ARG (argv, i, "luksOpen");  ADD_ARG (argv, i, device);  ADD_ARG (argv, i, mapname);  ADD_ARG (argv, i, NULL);  char *err;  int r = commandv (NULL, &err, (const char * const *) argv);  remove_temp (tempfile);  if (r == -1) {    reply_with_error ("%s", err);    free (err);    return -1;  }  free (err);  udev_settle ();  return 0;}

intdo_part_del (const char *device, int partnum){  if (partnum <= 0) {    reply_with_error ("partition number must be >= 1");    return -1;  }  char partnum_str[16];  snprintf (partnum_str, sizeof partnum_str, "%d", partnum);  RUN_PARTED (return -1, device, "rm", partnum_str, NULL);  udev_settle ();  return 0;}

intdo_pvremove (const char *device){  CLEANUP_FREE char *err = NULL;  int r;  r = command (NULL, &err,               str_lvm, "pvremove", "-ff", device, NULL);  if (r == -1) {    reply_with_error ("%s", err);    return -1;  }  udev_settle ();  return 0;}

intdo_vgchange_uuid_all (void){  CLEANUP_FREE char *err = NULL;  int r;  r = command (NULL, &err,               str_lvm, "vgchange", "-u", NULL);  if (r == -1) {    reply_with_error ("%s", err);    return -1;  }  udev_settle ();  return 0;}

/* Notes: * * Parted 1.9 sends error messages to stdout, hence use of the * COMMAND_FLAG_FOLD_STDOUT_ON_STDERR flag. * * parted occasionally fails to do ioctl(BLKRRPART) on the device, * probably because udev monitors all 'close' on block devices * and runs 'blkid' which opens and examines the device.  We attempt * to detect and recover from this error if we can. */static intrecover_blkrrpart (const char *device, const char *err){  int r;  if (!strstr (err,               "Error informing the kernel about modifications to partition"))    return -1;  r = command (NULL, NULL, "blockdev", "--rereadpt", device, NULL);  if (r == -1)    return -1;  udev_settle ();  return 0;}

intdo_vgrename (const char *volgroup, const char *newvolgroup){  CLEANUP_FREE char *err = NULL;  int r;  r = command (NULL, &err,               str_lvm, "vgrename",               volgroup, newvolgroup, NULL);  if (r == -1) {    reply_with_error ("%s -> %s: %s", volgroup, newvolgroup, err);    return -1;  }  udev_settle ();  return 0;}

intdo_lvrename (const char *logvol, const char *newlogvol){  CLEANUP_FREE char *err = NULL;  int r;  r = command (NULL, &err,               str_lvm, "lvrename",               logvol, newlogvol, NULL);  if (r == -1) {    reply_with_error ("%s -> %s: %s", logvol, newlogvol, err);    return -1;  }  udev_settle ();  return 0;}

/* Takes optional arguments, consult optargs_bitmask. */intdo_mkswap (const char *device, const char *label, const char *uuid){  const size_t MAX_ARGS = 64;  const char *argv[MAX_ARGS];  size_t i = 0;  int r;  CLEANUP_FREE char *err = NULL;  ADD_ARG (argv, i, "mkswap");  ADD_ARG (argv, i, "-f");  if (optargs_bitmask & GUESTFS_MKSWAP_LABEL_BITMASK) {    assert (label != NULL); /* suppress a warning with -O3 */    if (strlen (label) > SWAP_LABEL_MAX) {      reply_with_error ("%s: Linux swap labels are limited to %d bytes",                        label, SWAP_LABEL_MAX);      return -1;    }    ADD_ARG (argv, i, "-L");    ADD_ARG (argv, i, label);  }  if (optargs_bitmask & GUESTFS_MKSWAP_UUID_BITMASK) {    ADD_ARG (argv, i, "-U");    ADD_ARG (argv, i, uuid);  }  ADD_ARG (argv, i, device);  ADD_ARG (argv, i, NULL);  wipe_device_before_mkfs (device);  r = commandv (NULL, &err, argv);  if (r == -1) {    reply_with_error ("%s: %s", device, err);    return -1;  }  udev_settle ();  return 0;}

intdo_part_set_bootable (const char *device, int partnum, int bootable){  if (partnum <= 0) {    reply_with_error ("partition number must be >= 1");    return -1;  }  char partstr[16];  snprintf (partstr, sizeof partstr, "%d", partnum);  RUN_PARTED (return -1,              device, "set", partstr, "boot", bootable ? "on" : "off", NULL);  udev_settle ();  return 0;}

static intluks_format (const char *device, const char *key, int keyslot,             const char *cipher){  char *tempfile = write_key_to_temp (key);  if (!tempfile)    return -1;  const char *argv[MAX_ARGS];  char keyslot_s[16];  size_t i = 0;  ADD_ARG (argv, i, str_cryptsetup);  ADD_ARG (argv, i, "-q");  if (cipher) {    ADD_ARG (argv, i, "--cipher");    ADD_ARG (argv, i, cipher);  }  ADD_ARG (argv, i, "--key-slot");  snprintf (keyslot_s, sizeof keyslot_s, "%d", keyslot);  ADD_ARG (argv, i, keyslot_s);  ADD_ARG (argv, i, "luksFormat");  ADD_ARG (argv, i, device);  ADD_ARG (argv, i, tempfile);  ADD_ARG (argv, i, NULL);  char *err;  int r = commandv (NULL, &err, (const char * const *) argv);  remove_temp (tempfile);  if (r == -1) {    reply_with_error ("%s", err);    free (err);    return -1;  }  free (err);  udev_settle ();  return 0;}

intdo_pvremove (const char *device){  char *err;  int r;  r = command (NULL, &err,               "lvm", "pvremove", "-ff", device, NULL);  if (r == -1) {    reply_with_error ("%s", err);    free (err);    return -1;  }  free (err);  udev_settle ();  return 0;}

intdo_lvcreate (const char *logvol, const char *volgroup, int mbytes){  CLEANUP_FREE char *err = NULL;  int r;  char size[64];  snprintf (size, sizeof size, "%d", mbytes);  r = command (NULL, &err,               str_lvm, "lvcreate",               "-L", size, "-n", logvol, volgroup, NULL);  if (r == -1) {    reply_with_error ("%s", err);    return -1;  }  udev_settle ();  return 0;}