← Back to branch summary

~serge-hallyn/ubuntu/raring/libvirt/libvirt-hugepages

« back to all changes in this revision

Viewing changes to src/remote/remote_client_bodies.h

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2012-05-13 15:44:12 UTC
  • mfrom: (1.2.13)
  • Revision ID: package-import@ubuntu.com-20120513154412-fgmn5sxqdzgnzlx3
Tags: 0.9.12-0ubuntu1
* New upstream version:
  * Synchronize with debian packaging:
    - debian/control: Update build depends.
    - debian/libvirt-bin.postrm: Cleanup /var/log/libvirt
      on purge.
    - Bump standards verson (no changes).
    - debian/patches/Don-t-fail-if-we-can-t-setup-avahi.patch: Added
  * Dropped patches:
    - debian/patches/Debianize-libvirt-guests.patch
    - debian/patches/rewrite-lxc-controller-eof-handling-yet-again
    - debian/patches/ubuntu/libnl13.patch
    - debian/patches/ubuntu/fix-lxc-startup-error.patch
    - debian/patches/ubuntu/fix-bridge-fd.patch
    - debian/patches/ubuntu/skip-labelling-network-disks.patch
    - debian/patches/ubuntu/xen-xend-shutdown-detection.patch
    - debian/patches/ubuntu/xen-config-no-vfb-for-hvm.patch
    - debian/patches/debian/Disable-daemon-start-test.patch
    - debian/patches/debian/Disable-gnulib-s-test-nonplocking-pipe.sh.patch
    - debian/patches/ubuntu/9006-default-config-test-case.patch
    - debian/patches/fix-block-migration.patch
    - debian/patches/ubuntu/9022-qemu-unescape-HMP-commands-before-converting-them-to.patch
    - debian/patches/ubuntu/9023-qemu-change-rbd-auth_supported-separation-character-.patch
    - debian/patches/ubuntu/9024-qemu-allow-snapshotting-of-sheepdog-and-rbd-disks.patch
    - debian/patches/9025-qemu-change-rbd-auth_supported-separation-character-.patch
    - debian/patches/ubuntu/arm-gcc-workaround.patch
  * Rediffed:
    - debian/patches/Allow-libvirt-group-to-access-the-socket.patch
    - debian/patches/Disable-failing-virnetsockettest.patch
    - debian/patches/dnsmasq-as-priv-user
    - debian/patches/9002-better_default_uri_virsh.patch
  * debian/control: Add libnl-route-3-dev ass a build depends.
  * debian/patches/libnl3-build-fix.patch: Fix build with libnl3.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/remote/remote_client_bodies.h
23
23
    args.xmlCPUs.xmlCPUs_len = xmlCPUslen;
24
24
    args.flags = flags;
25
25
 
26
 
    memset(&ret, 0, sizeof ret);
 
26
    memset(&ret, 0, sizeof(ret));
27
27
 
28
28
    if (call(conn, priv, 0, REMOTE_PROC_CPU_BASELINE,
29
29
             (xdrproc_t)xdr_remote_cpu_baseline_args, (char *)&args,
51
51
    args.xml = (char *)xml;
52
52
    args.flags = flags;
53
53
 
54
 
    memset(&ret, 0, sizeof ret);
 
54
    memset(&ret, 0, sizeof(ret));
55
55
 
56
56
    if (call(conn, priv, 0, REMOTE_PROC_CPU_COMPARE,
57
57
             (xdrproc_t)xdr_remote_cpu_compare_args, (char *)&args,
222
222
}
223
223
 
224
224
static int
 
225
remoteDomainBlockRebase(virDomainPtr dom, const char *path, const char *base, unsigned long bandwidth, unsigned int flags)
 
226
{
 
227
    int rv = -1;
 
228
    struct private_data *priv = dom->conn->privateData;
 
229
    remote_domain_block_rebase_args args;
 
230
 
 
231
    remoteDriverLock(priv);
 
232
 
 
233
    make_nonnull_domain(&args.dom, dom);
 
234
    args.path = (char *)path;
 
235
    args.base = base ? (char **)&base : NULL;
 
236
    args.bandwidth = bandwidth;
 
237
    args.flags = flags;
 
238
 
 
239
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_BLOCK_REBASE,
 
240
             (xdrproc_t)xdr_remote_domain_block_rebase_args, (char *)&args,
 
241
             (xdrproc_t)xdr_void, (char *)NULL) == -1) {
 
242
        goto done;
 
243
    }
 
244
 
 
245
    rv = 0;
 
246
 
 
247
done:
 
248
    remoteDriverUnlock(priv);
 
249
    return rv;
 
250
}
 
251
 
 
252
static int
225
253
remoteDomainBlockResize(virDomainPtr dom, const char *disk, unsigned long long size, unsigned int flags)
226
254
{
227
255
    int rv = -1;
261
289
    make_nonnull_domain(&args.dom, dom);
262
290
    args.path = (char *)path;
263
291
 
264
 
    memset(&ret, 0, sizeof ret);
 
292
    memset(&ret, 0, sizeof(ret));
265
293
 
266
294
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_BLOCK_STATS,
267
295
             (xdrproc_t)xdr_remote_domain_block_stats_args, (char *)&args,
320
348
    make_nonnull_domain(&args.dom, dom);
321
349
    args.flags = flags;
322
350
 
323
 
    memset(&ret, 0, sizeof ret);
 
351
    memset(&ret, 0, sizeof(ret));
324
352
 
325
353
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_CREATE_WITH_FLAGS,
326
354
             (xdrproc_t)xdr_remote_domain_create_with_flags_args, (char *)&args,
350
378
    args.xml_desc = (char *)xml_desc;
351
379
    args.flags = flags;
352
380
 
353
 
    memset(&ret, 0, sizeof ret);
 
381
    memset(&ret, 0, sizeof(ret));
354
382
 
355
383
    if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_CREATE_XML,
356
384
             (xdrproc_t)xdr_remote_domain_create_xml_args, (char *)&args,
378
406
 
379
407
    args.xml = (char *)xml;
380
408
 
381
 
    memset(&ret, 0, sizeof ret);
 
409
    memset(&ret, 0, sizeof(ret));
382
410
 
383
411
    if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_DEFINE_XML,
384
412
             (xdrproc_t)xdr_remote_domain_define_xml_args, (char *)&args,
507
535
 
508
536
    make_nonnull_domain(&args.dom, dom);
509
537
 
510
 
    memset(&ret, 0, sizeof ret);
 
538
    memset(&ret, 0, sizeof(ret));
511
539
 
512
540
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_AUTOSTART,
513
541
             (xdrproc_t)xdr_remote_domain_get_autostart_args, (char *)&args,
537
565
    args.path = (char *)path;
538
566
    args.flags = flags;
539
567
 
540
 
    memset(&ret, 0, sizeof ret);
 
568
    memset(&ret, 0, sizeof(ret));
541
569
 
542
570
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_BLOCK_INFO,
543
571
             (xdrproc_t)xdr_remote_domain_get_block_info_args, (char *)&args,
568
596
    make_nonnull_domain(&args.dom, dom);
569
597
    args.flags = flags;
570
598
 
571
 
    memset(&ret, 0, sizeof ret);
 
599
    memset(&ret, 0, sizeof(ret));
572
600
 
573
601
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_CONTROL_INFO,
574
602
             (xdrproc_t)xdr_remote_domain_get_control_info_args, (char *)&args,
598
626
 
599
627
    make_nonnull_domain(&args.dom, dom);
600
628
 
601
 
    memset(&ret, 0, sizeof ret);
 
629
    memset(&ret, 0, sizeof(ret));
602
630
 
603
631
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_INFO,
604
632
             (xdrproc_t)xdr_remote_domain_get_info_args, (char *)&args,
630
658
 
631
659
    make_nonnull_domain(&args.dom, dom);
632
660
 
633
 
    memset(&ret, 0, sizeof ret);
 
661
    memset(&ret, 0, sizeof(ret));
634
662
 
635
663
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_JOB_INFO,
636
664
             (xdrproc_t)xdr_remote_domain_get_job_info_args, (char *)&args,
657
685
    return rv;
658
686
}
659
687
 
660
 
static unsigned long
 
688
static unsigned long long
661
689
remoteDomainGetMaxMemory(virDomainPtr dom)
662
690
{
663
 
    unsigned long rv = 0;
 
691
    unsigned long long rv = 0;
664
692
    struct private_data *priv = dom->conn->privateData;
665
693
    remote_domain_get_max_memory_args args;
666
694
    remote_domain_get_max_memory_ret ret;
669
697
 
670
698
    make_nonnull_domain(&args.dom, dom);
671
699
 
672
 
    memset(&ret, 0, sizeof ret);
 
700
    memset(&ret, 0, sizeof(ret));
673
701
 
674
702
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_MAX_MEMORY,
675
703
             (xdrproc_t)xdr_remote_domain_get_max_memory_args, (char *)&args,
677
705
        goto done;
678
706
    }
679
707
 
680
 
    HYPER_TO_ULONG(rv, ret.memory);
 
708
    rv = ret.memory;
681
709
 
682
710
done:
683
711
    remoteDriverUnlock(priv);
696
724
 
697
725
    make_nonnull_domain(&args.dom, dom);
698
726
 
699
 
    memset(&ret, 0, sizeof ret);
 
727
    memset(&ret, 0, sizeof(ret));
700
728
 
701
729
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_MAX_VCPUS,
702
730
             (xdrproc_t)xdr_remote_domain_get_max_vcpus_args, (char *)&args,
712
740
}
713
741
 
