virt_agent API 参考 ​

#include <ubs_virt_agent_case_conf.h>
virt_agent_ret_t ubs_virt_agent_case_conf_get(case_conf_info_t *case_conf_info);

typedef struct {
    char cur_case[128];
    char over_commitment_ratio[128];
    char migrate_waterLine[128];
    uint64_t index;
    char host_id[48];
} case_conf_info_t;

#include <stdio.h>
#include <ubs_virt_agent_case_conf.h>

int main(void)
{
    int32_t ret;
    case_conf_info_t case_conf_info;    
    ret = ubs_virt_agent_case_conf_get(&case_conf_info);
    if (ret != VA_SUCCESS) {
        perror("get failed.\n");
        return -1;
    }
    /* Do your work here... */
    return 0;
}

#include <ubs_virt_agent_case_conf.h>
virt_agent_ret_t ubs_virt_agent_case_conf_set(const char *param, case_conf_set_info_t *case_conf_set_info);

typedef struct {
    uint32_t ret;
} case_conf_set_info_t;

#include <stdio.h>
#include <ubs_virt_agent_case_conf.h>

int main(void)
{
    int32_t ret;
    char param[128] = "{\"caseType\": \"overCommitment\",\"overCommitment\": 1.25}";
    case_conf_set_info_t case_conf_set_info;    
    ret = ubs_virt_agent_case_conf_set(&param, &case_conf_set_info);
    if (ret != VA_SUCCESS) {
        perror("set failed.\n");
        return -1;
    }
    /* Do your work here... */
    return 0;
}

#include <ubs_virt_agent_container.h>
int32_t ubs_virt_agent_waterline_mem_borrow(mem_borrow_request_t *memBorrowRequest, char ***borrowIds,
                                            uint32_t *idsSize);

typedef struct {
    uint16_t highWaterMark;
    uint16_t lowWaterMark;
} watermark_t;
typedef struct {
    int socketId;
    int numaId;
} src_location_t;
typedef struct {
    char srcNid[16];
    src_location_t srcLocations[16];
    size_t srcLocationsSize;
} borrow_param_t
typedef struct {
    borrow_param_t borrowParam;
    uint64_t borrowSizes[64];
    size_t borrowSizesSize;
    watermark_t waterMark;
} mem_borrow_request_t;

#include <stdio.h>
#include <ubs_virt_agent_container.h>

int main(void)
{
    int32_t ret;
    borrow_param_t tmpBorrowParam {
        .srcNid = "1",
        .srcLocations = {{1, 1}, {2, 2}},
        .srcLocationsSize = 2
    };
    mem_borrow_request_t memBorrowRequest{
        .borrowParam = tmpBorrowParam,
        .borrowSizes = {128, 128},
        .borrowSizesSize = 2,
        .waterMark = {85, 80}
    };
    char **borrowIds = nullptr;
    uint32_t idsSize;
    ret = ubs_virt_agent_waterline_mem_borrow(&memBorrowRequest, &borrowIds, &idsSize);
    if (ret != 0) {
        perror("ubs_virt_agent_waterline_mem_borrow failed.\n");
        return -1;
    }
    /* Do your work here... */
    return 0;
}

#include <ubs_virt_agent_container.h>
int32_t ubs_virt_agent_waterline_mem_migrate(mem_migrate_request_t *memMigrateRequest);

typedef struct {
    pid_t pid;
    int ratio;
} container_param_t;
typedef struct {
    borrow_param_t borrowParam;
    uint64_t borrowSizes[64];
    size_t borrowSizesSize;
    watermark_t waterMark;
} mem_borrow_request_t;

#include <stdio.h>
#include <ubs_virt_agent_container.h>

int main(void)
{
    int32_t ret;
    borrow_param_t tmpBorrowParam {
        .srcNid = "1",
        .srcLocations = {{1, 1}, {2, 2}},
        .srcLocationsSize = 2
    };
    mem_migrate_request_t memMigrateRequest {
        .borrowParam = tmpBorrowParam,
        .borrowIds = {"1-abc123"},
        .borrowIdsSize = 1,
        .containerParam = {{12345, 25}},
        .containerParamSize = 1
    };
    ret = ubs_virt_agent_waterline_mem_migrate(&memBorrowRequest);
    if (ret != 0) {
        perror("ubs_virt_agent_waterline_mem_migrate failed.\n");
        return -1;
    }
    /* Do your work here... */
    return 0;
}

