mirrors/libguestfs
1
0
Fork 0
mirror of https://github.com/libguestfs/libguestfs.git synced 2026-03-21 22:53:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Generated code for blockdev_* calls, RInt64, enhanced tests.

Browse Source
This commit is contained in:
Richard Jones
2009-04-15 17:48:54 +01:00
parent e038597ebd
commit b348eacbc4
19 changed files with 5906 additions and 2917 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
daemon/actions.h
View File

@@ -76,3 +76,13 @@ extern guestfs_int_stat *do_stat (const char *path);
extern guestfs_int_stat *do_lstat (const char *path);
extern guestfs_int_statvfs *do_statvfs (const char *path);
extern char **do_tune2fs_l (const char *device);
extern int do_blockdev_setro (const char *device);
extern int do_blockdev_setrw (const char *device);
extern int do_blockdev_getro (const char *device);
extern int do_blockdev_getss (const char *device);
extern int do_blockdev_getbsz (const char *device);
extern int do_blockdev_setbsz (const char *device, int blocksize);
extern int64_t do_blockdev_getsz (const char *device);
extern int64_t do_blockdev_getsize64 (const char *device);
extern int do_blockdev_flushbufs (const char *device);
extern int do_blockdev_rereadpt (const char *device);

282
daemon/stubs.c
View File