714
742
static char *
 
743
remoteDomainGetMetadata(virDomainPtr dom, int type, const char *uri, unsigned int flags)
 
744
{
 
745
    char *rv = NULL;
 
746
    struct private_data *priv = dom->conn->privateData;
 
747
    remote_domain_get_metadata_args args;
 
748
    remote_domain_get_metadata_ret ret;
 
749
 
 
750
    remoteDriverLock(priv);
 
751
 
 
752
    make_nonnull_domain(&args.dom, dom);
 
753
    args.type = type;
 
754
    args.uri = uri ? (char **)&uri : NULL;
 
755
    args.flags = flags;
 
756
 
 
757
    memset(&ret, 0, sizeof(ret));
 
758
 
 
759
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_METADATA,
 
760
             (xdrproc_t)xdr_remote_domain_get_metadata_args, (char *)&args,
 
761
             (xdrproc_t)xdr_remote_domain_get_metadata_ret, (char *)&ret) == -1) {
 
762
        goto done;
 
763
    }
 
764
 
 
765
    rv = ret.metadata;
 
766
 
 
767
done:
 
768
    remoteDriverUnlock(priv);
 
769
    return rv;
 
770
}
 
771
 
 
772
static char *
715
773
remoteDomainGetOSType(virDomainPtr dom)
716
774
{
717
775
    char *rv = NULL;
723
781
 
724
782
    make_nonnull_domain(&args.dom, dom);
725
783
 
726
 
    memset(&ret, 0, sizeof ret);
 
784
    memset(&ret, 0, sizeof(ret));
727
785
 
728
786
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_OS_TYPE,
729
787
             (xdrproc_t)xdr_remote_domain_get_os_type_args, (char *)&args,
751
809
    make_nonnull_domain(&args.dom, dom);
752
810
    args.nparams = *nparams;
753
811
 
754
 
    memset(&ret, 0, sizeof ret);
 
812
    memset(&ret, 0, sizeof(ret));
755
813
 
756
814
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_SCHEDULER_PARAMETERS,
757
815
             (xdrproc_t)xdr_remote_domain_get_scheduler_parameters_args, (char *)&args,
790
848
    args.nparams = *nparams;
791
849
    args.flags = flags;
792
850
 
793
 
    memset(&ret, 0, sizeof ret);
 
851
    memset(&ret, 0, sizeof(ret));
794
852
 
795
853
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_SCHEDULER_PARAMETERS_FLAGS,
796
854
             (xdrproc_t)xdr_remote_domain_get_scheduler_parameters_flags_args, (char *)&args,
828
886
    make_nonnull_domain(&args.dom, dom);
829
887
    args.flags = flags;
830
888
 
831
 
    memset(&ret, 0, sizeof ret);
 
889
    memset(&ret, 0, sizeof(ret));
832
890
 
833
891
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_VCPUS_FLAGS,
834
892
             (xdrproc_t)xdr_remote_domain_get_vcpus_flags_args, (char *)&args,
856
914
    make_nonnull_domain(&args.dom, dom);
857
915
    args.flags = flags;
858
916
 
859
 
    memset(&ret, 0, sizeof ret);
 
917
    memset(&ret, 0, sizeof(ret));
860
918
 
861
919
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_XML_DESC,
862
920
             (xdrproc_t)xdr_remote_domain_get_xml_desc_args, (char *)&args,
884
942
    make_nonnull_domain(&args.dom, dom);
885
943
    args.flags = flags;
886
944
 
887
 
    memset(&ret, 0, sizeof ret);
 
945
    memset(&ret, 0, sizeof(ret));
888
946
 
889
947
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_HAS_CURRENT_SNAPSHOT,
890
948
             (xdrproc_t)xdr_remote_domain_has_current_snapshot_args, (char *)&args,
912
970
    make_nonnull_domain(&args.dom, dom);
913
971
    args.flags = flags;
914
972
 
915
 
    memset(&ret, 0, sizeof ret);
 
973
    memset(&ret, 0, sizeof(ret));
916
974
 
917
975
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_HAS_MANAGED_SAVE_IMAGE,
918
976
             (xdrproc_t)xdr_remote_domain_has_managed_save_image_args, (char *)&args,
965
1023
    make_nonnull_domain(&args.dom, dom);
966
1024
    args.path = (char *)path;
967
1025
 
968
 
    memset(&ret, 0, sizeof ret);
 
1026
    memset(&ret, 0, sizeof(ret));
969
1027
 
970
1028
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_INTERFACE_STATS,
971
1029
             (xdrproc_t)xdr_remote_domain_interface_stats_args, (char *)&args,
1000
1058
 
1001
1059
    make_nonnull_domain(&args.dom, dom);
1002
1060
 
1003
 
    memset(&ret, 0, sizeof ret);
 
1061
    memset(&ret, 0, sizeof(ret));
1004
1062
 
1005
1063
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_IS_ACTIVE,
1006
1064
             (xdrproc_t)xdr_remote_domain_is_active_args, (char *)&args,
1027
1085
 
1028
1086
    make_nonnull_domain(&args.dom, dom);
1029
1087
 
1030
 
    memset(&ret, 0, sizeof ret);
 
1088
    memset(&ret, 0, sizeof(ret));
1031
1089
 
1032
1090
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_IS_PERSISTENT,
1033
1091
             (xdrproc_t)xdr_remote_domain_is_persistent_args, (char *)&args,
1054
1112
 
1055
1113
    make_nonnull_domain(&args.dom, dom);
1056
1114
 
1057
 
    memset(&ret, 0, sizeof ret);
 
1115
    memset(&ret, 0, sizeof(ret));
1058
1116
 
1059
1117
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_IS_UPDATED,
1060
1118
             (xdrproc_t)xdr_remote_domain_is_updated_args, (char *)&args,
1081
1139
 
1082
1140
    args.id = id;
1083
1141
 
1084
 
    memset(&ret, 0, sizeof ret);
 
1142
    memset(&ret, 0, sizeof(ret));
1085
1143
 
1086
1144
    if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_LOOKUP_BY_ID,
1087
1145
             (xdrproc_t)xdr_remote_domain_lookup_by_id_args, (char *)&args,
1109
1167
 
1110
1168
    args.name = (char *)name;
1111
1169
 
1112
 
    memset(&ret, 0, sizeof ret);
 
1170
    memset(&ret, 0, sizeof(ret));
1113
1171
 
1114
1172
    if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_LOOKUP_BY_NAME,
1115
1173
             (xdrproc_t)xdr_remote_domain_lookup_by_name_args, (char *)&args,
1137
1195
 
1138
1196
    memcpy(args.uuid, uuid, VIR_UUID_BUFLEN);
1139
1197
 
1140
 
    memset(&ret, 0, sizeof ret);
 
1198
    memset(&ret, 0, sizeof(ret));
1141
1199
 
1142
1200
    if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_LOOKUP_BY_UUID,
1143
1201
             (xdrproc_t)xdr_remote_domain_lookup_by_uuid_args, (char *)&args,
1227
1285
    args.uri = (char *)uri;
1228
1286
    args.flags = flags;
1229
1287
 
1230
 
    memset(&ret, 0, sizeof ret);
 
1288
    memset(&ret, 0, sizeof(ret));
1231
1289
 
1232
1290
    if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_FINISH,
1233
1291
             (xdrproc_t)xdr_remote_domain_migrate_finish_args, (char *)&args,
1267
1325
    args.flags = flags;
1268
1326
    args.retcode = retcode;
1269
1327
 
1270
 
    memset(&ret, 0, sizeof ret);
 
1328
    memset(&ret, 0, sizeof(ret));
1271
1329
 
1272
1330
    if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_FINISH2,
1273
1331
             (xdrproc_t)xdr_remote_domain_migrate_finish2_args, (char *)&args,
1296
1354
    make_nonnull_domain(&args.dom, dom);
1297
1355
    args.flags = flags;
1298
1356
 
1299
 
    memset(&ret, 0, sizeof ret);
 
1357
    memset(&ret, 0, sizeof(ret));
1300
1358
 
1301
1359
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_GET_MAX_SPEED,
1302
1360
             (xdrproc_t)xdr_remote_domain_migrate_get_max_speed_args, (char *)&args,
1554
1612
}
1555
1613
 