#include <ubs_virt_agent_container.h>
int32_t ubs_virt_agent_waterline_mem_return(return_request_t *returnRequest);

typedef struct {
    borrow_param_t borrowParam;
    char borrowIds[64][128];
    size_t borrowIdsSize;
    pid_t pids[64];
    size_t pidsSize;
} return_request_t;

#include <stdio.h>
#include <ubs_virt_agent_container.h>

int main(void)
{
    int32_t ret;
    borrow_param_t tmpBorrowParam {
        .srcNid = "1",
        .srcLocations = {{1, 1}, {2, 2}},
        .srcLocationsSize = 2
    };
    return_request_t returnRequest {
        .borrowParam = tmpBorrowParam,
        .borrowIds = {"1-abc123"},
        .borrowIdsSize = 1,
        .pids = {{12345, 23456}},
        .pidsSize = 2
    };
    char **borrowIds = nullptr;
    uint32_t idsSize;
    ret = ubs_virt_agent_waterline_mem_return(&returnRequest);
    if (ret != 0) {
        perror("ubs_virt_agent_waterline_mem_return failed.\n");
        return -1;
    }
    /* Do your work here... */
    return 0;
}

#include <ubs_virt_agent_container.h>
int32_t ubs_container_info_query(pid_param* param, pid_mem_info **pidInfos, uint32_t *InfoSize);

typedef struct {
    char srcNid[16];
    pid_t pids[2048];
    size_t pids_size;
} pid_param;
typedef struct {
    pid_t pid;
    uint64_t localUsedMem;
    uint16_t localNumaIds[64];
    size_t localNumaCount;
    uint64_t remoteUsedMem;
} pid_mem_info;

#include <stdio.h>
#include <ubs_virt_agent_container.h>

int main(void)
{
    int32_t ret;
    pid_param param{
        .srcNid = "1",
        .pids = {123},
        .pids_size = 1
    };
    pid_mem_info *pidInfos = NULL;
    uint32_t InfoSize;
    ret = ubs_container_info_query(&param, &pidInfos, &InfoSize);
    if (ret != 0) {
        perror("ubs_container_info_query failed.\n");
        return -1;
    }
    /* Do your work here... */
    return 0;
}

#include <ubs_virt_agent_container.h>
int32_t ubs_container_inject_waterLine(watermark_t* param);

#include <stdio.h>
#include <ubs_virt_agent_container.h>

int main(void)
{
    int32_t ret;
    watermark_t param {
        .highWaterMark = 90,
        .lowWaterMark = 80
    };
    ret = ubs_container_inject_waterLine(&param);
    if (ret != 0) {
        perror("ubs_container_inject_waterLine failed.\n");
        return -1;
    }
    /* Do your work here... */
    return 0;
}

#include <ubs_virt_agent_container.h>
int32_t ubs_container_get_container_pids(container_id_list *containerIdList, container_pid_info **param,
                                         uint32_t *InfoSize);

typedef struct {
    char containerId[128][128];
    size_t containerIdSize;
} container_id_list;
typedef struct {
    pid_t pids[2048];
    size_t pidsCount;
    char* containerId;
} container_pid_info;

#include <stdio.h>
#include <ubs_virt_agent_container.h>

int main(void)
{
    int32_t ret;
    container_id_list containerIdList = {
            .containerId = {"123", "456"},
            .containerIdSize = 2
    };
    container_pid_info *param = null;
    uint32_t InfoSize;
    ret = ubs_container_get_container_pids(&containerIdList, &param, &InfoSize);
    if (ret != 0) {
        perror("get_container_pids failed.\n");
        return -1;
    }
    /* Do your work here... */
    return 0;
}

#include <ubs_virt_agent_mem_fragmentation.h>
virt_agent_ret_t ubs_virt_agent_mem_borrow_strategy(const src_memory_borrow_param* src_param, borrow_strategy_c* borrow_strategy);