@@ -1332,6 +1332,258 @@ done:
xdr_free ((xdrproc_t) xdr_guestfs_tune2fs_l_args, (char *) &args);
}
static void blockdev_setro_stub (XDR *xdr_in)
{
int r;
struct guestfs_blockdev_setro_args args;
const char *device;
memset (&args, 0, sizeof args);
if (!xdr_guestfs_blockdev_setro_args (xdr_in, &args)) {
reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_setro");
return;
}
device = args.device;
r = do_blockdev_setro (device);
if (r == -1)
/* do_blockdev_setro has already called reply_with_error */
goto done;
reply (NULL, NULL);
done:
xdr_free ((xdrproc_t) xdr_guestfs_blockdev_setro_args, (char *) &args);
}
static void blockdev_setrw_stub (XDR *xdr_in)
{
int r;
struct guestfs_blockdev_setrw_args args;
const char *device;
memset (&args, 0, sizeof args);
if (!xdr_guestfs_blockdev_setrw_args (xdr_in, &args)) {
reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_setrw");
return;
}
device = args.device;
r = do_blockdev_setrw (device);
if (r == -1)
/* do_blockdev_setrw has already called reply_with_error */
goto done;
reply (NULL, NULL);
done:
xdr_free ((xdrproc_t) xdr_guestfs_blockdev_setrw_args, (char *) &args);
}
static void blockdev_getro_stub (XDR *xdr_in)
{
int r;
struct guestfs_blockdev_getro_args args;
const char *device;
memset (&args, 0, sizeof args);
if (!xdr_guestfs_blockdev_getro_args (xdr_in, &args)) {
reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_getro");
return;
}
device = args.device;
r = do_blockdev_getro (device);
if (r == -1)
/* do_blockdev_getro has already called reply_with_error */
goto done;
struct guestfs_blockdev_getro_ret ret;
ret.ro = r;
reply ((xdrproc_t) &xdr_guestfs_blockdev_getro_ret, (char *) &ret);
done:
xdr_free ((xdrproc_t) xdr_guestfs_blockdev_getro_args, (char *) &args);
}
static void blockdev_getss_stub (XDR *xdr_in)
{
int r;
struct guestfs_blockdev_getss_args args;
const char *device;
memset (&args, 0, sizeof args);
if (!xdr_guestfs_blockdev_getss_args (xdr_in, &args)) {
reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_getss");
return;
}
device = args.device;
r = do_blockdev_getss (device);
if (r == -1)
/* do_blockdev_getss has already called reply_with_error */
goto done;
struct guestfs_blockdev_getss_ret ret;
ret.sectorsize = r;
reply ((xdrproc_t) &xdr_guestfs_blockdev_getss_ret, (char *) &ret);
done:
xdr_free ((xdrproc_t) xdr_guestfs_blockdev_getss_args, (char *) &args);
}
static void blockdev_getbsz_stub (XDR *xdr_in)
{
int r;
struct guestfs_blockdev_getbsz_args args;
const char *device;
memset (&args, 0, sizeof args);
if (!xdr_guestfs_blockdev_getbsz_args (xdr_in, &args)) {
reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_getbsz");
return;
}
device = args.device;
r = do_blockdev_getbsz (device);
if (r == -1)
/* do_blockdev_getbsz has already called reply_with_error */
goto done;
struct guestfs_blockdev_getbsz_ret ret;
ret.blocksize = r;
reply ((xdrproc_t) &xdr_guestfs_blockdev_getbsz_ret, (char *) &ret);
done:
xdr_free ((xdrproc_t) xdr_guestfs_blockdev_getbsz_args, (char *) &args);
}
static void blockdev_setbsz_stub (XDR *xdr_in)
{
int r;
struct guestfs_blockdev_setbsz_args args;
const char *device;
int blocksize;
memset (&args, 0, sizeof args);
if (!xdr_guestfs_blockdev_setbsz_args (xdr_in, &args)) {
reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_setbsz");
return;
}
device = args.device;
blocksize = args.blocksize;
r = do_blockdev_setbsz (device, blocksize);
if (r == -1)
/* do_blockdev_setbsz has already called reply_with_error */
goto done;
reply (NULL, NULL);
done:
xdr_free ((xdrproc_t) xdr_guestfs_blockdev_setbsz_args, (char *) &args);
}
static void blockdev_getsz_stub (XDR *xdr_in)
{
int64_t r;
struct guestfs_blockdev_getsz_args args;
const char *device;
memset (&args, 0, sizeof args);
if (!xdr_guestfs_blockdev_getsz_args (xdr_in, &args)) {
reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_getsz");
return;
}
device = args.device;
r = do_blockdev_getsz (device);
if (r == -1)
/* do_blockdev_getsz has already called reply_with_error */
goto done;
struct guestfs_blockdev_getsz_ret ret;
ret.sizeinsectors = r;
reply ((xdrproc_t) &xdr_guestfs_blockdev_getsz_ret, (char *) &ret);
done:
xdr_free ((xdrproc_t) xdr_guestfs_blockdev_getsz_args, (char *) &args);
}
static void blockdev_getsize64_stub (XDR *xdr_in)
{
int64_t r;
struct guestfs_blockdev_getsize64_args args;
const char *device;
memset (&args, 0, sizeof args);
if (!xdr_guestfs_blockdev_getsize64_args (xdr_in, &args)) {
reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_getsize64");
return;
}
device = args.device;
r = do_blockdev_getsize64 (device);
if (r == -1)
/* do_blockdev_getsize64 has already called reply_with_error */
goto done;
struct guestfs_blockdev_getsize64_ret ret;
ret.sizeinbytes = r;
reply ((xdrproc_t) &xdr_guestfs_blockdev_getsize64_ret, (char *) &ret);
done:
xdr_free ((xdrproc_t) xdr_guestfs_blockdev_getsize64_args, (char *) &args);
}
static void blockdev_flushbufs_stub (XDR *xdr_in)
{
int r;
struct guestfs_blockdev_flushbufs_args args;
const char *device;
memset (&args, 0, sizeof args);
if (!xdr_guestfs_blockdev_flushbufs_args (xdr_in, &args)) {
reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_flushbufs");
return;
}
device = args.device;
r = do_blockdev_flushbufs (device);
if (r == -1)
/* do_blockdev_flushbufs has already called reply_with_error */
goto done;
reply (NULL, NULL);
done:
xdr_free ((xdrproc_t) xdr_guestfs_blockdev_flushbufs_args, (char *) &args);
}
static void blockdev_rereadpt_stub (XDR *xdr_in)
{
int r;
struct guestfs_blockdev_rereadpt_args args;
const char *device;
memset (&args, 0, sizeof args);
if (!xdr_guestfs_blockdev_rereadpt_args (xdr_in, &args)) {
reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_rereadpt");
return;
}
device = args.device;
r = do_blockdev_rereadpt (device);
if (r == -1)
/* do_blockdev_rereadpt has already called reply_with_error */
goto done;
reply (NULL, NULL);
done:
xdr_free ((xdrproc_t) xdr_guestfs_blockdev_rereadpt_args, (char *) &args);
}
void dispatch_incoming_message (XDR *xdr_in)
{
switch (proc_nr) {
@@ -1500,6 +1752,36 @@ void dispatch_incoming_message (XDR *xdr_in)
case GUESTFS_PROC_TUNE2FS_L:
tune2fs_l_stub (xdr_in);
break;
case GUESTFS_PROC_BLOCKDEV_SETRO:
blockdev_setro_stub (xdr_in);
break;
case GUESTFS_PROC_BLOCKDEV_SETRW:
blockdev_setrw_stub (xdr_in);
break;
case GUESTFS_PROC_BLOCKDEV_GETRO:
blockdev_getro_stub (xdr_in);
break;
case GUESTFS_PROC_BLOCKDEV_GETSS:
blockdev_getss_stub (xdr_in);
break;
case GUESTFS_PROC_BLOCKDEV_GETBSZ:
blockdev_getbsz_stub (xdr_in);
break;
case GUESTFS_PROC_BLOCKDEV_SETBSZ:
blockdev_setbsz_stub (xdr_in);
break;
case GUESTFS_PROC_BLOCKDEV_GETSZ:
blockdev_getsz_stub (xdr_in);
break;
case GUESTFS_PROC_BLOCKDEV_GETSIZE64:
blockdev_getsize64_stub (xdr_in);
break;
case GUESTFS_PROC_BLOCKDEV_FLUSHBUFS:
blockdev_flushbufs_stub (xdr_in);
break;
case GUESTFS_PROC_BLOCKDEV_REREADPT:
blockdev_rereadpt_stub (xdr_in);
break;
default:
reply_with_error ("dispatch_incoming_message: unknown procedure number %d", proc_nr);
}

226
fish/cmds.c
View File

@@ -46,6 +46,16 @@ void list_commands (void)
printf ("%-20s %s\n", "aug-rm", "remove an Augeas path");
printf ("%-20s %s\n", "aug-save", "write all pending Augeas changes to disk");
printf ("%-20s %s\n", "aug-set", "set Augeas path to value");
printf ("%-20s %s\n", "blockdev-flushbufs", "flush device buffers");
printf ("%-20s %s\n", "blockdev-getbsz", "get blocksize of block device");
printf ("%-20s %s\n", "blockdev-getro", "is block device set to read-only");
printf ("%-20s %s\n", "blockdev-getsize64", "get total size of device in bytes");
printf ("%-20s %s\n", "blockdev-getss", "get sectorsize of block device");
printf ("%-20s %s\n", "blockdev-getsz", "get total size of device in 512-byte sectors");
printf ("%-20s %s\n", "blockdev-rereadpt", "reread partition table");
printf ("%-20s %s\n", "blockdev-setbsz", "set blocksize of block device");
printf ("%-20s %s\n", "blockdev-setro", "set block device to read-only");
printf ("%-20s %s\n", "blockdev-setrw", "set block device to read-write");
printf ("%-20s %s\n", "cat", "list the contents of a file");
printf ("%-20s %s\n", "chmod", "change file mode");
printf ("%-20s %s\n", "chown", "change file owner and group");
@@ -299,6 +309,36 @@ void display_command (const char *cmd)
else
if (strcasecmp (cmd, "tune2fs_l") == 0 || strcasecmp (cmd, "tune2fs-l") == 0)
pod2text ("tune2fs-l - get ext2/ext3 superblock details", " tune2fs-l <device>\n\nThis returns the contents of the ext2 or ext3 filesystem superblock\non C<device>.\n\nIt is the same as running C<tune2fs -l device>. See L<tune2fs(8)>\nmanpage for more details. The list of fields returned isn't\nclearly defined, and depends on both the version of C<tune2fs>\nthat libguestfs was built against, and the filesystem itself.");
else
if (strcasecmp (cmd, "blockdev_setro") == 0 || strcasecmp (cmd, "blockdev-setro") == 0)
pod2text ("blockdev-setro - set block device to read-only", " blockdev-setro <device>\n\nSets the block device named C<device> to read-only.\n\nThis uses the L<blockdev(8)> command.");
else
if (strcasecmp (cmd, "blockdev_setrw") == 0 || strcasecmp (cmd, "blockdev-setrw") == 0)
pod2text ("blockdev-setrw - set block device to read-write", " blockdev-setrw <device>\n\nSets the block device named C<device> to read-write.\n\nThis uses the L<blockdev(8)> command.");
else
if (strcasecmp (cmd, "blockdev_getro") == 0 || strcasecmp (cmd, "blockdev-getro") == 0)
pod2text ("blockdev-getro - is block device set to read-only", " blockdev-getro <device>\n\nReturns a boolean indicating if the block device is read-only\n(true if read-only, false if not).\n\nThis uses the L<blockdev(8)> command.");
else
if (strcasecmp (cmd, "blockdev_getss") == 0 || strcasecmp (cmd, "blockdev-getss") == 0)
pod2text ("blockdev-getss - get sectorsize of block device", " blockdev-getss <device>\n\nThis returns the size of sectors on a block device.\nUsually 512, but can be larger for modern devices.\n\n(Note, this is not the size in sectors, use C<blockdev_getsz>\nfor that).\n\nThis uses the L<blockdev(8)> command.");
else
if (strcasecmp (cmd, "blockdev_getbsz") == 0 || strcasecmp (cmd, "blockdev-getbsz") == 0)
pod2text ("blockdev-getbsz - get blocksize of block device", " blockdev-getbsz <device>\n\nThis returns the block size of a device.\n\n(Note this is different from both I<size in blocks> and\nI<filesystem block size>).\n\nThis uses the L<blockdev(8)> command.");
else
if (strcasecmp (cmd, "blockdev_setbsz") == 0 || strcasecmp (cmd, "blockdev-setbsz") == 0)
pod2text ("blockdev-setbsz - set blocksize of block device", " blockdev-setbsz <device> <blocksize>\n\nThis sets the block size of a device.\n\n(Note this is different from both I<size in blocks> and\nI<filesystem block size>).\n\nThis uses the L<blockdev(8)> command.");
else
if (strcasecmp (cmd, "blockdev_getsz") == 0 || strcasecmp (cmd, "blockdev-getsz") == 0)
pod2text ("blockdev-getsz - get total size of device in 512-byte sectors", " blockdev-getsz <device>\n\nThis returns the size of the device in units of 512-byte sectors\n(even if the sectorsize isn't 512 bytes ... weird).\n\nSee also C<blockdev_getss> for the real sector size of\nthe device, and C<blockdev_getsize64> for the more\nuseful I<size in bytes>.\n\nThis uses the L<blockdev(8)> command.");
else
if (strcasecmp (cmd, "blockdev_getsize64") == 0 || strcasecmp (cmd, "blockdev-getsize64") == 0)
pod2text ("blockdev-getsize64 - get total size of device in bytes", " blockdev-getsize64 <device>\n\nThis returns the size of the device in bytes.\n\nSee also C<blockdev_getsz>.\n\nThis uses the L<blockdev(8)> command.");
else
if (strcasecmp (cmd, "blockdev_flushbufs") == 0 || strcasecmp (cmd, "blockdev-flushbufs") == 0)
pod2text ("blockdev-flushbufs - flush device buffers", " blockdev-flushbufs <device>\n\nThis tells the kernel to flush internal buffers associated\nwith C<device>.\n\nThis uses the L<blockdev(8)> command.");
else
if (strcasecmp (cmd, "blockdev_rereadpt") == 0 || strcasecmp (cmd, "blockdev-rereadpt") == 0)
pod2text ("blockdev-rereadpt - reread partition table", " blockdev-rereadpt <device>\n\nReread the partition table on C<device>.\n\nThis uses the L<blockdev(8)> command.");
else
display_builtin_command (cmd);
}
@@ -861,7 +901,7 @@ static int run_aug_defvar (const char *cmd, int argc, char *argv[])
expr = strcmp (argv[1], "") != 0 ? argv[1] : NULL;
r = guestfs_aug_defvar (g, name, expr);
if (r == -1) return -1;
if (r) printf ("%d\n", r);
printf ("%d\n", r);
return 0;
}
@@ -950,7 +990,7 @@ static int run_aug_rm (const char *cmd, int argc, char *argv[])
path = argv[0];
r = guestfs_aug_rm (g, path);
if (r == -1) return -1;
if (r) printf ("%d\n", r);
printf ("%d\n", r);
return 0;
}
@@ -1456,6 +1496,158 @@ static int run_tune2fs_l (const char *cmd, int argc, char *argv[])
return 0;
}
static int run_blockdev_setro (const char *cmd, int argc, char *argv[])
{
int r;
const char *device;
if (argc != 1) {
fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
return -1;
}
device = argv[0];
r = guestfs_blockdev_setro (g, device);
return r;
}
static int run_blockdev_setrw (const char *cmd, int argc, char *argv[])
{
int r;
const char *device;
if (argc != 1) {
fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
return -1;
}
device = argv[0];
r = guestfs_blockdev_setrw (g, device);
return r;
}
static int run_blockdev_getro (const char *cmd, int argc, char *argv[])
{
int r;
const char *device;
if (argc != 1) {
fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
return -1;
}
device = argv[0];
r = guestfs_blockdev_getro (g, device);
if (r == -1) return -1;
if (r) printf ("true\n"); else printf ("false\n");
return 0;
}
static int run_blockdev_getss (const char *cmd, int argc, char *argv[])
{
int r;
const char *device;
if (argc != 1) {
fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
return -1;
}
device = argv[0];
r = guestfs_blockdev_getss (g, device);
if (r == -1) return -1;
printf ("%d\n", r);
return 0;
}
static int run_blockdev_getbsz (const char *cmd, int argc, char *argv[])
{
int r;
const char *device;
if (argc != 1) {
fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
return -1;
}
device = argv[0];
r = guestfs_blockdev_getbsz (g, device);
if (r == -1) return -1;
printf ("%d\n", r);
return 0;
}
static int run_blockdev_setbsz (const char *cmd, int argc, char *argv[])
{
int r;
const char *device;
int blocksize;
if (argc != 2) {
fprintf (stderr, "%s should have 2 parameter(s)\n", cmd);
fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
return -1;
}
device = argv[0];
blocksize = atoi (argv[1]);
r = guestfs_blockdev_setbsz (g, device, blocksize);
return r;
}
static int run_blockdev_getsz (const char *cmd, int argc, char *argv[])
{
int64_t r;
const char *device;
if (argc != 1) {
fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
return -1;
}
device = argv[0];
r = guestfs_blockdev_getsz (g, device);
if (r == -1) return -1;
printf ("%" PRIi64 "\n", r);
return 0;
}
static int run_blockdev_getsize64 (const char *cmd, int argc, char *argv[])
{
int64_t r;
const char *device;
if (argc != 1) {
fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
return -1;
}
device = argv[0];
r = guestfs_blockdev_getsize64 (g, device);
if (r == -1) return -1;
printf ("%" PRIi64 "\n", r);
return 0;
}
static int run_blockdev_flushbufs (const char *cmd, int argc, char *argv[])
{
int r;
const char *device;
if (argc != 1) {
fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
return -1;
}
device = argv[0];
r = guestfs_blockdev_flushbufs (g, device);
return r;
}
static int run_blockdev_rereadpt (const char *cmd, int argc, char *argv[])
{
int r;
const char *device;
if (argc != 1) {
fprintf (stderr, "%s should have 1 parameter(s)\n", cmd);
fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd);
return -1;
}
device = argv[0];
r = guestfs_blockdev_rereadpt (g, device);
return r;
}
int run_action (const char *cmd, int argc, char *argv[])
{
if (strcasecmp (cmd, "launch") == 0 || strcasecmp (cmd, "run") == 0)
@@ -1655,6 +1847,36 @@ int run_action (const char *cmd, int argc, char *argv[])
else
if (strcasecmp (cmd, "tune2fs_l") == 0 || strcasecmp (cmd, "tune2fs-l") == 0)
return run_tune2fs_l (cmd, argc, argv);
else
if (strcasecmp (cmd, "blockdev_setro") == 0 || strcasecmp (cmd, "blockdev-setro") == 0)
return run_blockdev_setro (cmd, argc, argv);
else
if (strcasecmp (cmd, "blockdev_setrw") == 0 || strcasecmp (cmd, "blockdev-setrw") == 0)
return run_blockdev_setrw (cmd, argc, argv);
else
if (strcasecmp (cmd, "blockdev_getro") == 0 || strcasecmp (cmd, "blockdev-getro") == 0)
return run_blockdev_getro (cmd, argc, argv);
else
if (strcasecmp (cmd, "blockdev_getss") == 0 || strcasecmp (cmd, "blockdev-getss") == 0)
return run_blockdev_getss (cmd, argc, argv);
else
if (strcasecmp (cmd, "blockdev_getbsz") == 0 || strcasecmp (cmd, "blockdev-getbsz") == 0)
return run_blockdev_getbsz (cmd, argc, argv);
else
if (strcasecmp (cmd, "blockdev_setbsz") == 0 || strcasecmp (cmd, "blockdev-setbsz") == 0)
return run_blockdev_setbsz (cmd, argc, argv);
else
if (strcasecmp (cmd, "blockdev_getsz") == 0 || strcasecmp (cmd, "blockdev-getsz") == 0)
return run_blockdev_getsz (cmd, argc, argv);
else
if (strcasecmp (cmd, "blockdev_getsize64") == 0 || strcasecmp (cmd, "blockdev-getsize64") == 0)
return run_blockdev_getsize64 (cmd, argc, argv);
else
if (strcasecmp (cmd, "blockdev_flushbufs") == 0 || strcasecmp (cmd, "blockdev-flushbufs") == 0)
return run_blockdev_flushbufs (cmd, argc, argv);
else
if (strcasecmp (cmd, "blockdev_rereadpt") == 0 || strcasecmp (cmd, "blockdev-rereadpt") == 0)
return run_blockdev_rereadpt (cmd, argc, argv);
else
{
fprintf (stderr, "%s: unknown command\n", cmd);

10
fish/completion.c
View File

@@ -51,6 +51,16 @@ static const char *commands[] = {
"aug-save",
"aug-set",
"autosync",
"blockdev-flushbufs",
"blockdev-getbsz",
"blockdev-getro",
"blockdev-getsize64",
"blockdev-getss",
"blockdev-getsz",
"blockdev-rereadpt",
"blockdev-setbsz",
"blockdev-setro",
"blockdev-setrw",
"cat",
"cdrom",
"chmod",

99
guestfish-actions.pod
View File

@@ -182,6 +182,105 @@ how files are saved.
Set the value associated with C<path> to C<value>.
=head2 blockdev-flushbufs
blockdev-flushbufs device
This tells the kernel to flush internal buffers associated
with C<device>.
This uses the L<blockdev(8)> command.
=head2 blockdev-getbsz
blockdev-getbsz device
This returns the block size of a device.
(Note this is different from both I<size in blocks> and
I<filesystem block size>).
This uses the L<blockdev(8)> command.
=head2 blockdev-getro
blockdev-getro device
Returns a boolean indicating if the block device is read-only
(true if read-only, false if not).
This uses the L<blockdev(8)> command.
=head2 blockdev-getsize64
blockdev-getsize64 device
This returns the size of the device in bytes.
See also C<blockdev_getsz>.
This uses the L<blockdev(8)> command.
=head2 blockdev-getss
blockdev-getss device
This returns the size of sectors on a block device.
Usually 512, but can be larger for modern devices.
(Note, this is not the size in sectors, use C<blockdev_getsz>
for that).
This uses the L<blockdev(8)> command.
=head2 blockdev-getsz
blockdev-getsz device
This returns the size of the device in units of 512-byte sectors
(even if the sectorsize isn't 512 bytes ... weird).
See also C<blockdev_getss> for the real sector size of
the device, and C<blockdev_getsize64> for the more
useful I<size in bytes>.
This uses the L<blockdev(8)> command.
=head2 blockdev-rereadpt
blockdev-rereadpt device
Reread the partition table on C<device>.
This uses the L<blockdev(8)> command.
=head2 blockdev-setbsz
blockdev-setbsz device blocksize
This sets the block size of a device.
(Note this is different from both I<size in blocks> and
I<filesystem block size>).
This uses the L<blockdev(8)> command.
=head2 blockdev-setro
blockdev-setro device
Sets the block device named C<device> to read-only.
This uses the L<blockdev(8)> command.
=head2 blockdev-setrw
blockdev-setrw device
Sets the block device named C<device> to read-write.
This uses the L<blockdev(8)> command.
=head2 cat
cat path

130
guestfs-actions.pod
View File

@@ -239,6 +239,136 @@ Set the value associated with C<path> to C<value>.
This function returns 0 on success or -1 on error.
=head2 guestfs_blockdev_flushbufs
int guestfs_blockdev_flushbufs (guestfs_h *handle,
const char *device);
This tells the kernel to flush internal buffers associated
with C<device>.
This uses the L<blockdev(8)> command.
This function returns 0 on success or -1 on error.
=head2 guestfs_blockdev_getbsz
int guestfs_blockdev_getbsz (guestfs_h *handle,
const char *device);
This returns the block size of a device.
(Note this is different from both I<size in blocks> and
I<filesystem block size>).
This uses the L<blockdev(8)> command.
On error this function returns -1.
=head2 guestfs_blockdev_getro
int guestfs_blockdev_getro (guestfs_h *handle,
const char *device);
Returns a boolean indicating if the block device is read-only
(true if read-only, false if not).
This uses the L<blockdev(8)> command.
This function returns a C truth value on success or -1 on error.
=head2 guestfs_blockdev_getsize64
int64_t guestfs_blockdev_getsize64 (guestfs_h *handle,
const char *device);
This returns the size of the device in bytes.
See also C<guestfs_blockdev_getsz>.
This uses the L<blockdev(8)> command.
On error this function returns -1.
=head2 guestfs_blockdev_getss
int guestfs_blockdev_getss (guestfs_h *handle,
const char *device);
This returns the size of sectors on a block device.
Usually 512, but can be larger for modern devices.
(Note, this is not the size in sectors, use C<guestfs_blockdev_getsz>
for that).
This uses the L<blockdev(8)> command.
On error this function returns -1.
=head2 guestfs_blockdev_getsz
int64_t guestfs_blockdev_getsz (guestfs_h *handle,
const char *device);
This returns the size of the device in units of 512-byte sectors
(even if the sectorsize isn't 512 bytes ... weird).
See also C<guestfs_blockdev_getss> for the real sector size of
the device, and C<guestfs_blockdev_getsize64> for the more
useful I<size in bytes>.
This uses the L<blockdev(8)> command.
On error this function returns -1.
=head2 guestfs_blockdev_rereadpt
int guestfs_blockdev_rereadpt (guestfs_h *handle,
const char *device);
Reread the partition table on C<device>.
This uses the L<blockdev(8)> command.
This function returns 0 on success or -1 on error.
=head2 guestfs_blockdev_setbsz
int guestfs_blockdev_setbsz (guestfs_h *handle,
const char *device,
int blocksize);
This sets the block size of a device.
(Note this is different from both I<size in blocks> and
I<filesystem block size>).
This uses the L<blockdev(8)> command.
This function returns 0 on success or -1 on error.
=head2 guestfs_blockdev_setro
int guestfs_blockdev_setro (guestfs_h *handle,
const char *device);
Sets the block device named C<device> to read-only.
This uses the L<blockdev(8)> command.
This function returns 0 on success or -1 on error.
=head2 guestfs_blockdev_setrw
int guestfs_blockdev_setrw (guestfs_h *handle,
const char *device);
Sets the block device named C<device> to read-write.
This uses the L<blockdev(8)> command.
This function returns 0 on success or -1 on error.
=head2 guestfs_cat
char *guestfs_cat (guestfs_h *handle,

10
ocaml/guestfs.ml
View File

@@ -182,3 +182,13 @@ external stat : t -> string -> stat = "ocaml_guestfs_stat"
external lstat : t -> string -> stat = "ocaml_guestfs_lstat"
external statvfs : t -> string -> statvfs = "ocaml_guestfs_statvfs"
external tune2fs_l : t -> string -> (string * string) list = "ocaml_guestfs_tune2fs_l"
external blockdev_setro : t -> string -> unit = "ocaml_guestfs_blockdev_setro"
external blockdev_setrw : t -> string -> unit = "ocaml_guestfs_blockdev_setrw"
external blockdev_getro : t -> string -> bool = "ocaml_guestfs_blockdev_getro"
external blockdev_getss : t -> string -> int = "ocaml_guestfs_blockdev_getss"
external blockdev_getbsz : t -> string -> int = "ocaml_guestfs_blockdev_getbsz"
external blockdev_setbsz : t -> string -> int -> unit = "ocaml_guestfs_blockdev_setbsz"
external blockdev_getsz : t -> string -> int64 = "ocaml_guestfs_blockdev_getsz"
external blockdev_getsize64 : t -> string -> int64 = "ocaml_guestfs_blockdev_getsize64"
external blockdev_flushbufs : t -> string -> unit = "ocaml_guestfs_blockdev_flushbufs"
external blockdev_rereadpt : t -> string -> unit = "ocaml_guestfs_blockdev_rereadpt"

30
ocaml/guestfs.mli
View File

@@ -325,3 +325,33 @@ val statvfs : t -> string -> statvfs
val tune2fs_l : t -> string -> (string * string) list
(** get ext2/ext3 superblock details *)
val blockdev_setro : t -> string -> unit
(** set block device to read-only *)
val blockdev_setrw : t -> string -> unit
(** set block device to read-write *)
val blockdev_getro : t -> string -> bool
(** is block device set to read-only *)
val blockdev_getss : t -> string -> int
(** get sectorsize of block device *)
val blockdev_getbsz : t -> string -> int
(** get blocksize of block device *)
val blockdev_setbsz : t -> string -> int -> unit
(** set blocksize of block device *)
val blockdev_getsz : t -> string -> int64
(** get total size of device in 512-byte sectors *)
val blockdev_getsize64 : t -> string -> int64
(** get total size of device in bytes *)
val blockdev_flushbufs : t -> string -> unit
(** flush device buffers *)
val blockdev_rereadpt : t -> string -> unit
(** reread partition table *)

231
ocaml/guestfs_c_actions.c
View File

@@ -1934,3 +1934,234 @@ ocaml_guestfs_tune2fs_l (value gv, value devicev)
CAMLreturn (rv);
}
CAMLprim value
ocaml_guestfs_blockdev_setro (value gv, value devicev)
{
CAMLparam2 (gv, devicev);
CAMLlocal1 (rv);
guestfs_h *g = Guestfs_val (gv);
if (g == NULL)
caml_failwith ("blockdev_setro: used handle after closing it");
const char *device = String_val (devicev);
int r;
caml_enter_blocking_section ();
r = guestfs_blockdev_setro (g, device);
caml_leave_blocking_section ();
if (r == -1)
ocaml_guestfs_raise_error (g, "blockdev_setro");
rv = Val_unit;
CAMLreturn (rv);
}
CAMLprim value
ocaml_guestfs_blockdev_setrw (value gv, value devicev)
{
CAMLparam2 (gv, devicev);
CAMLlocal1 (rv);
guestfs_h *g = Guestfs_val (gv);
if (g == NULL)
caml_failwith ("blockdev_setrw: used handle after closing it");
const char *device = String_val (devicev);
int r;
caml_enter_blocking_section ();
r = guestfs_blockdev_setrw (g, device);
caml_leave_blocking_section ();
if (r == -1)
ocaml_guestfs_raise_error (g, "blockdev_setrw");
rv = Val_unit;
CAMLreturn (rv);
}
CAMLprim value
ocaml_guestfs_blockdev_getro (value gv, value devicev)
{
CAMLparam2 (gv, devicev);
CAMLlocal1 (rv);
guestfs_h *g = Guestfs_val (gv);
if (g == NULL)
caml_failwith ("blockdev_getro: used handle after closing it");
const char *device = String_val (devicev);
int r;
caml_enter_blocking_section ();
r = guestfs_blockdev_getro (g, device);
caml_leave_blocking_section ();
if (r == -1)
ocaml_guestfs_raise_error (g, "blockdev_getro");
rv = Val_bool (r);
CAMLreturn (rv);
}
CAMLprim value
ocaml_guestfs_blockdev_getss (value gv, value devicev)
{
CAMLparam2 (gv, devicev);
CAMLlocal1 (rv);
guestfs_h *g = Guestfs_val (gv);
if (g == NULL)
caml_failwith ("blockdev_getss: used handle after closing it");
const char *device = String_val (devicev);
int r;
caml_enter_blocking_section ();
r = guestfs_blockdev_getss (g, device);
caml_leave_blocking_section ();
if (r == -1)
ocaml_guestfs_raise_error (g, "blockdev_getss");
rv = Val_int (r);
CAMLreturn (rv);
}
CAMLprim value
ocaml_guestfs_blockdev_getbsz (value gv, value devicev)
{
CAMLparam2 (gv, devicev);
CAMLlocal1 (rv);
guestfs_h *g = Guestfs_val (gv);
if (g == NULL)
caml_failwith ("blockdev_getbsz: used handle after closing it");
const char *device = String_val (devicev);
int r;
caml_enter_blocking_section ();
r = guestfs_blockdev_getbsz (g, device);
caml_leave_blocking_section ();
if (r == -1)
ocaml_guestfs_raise_error (g, "blockdev_getbsz");
rv = Val_int (r);
CAMLreturn (rv);
}
CAMLprim value
ocaml_guestfs_blockdev_setbsz (value gv, value devicev, value blocksizev)
{
CAMLparam3 (gv, devicev, blocksizev);
CAMLlocal1 (rv);
guestfs_h *g = Guestfs_val (gv);
if (g == NULL)
caml_failwith ("blockdev_setbsz: used handle after closing it");
const char *device = String_val (devicev);
int blocksize = Int_val (blocksizev);
int r;
caml_enter_blocking_section ();
r = guestfs_blockdev_setbsz (g, device, blocksize);
caml_leave_blocking_section ();
if (r == -1)
ocaml_guestfs_raise_error (g, "blockdev_setbsz");
rv = Val_unit;
CAMLreturn (rv);
}
CAMLprim value
ocaml_guestfs_blockdev_getsz (value gv, value devicev)
{
CAMLparam2 (gv, devicev);
CAMLlocal1 (rv);
guestfs_h *g = Guestfs_val (gv);
if (g == NULL)
caml_failwith ("blockdev_getsz: used handle after closing it");
const char *device = String_val (devicev);
int64_t r;
caml_enter_blocking_section ();
r = guestfs_blockdev_getsz (g, device);
caml_leave_blocking_section ();
if (r == -1)
ocaml_guestfs_raise_error (g, "blockdev_getsz");
rv = caml_copy_int64 (r);
CAMLreturn (rv);
}
CAMLprim value
ocaml_guestfs_blockdev_getsize64 (value gv, value devicev)
{
CAMLparam2 (gv, devicev);
CAMLlocal1 (rv);
guestfs_h *g = Guestfs_val (gv);
if (g == NULL)
caml_failwith ("blockdev_getsize64: used handle after closing it");
const char *device = String_val (devicev);
int64_t r;
caml_enter_blocking_section ();
r = guestfs_blockdev_getsize64 (g, device);
caml_leave_blocking_section ();
if (r == -1)
ocaml_guestfs_raise_error (g, "blockdev_getsize64");
rv = caml_copy_int64 (r);
CAMLreturn (rv);
}
CAMLprim value
ocaml_guestfs_blockdev_flushbufs (value gv, value devicev)
{
CAMLparam2 (gv, devicev);
CAMLlocal1 (rv);
guestfs_h *g = Guestfs_val (gv);
if (g == NULL)
caml_failwith ("blockdev_flushbufs: used handle after closing it");
const char *device = String_val (devicev);
int r;
caml_enter_blocking_section ();
r = guestfs_blockdev_flushbufs (g, device);
caml_leave_blocking_section ();
if (r == -1)
ocaml_guestfs_raise_error (g, "blockdev_flushbufs");
rv = Val_unit;
CAMLreturn (rv);
}
CAMLprim value
ocaml_guestfs_blockdev_rereadpt (value gv, value devicev)
{
CAMLparam2 (gv, devicev);
CAMLlocal1 (rv);
guestfs_h *g = Guestfs_val (gv);
if (g == NULL)
caml_failwith ("blockdev_rereadpt: used handle after closing it");
const char *device = String_val (devicev);
int r;
caml_enter_blocking_section ();
r = guestfs_blockdev_rereadpt (g, device);
caml_leave_blocking_section ();
if (r == -1)
ocaml_guestfs_raise_error (g, "blockdev_rereadpt");
rv = Val_unit;
CAMLreturn (rv);
}

126
perl/Guestfs.xs
View File

@@ -1106,3 +1106,129 @@ PREINIT:
}
free (superblock);
void
blockdev_setro (g, device)
guestfs_h *g;
char *device;
PREINIT:
int r;
PPCODE:
r = guestfs_blockdev_setro (g, device);
if (r == -1)
croak ("blockdev_setro: %s", guestfs_last_error (g));
void
blockdev_setrw (g, device)
guestfs_h *g;
char *device;
PREINIT:
int r;
PPCODE:
r = guestfs_blockdev_setrw (g, device);
if (r == -1)
croak ("blockdev_setrw: %s", guestfs_last_error (g));
SV *
blockdev_getro (g, device)
guestfs_h *g;
char *device;
PREINIT:
int ro;
CODE:
ro = guestfs_blockdev_getro (g, device);
if (ro == -1)
croak ("blockdev_getro: %s", guestfs_last_error (g));
RETVAL = newSViv (ro);
OUTPUT:
RETVAL
SV *
blockdev_getss (g, device)
guestfs_h *g;
char *device;
PREINIT:
int sectorsize;
CODE:
sectorsize = guestfs_blockdev_getss (g, device);
if (sectorsize == -1)
croak ("blockdev_getss: %s", guestfs_last_error (g));
RETVAL = newSViv (sectorsize);
OUTPUT:
RETVAL
SV *
blockdev_getbsz (g, device)
guestfs_h *g;
char *device;
PREINIT:
int blocksize;
CODE:
blocksize = guestfs_blockdev_getbsz (g, device);
if (blocksize == -1)
croak ("blockdev_getbsz: %s", guestfs_last_error (g));
RETVAL = newSViv (blocksize);
OUTPUT:
RETVAL
void
blockdev_setbsz (g, device, blocksize)
guestfs_h *g;
char *device;
int blocksize;
PREINIT:
int r;
PPCODE:
r = guestfs_blockdev_setbsz (g, device, blocksize);
if (r == -1)
croak ("blockdev_setbsz: %s", guestfs_last_error (g));
SV *
blockdev_getsz (g, device)
guestfs_h *g;
char *device;
PREINIT:
int64_t sizeinsectors;
CODE:
sizeinsectors = guestfs_blockdev_getsz (g, device);
if (sizeinsectors == -1)
croak ("blockdev_getsz: %s", guestfs_last_error (g));
RETVAL = my_newSVll (sizeinsectors);
OUTPUT:
RETVAL
SV *
blockdev_getsize64 (g, device)
guestfs_h *g;
char *device;
PREINIT:
int64_t sizeinbytes;
CODE:
sizeinbytes = guestfs_blockdev_getsize64 (g, device);
if (sizeinbytes == -1)
croak ("blockdev_getsize64: %s", guestfs_last_error (g));
RETVAL = my_newSVll (sizeinbytes);
OUTPUT:
RETVAL
void
blockdev_flushbufs (g, device)
guestfs_h *g;
char *device;
PREINIT:
int r;
PPCODE:
r = guestfs_blockdev_flushbufs (g, device);
if (r == -1)
croak ("blockdev_flushbufs: %s", guestfs_last_error (g));
void
blockdev_rereadpt (g, device)
guestfs_h *g;
char *device;
PREINIT:
int r;
PPCODE:
r = guestfs_blockdev_rereadpt (g, device);
if (r == -1)
croak ("blockdev_rereadpt: %s", guestfs_last_error (g));

79
perl/lib/Sys/Guestfs.pm
View File

@@ -245,6 +245,85 @@ how files are saved.
Set the value associated with C<path> to C<value>.
=item $h->blockdev_flushbufs ($device);
This tells the kernel to flush internal buffers associated
with C<device>.
This uses the L<blockdev(8)> command.
=item $blocksize = $h->blockdev_getbsz ($device);
This returns the block size of a device.
(Note this is different from both I<size in blocks> and
I<filesystem block size>).
This uses the L<blockdev(8)> command.
=item $ro = $h->blockdev_getro ($device);
Returns a boolean indicating if the block device is read-only
(true if read-only, false if not).
This uses the L<blockdev(8)> command.
=item $sizeinbytes = $h->blockdev_getsize64 ($device);
This returns the size of the device in bytes.
See also C<$h-E<gt>blockdev_getsz>.
This uses the L<blockdev(8)> command.
=item $sectorsize = $h->blockdev_getss ($device);
This returns the size of sectors on a block device.
Usually 512, but can be larger for modern devices.
(Note, this is not the size in sectors, use C<$h-E<gt>blockdev_getsz>
for that).
This uses the L<blockdev(8)> command.
=item $sizeinsectors = $h->blockdev_getsz ($device);
This returns the size of the device in units of 512-byte sectors
(even if the sectorsize isn't 512 bytes ... weird).
See also C<$h-E<gt>blockdev_getss> for the real sector size of
the device, and C<$h-E<gt>blockdev_getsize64> for the more
useful I<size in bytes>.
This uses the L<blockdev(8)> command.
=item $h->blockdev_rereadpt ($device);
Reread the partition table on C<device>.
This uses the L<blockdev(8)> command.
=item $h->blockdev_setbsz ($device, $blocksize);
This sets the block size of a device.
(Note this is different from both I<size in blocks> and
I<filesystem block size>).
This uses the L<blockdev(8)> command.
=item $h->blockdev_setro ($device);
Sets the block device named C<device> to read-only.
This uses the L<blockdev(8)> command.
=item $h->blockdev_setrw ($device);
Sets the block device named C<device> to read-write.
This uses the L<blockdev(8)> command.
=item $content = $h->cat ($path);
Return the contents of the file named C<path>.

256
python/guestfs-py.c
View File

@@ -2076,6 +2076,252 @@ py_guestfs_tune2fs_l (PyObject *self, PyObject *args)
return py_r;
}
static PyObject *
py_guestfs_blockdev_setro (PyObject *self, PyObject *args)
{
PyObject *py_g;
guestfs_h *g;
PyObject *py_r;
int r;
const char *device;
if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_setro",
&py_g, &device))
return NULL;
g = get_handle (py_g);
r = guestfs_blockdev_setro (g, device);
if (r == -1) {
PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
return NULL;
}
Py_INCREF (Py_None);
py_r = Py_None;
return py_r;
}
static PyObject *
py_guestfs_blockdev_setrw (PyObject *self, PyObject *args)
{
PyObject *py_g;
guestfs_h *g;
PyObject *py_r;
int r;
const char *device;
if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_setrw",
&py_g, &device))
return NULL;
g = get_handle (py_g);
r = guestfs_blockdev_setrw (g, device);
if (r == -1) {
PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
return NULL;
}
Py_INCREF (Py_None);
py_r = Py_None;
return py_r;
}
static PyObject *
py_guestfs_blockdev_getro (PyObject *self, PyObject *args)
{
PyObject *py_g;
guestfs_h *g;
PyObject *py_r;
int r;
const char *device;
if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getro",
&py_g, &device))
return NULL;
g = get_handle (py_g);
r = guestfs_blockdev_getro (g, device);
if (r == -1) {
PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
return NULL;
}
py_r = PyInt_FromLong ((long) r);
return py_r;
}
static PyObject *
py_guestfs_blockdev_getss (PyObject *self, PyObject *args)
{
PyObject *py_g;
guestfs_h *g;
PyObject *py_r;
int r;
const char *device;
if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getss",
&py_g, &device))
return NULL;
g = get_handle (py_g);
r = guestfs_blockdev_getss (g, device);
if (r == -1) {
PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
return NULL;
}
py_r = PyInt_FromLong ((long) r);
return py_r;
}
static PyObject *
py_guestfs_blockdev_getbsz (PyObject *self, PyObject *args)
{
PyObject *py_g;
guestfs_h *g;
PyObject *py_r;
int r;
const char *device;
if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getbsz",
&py_g, &device))
return NULL;
g = get_handle (py_g);
r = guestfs_blockdev_getbsz (g, device);
if (r == -1) {
PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
return NULL;
}
py_r = PyInt_FromLong ((long) r);
return py_r;
}
static PyObject *
py_guestfs_blockdev_setbsz (PyObject *self, PyObject *args)
{
PyObject *py_g;
guestfs_h *g;
PyObject *py_r;
int r;
const char *device;
int blocksize;
if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_blockdev_setbsz",
&py_g, &device, &blocksize))
return NULL;
g = get_handle (py_g);
r = guestfs_blockdev_setbsz (g, device, blocksize);
if (r == -1) {
PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
return NULL;
}
Py_INCREF (Py_None);
py_r = Py_None;
return py_r;
}
static PyObject *
py_guestfs_blockdev_getsz (PyObject *self, PyObject *args)
{
PyObject *py_g;
guestfs_h *g;
PyObject *py_r;
int64_t r;
const char *device;
if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsz",
&py_g, &device))
return NULL;
g = get_handle (py_g);
r = guestfs_blockdev_getsz (g, device);
if (r == -1) {
PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
return NULL;
}
py_r = PyLong_FromLongLong (r);
return py_r;
}
static PyObject *
py_guestfs_blockdev_getsize64 (PyObject *self, PyObject *args)
{
PyObject *py_g;
guestfs_h *g;
PyObject *py_r;
int64_t r;
const char *device;
if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsize64",
&py_g, &device))
return NULL;
g = get_handle (py_g);
r = guestfs_blockdev_getsize64 (g, device);
if (r == -1) {
PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
return NULL;
}
py_r = PyLong_FromLongLong (r);
return py_r;
}
static PyObject *
py_guestfs_blockdev_flushbufs (PyObject *self, PyObject *args)
{
PyObject *py_g;
guestfs_h *g;
PyObject *py_r;
int r;
const char *device;
if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_flushbufs",
&py_g, &device))
return NULL;
g = get_handle (py_g);
r = guestfs_blockdev_flushbufs (g, device);
if (r == -1) {
PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
return NULL;
}
Py_INCREF (Py_None);
py_r = Py_None;
return py_r;
}
static PyObject *
py_guestfs_blockdev_rereadpt (PyObject *self, PyObject *args)
{
PyObject *py_g;
guestfs_h *g;
PyObject *py_r;
int r;
const char *device;
if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_rereadpt",
&py_g, &device))
return NULL;
g = get_handle (py_g);
r = guestfs_blockdev_rereadpt (g, device);
if (r == -1) {
PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
return NULL;
}
Py_INCREF (Py_None);
py_r = Py_None;
return py_r;
}
static PyMethodDef methods[] = {
{ (char *) "create", py_guestfs_create, METH_VARARGS, NULL },
{ (char *) "close", py_guestfs_close, METH_VARARGS, NULL },
@@ -2146,6 +2392,16 @@ static PyMethodDef methods[] = {
{ (char *) "lstat", py_guestfs_lstat, METH_VARARGS, NULL },
{ (char *) "statvfs", py_guestfs_statvfs, METH_VARARGS, NULL },
{ (char *) "tune2fs_l", py_guestfs_tune2fs_l, METH_VARARGS, NULL },
{ (char *) "blockdev_setro", py_guestfs_blockdev_setro, METH_VARARGS, NULL },
{ (char *) "blockdev_setrw", py_guestfs_blockdev_setrw, METH_VARARGS, NULL },
{ (char *) "blockdev_getro", py_guestfs_blockdev_getro, METH_VARARGS, NULL },
{ (char *) "blockdev_getss", py_guestfs_blockdev_getss, METH_VARARGS, NULL },
{ (char *) "blockdev_getbsz", py_guestfs_blockdev_getbsz, METH_VARARGS, NULL },
{ (char *) "blockdev_setbsz", py_guestfs_blockdev_setbsz, METH_VARARGS, NULL },
{ (char *) "blockdev_getsz", py_guestfs_blockdev_getsz, METH_VARARGS, NULL },
{ (char *) "blockdev_getsize64", py_guestfs_blockdev_getsize64, METH_VARARGS, NULL },
{ (char *) "blockdev_flushbufs", py_guestfs_blockdev_flushbufs, METH_VARARGS, NULL },
{ (char *) "blockdev_rereadpt", py_guestfs_blockdev_rereadpt, METH_VARARGS, NULL },
{ NULL, NULL, 0, NULL }
};

30
python/guestfs.py
View File

@@ -228,3 +228,33 @@ class GuestFS:
def tune2fs_l (self, device):
return libguestfsmod.tune2fs_l (self._o, device)
def blockdev_setro (self, device):
return libguestfsmod.blockdev_setro (self._o, device)
def blockdev_setrw (self, device):
return libguestfsmod.blockdev_setrw (self._o, device)
def blockdev_getro (self, device):
return libguestfsmod.blockdev_getro (self._o, device)
def blockdev_getss (self, device):
return libguestfsmod.blockdev_getss (self._o, device)
def blockdev_getbsz (self, device):
return libguestfsmod.blockdev_getbsz (self._o, device)
def blockdev_setbsz (self, device, blocksize):
return libguestfsmod.blockdev_setbsz (self._o, device, blocksize)
def blockdev_getsz (self, device):
return libguestfsmod.blockdev_getsz (self._o, device)
def blockdev_getsize64 (self, device):
return libguestfsmod.blockdev_getsize64 (self._o, device)
def blockdev_flushbufs (self, device):
return libguestfsmod.blockdev_flushbufs (self._o, device)
def blockdev_rereadpt (self, device):
return libguestfsmod.blockdev_rereadpt (self._o, device)

717
src/guestfs-actions.c
View File

@@ -4002,3 +4002,720 @@ char **guestfs_tune2fs_l (guestfs_h *g,
return rv.ret.superblock.superblock_val;
}
struct blockdev_setro_rv {
int cb_done; /* flag to indicate callback was called */
struct guestfs_message_header hdr;
struct guestfs_message_error err;
};
static void blockdev_setro_cb (guestfs_h *g, void *data, XDR *xdr)
{
struct blockdev_setro_rv *rv = (struct blockdev_setro_rv *) data;
if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
error (g, "guestfs_blockdev_setro: failed to parse reply header");
return;
}
if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
if (!xdr_guestfs_message_error (xdr, &rv->err)) {
error (g, "guestfs_blockdev_setro: failed to parse reply error");
return;
}
goto done;
}
done:
rv->cb_done = 1;
main_loop.main_loop_quit (g);
}
int guestfs_blockdev_setro (guestfs_h *g,
const char *device)
{
struct guestfs_blockdev_setro_args args;
struct blockdev_setro_rv rv;
int serial;
if (g->state != READY) {
error (g, "guestfs_blockdev_setro called from the wrong state, %d != READY",
g->state);
return -1;
}
memset (&rv, 0, sizeof rv);
args.device = (char *) device;
serial = dispatch (g, GUESTFS_PROC_BLOCKDEV_SETRO,
(xdrproc_t) xdr_guestfs_blockdev_setro_args, (char *) &args);
if (serial == -1)
return -1;
rv.cb_done = 0;
g->reply_cb_internal = blockdev_setro_cb;
g->reply_cb_internal_data = &rv;
main_loop.main_loop_run (g);
g->reply_cb_internal = NULL;
g->reply_cb_internal_data = NULL;
if (!rv.cb_done) {
error (g, "guestfs_blockdev_setro failed, see earlier error messages");
return -1;
}
if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_BLOCKDEV_SETRO, serial) == -1)
return -1;
if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
error (g, "%s", rv.err.error);
return -1;
}
return 0;
}
struct blockdev_setrw_rv {
int cb_done; /* flag to indicate callback was called */
struct guestfs_message_header hdr;
struct guestfs_message_error err;
};
static void blockdev_setrw_cb (guestfs_h *g, void *data, XDR *xdr)
{
struct blockdev_setrw_rv *rv = (struct blockdev_setrw_rv *) data;
if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
error (g, "guestfs_blockdev_setrw: failed to parse reply header");
return;
}
if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
if (!xdr_guestfs_message_error (xdr, &rv->err)) {
error (g, "guestfs_blockdev_setrw: failed to parse reply error");
return;
}
goto done;
}
done:
rv->cb_done = 1;
main_loop.main_loop_quit (g);
}
int guestfs_blockdev_setrw (guestfs_h *g,
const char *device)
{
struct guestfs_blockdev_setrw_args args;
struct blockdev_setrw_rv rv;
int serial;
if (g->state != READY) {
error (g, "guestfs_blockdev_setrw called from the wrong state, %d != READY",
g->state);
return -1;
}
memset (&rv, 0, sizeof rv);
args.device = (char *) device;
serial = dispatch (g, GUESTFS_PROC_BLOCKDEV_SETRW,
(xdrproc_t) xdr_guestfs_blockdev_setrw_args, (char *) &args);
if (serial == -1)
return -1;
rv.cb_done = 0;
g->reply_cb_internal = blockdev_setrw_cb;
g->reply_cb_internal_data = &rv;
main_loop.main_loop_run (g);
g->reply_cb_internal = NULL;
g->reply_cb_internal_data = NULL;
if (!rv.cb_done) {
error (g, "guestfs_blockdev_setrw failed, see earlier error messages");
return -1;
}
if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_BLOCKDEV_SETRW, serial) == -1)
return -1;
if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
error (g, "%s", rv.err.error);
return -1;
}
return 0;
}
struct blockdev_getro_rv {
int cb_done; /* flag to indicate callback was called */
struct guestfs_message_header hdr;
struct guestfs_message_error err;
struct guestfs_blockdev_getro_ret ret;
};
static void blockdev_getro_cb (guestfs_h *g, void *data, XDR *xdr)
{
struct blockdev_getro_rv *rv = (struct blockdev_getro_rv *) data;
if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
error (g, "guestfs_blockdev_getro: failed to parse reply header");
return;
}
if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
if (!xdr_guestfs_message_error (xdr, &rv->err)) {
error (g, "guestfs_blockdev_getro: failed to parse reply error");
return;
}
goto done;
}
if (!xdr_guestfs_blockdev_getro_ret (xdr, &rv->ret)) {
error (g, "guestfs_blockdev_getro: failed to parse reply");
return;
}
done:
rv->cb_done = 1;
main_loop.main_loop_quit (g);
}
int guestfs_blockdev_getro (guestfs_h *g,
const char *device)
{
struct guestfs_blockdev_getro_args args;
struct blockdev_getro_rv rv;
int serial;
if (g->state != READY) {
error (g, "guestfs_blockdev_getro called from the wrong state, %d != READY",
g->state);
return -1;
}
memset (&rv, 0, sizeof rv);
args.device = (char *) device;
serial = dispatch (g, GUESTFS_PROC_BLOCKDEV_GETRO,
(xdrproc_t) xdr_guestfs_blockdev_getro_args, (char *) &args);
if (serial == -1)
return -1;
rv.cb_done = 0;
g->reply_cb_internal = blockdev_getro_cb;
g->reply_cb_internal_data = &rv;
main_loop.main_loop_run (g);
g->reply_cb_internal = NULL;
g->reply_cb_internal_data = NULL;
if (!rv.cb_done) {
error (g, "guestfs_blockdev_getro failed, see earlier error messages");
return -1;
}
if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_BLOCKDEV_GETRO, serial) == -1)
return -1;
if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
error (g, "%s", rv.err.error);
return -1;
}
return rv.ret.ro;
}
struct blockdev_getss_rv {
int cb_done; /* flag to indicate callback was called */
struct guestfs_message_header hdr;
struct guestfs_message_error err;
struct guestfs_blockdev_getss_ret ret;
};
static void blockdev_getss_cb (guestfs_h *g, void *data, XDR *xdr)
{
struct blockdev_getss_rv *rv = (struct blockdev_getss_rv *) data;
if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
error (g, "guestfs_blockdev_getss: failed to parse reply header");
return;
}
if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
if (!xdr_guestfs_message_error (xdr, &rv->err)) {
error (g, "guestfs_blockdev_getss: failed to parse reply error");
return;
}
goto done;
}
if (!xdr_guestfs_blockdev_getss_ret (xdr, &rv->ret)) {
error (g, "guestfs_blockdev_getss: failed to parse reply");
return;
}
done:
rv->cb_done = 1;
main_loop.main_loop_quit (g);
}
int guestfs_blockdev_getss (guestfs_h *g,
const char *device)
{
struct guestfs_blockdev_getss_args args;
struct blockdev_getss_rv rv;
int serial;
if (g->state != READY) {
error (g, "guestfs_blockdev_getss called from the wrong state, %d != READY",
g->state);
return -1;
}
memset (&rv, 0, sizeof rv);
args.device = (char *) device;
serial = dispatch (g, GUESTFS_PROC_BLOCKDEV_GETSS,
(xdrproc_t) xdr_guestfs_blockdev_getss_args, (char *) &args);
if (serial == -1)
return -1;
rv.cb_done = 0;
g->reply_cb_internal = blockdev_getss_cb;
g->reply_cb_internal_data = &rv;
main_loop.main_loop_run (g);
g->reply_cb_internal = NULL;
g->reply_cb_internal_data = NULL;
if (!rv.cb_done) {
error (g, "guestfs_blockdev_getss failed, see earlier error messages");
return -1;
}
if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_BLOCKDEV_GETSS, serial) == -1)
return -1;
if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
error (g, "%s", rv.err.error);
return -1;
}
return rv.ret.sectorsize;
}
struct blockdev_getbsz_rv {
int cb_done; /* flag to indicate callback was called */
struct guestfs_message_header hdr;
struct guestfs_message_error err;
struct guestfs_blockdev_getbsz_ret ret;
};
static void blockdev_getbsz_cb (guestfs_h *g, void *data, XDR *xdr)
{
struct blockdev_getbsz_rv *rv = (struct blockdev_getbsz_rv *) data;
if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
error (g, "guestfs_blockdev_getbsz: failed to parse reply header");
return;
}
if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
if (!xdr_guestfs_message_error (xdr, &rv->err)) {
error (g, "guestfs_blockdev_getbsz: failed to parse reply error");
return;
}
goto done;
}
if (!xdr_guestfs_blockdev_getbsz_ret (xdr, &rv->ret)) {
error (g, "guestfs_blockdev_getbsz: failed to parse reply");
return;
}
done:
rv->cb_done = 1;
main_loop.main_loop_quit (g);
}
int guestfs_blockdev_getbsz (guestfs_h *g,
const char *device)
{
struct guestfs_blockdev_getbsz_args args;
struct blockdev_getbsz_rv rv;
int serial;
if (g->state != READY) {
error (g, "guestfs_blockdev_getbsz called from the wrong state, %d != READY",
g->state);
return -1;
}
memset (&rv, 0, sizeof rv);
args.device = (char *) device;
serial = dispatch (g, GUESTFS_PROC_BLOCKDEV_GETBSZ,
(xdrproc_t) xdr_guestfs_blockdev_getbsz_args, (char *) &args);
if (serial == -1)
return -1;
rv.cb_done = 0;
g->reply_cb_internal = blockdev_getbsz_cb;
g->reply_cb_internal_data = &rv;
main_loop.main_loop_run (g);
g->reply_cb_internal = NULL;
g->reply_cb_internal_data = NULL;
if (!rv.cb_done) {
error (g, "guestfs_blockdev_getbsz failed, see earlier error messages");
return -1;
}
if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_BLOCKDEV_GETBSZ, serial) == -1)
return -1;
if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
error (g, "%s", rv.err.error);
return -1;
}
return rv.ret.blocksize;
}
struct blockdev_setbsz_rv {
int cb_done; /* flag to indicate callback was called */
struct guestfs_message_header hdr;
struct guestfs_message_error err;
};
static void blockdev_setbsz_cb (guestfs_h *g, void *data, XDR *xdr)
{
struct blockdev_setbsz_rv *rv = (struct blockdev_setbsz_rv *) data;
if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
error (g, "guestfs_blockdev_setbsz: failed to parse reply header");
return;
}
if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
if (!xdr_guestfs_message_error (xdr, &rv->err)) {
error (g, "guestfs_blockdev_setbsz: failed to parse reply error");
return;
}
goto done;
}
done:
rv->cb_done = 1;
main_loop.main_loop_quit (g);
}
int guestfs_blockdev_setbsz (guestfs_h *g,
const char *device,
int blocksize)
{
struct guestfs_blockdev_setbsz_args args;
struct blockdev_setbsz_rv rv;
int serial;
if (g->state != READY) {
error (g, "guestfs_blockdev_setbsz called from the wrong state, %d != READY",
g->state);
return -1;
}
memset (&rv, 0, sizeof rv);
args.device = (char *) device;
args.blocksize = blocksize;
serial = dispatch (g, GUESTFS_PROC_BLOCKDEV_SETBSZ,
(xdrproc_t) xdr_guestfs_blockdev_setbsz_args, (char *) &args);
if (serial == -1)
return -1;
rv.cb_done = 0;
g->reply_cb_internal = blockdev_setbsz_cb;
g->reply_cb_internal_data = &rv;
main_loop.main_loop_run (g);
g->reply_cb_internal = NULL;
g->reply_cb_internal_data = NULL;
if (!rv.cb_done) {
error (g, "guestfs_blockdev_setbsz failed, see earlier error messages");
return -1;
}
if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_BLOCKDEV_SETBSZ, serial) == -1)
return -1;
if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
error (g, "%s", rv.err.error);
return -1;
}
return 0;
}
struct blockdev_getsz_rv {
int cb_done; /* flag to indicate callback was called */
struct guestfs_message_header hdr;
struct guestfs_message_error err;
struct guestfs_blockdev_getsz_ret ret;
};
static void blockdev_getsz_cb (guestfs_h *g, void *data, XDR *xdr)
{
struct blockdev_getsz_rv *rv = (struct blockdev_getsz_rv *) data;
if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
error (g, "guestfs_blockdev_getsz: failed to parse reply header");
return;
}
if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
if (!xdr_guestfs_message_error (xdr, &rv->err)) {
error (g, "guestfs_blockdev_getsz: failed to parse reply error");
return;
}
goto done;
}
if (!xdr_guestfs_blockdev_getsz_ret (xdr, &rv->ret)) {
error (g, "guestfs_blockdev_getsz: failed to parse reply");
return;
}
done:
rv->cb_done = 1;
main_loop.main_loop_quit (g);
}
int64_t guestfs_blockdev_getsz (guestfs_h *g,
const char *device)
{
struct guestfs_blockdev_getsz_args args;
struct blockdev_getsz_rv rv;
int serial;
if (g->state != READY) {
error (g, "guestfs_blockdev_getsz called from the wrong state, %d != READY",
g->state);
return -1;
}
memset (&rv, 0, sizeof rv);
args.device = (char *) device;
serial = dispatch (g, GUESTFS_PROC_BLOCKDEV_GETSZ,
(xdrproc_t) xdr_guestfs_blockdev_getsz_args, (char *) &args);
if (serial == -1)
return -1;
rv.cb_done = 0;
g->reply_cb_internal = blockdev_getsz_cb;
g->reply_cb_internal_data = &rv;
main_loop.main_loop_run (g);
g->reply_cb_internal = NULL;
g->reply_cb_internal_data = NULL;
if (!rv.cb_done) {
error (g, "guestfs_blockdev_getsz failed, see earlier error messages");
return -1;
}
if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_BLOCKDEV_GETSZ, serial) == -1)
return -1;
if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
error (g, "%s", rv.err.error);
return -1;
}
return rv.ret.sizeinsectors;
}
struct blockdev_getsize64_rv {
int cb_done; /* flag to indicate callback was called */
struct guestfs_message_header hdr;
struct guestfs_message_error err;
struct guestfs_blockdev_getsize64_ret ret;
};
static void blockdev_getsize64_cb (guestfs_h *g, void *data, XDR *xdr)
{
struct blockdev_getsize64_rv *rv = (struct blockdev_getsize64_rv *) data;
if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
error (g, "guestfs_blockdev_getsize64: failed to parse reply header");
return;
}
if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
if (!xdr_guestfs_message_error (xdr, &rv->err)) {
error (g, "guestfs_blockdev_getsize64: failed to parse reply error");
return;
}
goto done;
}
if (!xdr_guestfs_blockdev_getsize64_ret (xdr, &rv->ret)) {
error (g, "guestfs_blockdev_getsize64: failed to parse reply");
return;
}
done:
rv->cb_done = 1;
main_loop.main_loop_quit (g);
}
int64_t guestfs_blockdev_getsize64 (guestfs_h *g,
const char *device)
{
struct guestfs_blockdev_getsize64_args args;
struct blockdev_getsize64_rv rv;
int serial;
if (g->state != READY) {
error (g, "guestfs_blockdev_getsize64 called from the wrong state, %d != READY",
g->state);
return -1;
}
memset (&rv, 0, sizeof rv);
args.device = (char *) device;
serial = dispatch (g, GUESTFS_PROC_BLOCKDEV_GETSIZE64,
(xdrproc_t) xdr_guestfs_blockdev_getsize64_args, (char *) &args);
if (serial == -1)
return -1;
rv.cb_done = 0;
g->reply_cb_internal = blockdev_getsize64_cb;
g->reply_cb_internal_data = &rv;
main_loop.main_loop_run (g);
g->reply_cb_internal = NULL;
g->reply_cb_internal_data = NULL;
if (!rv.cb_done) {
error (g, "guestfs_blockdev_getsize64 failed, see earlier error messages");
return -1;
}
if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_BLOCKDEV_GETSIZE64, serial) == -1)
return -1;
if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
error (g, "%s", rv.err.error);
return -1;
}
return rv.ret.sizeinbytes;
}
struct blockdev_flushbufs_rv {
int cb_done; /* flag to indicate callback was called */
struct guestfs_message_header hdr;
struct guestfs_message_error err;
};
static void blockdev_flushbufs_cb (guestfs_h *g, void *data, XDR *xdr)
{
struct blockdev_flushbufs_rv *rv = (struct blockdev_flushbufs_rv *) data;
if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
error (g, "guestfs_blockdev_flushbufs: failed to parse reply header");
return;
}
if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
if (!xdr_guestfs_message_error (xdr, &rv->err)) {
error (g, "guestfs_blockdev_flushbufs: failed to parse reply error");
return;
}
goto done;
}
done:
rv->cb_done = 1;
main_loop.main_loop_quit (g);
}
int guestfs_blockdev_flushbufs (guestfs_h *g,
const char *device)
{
struct guestfs_blockdev_flushbufs_args args;
struct blockdev_flushbufs_rv rv;
int serial;
if (g->state != READY) {
error (g, "guestfs_blockdev_flushbufs called from the wrong state, %d != READY",
g->state);
return -1;
}
memset (&rv, 0, sizeof rv);
args.device = (char *) device;
serial = dispatch (g, GUESTFS_PROC_BLOCKDEV_FLUSHBUFS,
(xdrproc_t) xdr_guestfs_blockdev_flushbufs_args, (char *) &args);
if (serial == -1)
return -1;
rv.cb_done = 0;
g->reply_cb_internal = blockdev_flushbufs_cb;
g->reply_cb_internal_data = &rv;
main_loop.main_loop_run (g);
g->reply_cb_internal = NULL;
g->reply_cb_internal_data = NULL;
if (!rv.cb_done) {
error (g, "guestfs_blockdev_flushbufs failed, see earlier error messages");
return -1;
}
if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_BLOCKDEV_FLUSHBUFS, serial) == -1)
return -1;
if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
error (g, "%s", rv.err.error);
return -1;
}
return 0;
}
struct blockdev_rereadpt_rv {
int cb_done; /* flag to indicate callback was called */
struct guestfs_message_header hdr;
struct guestfs_message_error err;
};
static void blockdev_rereadpt_cb (guestfs_h *g, void *data, XDR *xdr)
{
struct blockdev_rereadpt_rv *rv = (struct blockdev_rereadpt_rv *) data;
if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
error (g, "guestfs_blockdev_rereadpt: failed to parse reply header");
return;
}
if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
if (!xdr_guestfs_message_error (xdr, &rv->err)) {
error (g, "guestfs_blockdev_rereadpt: failed to parse reply error");
return;
}
goto done;
}
done:
rv->cb_done = 1;
main_loop.main_loop_quit (g);
}
int guestfs_blockdev_rereadpt (guestfs_h *g,
const char *device)
{
struct guestfs_blockdev_rereadpt_args args;
struct blockdev_rereadpt_rv rv;
int serial;
if (g->state != READY) {
error (g, "guestfs_blockdev_rereadpt called from the wrong state, %d != READY",
g->state);
return -1;
}
memset (&rv, 0, sizeof rv);
args.device = (char *) device;
serial = dispatch (g, GUESTFS_PROC_BLOCKDEV_REREADPT,
(xdrproc_t) xdr_guestfs_blockdev_rereadpt_args, (char *) &args);
if (serial == -1)
return -1;
rv.cb_done = 0;
g->reply_cb_internal = blockdev_rereadpt_cb;
g->reply_cb_internal_data = &rv;
main_loop.main_loop_run (g);
g->reply_cb_internal = NULL;
g->reply_cb_internal_data = NULL;
if (!rv.cb_done) {
error (g, "guestfs_blockdev_rereadpt failed, see earlier error messages");
return -1;
}
if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_BLOCKDEV_REREADPT, serial) == -1)
return -1;
if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
error (g, "%s", rv.err.error);
return -1;
}
return 0;
}