1556
1614
static int
 
1615
remoteDomainPMSuspendForDuration(virDomainPtr dom, unsigned int target, unsigned long long duration, unsigned int flags)
 
1616
{
 
1617
    int rv = -1;
 
1618
    struct private_data *priv = dom->conn->privateData;
 
1619
    remote_domain_pm_suspend_for_duration_args args;
 
1620
 
 
1621
    remoteDriverLock(priv);
 
1622
 
 
1623
    make_nonnull_domain(&args.dom, dom);
 
1624
    args.target = target;
 
1625
    args.duration = duration;
 
1626
    args.flags = flags;
 
1627
 
 
1628
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_PM_SUSPEND_FOR_DURATION,
 
1629
             (xdrproc_t)xdr_remote_domain_pm_suspend_for_duration_args, (char *)&args,
 
1630
             (xdrproc_t)xdr_void, (char *)NULL) == -1) {
 
1631
        goto done;
 
1632
    }
 
1633
 
 
1634
    rv = 0;
 
1635
 
 
1636
done:
 
1637
    remoteDriverUnlock(priv);
 
1638
    return rv;
 
1639
}
 
1640
 
 
1641
static int
 
1642
remoteDomainPMWakeup(virDomainPtr dom, unsigned int flags)
 
1643
{
 
1644
    int rv = -1;
 
1645
    struct private_data *priv = dom->conn->privateData;
 
1646
    remote_domain_pm_wakeup_args args;
 
1647
 
 
1648
    remoteDriverLock(priv);
 
1649
 
 
1650
    make_nonnull_domain(&args.dom, dom);
 
1651
    args.flags = flags;
 
1652
 
 
1653
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_PM_WAKEUP,
 
1654
             (xdrproc_t)xdr_remote_domain_pm_wakeup_args, (char *)&args,
 
1655
             (xdrproc_t)xdr_void, (char *)NULL) == -1) {
 
1656
        goto done;
 
1657
    }
 
1658
 
 
1659
    rv = 0;
 
1660
 
 
1661
done:
 
1662
    remoteDriverUnlock(priv);
 
1663
    return rv;
 
1664
}
 
1665
 
 
1666
static int
1557
1667
remoteDomainReboot(virDomainPtr dom, unsigned int flags)
1558
1668
{
1559
1669
    int rv = -1;
1794
1904
    args.file = (char *)file;
1795
1905
    args.flags = flags;
1796
1906
 
1797
 
    memset(&ret, 0, sizeof ret);
 
1907
    memset(&ret, 0, sizeof(ret));
1798
1908
 
1799
1909
    if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_SAVE_IMAGE_GET_XML_DESC,
1800
1910
             (xdrproc_t)xdr_remote_domain_save_image_get_xml_desc_args, (char *)&args,
1834
1944
    args.screen = screen;
1835
1945
    args.flags = flags;
1836
1946
 
1837
 
    memset(&ret, 0, sizeof ret);
 
1947
    memset(&ret, 0, sizeof(ret));
1838
1948
 
1839
1949
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SCREENSHOT,
1840
1950
             (xdrproc_t)xdr_remote_domain_screenshot_args, (char *)&args,
1979
2089
}
1980
2090
 
1981
2091
static int
 
2092
remoteDomainSetInterfaceParameters(virDomainPtr dom, const char *device, virTypedParameterPtr params, int nparams, unsigned int flags)
 
2093
{
 
2094
    int rv = -1;
 
2095
    struct private_data *priv = dom->conn->privateData;
 
2096
    remote_domain_set_interface_parameters_args args;
 
2097
 
 
2098
    remoteDriverLock(priv);
 
2099
 
 
2100
    make_nonnull_domain(&args.dom, dom);
 
2101
    args.device = (char *)device;
 
2102
    args.flags = flags;
 
2103
 
 
2104
    if (remoteSerializeTypedParameters(params, nparams, &args.params.params_val, &args.params.params_len) < 0) {
 
2105
        xdr_free((xdrproc_t)xdr_remote_domain_set_interface_parameters_args, (char *)&args);
 
2106
        goto done;
 
2107
    }
 
2108
 
 
2109
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_INTERFACE_PARAMETERS,
 
2110
             (xdrproc_t)xdr_remote_domain_set_interface_parameters_args, (char *)&args,
 
2111
             (xdrproc_t)xdr_void, (char *)NULL) == -1) {
 
2112
        goto done;
 
2113
    }
 
2114
 
 
2115
    rv = 0;
 
2116
 
 
2117
done:
 
2118
    remoteFreeTypedParameters(args.params.params_val, args.params.params_len);
 
2119
    remoteDriverUnlock(priv);
 
2120
    return rv;
 
2121
}
 
2122
 
 
2123
static int
1982
2124
remoteDomainSetMaxMemory(virDomainPtr dom, unsigned long memory)
1983
2125
{
1984
2126
    int rv = -1;
2086
2228
}
2087
2229
 
2088
2230
static int
 
2231
remoteDomainSetMetadata(virDomainPtr dom, int type, const char *metadata, const char *key, const char *uri, unsigned int flags)
 
2232
{
 
2233
    int rv = -1;
 
2234
    struct private_data *priv = dom->conn->privateData;
 
2235
    remote_domain_set_metadata_args args;
 
2236
 
 
2237
    remoteDriverLock(priv);
 
2238
 
 
2239
    make_nonnull_domain(&args.dom, dom);
 
2240
    args.type = type;
 
2241
    args.metadata = metadata ? (char **)&metadata : NULL;
 
2242
    args.key = key ? (char **)&key : NULL;
 
2243
    args.uri = uri ? (char **)&uri : NULL;
 
2244
    args.flags = flags;
 
2245
 
 
2246
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_METADATA,
 
2247
             (xdrproc_t)xdr_remote_domain_set_metadata_args, (char *)&args,
 
2248
             (xdrproc_t)xdr_void, (char *)NULL) == -1) {
 
2249
        goto done;
 
2250
    }
 
2251
 
 
2252
    rv = 0;
 
2253
 
 
2254
done:
 
2255
    remoteDriverUnlock(priv);
 
2256
    return rv;
 
2257
}
 
2258
 
 
2259
static int
 
2260
remoteDomainSetNumaParameters(virDomainPtr dom, virTypedParameterPtr params, int nparams, unsigned int flags)
 
2261
{
 
2262
    int rv = -1;
 
2263
    struct private_data *priv = dom->conn->privateData;
 
2264
    remote_domain_set_numa_parameters_args args;
 
2265
 
 
2266
    remoteDriverLock(priv);
 
2267
 
 
2268
    make_nonnull_domain(&args.dom, dom);
 
2269
    args.flags = flags;
 
2270
 
 
2271
    if (remoteSerializeTypedParameters(params, nparams, &args.params.params_val, &args.params.params_len) < 0) {
 
2272
        xdr_free((xdrproc_t)xdr_remote_domain_set_numa_parameters_args, (char *)&args);
 
2273
        goto done;
 
2274
    }
 
2275
 
 
2276
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_NUMA_PARAMETERS,
 
2277
             (xdrproc_t)xdr_remote_domain_set_numa_parameters_args, (char *)&args,
 
2278
             (xdrproc_t)xdr_void, (char *)NULL) == -1) {
 
2279
        goto done;
 
2280
    }
 
2281
 
 
2282
    rv = 0;
 
2283
 
 
2284
done:
 
2285
    remoteFreeTypedParameters(args.params.params_val, args.params.params_len);
 
2286
    remoteDriverUnlock(priv);
 
2287
    return rv;
 
2288
}
 
2289
 
 
2290
static int
2089
2291
remoteDomainSetSchedulerParameters(virDomainPtr dom, virTypedParameterPtr params, int nparams)
2090
2292
{
2091
2293
    int rv = -1;
2221
2423
    return rv;
2222
2424
}
2223
2425
 
 
2426
static int
 
2427
remoteDomainShutdownFlags(virDomainPtr dom, unsigned int flags)
 
2428
{
 
2429
    int rv = -1;
 
2430
    struct private_data *priv = dom->conn->privateData;
 
2431
    remote_domain_shutdown_flags_args args;
 
2432
 
 
2433
    remoteDriverLock(priv);
 
2434
 
 
2435
    make_nonnull_domain(&args.dom, dom);
 
2436
    args.flags = flags;
 
2437
 
 
2438
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SHUTDOWN_FLAGS,
 
2439
             (xdrproc_t)xdr_remote_domain_shutdown_flags_args, (char *)&args,
 
2440
             (xdrproc_t)xdr_void, (char *)NULL) == -1) {
 
2441
        goto done;
 
2442
    }
 