constexpr uint32_t MAX_BORROW_ID_COUNT = 2000;
constexpr uint32_t MAX_BORROW_ID_LENGTH = 128;
constexpr uint32_t MAX_DEST_NUMA_NUM = 1;
constexpr uint32_t MAX_VM_NUM = 300;
constexpr uint32_t MAX_NODE_NUM = 32;
constexpr uint32_t MAX_DEST_PARAM_SIZE = MAX_BORROW_ID_COUNT;
constexpr uint32_t VIRT_MAX_NODE_ID_LENGTH = 48;
constexpr uint32_t MEM_TASK_ID_MAX = 256;
typedef struct {
    char src_nid[VIRT_MAX_NODE_ID_LENGTH];
    int16_t src_socket_id;
    int16_t src_numa_id;
    uint64_t borrow_size;
}src_memory_borrow_param;
typedef struct {
    char host_id[VIRT_MAX_NODE_ID_LENGTH];
    uint16_t socket_id;
    uint16_t numa_nums;
    int numa_ids[MAX_DEST_NUMA_NUM];
    uint64_t mem_sizes[MAX_DEST_NUMA_NUM];
}dst_numa_info_c;
typedef struct {
    char src_host_id[VIRT_MAX_NODE_ID_LENGTH];
    int16_t src_socket_id;
    int16_t src_numa_id;
    uint64_t borrow_size;
    dst_numa_info_c dest_numa_infos[MAX_DEST_PARAM_SIZE];
    uint32_t dest_numa_infos_size;
}borrow_strategy_c;

#include <stdio.h>
#include <ubs_virt_agent_mem_fragmentation.h>

int main(void)
{
    int32_t ret;
    src_memory_borrow_param src_param = {
            .src_nid = "1",
            .src_socket_id = 2,
            .src_numa_id = 0,
            .borrow_size = 128
    };
    borrow_strategy_c borrow_strategy;
    ret = ubs_virt_agent_mem_borrow_strategy(&src_param, &borrow_strategy);
    if (ret != VA_SUCCESS) {
        perror("ubs_virt_agent_mem_borrow_strategy failed.\n");
        return -1;
    }
    /* Do your work here... */
    return 0;
}

#include <ubs_virt_agent_mem_fragmentation.h>
virt_agent_ret_t ubs_virt_agent_mem_borrow_execute(const borrow_setting_c *borrow_setting, mem_borrow_result_c *result);

typedef struct {
    borrow_strategy_c borrow_strategy;
    bool isAsync;
}borrow_setting_c;
typedef struct {
    char borrow_ids_ptr[MAX_BORROW_ID_COUNT][MAX_BORROW_ID_LENGTH];
    uint16_t present_numa_ids_ptr[MAX_BORROW_ID_COUNT];
    uint32_t borrow_ids_size;
    uint32_t present_numa_ids_size;
    char task_id[MEM_TASK_ID_MAX];
} mem_borrow_result_c;

#include <stdio.h>
#include <ubs_virt_agent_mem_fragmentation.h>

int main(void)
{
    int32_t ret;
    borrow_strategy_c borrow_strategy = {
            .src_host_id = "1",
            .src_socket_id = 1,
            .src_numa_id = 0,
            .borrow_size = 128,
            .dest_numa_infos = {"1", 1, 1, {1}, {128}},
            .dest_numa_infos_size = 1
    };
    borrow_setting_c borrow_setting = {
            borrow_strategy = borrow_strategy,
            isAsync = true
    };
    mem_borrow_result_c result;
    ret = ubs_virt_agent_mem_borrow_execute(&borrow_setting, &result);
    if (ret != VA_SUCCESS) {
        perror("ubs_virt_agent_mem_borrow_execute failed.\n");
        return -1;
    }
    /* Do your work here... */
    return 0;
}

#include <ubs_virt_agent_mem_fragmentation.h>
virt_agent_ret_t ubs_virt_agent_mem_migrate_strategy(const MemMigrateStrategySrcParam* srcParam,
                                                     MemMigrateStrategy* strategy);