10
src/guestfs-actions.h
View File

@@ -86,3 +86,13 @@ extern struct guestfs_stat *guestfs_stat (guestfs_h *handle, const char *path);
extern struct guestfs_stat *guestfs_lstat (guestfs_h *handle, const char *path);
extern struct guestfs_statvfs *guestfs_statvfs (guestfs_h *handle, const char *path);
extern char **guestfs_tune2fs_l (guestfs_h *handle, const char *device);
extern int guestfs_blockdev_setro (guestfs_h *handle, const char *device);
extern int guestfs_blockdev_setrw (guestfs_h *handle, const char *device);
extern int guestfs_blockdev_getro (guestfs_h *handle, const char *device);
extern int guestfs_blockdev_getss (guestfs_h *handle, const char *device);
extern int guestfs_blockdev_getbsz (guestfs_h *handle, const char *device);
extern int guestfs_blockdev_setbsz (guestfs_h *handle, const char *device, int blocksize);
extern int64_t guestfs_blockdev_getsz (guestfs_h *handle, const char *device);
extern int64_t guestfs_blockdev_getsize64 (guestfs_h *handle, const char *device);
extern int guestfs_blockdev_flushbufs (guestfs_h *handle, const char *device);
extern int guestfs_blockdev_rereadpt (guestfs_h *handle, const char *device);