2443
 
 
2444
    rv = 0;
 
2445
 
 
2446
done:
 
2447
    remoteDriverUnlock(priv);
 
2448
    return rv;
 
2449
}
 
2450
 
2224
2451
static virDomainSnapshotPtr
2225
2452
remoteDomainSnapshotCreateXML(virDomainPtr dom, const char *xml_desc, unsigned int flags)
2226
2453
{
2235
2462
    args.xml_desc = (char *)xml_desc;
2236
2463
    args.flags = flags;
2237
2464
 
2238
 
    memset(&ret, 0, sizeof ret);
 
2465
    memset(&ret, 0, sizeof(ret));
2239
2466
 
2240
2467
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_CREATE_XML,
2241
2468
             (xdrproc_t)xdr_remote_domain_snapshot_create_xml_args, (char *)&args,
2264
2491
    make_nonnull_domain(&args.dom, dom);
2265
2492
    args.flags = flags;
2266
2493
 
2267
 
    memset(&ret, 0, sizeof ret);
 
2494
    memset(&ret, 0, sizeof(ret));
2268
2495
 
2269
2496
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_CURRENT,
2270
2497
             (xdrproc_t)xdr_remote_domain_snapshot_current_args, (char *)&args,
2318
2545
    make_nonnull_domain_snapshot(&args.snap, snap);
2319
2546
    args.flags = flags;
2320
2547
 
2321
 
    memset(&ret, 0, sizeof ret);
 
2548
    memset(&ret, 0, sizeof(ret));
2322
2549
 
2323
2550
    if (call(snap->domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_GET_PARENT,
2324
2551
             (xdrproc_t)xdr_remote_domain_snapshot_get_parent_args, (char *)&args,
2347
2574
    make_nonnull_domain_snapshot(&args.snap, snap);
2348
2575
    args.flags = flags;
2349
2576
 
2350
 
    memset(&ret, 0, sizeof ret);
 
2577
    memset(&ret, 0, sizeof(ret));
2351
2578
 
2352
2579
    if (call(snap->domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_GET_XML_DESC,
2353
2580
             (xdrproc_t)xdr_remote_domain_snapshot_get_xml_desc_args, (char *)&args,
2384
2611
    args.maxnames = maxnames;
2385
2612
    args.flags = flags;
2386
2613
 
2387
 
    memset(&ret, 0, sizeof ret);
 
2614
    memset(&ret, 0, sizeof(ret));
2388
2615
 
2389
2616
    if (call(snap->domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_LIST_CHILDREN_NAMES,
2390
2617
             (xdrproc_t)xdr_remote_domain_snapshot_list_children_names_args, (char *)&args,
2447
2674
    args.maxnames = maxnames;
2448
2675
    args.flags = flags;
2449
2676
 
2450
 
    memset(&ret, 0, sizeof ret);
 
2677
    memset(&ret, 0, sizeof(ret));
2451
2678
 
2452
2679
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_LIST_NAMES,
2453
2680
             (xdrproc_t)xdr_remote_domain_snapshot_list_names_args, (char *)&args,
2502
2729
    args.name = (char *)name;
2503
2730
    args.flags = flags;
2504
2731
 
2505
 
    memset(&ret, 0, sizeof ret);
 
2732
    memset(&ret, 0, sizeof(ret));
2506
2733
 
2507
2734
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_LOOKUP_BY_NAME,
2508
2735
             (xdrproc_t)xdr_remote_domain_snapshot_lookup_by_name_args, (char *)&args,
2531
2758
    make_nonnull_domain(&args.dom, dom);
2532
2759
    args.flags = flags;
2533
2760
 
2534
 
    memset(&ret, 0, sizeof ret);
 
2761
    memset(&ret, 0, sizeof(ret));
2535
2762
 
2536
2763
    if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_NUM,
2537
2764
             (xdrproc_t)xdr_remote_domain_snapshot_num_args, (char *)&args,
2559
2786
    make_nonnull_domain_snapshot(&args.snap, snap);
2560
2787
    args.flags = flags;
2561
2788
 
2562
 
    memset(&ret, 0, sizeof ret);
 
2789
    memset(&ret, 0, sizeof(ret));
2563
2790
 
2564
2791
    if (call(snap->domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_NUM_CHILDREN,
2565
2792
             (xdrproc_t)xdr_remote_domain_snapshot_num_children_args, (char *)&args,
2687
2914
    args.nativeConfig = (char *)nativeConfig;
2688
2915
    args.flags = flags;
2689
2916
 
2690
 
    memset(&ret, 0, sizeof ret);
 
2917
    memset(&ret, 0, sizeof(ret));
2691
2918
 
2692
2919
    if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_XML_FROM_NATIVE,
2693
2920
             (xdrproc_t)xdr_remote_domain_xml_from_native_args, (char *)&args,
2716
2943
    args.domainXml = (char *)domainXml;
2717
2944
    args.flags = flags;
2718
2945
 
2719
 
    memset(&ret, 0, sizeof ret);
 
2946
    memset(&ret, 0, sizeof(ret));
2720
2947
 
2721
2948
    if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_XML_TO_NATIVE,
2722
2949
             (xdrproc_t)xdr_remote_domain_xml_to_native_args, (char *)&args,
2740
2967
 
2741
2968
    remoteDriverLock(priv);
2742
2969
 
2743
 
    memset(&ret, 0, sizeof ret);
 
2970
    memset(&ret, 0, sizeof(ret));
2744
2971
 
2745
2972
    if (call(conn, priv, 0, REMOTE_PROC_GET_CAPABILITIES,
2746
2973
             (xdrproc_t)xdr_void, (char *)NULL,
2764
2991
 
2765
2992
    remoteDriverLock(priv);
2766
2993
 
2767
 
    memset(&ret, 0, sizeof ret);
 
2994
    memset(&ret, 0, sizeof(ret));
2768
2995
 
2769
2996
    if (call(conn, priv, 0, REMOTE_PROC_GET_HOSTNAME,
2770
2997
             (xdrproc_t)xdr_void, (char *)NULL,
2788
3015
 
2789
3016
    remoteDriverLock(priv);
2790
3017
 
2791
 
    memset(&ret, 0, sizeof ret);
 
3018
    memset(&ret, 0, sizeof(ret));
2792
3019
 
2793
3020
    if (call(conn, priv, 0, REMOTE_PROC_GET_LIB_VERSION,
2794
3021
             (xdrproc_t)xdr_void, (char *)NULL,
2816
3043
 
2817
3044
    args.type = type ? (char **)&type : NULL;
2818
3045
 
2819
 
    memset(&ret, 0, sizeof ret);
 
3046
    memset(&ret, 0, sizeof(ret));
2820
3047
 
2821
3048
    if (call(conn, priv, 0, REMOTE_PROC_GET_MAX_VCPUS,
2822
3049
             (xdrproc_t)xdr_remote_get_max_vcpus_args, (char *)&args,
2843
3070
 
2844
3071
    args.flags = flags;
2845
3072
 
2846
 
    memset(&ret, 0, sizeof ret);
 
3073
    memset(&ret, 0, sizeof(ret));
2847
3074
 
2848
3075
    if (call(conn, priv, 0, REMOTE_PROC_GET_SYSINFO,
2849
3076
             (xdrproc_t)xdr_remote_get_sysinfo_args, (char *)&args,
2867
3094
 
2868
3095
    remoteDriverLock(priv);
2869
3096
 
2870
 
    memset(&ret, 0, sizeof ret);
 
3097
    memset(&ret, 0, sizeof(ret));
2871
3098
 
2872
3099
    if (call(conn, priv, 0, REMOTE_PROC_GET_VERSION,
2873
3100
             (xdrproc_t)xdr_void, (char *)NULL,
2993
3220
    args.xml = (char *)xml;
2994
3221
    args.flags = flags;
2995
3222
 
2996
 
    memset(&ret, 0, sizeof ret);
 
3223
    memset(&ret, 0, sizeof(ret));
2997
3224
 
2998
3225
    if (call(conn, priv, 0, REMOTE_PROC_INTERFACE_DEFINE_XML,
2999
3226
             (xdrproc_t)xdr_remote_interface_define_xml_args, (char *)&args,
3047
3274
    make_nonnull_interface(&args.iface, iface);
3048
3275
    args.flags = flags;
3049
3276
 
3050
 
    memset(&ret, 0, sizeof ret);
 
3277
    memset(&ret, 0, sizeof(ret));
3051
3278
 
3052
3279
    if (call(iface->conn, priv, 0, REMOTE_PROC_INTERFACE_GET_XML_DESC,
3053
3280
             (xdrproc_t)xdr_remote_interface_get_xml_desc_args, (char *)&args,
3074
3301
 
3075
3302
    make_nonnull_interface(&args.iface, iface);
3076
3303
 
3077
 
    memset(&ret, 0, sizeof ret);
 
3304
    memset(&ret, 0, sizeof(ret));
3078
3305
 
3079
3306
    if (call(iface->conn, priv, 0, REMOTE_PROC_INTERFACE_IS_ACTIVE,
3080
3307
             (xdrproc_t)xdr_remote_interface_is_active_args, (char *)&args,
3101
3328
 
3102
3329
    args.mac = (char *)mac;
3103
3330
 
3104
 
    memset(&ret, 0, sizeof ret);
 
3331
    memset(&ret, 0, sizeof(ret));
3105
3332
 
3106
3333
    if (call(conn, priv, 0, REMOTE_PROC_INTERFACE_LOOKUP_BY_MAC_STRING,
3107
3334
             (xdrproc_t)xdr_remote_interface_lookup_by_mac_string_args, (char *)&args,
3129
3356
 
3130
3357
    args.name = (char *)name;
3131
3358
 
3132
 
    memset(&ret, 0, sizeof ret);
 
3359
    memset(&ret, 0, sizeof(ret));
3133
3360
 
3134
3361
    if (call(conn, priv, 0, REMOTE_PROC_INTERFACE_LOOKUP_BY_NAME,
3135
3362
             (xdrproc_t)xdr_remote_interface_lookup_by_name_args, (char *)&args,
3189
3416
 
3190
3417
    args.maxnames = maxnames;
3191
3418
 
3192
 
    memset(&ret, 0, sizeof ret);
 
3419
    memset(&ret, 0, sizeof(ret));
3193
3420
 
3194
3421
    if (call(conn, priv, 0, REMOTE_PROC_LIST_DEFINED_DOMAINS,
3195
3422
             (xdrproc_t)xdr_remote_list_defined_domains_args, (char *)&args,
3250
3477
 
3251
3478
    args.maxnames = maxnames;
3252
3479
 
3253
 
    memset(&ret, 0, sizeof ret);
 
3480
    memset(&ret, 0, sizeof(ret));
3254
3481
 
3255
3482
    if (call(conn, priv, 0, REMOTE_PROC_LIST_DEFINED_INTERFACES,
3256
3483
             (xdrproc_t)xdr_remote_list_defined_interfaces_args, (char *)&args,
3311
3538
 
3312
3539
    args.maxnames = maxnames;
3313
3540
 
3314
 
    memset(&ret, 0, sizeof ret);
 
3541
    memset(&ret, 0, sizeof(ret));
3315
3542
 
3316
3543
    if (call(conn, priv, 0, REMOTE_PROC_LIST_DEFINED_NETWORKS,
3317
3544
             (xdrproc_t)xdr_remote_list_defined_networks_args, (char *)&args,
3372
3599
 
3373
3600
    args.maxnames = maxnames;
3374
3601
 
3375
 
    memset(&ret, 0, sizeof ret);
 
3602
    memset(&ret, 0, sizeof(ret));
3376
3603
 
3377
3604
    if (call(conn, priv, 0, REMOTE_PROC_LIST_DEFINED_STORAGE_POOLS,
3378
3605
             (xdrproc_t)xdr_remote_list_defined_storage_pools_args, (char *)&args,
3433
3660
 
3434
3661
    args.maxnames = maxnames;
3435
3662
 
3436
 
    memset(&ret, 0, sizeof ret);
 
3663
    memset(&ret, 0, sizeof(ret));
3437
3664
 
3438
3665
    if (call(conn, priv, 0, REMOTE_PROC_LIST_INTERFACES,
3439
3666
             (xdrproc_t)xdr_remote_list_interfaces_args, (char *)&args,
3494
3721
 
3495
3722
    args.maxnames = maxnames;
3496
3723
 
3497
 
    memset(&ret, 0, sizeof ret);
 
3724
    memset(&ret, 0, sizeof(ret));
3498
3725
 
3499
3726
    if (call(conn, priv, 0, REMOTE_PROC_LIST_NETWORKS,
3500
3727
             (xdrproc_t)xdr_remote_list_networks_args, (char *)&args,
3555
3782
 
3556
3783
    args.maxnames = maxnames;
3557
3784
 
3558
 
    memset(&ret, 0, sizeof ret);
 
3785
    memset(&ret, 0, sizeof(ret));
3559
3786
 
3560
3787
    if (call(conn, priv, 0, REMOTE_PROC_LIST_NWFILTERS,
3561
3788
             (xdrproc_t)xdr_remote_list_nwfilters_args, (char *)&args,
3616
3843
 
3617
3844
    args.maxuuids = maxuuids;
3618
3845
 
3619
 
    memset(&ret, 0, sizeof ret);
 
3846
    memset(&ret, 0, sizeof(ret));
3620
3847
 
3621
3848
    if (call(conn, priv, 0, REMOTE_PROC_LIST_SECRETS,
3622
3849
             (xdrproc_t)xdr_remote_list_secrets_args, (char *)&args,
3677
3904
 
3678
3905
    args.maxnames = maxnames;
3679
3906
 
3680
 
    memset(&ret, 0, sizeof ret);
 
3907
    memset(&ret, 0, sizeof(ret));
3681
3908
 
3682
3909
    if (call(conn, priv, 0, REMOTE_PROC_LIST_STORAGE_POOLS,
3683
3910
             (xdrproc_t)xdr_remote_list_storage_pools_args, (char *)&args,
3754
3981
 
3755
3982
    args.xml = (char *)xml;
3756
3983
 
3757
 
    memset(&ret, 0, sizeof ret);
 
3984
    memset(&ret, 0, sizeof(ret));
3758
3985
 
3759
3986
    if (call(conn, priv, 0, REMOTE_PROC_NETWORK_CREATE_XML,
3760
3987
             (xdrproc_t)xdr_remote_network_create_xml_args, (char *)&args,
3782
4009
 
3783
4010
    args.xml = (char *)xml;
3784
4011
 
3785
 
    memset(&ret, 0, sizeof ret);
 
4012
    memset(&ret, 0, sizeof(ret));
3786
4013
 
3787
4014
    if (call(conn, priv, 0, REMOTE_PROC_NETWORK_DEFINE_XML,
3788
4015
             (xdrproc_t)xdr_remote_network_define_xml_args, (char *)&args,
3834
4061
 
3835
4062
    make_nonnull_network(&args.net, net);
3836
4063
 
3837
 
    memset(&ret, 0, sizeof ret);
 
4064
    memset(&ret, 0, sizeof(ret));
3838
4065
 
3839
4066
    if (call(net->conn, priv, 0, REMOTE_PROC_NETWORK_GET_AUTOSTART,
3840
4067
             (xdrproc_t)xdr_remote_network_get_autostart_args, (char *)&args,
3862
4089
 
3863
4090
    make_nonnull_network(&args.net, net);
3864
4091
 
3865
 
    memset(&ret, 0, sizeof ret);
 
4092
    memset(&ret, 0, sizeof(ret));
3866
4093
 
3867
4094
    if (call(net->conn, priv, 0, REMOTE_PROC_NETWORK_GET_BRIDGE_NAME,
3868
4095
             (xdrproc_t)xdr_remote_network_get_bridge_name_args, (char *)&args,
3890
4117
    make_nonnull_network(&args.net, net);
3891
4118
    args.flags = flags;
3892
4119
 
3893
 
    memset(&ret, 0, sizeof ret);
 
4120
    memset(&ret, 0, sizeof(ret));
3894
4121
 
3895
4122
    if (call(net->conn, priv, 0, REMOTE_PROC_NETWORK_GET_XML_DESC,
3896
4123
             (xdrproc_t)xdr_remote_network_get_xml_desc_args, (char *)&args,
3917
4144
 
3918
4145
    make_nonnull_network(&args.net, net);
3919
4146
 
3920
 
    memset(&ret, 0, sizeof ret);
 
4147
    memset(&ret, 0, sizeof(ret));
3921
4148
 
3922
4149
    if (call(net->conn, priv, 0, REMOTE_PROC_NETWORK_IS_ACTIVE,
3923
4150
             (xdrproc_t)xdr_remote_network_is_active_args, (char *)&args,
3944
4171
 
3945
4172
    make_nonnull_network(&args.net, net);
3946
4173
 
3947
 
    memset(&ret, 0, sizeof ret);
 
4174
    memset(&ret, 0, sizeof(ret));
3948
4175
 
3949
4176
    if (call(net->conn, priv, 0, REMOTE_PROC_NETWORK_IS_PERSISTENT,
3950
4177
             (xdrproc_t)xdr_remote_network_is_persistent_args, (char *)&args,
3971
4198
 
3972
4199
    args.name = (char *)name;
3973
4200
 
3974
 
    memset(&ret, 0, sizeof ret);
 
4201
    memset(&ret, 0, sizeof(ret));
3975
4202
 
3976
4203
    if (call(conn, priv, 0, REMOTE_PROC_NETWORK_LOOKUP_BY_NAME,
3977
4204
             (xdrproc_t)xdr_remote_network_lookup_by_name_args, (char *)&args,
3999
4226
 
4000
4227
    memcpy(args.uuid, uuid, VIR_UUID_BUFLEN);
4001
4228
 
4002
 
    memset(&ret, 0, sizeof ret);
 
4229
    memset(&ret, 0, sizeof(ret));
4003
4230
 
4004
4231
    if (call(conn, priv, 0, REMOTE_PROC_NETWORK_LOOKUP_BY_UUID,
4005
4232
             (xdrproc_t)xdr_remote_network_lookup_by_uuid_args, (char *)&args,
4077
4304
    args.xml_desc = (char *)xml_desc;
4078
4305
    args.flags = flags;
4079
4306
 
4080
 
    memset(&ret, 0, sizeof ret);
 
4307
    memset(&ret, 0, sizeof(ret));
4081
4308
 
4082
4309
    if (call(conn, priv, 0, REMOTE_PROC_NODE_DEVICE_CREATE_XML,
4083
4310
             (xdrproc_t)xdr_remote_node_device_create_xml_args, (char *)&args,
4129
4356
 
4130
4357
    args.name = dev->name;
4131
4358
 
4132
 
    memset(&ret, 0, sizeof ret);
 
4359
    memset(&ret, 0, sizeof(ret));
4133
4360
 
4134
4361
    if (call(dev->conn, priv, 0, REMOTE_PROC_NODE_DEVICE_GET_PARENT,
4135
4362
             (xdrproc_t)xdr_remote_node_device_get_parent_args, (char *)&args,
4158
4385
    args.name = dev->name;
4159
4386
    args.flags = flags;
4160
4387
 
4161
 
    memset(&ret, 0, sizeof ret);
 
4388
    memset(&ret, 0, sizeof(ret));
4162
4389
 
4163
4390
    if (call(dev->conn, priv, 0, REMOTE_PROC_NODE_DEVICE_GET_XML_DESC,
4164
4391
             (xdrproc_t)xdr_remote_node_device_get_xml_desc_args, (char *)&args,
4194
4421
    args.name = dev->name;
4195
4422
    args.maxnames = maxnames;
4196
4423
 
4197
 
    memset(&ret, 0, sizeof ret);
 
4424
    memset(&ret, 0, sizeof(ret));
4198
4425
 
4199
4426
    if (call(dev->conn, priv, 0, REMOTE_PROC_NODE_DEVICE_LIST_CAPS,
4200
4427
             (xdrproc_t)xdr_remote_node_device_list_caps_args, (char *)&args,
4247
4474
 
4248
4475
    args.name = (char *)name;
4249
4476
 
4250
 
    memset(&ret, 0, sizeof ret);
 
4477
    memset(&ret, 0, sizeof(ret));
4251
4478
 
4252
4479
    if (call(conn, priv, 0, REMOTE_PROC_NODE_DEVICE_LOOKUP_BY_NAME,
4253
4480
             (xdrproc_t)xdr_remote_node_device_lookup_by_name_args, (char *)&args,
4275
4502
 
4276
4503
    args.name = dev->name;
4277
4504
 
4278
 
    memset(&ret, 0, sizeof ret);
 
4505
    memset(&ret, 0, sizeof(ret));
4279
4506
 
4280
4507
    if (call(dev->conn, priv, 0, REMOTE_PROC_NODE_DEVICE_NUM_OF_CAPS,
4281
4508
             (xdrproc_t)xdr_remote_node_device_num_of_caps_args, (char *)&args,
4299
4526
 
4300
4527
    remoteDriverLock(priv);
4301
4528
 
4302
 
    memset(&ret, 0, sizeof ret);
 
4529
    memset(&ret, 0, sizeof(ret));
4303
4530
 
4304
4531
    if (call(conn, priv, 0, REMOTE_PROC_NODE_GET_FREE_MEMORY,
4305
4532
             (xdrproc_t)xdr_void, (char *)NULL,
4323
4550
 
4324
4551
    remoteDriverLock(priv);
4325
4552
 
4326
 
    memset(&ret, 0, sizeof ret);
 
4553
    memset(&ret, 0, sizeof(ret));
4327
4554
 
4328
4555
    if (call(conn, priv, 0, REMOTE_PROC_NODE_GET_INFO,
4329
4556
             (xdrproc_t)xdr_void, (char *)NULL,
4331
4558
        goto done;
4332
4559
    }
4333
4560
 
4334
 
    memcpy(result->model, ret.model, sizeof result->model);
 
4561
    memcpy(result->model, ret.model, sizeof(result->model));
4335
4562
    HYPER_TO_ULONG(result->memory, ret.memory);
4336
4563
    result->cpus = ret.cpus;
4337
4564
    result->mhz = ret.mhz;
4368
4595
    args.maxnames = maxnames;
4369
4596
    args.flags = flags;
4370
4597
 
4371
 
    memset(&ret, 0, sizeof ret);
 
4598
    memset(&ret, 0, sizeof(ret));
4372
4599
 
4373
4600
    if (call(conn, priv, 0, REMOTE_PROC_NODE_LIST_DEVICES,
4374
4601
             (xdrproc_t)xdr_remote_node_list_devices_args, (char *)&args,
4422
4649
    args.cap = cap ? (char **)&cap : NULL;
4423
4650
    args.flags = flags;
4424
4651
 
4425
 
    memset(&ret, 0, sizeof ret);
 
4652
    memset(&ret, 0, sizeof(ret));
4426
4653
 
4427
4654
    if (call(conn, priv, 0, REMOTE_PROC_NODE_NUM_OF_DEVICES,
4428
4655
             (xdrproc_t)xdr_remote_node_num_of_devices_args, (char *)&args,
4472
4699
 
4473
4700
    remoteDriverLock(priv);
4474
4701
 
4475
 
    memset(&ret, 0, sizeof ret);
 
4702
    memset(&ret, 0, sizeof(ret));
4476
4703
 
4477
4704
    if (call(conn, priv, 0, REMOTE_PROC_NUM_OF_DEFINED_DOMAINS,
4478
4705
             (xdrproc_t)xdr_void, (char *)NULL,
4496
4723
 
4497
4724
    remoteDriverLock(priv);
4498
4725
 
4499
 
    memset(&ret, 0, sizeof ret);
 
4726
    memset(&ret, 0, sizeof(ret));
4500
4727
 
4501
4728
    if (call(conn, priv, 0, REMOTE_PROC_NUM_OF_DEFINED_INTERFACES,
4502
4729
             (xdrproc_t)xdr_void, (char *)NULL,
4520
4747
 
4521
4748
    remoteDriverLock(priv);
4522
4749
 
4523
 
    memset(&ret, 0, sizeof ret);
 
4750
    memset(&ret, 0, sizeof(ret));
4524
4751
 
4525
4752
    if (call(conn, priv, 0, REMOTE_PROC_NUM_OF_DEFINED_NETWORKS,
4526
4753
             (xdrproc_t)xdr_void, (char *)NULL,
4544
4771
 
4545
4772
    remoteDriverLock(priv);
4546
4773
 
4547
 
    memset(&ret, 0, sizeof ret);
 
4774
    memset(&ret, 0, sizeof(ret));
4548
4775
 
4549
4776
    if (call(conn, priv, 0, REMOTE_PROC_NUM_OF_DEFINED_STORAGE_POOLS,
4550
4777
             (xdrproc_t)xdr_void, (char *)NULL,
4568
4795
 
4569
4796
    remoteDriverLock(priv);
4570
4797
 
4571
 
    memset(&ret, 0, sizeof ret);
 
4798
    memset(&ret, 0, sizeof(ret));
4572
4799
 
4573
4800
    if (call(conn, priv, 0, REMOTE_PROC_NUM_OF_DOMAINS,
4574
4801
             (xdrproc_t)xdr_void, (char *)NULL,
4592
4819
 
4593
4820
    remoteDriverLock(priv);
4594
4821
 
4595
 
    memset(&ret, 0, sizeof ret);
 
4822
    memset(&ret, 0, sizeof(ret));
4596
4823
 
4597
4824
    if (call(conn, priv, 0, REMOTE_PROC_NUM_OF_INTERFACES,
4598
4825
             (xdrproc_t)xdr_void, (char *)NULL,
4616
4843
 
4617
4844
    remoteDriverLock(priv);
4618
4845
 
4619
 
    memset(&ret, 0, sizeof ret);
 
4846
    memset(&ret, 0, sizeof(ret));
4620
4847
 
4621
4848
    if (call(conn, priv, 0, REMOTE_PROC_NUM_OF_NETWORKS,
4622
4849
             (xdrproc_t)xdr_void, (char *)NULL,
4640
4867
 
4641
4868
    remoteDriverLock(priv);
4642
4869
 
4643
 
    memset(&ret, 0, sizeof ret);
 
4870
    memset(&ret, 0, sizeof(ret));
4644
4871
 
4645
4872
    if (call(conn, priv, 0, REMOTE_PROC_NUM_OF_NWFILTERS,
4646
4873
             (xdrproc_t)xdr_void, (char *)NULL,
4664
4891
 
4665
4892
    remoteDriverLock(priv);
4666
4893
 
4667
 
    memset(&ret, 0, sizeof ret);
 
4894
    memset(&ret, 0, sizeof(ret));
4668
4895
 
4669
4896
    if (call(conn, priv, 0, REMOTE_PROC_NUM_OF_SECRETS,
4670
4897
             (xdrproc_t)xdr_void, (char *)NULL,
4688
4915
 
4689
4916
    remoteDriverLock(priv);
4690
4917
 
4691
 
    memset(&ret, 0, sizeof ret);
 
4918
    memset(&ret, 0, sizeof(ret));
4692
4919
 
4693
4920
    if (call(conn, priv, 0, REMOTE_PROC_NUM_OF_STORAGE_POOLS,
4694
4921
             (xdrproc_t)xdr_void, (char *)NULL,
4715
4942
 
4716
4943
    args.xml = (char *)xml;
4717
4944
 
4718
 
    memset(&ret, 0, sizeof ret);
 
4945
    memset(&ret, 0, sizeof(ret));
4719
4946
 
4720
4947
    if (call(conn, priv, 0, REMOTE_PROC_NWFILTER_DEFINE_XML,
4721
4948
             (xdrproc_t)xdr_remote_nwfilter_define_xml_args, (char *)&args,
4744
4971
    make_nonnull_nwfilter(&args.nwfilter, nwfilter);
4745
4972
    args.flags = flags;
4746
4973
 
4747
 
    memset(&ret, 0, sizeof ret);
 
4974
    memset(&ret, 0, sizeof(ret));
4748
4975
 
4749
4976
    if (call(nwfilter->conn, priv, 0, REMOTE_PROC_NWFILTER_GET_XML_DESC,
4750
4977
             (xdrproc_t)xdr_remote_nwfilter_get_xml_desc_args, (char *)&args,
4771
4998
 
4772
4999
    args.name = (char *)name;
4773
5000
 
4774
 
    memset(&ret, 0, sizeof ret);
 
5001
    memset(&ret, 0, sizeof(ret));
4775
5002
 
4776
5003
    if (call(conn, priv, 0, REMOTE_PROC_NWFILTER_LOOKUP_BY_NAME,
4777
5004
             (xdrproc_t)xdr_remote_nwfilter_lookup_by_name_args, (char *)&args,
4799
5026
 
4800
5027
    memcpy(args.uuid, uuid, VIR_UUID_BUFLEN);
4801
5028
 
4802
 
    memset(&ret, 0, sizeof ret);
 
5029
    memset(&ret, 0, sizeof(ret));
4803
5030
 
4804
5031
    if (call(conn, priv, 0, REMOTE_PROC_NWFILTER_LOOKUP_BY_UUID,
4805
5032
             (xdrproc_t)xdr_remote_nwfilter_lookup_by_uuid_args, (char *)&args,
4852
5079
    args.xml = (char *)xml;
4853
5080
    args.flags = flags;
4854
5081
 
4855
 
    memset(&ret, 0, sizeof ret);
 
5082
    memset(&ret, 0, sizeof(ret));
4856
5083
 
4857
5084
    if (call(conn, priv, 0, REMOTE_PROC_SECRET_DEFINE_XML,
4858
5085
             (xdrproc_t)xdr_remote_secret_define_xml_args, (char *)&args,
4881
5108
    make_nonnull_secret(&args.secret, secret);
4882
5109
    args.flags = flags;
4883
5110
 
4884
 
    memset(&ret, 0, sizeof ret);
 
5111
    memset(&ret, 0, sizeof(ret));
4885
5112
 
4886
5113
    if (call(secret->conn, priv, 0, REMOTE_PROC_SECRET_GET_XML_DESC,
4887
5114
             (xdrproc_t)xdr_remote_secret_get_xml_desc_args, (char *)&args,
4909
5136
    args.usageType = usageType;
4910
5137
    args.usageID = (char *)usageID;
4911
5138
 
4912
 
    memset(&ret, 0, sizeof ret);
 
5139
    memset(&ret, 0, sizeof(ret));
4913
5140
 
4914
5141
    if (call(conn, priv, 0, REMOTE_PROC_SECRET_LOOKUP_BY_USAGE,
4915
5142
             (xdrproc_t)xdr_remote_secret_lookup_by_usage_args, (char *)&args,
4937
5164
 
4938
5165
    memcpy(args.uuid, uuid, VIR_UUID_BUFLEN);
4939
5166
 
4940
 
    memset(&ret, 0, sizeof ret);
 
5167
    memset(&ret, 0, sizeof(ret));
4941
5168
 
4942
5169
    if (call(conn, priv, 0, REMOTE_PROC_SECRET_LOOKUP_BY_UUID,
4943
5170
             (xdrproc_t)xdr_remote_secret_lookup_by_uuid_args, (char *)&args,
5074
5301
    args.xml = (char *)xml;
5075
5302
    args.flags = flags;
5076
5303
 
5077
 
    memset(&ret, 0, sizeof ret);
 
5304
    memset(&ret, 0, sizeof(ret));
5078
5305
 
5079
5306
    if (call(conn, priv, 0, REMOTE_PROC_STORAGE_POOL_CREATE_XML,
5080
5307
             (xdrproc_t)xdr_remote_storage_pool_create_xml_args, (char *)&args,
5103
5330
    args.xml = (char *)xml;
5104
5331
    args.flags = flags;
5105
5332
 
5106
 
    memset(&ret, 0, sizeof ret);
 
5333
    memset(&ret, 0, sizeof(ret));
5107
5334
 
5108
5335
    if (call(conn, priv, 0, REMOTE_PROC_STORAGE_POOL_DEFINE_XML,
5109
5336
             (xdrproc_t)xdr_remote_storage_pool_define_xml_args, (char *)&args,
5180
5407
 
5181
5408
    make_nonnull_storage_pool(&args.pool, pool);
5182
5409
 
5183
 
    memset(&ret, 0, sizeof ret);
 
5410
    memset(&ret, 0, sizeof(ret));
5184
5411
 
5185
5412
    if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_GET_AUTOSTART,
5186
5413
             (xdrproc_t)xdr_remote_storage_pool_get_autostart_args, (char *)&args,
5208
5435
 
5209
5436
    make_nonnull_storage_pool(&args.pool, pool);
5210
5437
 
5211
 
    memset(&ret, 0, sizeof ret);
 
5438
    memset(&ret, 0, sizeof(ret));
5212
5439
 
5213
5440
    if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_GET_INFO,
5214
5441
             (xdrproc_t)xdr_remote_storage_pool_get_info_args, (char *)&args,
5240
5467
    make_nonnull_storage_pool(&args.pool, pool);
5241
5468
    args.flags = flags;
5242
5469
 
5243
 
    memset(&ret, 0, sizeof ret);
 
5470
    memset(&ret, 0, sizeof(ret));
5244
5471
 
5245
5472
    if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_GET_XML_DESC,
5246
5473
             (xdrproc_t)xdr_remote_storage_pool_get_xml_desc_args, (char *)&args,
5267
5494
 
5268
5495
    make_nonnull_storage_pool(&args.pool, pool);
5269
5496
 
5270
 
    memset(&ret, 0, sizeof ret);
 
5497
    memset(&ret, 0, sizeof(ret));
5271
5498
 
5272
5499
    if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_IS_ACTIVE,
5273
5500
             (xdrproc_t)xdr_remote_storage_pool_is_active_args, (char *)&args,
5294
5521
 
5295
5522
    make_nonnull_storage_pool(&args.pool, pool);
5296
5523
 
5297
 
    memset(&ret, 0, sizeof ret);
 
5524
    memset(&ret, 0, sizeof(ret));
5298
5525
 
5299
5526
    if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_IS_PERSISTENT,
5300
5527
             (xdrproc_t)xdr_remote_storage_pool_is_persistent_args, (char *)&args,
5330
5557
    make_nonnull_storage_pool(&args.pool, pool);
5331
5558
    args.maxnames = maxnames;
5332
5559
 
5333
 
    memset(&ret, 0, sizeof ret);
 
5560
    memset(&ret, 0, sizeof(ret));
5334
5561
 
5335
5562
    if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_LIST_VOLUMES,
5336
5563
             (xdrproc_t)xdr_remote_storage_pool_list_volumes_args, (char *)&args,
5383
5610
 
5384
5611
    args.name = (char *)name;
5385
5612
 
5386
 
    memset(&ret, 0, sizeof ret);
 
5613
    memset(&ret, 0, sizeof(ret));
5387
5614
 
5388
5615
    if (call(conn, priv, 0, REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_NAME,
5389
5616
             (xdrproc_t)xdr_remote_storage_pool_lookup_by_name_args, (char *)&args,
5411
5638
 
5412
5639
    memcpy(args.uuid, uuid, VIR_UUID_BUFLEN);
5413
5640
 
5414
 
    memset(&ret, 0, sizeof ret);
 
5641
    memset(&ret, 0, sizeof(ret));
5415
5642
 
5416
5643
    if (call(conn, priv, 0, REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_UUID,
5417
5644
             (xdrproc_t)xdr_remote_storage_pool_lookup_by_uuid_args, (char *)&args,
5439
5666
 
5440
5667
    make_nonnull_storage_vol(&args.vol, vol);
5441
5668
 
5442
 
    memset(&ret, 0, sizeof ret);
 
5669
    memset(&ret, 0, sizeof(ret));
5443
5670
 
5444
5671
    if (call(vol->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_VOLUME,
5445
5672
             (xdrproc_t)xdr_remote_storage_pool_lookup_by_volume_args, (char *)&args,
5467
5694
 
5468
5695
    make_nonnull_storage_pool(&args.pool, pool);
5469
5696
 
5470
 
    memset(&ret, 0, sizeof ret);
 
5697
    memset(&ret, 0, sizeof(ret));
5471
5698
 
5472
5699
    if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_NUM_OF_VOLUMES,
5473
5700
             (xdrproc_t)xdr_remote_storage_pool_num_of_volumes_args, (char *)&args,
5570
5797
    args.xml = (char *)xml;
5571
5798
    args.flags = flags;
5572
5799
 
5573
 
    memset(&ret, 0, sizeof ret);
 
5800
    memset(&ret, 0, sizeof(ret));
5574
5801
 
5575
5802
    if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_CREATE_XML,
5576
5803
             (xdrproc_t)xdr_remote_storage_vol_create_xml_args, (char *)&args,
5601
5828
    make_nonnull_storage_vol(&args.clonevol, clonevol);
5602
5829
    args.flags = flags;
5603
5830
 
5604
 
    memset(&ret, 0, sizeof ret);
 
5831
    memset(&ret, 0, sizeof(ret));
5605
5832
 
5606
5833
    if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_CREATE_XML_FROM,
5607
5834
             (xdrproc_t)xdr_remote_storage_vol_create_xml_from_args, (char *)&args,
5696
5923
 
5697
5924
    make_nonnull_storage_vol(&args.vol, vol);
5698
5925
 
5699
 
    memset(&ret, 0, sizeof ret);
 
5926
    memset(&ret, 0, sizeof(ret));
5700
5927
 
5701
5928
    if (call(vol->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_GET_INFO,
5702
5929
             (xdrproc_t)xdr_remote_storage_vol_get_info_args, (char *)&args,
5726
5953
 
5727
5954
    make_nonnull_storage_vol(&args.vol, vol);
5728
5955
 
5729
 
    memset(&ret, 0, sizeof ret);
 
5956
    memset(&ret, 0, sizeof(ret));
5730
5957
 
5731
5958
    if (call(vol->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_GET_PATH,
5732
5959
             (xdrproc_t)xdr_remote_storage_vol_get_path_args, (char *)&args,
5754
5981
    make_nonnull_storage_vol(&args.vol, vol);
5755
5982
    args.flags = flags;
5756
5983
 
5757
 
    memset(&ret, 0, sizeof ret);
 
5984
    memset(&ret, 0, sizeof(ret));
5758
5985
 
5759
5986
    if (call(vol->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_GET_XML_DESC,
5760
5987
             (xdrproc_t)xdr_remote_storage_vol_get_xml_desc_args, (char *)&args,
5781
6008
 
5782
6009
    args.key = (char *)key;
5783
6010
 
5784
 
    memset(&ret, 0, sizeof ret);
 
6011
    memset(&ret, 0, sizeof(ret));
5785
6012
 
5786
6013
    if (call(conn, priv, 0, REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_KEY,
5787
6014
             (xdrproc_t)xdr_remote_storage_vol_lookup_by_key_args, (char *)&args,
5810
6037
    make_nonnull_storage_pool(&args.pool, pool);
5811
6038
    args.name = (char *)name;
5812
6039
 
5813
 
    memset(&ret, 0, sizeof ret);
 
6040
    memset(&ret, 0, sizeof(ret));
5814
6041
 
5815
6042
    if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_NAME,
5816
6043
             (xdrproc_t)xdr_remote_storage_vol_lookup_by_name_args, (char *)&args,
5838
6065
 
5839
6066
    args.path = (char *)path;
5840
6067
 
5841
 
    memset(&ret, 0, sizeof ret);
 
6068
    memset(&ret, 0, sizeof(ret));
5842
6069
 
5843
6070
    if (call(conn, priv, 0, REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_PATH,
5844
6071
             (xdrproc_t)xdr_remote_storage_vol_lookup_by_path_args, (char *)&args,
5855
6082
}
5856
6083
 
5857
6084
static int
 
6085
remoteStorageVolResize(virStorageVolPtr vol, unsigned long long capacity, unsigned int flags)
 
6086
{
 
6087
    int rv = -1;
 
6088
    struct private_data *priv = vol->conn->storagePrivateData;
 
6089
    remote_storage_vol_resize_args args;
 
6090
 
 
6091
    remoteDriverLock(priv);
 
6092
 
 
6093
    make_nonnull_storage_vol(&args.vol, vol);
 
6094
    args.capacity = capacity;
 
6095
    args.flags = flags;
 
6096
 
 
6097
    if (call(vol->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_RESIZE,
 
6098
             (xdrproc_t)xdr_remote_storage_vol_resize_args, (char *)&args,
 
6099
             (xdrproc_t)xdr_void, (char *)NULL) == -1) {
 
6100
        goto done;
 
6101
    }
 
6102
 
 
6103
    rv = 0;
 
6104
 
 
6105
done:
 
6106
    remoteDriverUnlock(priv);
 
6107
    return rv;
 
6108
}
 
6109
 
 
6110
static int
5858
6111
remoteStorageVolUpload(virStorageVolPtr vol, virStreamPtr st, unsigned long long offset, unsigned long long length, unsigned int flags)
5859
6112
{
5860
6113
    int rv = -1;
5922
6175
}
5923
6176
 
5924
6177
static int
 
6178
remoteStorageVolWipePattern(virStorageVolPtr vol, unsigned int algorithm, unsigned int flags)
 
6179
{
 
6180
    int rv = -1;
 
6181
    struct private_data *priv = vol->conn->storagePrivateData;
 
6182
    remote_storage_vol_wipe_pattern_args args;
 
6183
 
 
6184
    remoteDriverLock(priv);
 
6185
 
 
6186
    make_nonnull_storage_vol(&args.vol, vol);
 
6187
    args.algorithm = algorithm;
 
6188
    args.flags = flags;
 
6189
 
 
6190
    if (call(vol->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_WIPE_PATTERN,
 
6191
             (xdrproc_t)xdr_remote_storage_vol_wipe_pattern_args, (char *)&args,
 
6192
             (xdrproc_t)xdr_void, (char *)NULL) == -1) {
 
6193
        goto done;
 
6194
    }
 
6195
 
 
6196
    rv = 0;
 
6197
 
 
6198
done:
 
6199
    remoteDriverUnlock(priv);
 
6200
    return rv;
 
6201
}
 
6202
 
 
6203
static int
5925
6204
remoteSupportsFeature(virConnectPtr conn, int feature)
5926
6205
{
5927
6206
    int rv = -1;
5938
6217
 
5939
6218
    args.feature = feature;
5940
6219
 
5941
 
    memset(&ret, 0, sizeof ret);
 
6220
    memset(&ret, 0, sizeof(ret));
5942
6221
 
5943
6222
    if (call(conn, priv, 0, REMOTE_PROC_SUPPORTS_FEATURE,
5944
6223
             (xdrproc_t)xdr_remote_supports_feature_args, (char *)&args,