typedef struct {
    pid_t pid;
    uint16_t ratio;
}MemMigrateStrategyVmInfo;
typedef struct {
    uint64_t borrowSize;
    char borrowInNode[VIRT_MAX_NODE_ID_LENGTH];
    MemMigrateStrategyVmInfo vmInfoList[MAX_VM_NUM];
    uint32_t vmInfoListSize;
}MemMigrateStrategySrcParam;
typedef struct {
    uint16_t destNumaId;
    uint64_t memSize;
    pid_t pid;
}VmMigrateStrategy;
typedef struct {
    uint32_t vmInfoListSize;
    VmMigrateStrategy* vmInfoList;
    uint64_t waitingTime;
}MemMigrateStrategy;

#include <stdio.h>
#include <ubs_virt_agent_mem_fragmentation.h>

int main(void)
{
    int32_t ret;
    MemMigrateStrategySrcParam srcParam = {
            .borrowSize = 128,
            .borrowInNode = "1",
            .vmInfoList = {{123, 25}},
            .vmInfoListSize = 1
    };
    MemMigrateStrategy strategy;
    ret = ubs_virt_agent_mem_migrate_strategy(&srcParam, &strategy);
    if (ret != VA_SUCCESS) {
        perror("ubs_virt_agent_mem_migrate_strategy failed.\n");
        return -1;
    }
    /* Do your work here... */
    return 0;
}

#include <ubs_virt_agent_mem_fragmentation.h>
virt_agent_ret_t ubs_virt_agent_mem_migrate_execute(const MemMigrateExecuteSrcParam *srcParam);

typedef struct {    
    char borrowInNode[VIRT_MAX_NODE_ID_LENGTH];
    char borrowIds[MAX_BORROW_ID_COUNT][MAX_BORROW_ID_LENGTH];
    uint32_t borrowIdsCount;
    VmMigrateStrategy vmInfoList[MAX_VM_NUM];
    uint32_t vmInfoListSize;
    uint64_t waitingTime;
}MemMigrateExecuteSrcParam;

#include <stdio.h>
#include <ubs_virt_agent_mem_fragmentation.h>

int main(void)
{
    int32_t ret;
    MemMigrateExecuteSrcParam srcParam = {
            .borrowInNode = "1",
            .borrowIds = {"1-abc123"},
            .borrowIdsCount = 1,
            .vmInfoList = {{1, 128, 123}},
            .vmInfoListSize = 1,
            .waitingTime = 1000
    };
    ret = ubs_virt_agent_mem_migrate_execute(&srcParam);
    if (ret != VA_SUCCESS) {
        perror("ubs_virt_agent_mem_migrate_execute failed.\n");
        return -1;
    }
    /* Do your work here... */
    return 0;
}

#include <ubs_virt_agent_mem_fragmentation.h>
virt_agent_ret_t ubs_virt_agent_mem_return(bool isAsync, char **task_id, uint32_t *task_id_len);

#include <stdio.h>
#include <ubs_virt_agent_mem_fragmentation.h>

int main(void)
{
    int32_t ret;
    bool isAsync = true;
    char *task_id;
    uint32_t task_id_len;
    ret = ubs_virt_agent_mem_return(isAsync, &task_id, &task_id_len);
    if (ret != VA_SUCCESS) {
        perror("ubs_virt_agent_mem_return failed.\n");
        return -1;
    }
    /* Do your work here... */
    return 0;
}

#include <ubs_virt_agent_mem_fragmentation.h>
virt_agent_ret_t ubs_virt_agent_mem_rollback(const RollbackSrcParam *srcParam);

typedef struct {
    char node_id[VIRT_MAX_NODE_ID_LENGTH];
    char borrow_id_list[MAX_BORROW_ID_COUNT][MAX_BORROW_ID_LENGTH];
    uint32_t borrow_id_size;
}RollbackSrcParam;

#include <stdio.h>
#include <ubs_virt_agent_mem_fragmentation.h>

int main(void)
{
    int32_t ret;
    RollbackSrcParam srcParam = {
            .node_id = "1",
            .borrow_id_list = {"1-abc123"},
            .borrow_id_size = 1
    };
    ret = ubs_virt_agent_mem_rollback(&srcParam);
    if (ret != VA_SUCCESS) {
        perror("ubs_virt_agent_mem_rollback failed.\n");
        return -1;
    }
    /* Do your work here... */
    return 0;
}