152
src/guestfs_protocol.c
View File

@@ -1034,6 +1034,158 @@ xdr_guestfs_tune2fs_l_ret (XDR *xdrs, guestfs_tune2fs_l_ret *objp)
return TRUE;
}
bool_t
xdr_guestfs_blockdev_setro_args (XDR *xdrs, guestfs_blockdev_setro_args *objp)
{
register int32_t *buf;
if (!xdr_string (xdrs, &objp->device, ~0))
return FALSE;
return TRUE;
}
bool_t
xdr_guestfs_blockdev_setrw_args (XDR *xdrs, guestfs_blockdev_setrw_args *objp)
{
register int32_t *buf;
if (!xdr_string (xdrs, &objp->device, ~0))
return FALSE;
return TRUE;
}
bool_t
xdr_guestfs_blockdev_getro_args (XDR *xdrs, guestfs_blockdev_getro_args *objp)
{
register int32_t *buf;
if (!xdr_string (xdrs, &objp->device, ~0))
return FALSE;
return TRUE;
}
bool_t
xdr_guestfs_blockdev_getro_ret (XDR *xdrs, guestfs_blockdev_getro_ret *objp)
{
register int32_t *buf;
if (!xdr_bool (xdrs, &objp->ro))
return FALSE;
return TRUE;
}
bool_t
xdr_guestfs_blockdev_getss_args (XDR *xdrs, guestfs_blockdev_getss_args *objp)
{
register int32_t *buf;
if (!xdr_string (xdrs, &objp->device, ~0))
return FALSE;
return TRUE;
}
bool_t
xdr_guestfs_blockdev_getss_ret (XDR *xdrs, guestfs_blockdev_getss_ret *objp)
{
register int32_t *buf;
if (!xdr_int (xdrs, &objp->sectorsize))
return FALSE;
return TRUE;
}
bool_t
xdr_guestfs_blockdev_getbsz_args (XDR *xdrs, guestfs_blockdev_getbsz_args *objp)
{
register int32_t *buf;
if (!xdr_string (xdrs, &objp->device, ~0))
return FALSE;
return TRUE;
}
bool_t
xdr_guestfs_blockdev_getbsz_ret (XDR *xdrs, guestfs_blockdev_getbsz_ret *objp)
{
register int32_t *buf;
if (!xdr_int (xdrs, &objp->blocksize))
return FALSE;
return TRUE;
}
bool_t
xdr_guestfs_blockdev_setbsz_args (XDR *xdrs, guestfs_blockdev_setbsz_args *objp)
{
register int32_t *buf;
if (!xdr_string (xdrs, &objp->device, ~0))
return FALSE;
if (!xdr_int (xdrs, &objp->blocksize))
return FALSE;
return TRUE;
}
bool_t
xdr_guestfs_blockdev_getsz_args (XDR *xdrs, guestfs_blockdev_getsz_args *objp)
{
register int32_t *buf;
if (!xdr_string (xdrs, &objp->device, ~0))
return FALSE;
return TRUE;
}
bool_t
xdr_guestfs_blockdev_getsz_ret (XDR *xdrs, guestfs_blockdev_getsz_ret *objp)
{
register int32_t *buf;
if (!xdr_quad_t (xdrs, &objp->sizeinsectors))
return FALSE;
return TRUE;
}
bool_t
xdr_guestfs_blockdev_getsize64_args (XDR *xdrs, guestfs_blockdev_getsize64_args *objp)
{
register int32_t *buf;
if (!xdr_string (xdrs, &objp->device, ~0))
return FALSE;
return TRUE;
}
bool_t
xdr_guestfs_blockdev_getsize64_ret (XDR *xdrs, guestfs_blockdev_getsize64_ret *objp)
{
register int32_t *buf;
if (!xdr_quad_t (xdrs, &objp->sizeinbytes))
return FALSE;
return TRUE;
}
bool_t
xdr_guestfs_blockdev_flushbufs_args (XDR *xdrs, guestfs_blockdev_flushbufs_args *objp)
{
register int32_t *buf;
if (!xdr_string (xdrs, &objp->device, ~0))
return FALSE;
return TRUE;
}
bool_t
xdr_guestfs_blockdev_rereadpt_args (XDR *xdrs, guestfs_blockdev_rereadpt_args *objp)
{
register int32_t *buf;
if (!xdr_string (xdrs, &objp->device, ~0))
return FALSE;
return TRUE;
}
bool_t
xdr_guestfs_procedure (XDR *xdrs, guestfs_procedure *objp)
{

118
src/guestfs_protocol.h
View File

@@ -540,6 +540,82 @@ struct guestfs_tune2fs_l_ret {
};
typedef struct guestfs_tune2fs_l_ret guestfs_tune2fs_l_ret;
struct guestfs_blockdev_setro_args {
char *device;
};
typedef struct guestfs_blockdev_setro_args guestfs_blockdev_setro_args;
struct guestfs_blockdev_setrw_args {
char *device;
};
typedef struct guestfs_blockdev_setrw_args guestfs_blockdev_setrw_args;
struct guestfs_blockdev_getro_args {
char *device;
};
typedef struct guestfs_blockdev_getro_args guestfs_blockdev_getro_args;
struct guestfs_blockdev_getro_ret {
bool_t ro;
};
typedef struct guestfs_blockdev_getro_ret guestfs_blockdev_getro_ret;
struct guestfs_blockdev_getss_args {
char *device;
};
typedef struct guestfs_blockdev_getss_args guestfs_blockdev_getss_args;
struct guestfs_blockdev_getss_ret {
int sectorsize;
};
typedef struct guestfs_blockdev_getss_ret guestfs_blockdev_getss_ret;
struct guestfs_blockdev_getbsz_args {
char *device;
};
typedef struct guestfs_blockdev_getbsz_args guestfs_blockdev_getbsz_args;
struct guestfs_blockdev_getbsz_ret {
int blocksize;
};
typedef struct guestfs_blockdev_getbsz_ret guestfs_blockdev_getbsz_ret;
struct guestfs_blockdev_setbsz_args {
char *device;
int blocksize;
};
typedef struct guestfs_blockdev_setbsz_args guestfs_blockdev_setbsz_args;
struct guestfs_blockdev_getsz_args {
char *device;
};
typedef struct guestfs_blockdev_getsz_args guestfs_blockdev_getsz_args;
struct guestfs_blockdev_getsz_ret {
quad_t sizeinsectors;
};
typedef struct guestfs_blockdev_getsz_ret guestfs_blockdev_getsz_ret;
struct guestfs_blockdev_getsize64_args {
char *device;
};
typedef struct guestfs_blockdev_getsize64_args guestfs_blockdev_getsize64_args;
struct guestfs_blockdev_getsize64_ret {
quad_t sizeinbytes;
};
typedef struct guestfs_blockdev_getsize64_ret guestfs_blockdev_getsize64_ret;
struct guestfs_blockdev_flushbufs_args {
char *device;
};
typedef struct guestfs_blockdev_flushbufs_args guestfs_blockdev_flushbufs_args;
struct guestfs_blockdev_rereadpt_args {
char *device;
};
typedef struct guestfs_blockdev_rereadpt_args guestfs_blockdev_rereadpt_args;
enum guestfs_procedure {
GUESTFS_PROC_MOUNT = 1,
GUESTFS_PROC_SYNC = 2,
@@ -596,7 +672,17 @@ enum guestfs_procedure {
GUESTFS_PROC_LSTAT = 53,
GUESTFS_PROC_STATVFS = 54,
GUESTFS_PROC_TUNE2FS_L = 55,
GUESTFS_PROC_dummy = 55 + 1,
GUESTFS_PROC_BLOCKDEV_SETRO = 56,
GUESTFS_PROC_BLOCKDEV_SETRW = 57,
GUESTFS_PROC_BLOCKDEV_GETRO = 58,
GUESTFS_PROC_BLOCKDEV_GETSS = 59,
GUESTFS_PROC_BLOCKDEV_GETBSZ = 60,
GUESTFS_PROC_BLOCKDEV_SETBSZ = 61,
GUESTFS_PROC_BLOCKDEV_GETSZ = 62,
GUESTFS_PROC_BLOCKDEV_GETSIZE64 = 63,
GUESTFS_PROC_BLOCKDEV_FLUSHBUFS = 64,
GUESTFS_PROC_BLOCKDEV_REREADPT = 65,
GUESTFS_PROC_dummy = 65 + 1,
};
typedef enum guestfs_procedure guestfs_procedure;
#define GUESTFS_MESSAGE_MAX 4194304
@@ -712,6 +798,21 @@ extern bool_t xdr_guestfs_statvfs_args (XDR *, guestfs_statvfs_args*);
extern bool_t xdr_guestfs_statvfs_ret (XDR *, guestfs_statvfs_ret*);
extern bool_t xdr_guestfs_tune2fs_l_args (XDR *, guestfs_tune2fs_l_args*);
extern bool_t xdr_guestfs_tune2fs_l_ret (XDR *, guestfs_tune2fs_l_ret*);
extern bool_t xdr_guestfs_blockdev_setro_args (XDR *, guestfs_blockdev_setro_args*);
extern bool_t xdr_guestfs_blockdev_setrw_args (XDR *, guestfs_blockdev_setrw_args*);
extern bool_t xdr_guestfs_blockdev_getro_args (XDR *, guestfs_blockdev_getro_args*);
extern bool_t xdr_guestfs_blockdev_getro_ret (XDR *, guestfs_blockdev_getro_ret*);
extern bool_t xdr_guestfs_blockdev_getss_args (XDR *, guestfs_blockdev_getss_args*);
extern bool_t xdr_guestfs_blockdev_getss_ret (XDR *, guestfs_blockdev_getss_ret*);
extern bool_t xdr_guestfs_blockdev_getbsz_args (XDR *, guestfs_blockdev_getbsz_args*);
extern bool_t xdr_guestfs_blockdev_getbsz_ret (XDR *, guestfs_blockdev_getbsz_ret*);
extern bool_t xdr_guestfs_blockdev_setbsz_args (XDR *, guestfs_blockdev_setbsz_args*);
extern bool_t xdr_guestfs_blockdev_getsz_args (XDR *, guestfs_blockdev_getsz_args*);
extern bool_t xdr_guestfs_blockdev_getsz_ret (XDR *, guestfs_blockdev_getsz_ret*);
extern bool_t xdr_guestfs_blockdev_getsize64_args (XDR *, guestfs_blockdev_getsize64_args*);
extern bool_t xdr_guestfs_blockdev_getsize64_ret (XDR *, guestfs_blockdev_getsize64_ret*);
extern bool_t xdr_guestfs_blockdev_flushbufs_args (XDR *, guestfs_blockdev_flushbufs_args*);
extern bool_t xdr_guestfs_blockdev_rereadpt_args (XDR *, guestfs_blockdev_rereadpt_args*);
extern bool_t xdr_guestfs_procedure (XDR *, guestfs_procedure*);
extern bool_t xdr_guestfs_message_direction (XDR *, guestfs_message_direction*);
extern bool_t xdr_guestfs_message_status (XDR *, guestfs_message_status*);
@@ -797,6 +898,21 @@ extern bool_t xdr_guestfs_statvfs_args ();
extern bool_t xdr_guestfs_statvfs_ret ();
extern bool_t xdr_guestfs_tune2fs_l_args ();
extern bool_t xdr_guestfs_tune2fs_l_ret ();
extern bool_t xdr_guestfs_blockdev_setro_args ();
extern bool_t xdr_guestfs_blockdev_setrw_args ();
extern bool_t xdr_guestfs_blockdev_getro_args ();
extern bool_t xdr_guestfs_blockdev_getro_ret ();
extern bool_t xdr_guestfs_blockdev_getss_args ();
extern bool_t xdr_guestfs_blockdev_getss_ret ();
extern bool_t xdr_guestfs_blockdev_getbsz_args ();
extern bool_t xdr_guestfs_blockdev_getbsz_ret ();
extern bool_t xdr_guestfs_blockdev_setbsz_args ();
extern bool_t xdr_guestfs_blockdev_getsz_args ();
extern bool_t xdr_guestfs_blockdev_getsz_ret ();
extern bool_t xdr_guestfs_blockdev_getsize64_args ();
extern bool_t xdr_guestfs_blockdev_getsize64_ret ();
extern bool_t xdr_guestfs_blockdev_flushbufs_args ();
extern bool_t xdr_guestfs_blockdev_rereadpt_args ();
extern bool_t xdr_guestfs_procedure ();
extern bool_t xdr_guestfs_message_direction ();
extern bool_t xdr_guestfs_message_status ();

71
src/guestfs_protocol.x
View File

@@ -414,6 +414,67 @@ struct guestfs_tune2fs_l_ret {
str superblock<>;
};
struct guestfs_blockdev_setro_args {
string device<>;
};
struct guestfs_blockdev_setrw_args {
string device<>;
};
struct guestfs_blockdev_getro_args {
string device<>;
};
struct guestfs_blockdev_getro_ret {
bool ro;
};
struct guestfs_blockdev_getss_args {
string device<>;
};
struct guestfs_blockdev_getss_ret {
int sectorsize;
};
struct guestfs_blockdev_getbsz_args {
string device<>;
};
struct guestfs_blockdev_getbsz_ret {
int blocksize;
};
struct guestfs_blockdev_setbsz_args {
string device<>;
int blocksize;
};
struct guestfs_blockdev_getsz_args {
string device<>;
};
struct guestfs_blockdev_getsz_ret {
hyper sizeinsectors;
};
struct guestfs_blockdev_getsize64_args {
string device<>;
};
struct guestfs_blockdev_getsize64_ret {
hyper sizeinbytes;
};
struct guestfs_blockdev_flushbufs_args {
string device<>;
};
struct guestfs_blockdev_rereadpt_args {
string device<>;
};
enum guestfs_procedure {
GUESTFS_PROC_MOUNT = 1,
GUESTFS_PROC_SYNC = 2,
@@ -470,6 +531,16 @@ enum guestfs_procedure {
GUESTFS_PROC_LSTAT = 53,
GUESTFS_PROC_STATVFS = 54,
GUESTFS_PROC_TUNE2FS_L = 55,
GUESTFS_PROC_BLOCKDEV_SETRO = 56,
GUESTFS_PROC_BLOCKDEV_SETRW = 57,
GUESTFS_PROC_BLOCKDEV_GETRO = 58,
GUESTFS_PROC_BLOCKDEV_GETSS = 59,
GUESTFS_PROC_BLOCKDEV_GETBSZ = 60,
GUESTFS_PROC_BLOCKDEV_SETBSZ = 61,
GUESTFS_PROC_BLOCKDEV_GETSZ = 62,
GUESTFS_PROC_BLOCKDEV_GETSIZE64 = 63,
GUESTFS_PROC_BLOCKDEV_FLUSHBUFS = 64,
GUESTFS_PROC_BLOCKDEV_REREADPT = 65,
GUESTFS_PROC_dummy
};

6236
tests.c
View File

File diff suppressed because it is too large Load Diff