#include <ubs_virt_agent_mem_fragmentation.h>
virt_agent_ret_t ubs_virt_agent_mem_fragmentation_node_anti_affinity(const NodeAntiDictionary* dict);

struct KeyValuePair {
    char key[VIRT_MAX_NODE_ID_LENGTH];
    char value[MAX_NODE_NUM][VIRT_MAX_NODE_ID_LENGTH];
    size_t value_count;
};
struct NodeAntiDictionary {
    struct KeyValuePair entries[MAX_NODE_NUM];
    size_t entry_count;
};

#include <stdio.h>
#include <ubs_virt_agent_mem_fragmentation.h>

int main(void)
{
    int32_t ret;
    NodeAntiDictionary dict = {
            .entries = {
            {"1", {"2"}, 1},
            {"2", {"3"}, 1},
            {"3", {"1"}, 1},
            },
            .entry_count = 3
    };
    ret = ubs_virt_agent_mem_fragmentation_node_anti_affinity(&dict);
    if (ret != VA_SUCCESS) {
        perror("ubs_virt_agent_mem_fragmentation_node_anti_affinity failed.\n");
        return -1;
    }
    /* Do your work here... */
    return 0;
}

#include <ubs_virt_agent_mem_fragmentation.h>
virt_agent_ret_t ubs_virt_agent_sync_task_query(char *task_id, uint32_t task_id_len, async_task_info_c *result);

using async_task_status_c = enum {
    ASYNC_TASK_NOT_EXIST = 0,
    ASYNC_TASK_RUNNING   = 1,
    ASYNC_TASK_SUCCESS   = 2,
    ASYNC_TASK_FAILED    = 3
};

#include <stdio.h>
#include <ubs_virt_agent_mem_fragmentation.h>

int main(void)
{
    int32_t ret;
    char task_id[128] = "abc123";
    uint32_t task_id_len = 6;
    async_task_info_c *result;
    ret = ubs_virt_agent_sync_task_query(task_id, task_id_len, &result);
    if (ret != VA_SUCCESS) {
        perror("ubs_virt_agent_sync_task_query failed.\n");
        return -1;
    }
    /* Do your work here... */
    return 0;
}

#include <ubs_virt_agent_mem_migrate.h>
int32_t update_page_flow_and_status(const char *opt, const char *uuid);

#include <stdio.h>
#include <ubs_virt_agent_mem_migrate.h>

int main(void)
{
    int32_t ret;
    char opt[128] = "true";
    char uuid[128] = "xxxx";
    ret = update_page_flow_and_status(opt, uuid);
    if (ret != VA_SUCCESS) {
        perror("update_page_flow_and_status failed.\n");
        return -1;
    }
    /* Do your work here... */
    return 0;
}

#include <ubs_virt_agent_ham_migrate.h>
virt_agent_ret_t ubs_virt_agent_make_migrate_decision(uint32_t vmMemoryMB, const char *uuid, const char *destHostName,
                                                      uint32_t destNumaId, uint32_t *migrateStrategy);

#include <stdio.h>
#include <ubs_virt_agent_ham_migrate.h>

int main(void)
{
    int32_t ret;
    uint32_t vmMemoryMB = 2048;
    char uuid[128] = "1863ec26-3fda-4f6f-97b2-fcaf9139ac7d";
    char destHostName[128] = "computer02";
    uint32_t destNumaId = 0;
    uint32_t migrateStrategy;
    ret = ubs_virt_agent_make_migrate_decision(vmMemoryMB, uuid, destHostName, destNumaId, &migrateStrategy);
    if (ret != VA_SUCCESS) {
        perror("ubs_virt_agent_make_migrate_decision failed.\n");
        return -1;
    }
    /* Do your work here... */
    return 0;
}

#include <ubs_virt_agent_ham_migrate.h>
virt_agent_ret_t RackStartIpcClientWithTimeout(uint16_t timeout);

#include <stdio.h>
#include <ubs_virt_agent_ham_migrate.h>

int main(void)
{
    int32_t ret;
    uint16_t timeout = 128;
    ret = RackStartIpcClientWithTimeout(timeout);
    if (ret != VA_SUCCESS) {
        perror("RackStartIpcClientWithTimeout failed.\n");
        return -1;
    }
    /* Do your work here... */
    return 0;
}

#include <ubs_virt_agent_ham_migrate.h>
int RackSyncSendForHam(HamComByteBuffer *request, HamComByteBuffer *response);

typedef struct {
    uint8_t *data;
    uint32_t len;
} HamComByteBuffer;

#include <ubs_virt_agent_ham_migrate.h>
int RackAsyncSendForHam(HamComByteBuffer *request, HamComCallbackDef *callback);

typedef void (*HamComCallbackFunc)(void *ctx, void *recv, uint32_t len, int32_t result);
typedef struct {
    HamComCallbackFunc cb; 
    void *cbCtx;         
} HamComCallbackDef;

#include <ubs_virt_agent_mem_fragmentation.h>
virt_agent_ret_t ubs_virt_agent_mem_fragmentation_node_info(numa_info_t **node_list, uint32_t *node_cnt);

VIRT_MAX_NODE_ID_LENGTH = 48
VIRT_MAX_UUID_LENGTH = 37
VIRT_MAX_NAME_LENGTH = 128
VIRT_MAX_STATE_LENGTH = 128
UBS_VA_HOST_NAME_MAX = 64
typedef struct {
    uint64_t pageSize{};
    uint64_t hugePageTotal{};
    uint64_t hugePageFree{};
} numa_page_data;
typedef struct {
    time_t timestamp;
    char node_id[VIRT_MAX_NODE_ID_LENGTH];
    char host_name[UBS_VA_HOST_NAME_MAX];
    int16_t numa_id;
    int16_t socket_id;             // Socket ID mapped to CPUs bound to this NUMA
    int16_t is_local;              // Whether this is a local NUMA (0: non-local, 1: local)
    uint64_t mem_total;            // Total memory of this NUMA node (inclusive), collected from system files, in kB
    uint64_t mem_free;             // Free memory on this NUMA node, collected from system files, in kB
    numa_page_data* huge_page_data;
    uint64_t numaPageInfoCount;
} numa_info_t;

#include <stdio.h>
#include <ubs_virt_agent_mem_fragmentation.h>

int main(void)
{
    int32_t ret;
    numa_info_t* node_list = null;
    uint32_t node_cnt;
    ret = ubs_virt_agent_mem_fragmentation_node_info(&node_list, &node_cnt);
    if (ret != VA_SUCCESS) {
        perror("ubs_virt_agent_mem_fragmentation_node_info failed.\n");
        return -1;
    }
    /* Do your work here... */
    return 0;
}

#include <ubs_virt_agent_mem_fragmentation.h>
virt_agent_ret_t ubs_virt_agent_mem_fragmentation_vm_info(vm_domain_info_t **vm_info_list, uint32_t *vm_info_cnt);

typedef struct {
    char nodeId[VIRT_MAX_NODE_ID_LENGTH]; // Physical node ID (from control-plane configuration file)
    char hostName[UBS_VA_HOST_NAME_MAX];  // Physical node host name (from VM XML definition)
    char uuid[VIRT_MAX_UUID_LENGTH];       // VM UUID (from VM XML definition)
    char name[VIRT_MAX_NAME_LENGTH];       // VM name (from VM XML definition)
    char state[VIRT_MAX_STATE_LENGTH];     // VM state
    int64_t vmCreateTime;
    uint64_t maxMem;
    pid_t pid;
} vm_meta_data_t;
typedef struct {
    time_t timestamp;
    vm_meta_data_t metadata;
    vm_numa_info_t* numaInfo;
    uint64_t numaInfoCount;
} vm_domain_info_t;

#include <stdio.h>
#include <ubs_virt_agent_mem_fragmentation.h>

int main(void)
{
    int32_t ret;
    vm_domain_info_t* vm_info_list = null;
    uint32_t vm_info_cnt;
    ret = ubs_virt_agent_mem_fragmentation_vm_info(&vm_info_list, &vm_info_cnt);
    if (ret != VA_SUCCESS) {
        perror("ubs_virt_agent_mem_fragmentation_vm_info failed.\n");
        return -1;
    }
    /* Do your work here... */
    return 0;
}