JackrabbitLabs-Releases/libmem-release
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
main
libmem-release/cli.c

2283 lines
41 KiB
C
Raw Permalink Normal View History

initial commit for release
2024-08-07 22:24:28 +00:00
/**
* @file cli.c
*
* @brief cli code file for memory management library
*
* @copyright Copyright (C) 2024 Jackrabbit Founders LLC. All rights reserved.
*
* @date Jul 2024
* @author Barrett Edwards <code@jrlabs.io>
*
*/
/* INCLUDES ==================================================================*/
/* printf()
* fprintf()
* stderr
*/
#include <stdio.h>
/* atoi()
* calloc()
* free()
*/
#include <stdlib.h>
/* strcmp()
*/
#include <string.h>
/* errno MACROS
*/
#include <errno.h>
/* CLI_LOG_LEVEL
*/
#include <sys/syslog.h>
/* cxl_new()
* cxl_region
* cxl_memdev
* cxl_decoder
*/
#include <cxl/libcxl.h>
#include "options.h"
#include "libmem.h"
/* MACROS ====================================================================*/
#define CLI_LOG_LEVEL LOG_DEBUG
#define CLI_LOG_DST LMLD_SYSLOG
#define CLI_IG 4096
/* ENUMERATIONS ==============================================================*/
/* STRUCTS ===================================================================*/
struct cli_arg
{
char *name;
char *args;
char *help;
int (*fn)(int argc, char **argv);
};
/* PROTOTYPES ================================================================*/
int cmd_blk_offline(int num, int start);
int cmd_blk_online(int num, int start);
int cmd_info();
int cmd_list(int online, int offline, char *region_name);
int cmd_region_create(int granularity, int num, char **names);
int cmd_region_delete(char *name);
int cmd_region_disable(char *name);
int cmd_region_enable(char *name);
int cmd_region_daxmode(char *name);
int cmd_region_rammode(char *name);
int cmd_region_set_blk_state(char *name, int offset, int state);
int cmd_set_blk_state(int index, int state);
int cmd_set_system_policy(int policy);
int cmd_show_blk_device(int id);
int cmd_show_blk_isonline(int id);
int cmd_show_blk_isremovable(int id);
int cmd_show_blk_node(int id);
int cmd_show_blk_state(int id);
int cmd_show_blk_zones(int id);
int cmd_show_blocks(int online, int offline, char *region_name);
int cmd_show_capacity(int online, int offline, char *region_name, int human);
int cmd_show_memdev_interleave_granulariy(char *name); //todo
int cmd_show_memdev_isavailable(char *name);
int cmd_show_memdevs(char *memdev_name, char *region_name, int human);
int cmd_show_num_blocks(int online, int offline, char *region_name);
int cmd_show_num_devices();
int cmd_show_num_regions();
int cmd_show_region_blk_state(char *name, int offset);
int cmd_show_region_isenabled(char *name);
int cmd_show_regions(char *name, int human);
int cmd_show_system_blocksize(int human);
int cmd_show_system_policy();
/* GLOBAL VARIABLES ==========================================================*/
/* FUNCTIONS =================================================================*/
int cmd_blk_offline(int num, int start)
{
int rv;
struct mem_ctx *ctx;
rv = 1;
// Validate Privileges
if ( getuid() != 0 )
{
fprintf(stderr, "Error: Command must be run as root\n");
rv = -EACCES;
goto end;
}
// Get mem contex
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
for ( int i = start ; i < (start + num) ; i++)
{
if (mem_blkid_is_online(ctx, i) == 1)
{
// Online a memory block
rv = mem_blkid_offline(ctx, i);
if (rv != 0)
{
fprintf(stderr, "Error: Could not offline memory block %d. %d\n", i, rv);
goto err;
}
}
}
rv = 0;
err:
mem_unref(ctx);
end:
return rv;
}
int cmd_blk_online(int num, int start)
{
int rv;
struct mem_ctx *ctx;
struct mem_blk *blk;
rv = 1;
// Validate Privileges
if ( getuid() != 0 )
{
fprintf(stderr, "Error: Command must be run as root\n");
rv = -EACCES;
goto end;
}
// Get mem contex
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
// Online all blocks
if (num < 0)
{
mem_blk_foreach(ctx, blk)
if (!mem_blk_is_online(blk))
mem_blk_online(blk);
}
else
{
for ( int i = start ; i < (start + num) ; i++)
{
if (!mem_blkid_is_online(ctx, i))
{
// Online a memory block
rv = mem_blkid_online(ctx, i);
if (rv != 0)
{
fprintf(stderr, "Error: Could not online memory block %d. %d\n", i, rv);
goto err;
}
}
}
}
rv = 0;
err:
mem_unref(ctx);
end:
return rv;
}
int cmd_info()
{
int rv;
struct mem_ctx *ctx;
// Create mem context
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
printf("Memory Blocksize: %llu\n", mem_system_get_blocksize(ctx));
printf("Auto Online Memory Policy: %s\n", mem_lmpl(mem_system_get_policy(ctx)));
printf("Number of Blocks: %d\n", mem_system_num_blocks(ctx));
printf(" Number of Blocks online: %d\n", mem_system_num_blocks_online(ctx));
printf(" Number of Blocks offline: %d\n", mem_system_num_blocks_offline(ctx));
printf("Memory Capacity: %llu\n", mem_system_get_capacity(ctx));
printf(" Memory Capacity online: %llu\n", mem_system_get_capacity_online(ctx));
printf(" Memory Capacity offline: %llu\n", mem_system_get_capacity_offline(ctx));
printf("Number of CXL regions: %d\n", mem_num_regions(ctx));
printf("Number of CXL memdevs: %d\n", mem_num_memdevs(ctx));
mem_unref(ctx);
end:
return rv;
}
int cmd_list(int online, int offline, char *region_name)
{
int rv;
struct mem_blk *blk;
struct mem_ctx *ctx;
struct cxl_region *region;
unsigned long u;
// Initialize variables
rv = 1;
// Get mem context
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
printf("Index node online cxl_region zones\n");
printf("----- ---- ------ ---------- -------------------\n");
mem_blk_foreach(ctx, blk)
{
if (online && !mem_blk_is_online(blk))
continue;
if (offline && mem_blk_is_online(blk))
continue;
region = mem_blk_get_region(blk);
if (region == NULL && region_name != NULL)
continue;
if (region != NULL && region_name != NULL && strcmp(region_name, cxl_region_get_devname(region)) )
continue;
printf("%-5d %-4d %-6d ",
mem_blk_get_id(blk),
mem_blk_get_node(blk),
mem_blk_is_online(blk));
if (region != NULL)
printf("%-10s ", cxl_region_get_devname(region));
else
printf("%-10s ", "-");
// Print zones
u = mem_blk_get_zones(blk);
for ( int k = 0 ; k < LMZN_MAX ; k++)
{
if (u & (0x01 << k))
printf("%s ", mem_lmzn(k));
}
printf("\n");
}
end:
return rv;
}
int cmd_region_create(int granularity, int num, char **names)
{
int rv;
struct cxl_memdev **memdevs;
struct mem_ctx *ctx;
// Initialize variables
rv = 1;
// Validate Privileges
if ( getuid() != 0 )
{
fprintf(stderr, "Error: Command must be run as root\n");
rv = -EACCES;
goto end;
}
// Validate Inputs
if (granularity == 0)
granularity = CLI_IG;
if (!(granularity == 256
|| granularity == 512
|| granularity == 1024
|| granularity == 2048
|| granularity == 4096
|| granularity == 8192))
{
fprintf(stderr, "Error: Invalid Interleave Granularity: %d\n", granularity);
rv = -EINVAL;
goto end;
}
if (num < 0)
{
fprintf(stderr, "Error: Missing memdev[s]\n");
rv = -EINVAL;
goto end;
}
// Get mem context
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
// Use all memdevs
if (num == 0)
{
num = mem_num_memdevs(ctx);
memdevs = mem_get_memdevs(ctx);
}
else
{
// Allocate memory for the array of memdevs
memdevs = calloc(num, sizeof(*memdevs));
if (memdevs == NULL)
{
fprintf(stderr, "Error: Could not allocate memory. %d - %s\n", errno, strerror(errno));
rv = -ENOMEM;
goto err;
}
// Loop through requested memory devices
for ( int i = 0 ; i < num ; i++ )
{
memdevs[i] = mem_get_memdev(ctx, names[i]);
if (memdevs[i] == NULL)
{
fprintf(stderr, "Error: Could not obtain memdev: %s\n", names[i]);
rv = 1;
goto err;
}
}
}
// Create the region
rv = mem_region_create(ctx, granularity, num, memdevs);
if (rv != 0)
{
fprintf(stderr, "Error: Could not create region: %d\n", rv);
rv = 1;
goto err;
}
rv = 0;
err:
free(memdevs);
mem_unref(ctx);
end:
return rv;
}
int cmd_region_daxmode(char *name)
{
int rv;
struct mem_ctx *ctx;
struct cxl_region *region;
// Initialize variables
rv = 1;
// Validate Privileges
if ( getuid() != 0 )
{
fprintf(stderr, "Error: Command must be run as root\n");
rv = -EACCES;
goto end;
}
// Validate Inputs
if (name == NULL)
{
fprintf(stderr, "Error: Missing region\n");
rv = -EINVAL;
goto end;
}
// Get mem context
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
// Get region
region = mem_get_region(ctx, name);
if (region == NULL)
{
fprintf(stderr, "Error: Could not obtain region: %s\n", name);
rv = 1;
goto err;
}
// Enable devdax mode
rv = mem_region_daxmode(ctx, region);
if (rv != 0)
{
fprintf(stderr, "Error: Enable of devdax mode failed: %d\n", rv);
rv = 1;
goto err;
}
rv = 0;
err:
mem_unref(ctx);
end:
return rv;
}
int cmd_region_delete(char *name)
{
int rv, num;
struct mem_ctx *ctx;
struct cxl_region *region, **regions;
// Initialize variables
rv = 1;
// Validate Privileges
if ( getuid() != 0 )
{
fprintf(stderr, "Error: Command must be run as root\n");
rv = -EACCES;
goto end;
}
// Get mem context
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
// Delete all regions
if (name == NULL)
{
num = mem_num_regions(ctx);
regions = mem_get_regions(ctx);
char name[256];
for ( int i = 0 ; i < num ; i++)
{
// Delete region
strcpy(name, cxl_region_get_devname(regions[i]));
rv = mem_region_delete(ctx, regions[i]);
if (rv != 0)
{
fprintf(stderr, "Error: Could not delete region: %s\n", name);
rv = 1;
goto err;
}
}
}
else
{
// Get region
region = mem_get_region(ctx, name);
if (region == NULL)
{
fprintf(stderr, "Error: Could not obtain region: %s\n", name);
rv = 1;
goto err;
}
// Delete region
rv = mem_region_delete(ctx, region);
if (rv != 0)
{
fprintf(stderr, "Error: Could not delete region: %s\n", name);
rv = 1;
goto err;
}
}
rv = 0;
err:
mem_unref(ctx);
end:
return rv;
}
int cmd_region_disable(char *name)
{
int rv;
struct mem_ctx *ctx;
struct cxl_region *region;
// Initialize variables
rv = 1;
// Validate Privileges
if ( getuid() != 0 )
{
fprintf(stderr, "Error: Command must be run as root\n");
rv = -EACCES;
goto end;
}
// Validate Inputs
if (name == NULL)
{
fprintf(stderr, "Error: Missing region\n");
rv = -EINVAL;
goto end;
}
// Get mem context
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
// Get region
region = mem_get_region(ctx, name);
if (region == NULL)
{
fprintf(stderr, "Error: Could not obtain region: %s\n", name);
rv = 1;
goto err;
}
// Check if Region was enabled
rv = cxl_region_is_enabled(region);
if (rv == 0)
{
fprintf(stderr, "Region was already disabled\n");
rv = 1;
goto err;
}
// Disable Region
rv = cxl_region_disable(region);
if (rv != 0)
{
fprintf(stderr, "Error: Could not disable region: %d\n", rv);
rv = 1;
goto err;
}
rv = 0;
err:
mem_unref(ctx);
end:
return rv;
}
int cmd_region_enable(char *name)
{
int rv;
struct mem_ctx *ctx;
struct cxl_region *region;
// Initialize variables
rv = 1;
// Validate Privileges
if ( getuid() != 0 )
{
fprintf(stderr, "Error: Command must be run as root\n");
rv = -EACCES;
goto end;
}
// Validate Inputs
if (name == NULL)
{
fprintf(stderr, "Error: Missing region\n");
rv = -EINVAL;
goto end;
}
// Get mem context
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
// Get the region
region = mem_get_region(ctx, name);
if (region == NULL)
{
fprintf(stderr, "Error: Could not obtain region: %s\n", name);
rv = 1;
goto err;
}
// Check if region is already enabled
rv = cxl_region_is_enabled(region);
if (rv == 1)
{
fprintf(stderr, "Region was already enabled\n");
rv = 1;
goto err;
}
// Enable the region
rv = cxl_region_enable(region);
if (rv != 0)
{
fprintf(stderr, "Error: Could not enable region: %d\n", rv);
rv = 1;
goto err;
}
rv = 0;
err:
mem_unref(ctx);
end:
return rv;
}
int cmd_region_rammode(char *name)
{
int rv;
struct mem_ctx *ctx;
struct cxl_region *region;
// Initialize variables
rv = 1;
// Validate Privileges
if ( getuid() != 0 )
{
fprintf(stderr, "Error: Command must be run as root\n");
rv = -EACCES;
goto end;
}
// Validate Inputs
if (name == NULL)
{
fprintf(stderr, "Error: Missing region\n");
rv = -EINVAL;
goto end;
}
// Get mem context
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
// Get Region
region = mem_get_region(ctx, name);
if (region == NULL)
{
fprintf(stderr, "Error: Could not obtain region: %s\n", name);
rv = 1;
goto err;
}
// Enable Ram mode
rv = mem_region_rammode(ctx, region);
if (rv != 0)
{
fprintf(stderr, "Error: Enable of systemram mode failed: %d\n", rv);
rv = 1;
goto err;
}
rv = 0;
err:
mem_unref(ctx);
end:
return rv;
}
int cmd_region_set_blk_state(char *name, int offset, int state)
{
int rv, num;
struct mem_ctx *ctx;
struct cxl_region *region;
rv = 1;
// Validate Privileges
if ( getuid() != 0 )
{
fprintf(stderr, "Error: Command must be run as root\n");
rv = -EACCES;
goto end;
}
// Validate Inputs
if (name == NULL)
{
fprintf(stderr, "Error: Missing region\n");
rv = -EINVAL;
goto end;
}
if (offset < -1)
{
fprintf(stderr, "Error: Invalid index\n");
rv = -EINVAL;
goto end;
}
if (state <0 || state >= LMPL_MAX)
{
fprintf(stderr, "Error: Invalid state\n");
rv = -EINVAL;
goto end;
}
// Get mem contex
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
region = mem_get_region(ctx, name);
if (region == NULL)
{
fprintf(stderr, "Error: Could not obtain region\n");
rv = 1;
goto err;
}
if (offset == -1)
{
num = mem_region_num_blocks(ctx, region);
for ( int i = 0 ; i < num ; i++)
{
// Set the state
rv = mem_region_set_blk_state(ctx, region, i, state);
if (rv < 0)
{
fprintf(stderr, "Error: Could not set state of memory block %d in region %s: %d\n", i, cxl_region_get_devname(region), rv);
rv = 1;
goto err;
}
}
}
else
{
// Set the state
rv = mem_region_set_blk_state(ctx, region, offset, state);
if (rv < 0)
{
fprintf(stderr, "Error: Could not set state of memory block %d in region %s: %d\n", offset, cxl_region_get_devname(region), rv);
rv = 1;
goto err;
}
}
rv = 0;
err:
mem_unref(ctx);
end:
return rv;
}
int cmd_set_blk_state(int index, int state)
{
int rv;
struct mem_ctx *ctx;
rv = 1;
// Validate Privileges
if ( getuid() != 0 )
{
fprintf(stderr, "Error: Command must be run as root\n");
rv = -EACCES;
goto end;
}
// Validate Inputs
if (index < 0)
{
fprintf(stderr, "Error: Invalid index\n");
rv = -EINVAL;
goto end;
}
if (state < 0 || state >= LMPL_MAX)
{
fprintf(stderr, "Error: Invalid state\n");
rv = -EINVAL;
goto end;
}
// Get mem contex
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
// Set the state
rv = mem_blkid_set_state(ctx, index, state);
if (rv != 0)
{
fprintf(stderr, "Error: Could not set state of memory block. %d\n", rv);
rv = 1;
goto err;
}
rv = 0;
err:
mem_unref(ctx);
end:
return rv;
}
int cmd_set_system_policy(int policy)
{
int rv;
struct mem_ctx *ctx;
rv = 1;
// Validate Privileges
if ( getuid() != 0 )
{
fprintf(stderr, "Error: Command must be run as root\n");
rv = -EACCES;
goto end;
}
// Validate Inputs
if (policy < 0 || policy >= LMPL_MAX)
{
fprintf(stderr, "Error: Inavlid policy\n");
rv = 1;
goto end;
}
// Get mem contex
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
// Set the policy
rv = mem_system_set_policy(ctx, policy);
if (rv != 0)
{
fprintf(stderr, "Error: Could not set policy. %d\n", rv);
rv = 1;
goto err;
}
rv = 0;
err:
mem_unref(ctx);
end:
return rv;
}
int cmd_show_blk_device(int id)
{
int rv;
struct mem_ctx *ctx;
rv = 1;
// Validate Inputs
if (id < 1)
{
fprintf(stderr, "Error: Missing block index\n");
rv = -EINVAL;
goto end;
}
// Get mem contex
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
// Get phys device
rv = mem_blkid_get_device(ctx, id);
if (rv < 0)
{
fprintf(stderr, "Error: Could not obtain phys_device. %d\n", rv);
rv = 1;
goto err;
}
printf("%d\n", rv);
rv = 0;
err:
mem_unref(ctx);
end:
return rv;
}
int cmd_show_blk_isonline(int id)
{
int rv;
struct mem_ctx *ctx;
struct mem_blk *blk;
rv = 1;
// Validate Inputs
if (id < 1)
{
fprintf(stderr, "Error: Missing block index\n");
rv = -EINVAL;
goto end;
}
// Get mem contex
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
// Check if memory block is online
rv = -1;
mem_blk_foreach(ctx, blk)
if (id == mem_blk_get_id(blk))
{
rv = mem_blk_is_online(blk);
break;
}
printf("%d\n", rv);
rv = 0;
mem_unref(ctx);
end:
return rv;
}
int cmd_show_blk_isremovable(int id)
{
int rv;
struct mem_ctx *ctx;
rv = 1;
// Validate Inputs
if (id < 1)
{
fprintf(stderr, "Error: Missing block index\n");
rv = -EINVAL;
goto end;
}
// Get mem contex
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
rv = mem_blkid_is_removable(ctx, id);
printf("%d\n", rv);
rv = 0;
mem_unref(ctx);
end:
return rv;
}
int cmd_show_blk_node(int id)
{
int rv;
struct mem_ctx *ctx;
rv = 1;
// Validate Inputs
if (id < 1)
{
fprintf(stderr, "Error: Missing block index\n");
rv = -EINVAL;
goto end;
}
// Get mem contex
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
rv = mem_blkid_get_node(ctx, id);
printf("%d\n", rv);
rv = 0;
mem_unref(ctx);
end:
return rv;
}
int cmd_show_blk_state(int id)
{
int rv;
struct mem_ctx *ctx;
rv = 1;
// Validate Inputs
if (id < 1)
{
fprintf(stderr, "Error: Missing block index\n");
rv = -EINVAL;
goto end;
}
// Get mem contex
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
rv = mem_blkid_get_state(ctx, id);
if (rv < 0)
{
fprintf(stderr, "Error: Could not obtain block state: %d\n", rv);
rv = 1;
goto err;
}
printf("%s\n", mem_lmpl(rv));
rv = 0;
err:
mem_unref(ctx);
end:
return rv;
}
int cmd_show_blk_zones(int id)
{
int i, rv;
unsigned long u;
struct mem_ctx *ctx;
rv = 1;
// Validate Inputs
if (id < 1)
{
fprintf(stderr, "Error: Missing block index\n");
rv = -EINVAL;
goto end;
}
// Get mem contex
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
u = mem_blkid_get_zones(ctx, id);
for ( i = 0 ; i < LMZN_MAX ; i++ )
{
if ((0x01 << i) & u)
printf("%s ", mem_lmzn(i));
}
printf("\n");
rv = 0;
mem_unref(ctx);
end:
return rv;
}
int cmd_show_blocks(int online, int offline, char *region_name)
{
int rv;
struct mem_ctx *ctx;
struct mem_blk *blk;
struct cxl_region *region;
rv = 1;
// Get mem contex
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
mem_blk_foreach(ctx, blk)
{
if (online && !mem_blk_is_online(blk))
continue;
if (offline && mem_blk_is_online(blk))
continue;
region = mem_blk_get_region(blk);
if (region_name != NULL && region == NULL)
continue;
if (region_name != NULL && region != NULL && strcmp(region_name, cxl_region_get_devname(region)))
continue;
printf("%d\n", mem_blk_get_id(blk));
}
rv = 0;
mem_unref(ctx);
end:
return rv;
}
int cmd_show_capacity(int online, int offline, char *region_name, int human)
{
unsigned long long size;
double d;
int i, rv;
struct mem_ctx *ctx;
struct cxl_region *region;
i = 0;
// Get mem contex
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
if (region_name == NULL)
{
if (online)
size = mem_system_get_capacity_online(ctx);
else if (offline)
size = mem_system_get_capacity_offline(ctx);
else
size = mem_system_get_capacity(ctx);
}
else
{
region = mem_get_region(ctx, region_name);
if (region == NULL)
{
fprintf(stderr, "Error: Could not obtain region: %s\n", region_name);
goto end;
}
if (online)
size = mem_region_get_capacity_online(ctx, region);
else if (offline)
size = mem_region_get_capacity_offline(ctx, region);
else
size = mem_region_get_capacity(ctx, region);
}
if (human)
{
char units[] = {' ', 'K', 'M', 'G', 'T'};
d = (double) size;
while ((d > 1024) && i++ < 5)
d /= 1024;
printf("%0.2f %c\n", d, units[i]);
}
else
printf("%llu\n", size);
rv = 0;
mem_unref(ctx);
end:
return rv;
}
int cmd_show_memdev_interleave_granulariy(char *name)
{
int rv;
struct mem_ctx *ctx;
struct cxl_memdev *memdev;
// Initialize variables
rv = 1;
ctx = NULL;
// Validate Inputs
if (name == NULL)
{
fprintf(stderr, "Error: Missing memdev\n");
rv = -EINVAL;
goto end;
}
// Get mem context
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
// Get memdev
memdev = mem_get_memdev(ctx, name);
if (memdev == NULL)
{
fprintf(stderr, "Error: Could not obtain memdev: %s\n", name);
rv = 1;
goto err;
}
rv = mem_memdev_get_interleave_granularity(ctx, memdev);
printf("%d\n", rv);
rv = 0;
err:
mem_unref(ctx);
end:
return rv;
}
int cmd_show_memdev_isavailable(char *name)
{
int rv;
struct mem_ctx *ctx;
struct cxl_memdev *memdev;
// Initialize variables
rv = 1;
// Validate Inputs
if (name == NULL)
{
fprintf(stderr, "Error: Missing memdev\n");
rv = -EINVAL;
goto end;
}
// Get mem context
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
// Get memdev
memdev = mem_get_memdev(ctx, name);
if (memdev == NULL)
{
fprintf(stderr, "Error: Could not obtain memdev: %s\n", name);
rv = 1;
goto err;
}
rv = mem_memdev_is_available(ctx, memdev);
printf("%d\n", rv);
rv = 0;
err:
mem_unref(ctx);
end:
return rv;
}
int cmd_show_memdevs(char *memdev_name, char *region_name, int human)
{
int rv;
struct mem_ctx *ctx;
struct cxl_memdev *memdev;
struct cxl_endpoint *endpoint;
struct cxl_port *port;
struct cxl_decoder *decoder;
struct cxl_region *region;
int i, num;
struct cxl_memdev **array;
rv = 1;
i = 0;
array = NULL;
// Get mem context
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
// Get the number of memdevs
num = mem_num_memdevs(ctx);
if (opts[CLOP_NUM].set)
{
printf("%d\n", num);
goto end;
}
if (num <= 0)
{
rv = 0;
goto end;
}
// Get a sorted list of memdevs
array = mem_get_memdevs(ctx);
if (array == NULL)
{
fprintf(stderr, "Error: Could not obtain list of memdevs\n");
rv = 1;
goto err;
}
printf("Name Enabled Mode Size Host Endpoint Decoder Region FW Version\n");
printf("------ ------- ------ -------------- ------------ ----------- ----------- ------------ -------------------\n");
for ( i = 0 ; i < num ; i++)
{
memdev = array[i];
if (memdev_name != NULL && strcmp(memdev_name, cxl_memdev_get_devname(memdev)))
continue;
endpoint = cxl_memdev_get_endpoint(memdev);
port = cxl_endpoint_get_port(endpoint);
decoder = cxl_decoder_get_first(port);
region = cxl_decoder_get_region(decoder);
int mode = cxl_decoder_get_mode(decoder);
unsigned long long size = cxl_memdev_get_ram_size(memdev);
const char *host = cxl_memdev_get_host(memdev);
const char *reg_name = NULL;
if (region != NULL)
{
reg_name = cxl_region_get_devname(region);
}
else
reg_name ="-";
if (region_name != NULL && strcmp(reg_name, region_name))
continue;
printf("%-6s %7d %6s ",
cxl_memdev_get_devname(memdev),
cxl_memdev_is_enabled(memdev),
cxl_decoder_mode_name(mode));
if (human)
{
char units[] = {' ', 'K', 'M', 'G', 'T'};
double d = (double) size;
int i = 0;
while ((d > 1024) && i++ < 5)
d /= 1024;
printf("%12.2f %c ", d, units[i]);
}
else
printf("%14llu ", size);
printf("%12s %11s %11s %12s %-20s\n",
host,
cxl_endpoint_get_devname(endpoint),
cxl_decoder_get_devname(decoder),
reg_name,
cxl_memdev_get_firmware_verison(memdev)
);
}
// Free the sorted array of memdevs
if (array != NULL)
free(array);
rv = 0;
err:
mem_unref(ctx);
end:
return rv;
}
int cmd_show_num_blocks(int online, int offline, char *region_name)
{
int rv, num;
struct mem_ctx *ctx;
struct cxl_region *region;
// Initialize variables
num = 0;
// Get mem contex
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
if (region_name != NULL)
{
region = mem_get_region(ctx, region_name);
if (region == NULL)
{
fprintf(stderr, "Error: Could not obtain region: %s\n", region_name);
rv = 1;
goto end;
}
if (online)
num = mem_region_num_blocks_online(ctx, region);
else if (offline)
num = mem_region_num_blocks_offline(ctx, region);
else
num = mem_region_num_blocks(ctx, region);
}
else
{
if (online)
num = mem_system_num_blocks_online(ctx);
else if (offline)
num = mem_system_num_blocks_offline(ctx);
else
num = mem_system_num_blocks(ctx);
}
printf("%d\n", num);
rv = 0;
mem_unref(ctx);
end:
return rv;
}
int cmd_show_num_blocks_offline()
{
struct mem_ctx *ctx;
int rv;
// Get mem contex
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
printf("%d\n", mem_system_num_blocks_offline(ctx));
rv = 0;
mem_unref(ctx);
end:
return rv;
}
int cmd_show_num_blocks_online()
{
struct mem_ctx *ctx;
int rv;
// Get mem contex
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
printf("%d\n", mem_system_num_blocks_online(ctx));
rv = 0;
mem_unref(ctx);
end:
return rv;
}
int cmd_show_num_devices()
{
int rv;
struct mem_ctx *ctx;
rv = 1;
// Get mem context
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
printf("%d\n", mem_num_memdevs(ctx));
rv = 0;
mem_unref(ctx);
end:
return rv;
}
int cmd_show_num_regions()
{
int rv;
struct mem_ctx *ctx;
rv = 1;
// Get mem cntext
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
printf("%d\n", mem_num_regions(ctx));
rv = 0;
mem_unref(ctx);
end:
return rv;
}
int cmd_show_region_blk_state(char *name, int offset)
{
int rv;
struct mem_ctx *ctx;
struct cxl_region *region;
rv = 1;
// Validate Inputs
if (name == NULL)
{
fprintf(stderr, "Error: Missing region\n");
rv = -EINVAL;
goto end;
}
// Validate Inputs
if (offset < 0)
{
fprintf(stderr, "Error: Missing block index\n");
rv = -EINVAL;
goto end;
}
// Get mem contex
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
region = mem_get_region(ctx, name);
if (region == NULL)
{
fprintf(stderr, "Error: Could not obtain region\n");
rv = 1;
goto err;
}
rv = mem_region_get_blk_state(ctx, region, offset);
if (rv < 0)
{
fprintf(stderr, "Error: Could not obtain state of block %d in region %s: %d\n", offset, cxl_region_get_devname(region), rv);
rv = 1;
goto err;
}
printf("%s\n", mem_lmpl(rv));
rv = 0;
err:
mem_unref(ctx);
end:
return rv;
}
int cmd_show_region_isenabled(char *name)
{
int rv;
struct mem_ctx *ctx;
struct cxl_region *region;
rv = 1;
// Validate Inputs
if (name == NULL)
{
fprintf(stderr, "Error: Missing region\n");
rv = -EINVAL;
goto end;
}
// Get mem context
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
region = mem_get_region(ctx, name);
if (region == NULL)
{
fprintf(stderr, "Error: Could not obtain region: %s\n", name);
rv = 1;
goto err;
}
rv = cxl_region_is_enabled(region);
printf("%d\n", rv);
rv = 0;
err:
mem_unref(ctx);
end:
return rv;
}
int cmd_show_regions(char *name, int human)
{
int rv;
struct mem_ctx *ctx;
struct cxl_decoder *d;
struct cxl_region **regions, *region;
struct cxl_memdev *memdev;
int i, j, num, num_regions;
rv = 1;
// Get mem context
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
num_regions = mem_num_regions(ctx);
regions = mem_get_regions(ctx);
if (num_regions <= 0 || regions == NULL)
{
rv = 0;
goto err;
}
printf("Name Enabled Dax Mode Size Ways Granularity Num Blocks Blocks Online Devices\n");
printf("--------- ------- --- ------ -------------- ---- ----------- ---------- ------------- -------\n");
for ( i = 0 ; i < num_regions ; i++)
{
region = regions[i];
// Skip if a region name was provided and doesn't match this region name
if (name != NULL && strcmp(name, cxl_region_get_devname(region)))
continue;
printf("%-9s %7d %3d %6s ",
cxl_region_get_devname(region),
cxl_region_is_enabled(region),
mem_region_is_daxmode(ctx, region),
cxl_decoder_mode_name(cxl_region_get_mode(region)));
if (human)
{
char units[] = {' ', 'K', 'M', 'G', 'T'};
double d = (double) cxl_region_get_size(region);
int i = 0;
while ((d > 1024) && i++ < 5)
d /= 1024;
printf("%12.2f %c ", d, units[i]);
}
else
printf("%14llu ", cxl_region_get_size(region));
printf("%4d %11d %10d %13d ",
cxl_region_get_interleave_ways(region),
cxl_region_get_interleave_granularity(region),
mem_region_num_blocks(ctx, region),
mem_region_num_blocks_online(ctx, region)
);
num = cxl_region_get_interleave_ways(region);
if (cxl_region_decode_is_committed(region))
{
for ( j = 0 ; j < num ; j++)
{
d = cxl_region_get_target_decoder(region, j);
if (d == NULL)
{
printf("%d:%s ", j, "-");
continue;
}
memdev = cxl_decoder_get_memdev(d);
if (memdev != NULL)
printf("%d:%s ", j, cxl_memdev_get_devname(memdev));
else
printf("%d:%s ", j, "-");
}
}
else
printf(" -");
printf("\n");
}
rv = 0;
err:
mem_unref(ctx);
end:
return rv;
}
int cmd_show_system_blocksize(int human)
{
int rv;
unsigned long long size;
struct mem_ctx *ctx;
// Get mem contex
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
size = mem_system_get_blocksize(ctx);
if (human)
{
char units[] = {' ', 'K', 'M', 'G', 'T'};
double d = (double) size;
int i = 0;
while ((d > 1024) && i++ < 5)
d /= 1024;
printf("%0.2f %c\n", d, units[i]);
}
else
printf("%llu\n", size);
rv = 0;
mem_unref(ctx);
end:
return rv;
}
int cmd_show_system_policy()
{
struct mem_ctx *ctx;
int rv;
// Get mem contex
rv = mem_new(&ctx);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to obtain mem context: %d\n", rv);
rv = 1;
goto end;
}
mem_log_set_destination(ctx, CLI_LOG_DST, NULL);
mem_log_set_priority(ctx, CLI_LOG_LEVEL);
rv = mem_system_get_policy(ctx);
printf("%s\n", mem_lmpl(rv));
rv = 0;
mem_unref(ctx);
end:
return rv;
}
int run()
{
int rv;
rv = 1;
switch(opts[CLOP_CMD].val)
{
case CLCM_INFO:
rv = cmd_info();
break;
case CLCM_LIST:
rv = cmd_list(opts[CLOP_ONLINE].set, opts[CLOP_OFFLINE].set, opts[CLOP_REGION].str);
break;
case CLCM_BLOCK_ONLINE:
if (opts[CLOP_ALL].set)
rv = cmd_blk_online(-1, 0);
else if (opts[CLOP_BLOCK].num == 0)
rv = cmd_blk_online(1, opts[CLOP_BLOCK].val);
else if (opts[CLOP_BLOCK].num >= 0)
rv = cmd_blk_online(opts[CLOP_BLOCK].num, *((int*)opts[CLOP_BLOCK].buf));
break;
case CLCM_BLOCK_OFFLINE:
if (opts[CLOP_BLOCK].num == 0)
rv = cmd_blk_offline(1, opts[CLOP_BLOCK].val);
else if (opts[CLOP_BLOCK].num > 0)
rv = cmd_blk_offline(opts[CLOP_BLOCK].num, *((int*)opts[CLOP_BLOCK].buf));
break;
case CLCM_REGION_CREATE:
if (opts[CLOP_ALL].set)
rv = cmd_region_create(opts[CLOP_GRANULARITY].u32, 0, NULL);
else
rv = cmd_region_create(opts[CLOP_GRANULARITY].u32, opts[CLOP_DEVICE].num, (char**)opts[CLOP_DEVICE].buf);
break;
case CLCM_REGION_DAXMODE:
rv = cmd_region_daxmode(opts[CLOP_REGION].str);
break;
case CLCM_REGION_RAMMODE:
rv = cmd_region_rammode(opts[CLOP_REGION].str);
break;
case CLCM_REGION_DELETE:
if (opts[CLOP_ALL].set)
rv = cmd_region_delete(NULL);
else
rv = cmd_region_delete(opts[CLOP_REGION].str);
break;
case CLCM_REGION_DISABLE:
rv = cmd_region_disable(opts[CLOP_REGION].str);
break;
case CLCM_REGION_ENABLE:
rv = cmd_region_enable(opts[CLOP_REGION].str);
break;
case CLCM_SET_BLOCK_STATE:
if (opts[CLOP_ALL].set && (opts[CLOP_ONLINE].set || opts[CLOP_MOVABLE].set))
rv = cmd_blk_online(-1, 0);
else if (opts[CLOP_ONLINE].set || opts[CLOP_MOVABLE].set)
rv = cmd_set_blk_state(opts[CLOP_BLOCK].val, LMPL_MOVABLE);
else if (opts[CLOP_KERNEL].set)
rv = cmd_set_blk_state(opts[CLOP_BLOCK].val, LMPL_KERNEL);
else
rv = cmd_set_blk_state(opts[CLOP_BLOCK].val, LMPL_OFFLINE);
break;
case CLCM_SET_REGION_BLOCK_STATE:
{
int mode;
if (opts[CLOP_ONLINE].set || opts[CLOP_MOVABLE].set)
mode = LMPL_MOVABLE;
else if (opts[CLOP_KERNEL].set)
mode = LMPL_KERNEL;
else
mode = LMPL_OFFLINE;
if (opts[CLOP_BLOCK].num > 0)
{
rv = 0;
int start = *((int*)opts[CLOP_BLOCK].buf);
for (int i = 0 ; i < (int) opts[CLOP_BLOCK].num ; i++)
rv += cmd_region_set_blk_state(opts[CLOP_REGION].str, start+i, mode);
}
else if (opts[CLOP_ALL].set)
{
rv = cmd_region_set_blk_state(opts[CLOP_REGION].str, -1, mode);
}
else
rv = cmd_region_set_blk_state(opts[CLOP_REGION].str, opts[CLOP_BLOCK].val, mode);
}
break;
case CLCM_SET_SYSTEM_POLICY:
if (opts[CLOP_ONLINE].set)
rv = cmd_set_system_policy(LMPL_ONLINE);
else if (opts[CLOP_MOVABLE].set)
rv = cmd_set_system_policy(LMPL_MOVABLE);
else if (opts[CLOP_KERNEL].set)
rv = cmd_set_system_policy(LMPL_KERNEL);
else
rv = cmd_set_system_policy(LMPL_OFFLINE);
break;
case CLCM_SHOW_BLK_ISONLINE:
rv = cmd_show_blk_isonline(opts[CLOP_BLOCK].val);
break;
case CLCM_SHOW_BLK_ISREMOVABLE:
rv = cmd_show_blk_isremovable(opts[CLOP_BLOCK].val);
break;
case CLCM_SHOW_BLK_NODE:
rv = cmd_show_blk_node(opts[CLOP_BLOCK].val);
break;
case CLCM_SHOW_BLK_PHYSDEVICE:
rv = cmd_show_blk_node(opts[CLOP_BLOCK].val);
break;
case CLCM_SHOW_BLK_STATE:
if (opts[CLOP_REGION].set)
rv = cmd_show_region_blk_state(opts[CLOP_REGION].str, opts[CLOP_BLOCK].val);
else
rv = cmd_show_blk_state(opts[CLOP_BLOCK].val);
break;
case CLCM_SHOW_BLK_ZONES:
rv = cmd_show_blk_zones(opts[CLOP_BLOCK].val);
break;
case CLCM_SHOW_BLOCKS:
rv = cmd_show_blocks(opts[CLOP_ONLINE].set, opts[CLOP_OFFLINE].set, opts[CLOP_REGION].str);
break;
case CLCM_SHOW_CAPACITY:
rv = cmd_show_capacity(opts[CLOP_ONLINE].set, opts[CLOP_OFFLINE].set, opts[CLOP_REGION].str, opts[CLOP_HUMAN].set);
break;
case CLCM_SHOW_DEVICES:
rv = cmd_show_memdevs(opts[CLOP_DEVICE].str, opts[CLOP_REGION].str, opts[CLOP_HUMAN].set);
break;
case CLCM_SHOW_DEVICE_ISAVAILABLE:
rv = cmd_show_memdev_isavailable(opts[CLOP_DEVICE].str);
break;
case CLCM_SHOW_DEVICE_INTERLEAVE_GRANULARITY:
rv = cmd_show_memdev_interleave_granulariy(opts[CLOP_DEVICE].str);
break;
case CLCM_SHOW_REGIONS:
rv = cmd_show_regions(opts[CLOP_REGION].str, opts[CLOP_HUMAN].set);
break;
case CLCM_SHOW_NUM_BLOCKS:
rv = cmd_show_num_blocks(opts[CLOP_ONLINE].set, opts[CLOP_OFFLINE].set, opts[CLOP_REGION].str);
break;
case CLCM_SHOW_NUM_DEVICES:
rv = cmd_show_num_devices();
break;
case CLCM_SHOW_NUM_REGIONS:
rv = cmd_show_num_regions();
break;
case CLCM_SHOW_REGION_ISENABLED:
rv = cmd_show_region_isenabled(opts[CLOP_REGION].str);
break;
case CLCM_SHOW_SYSTEM_BLOCKSIZE:
rv = cmd_show_system_blocksize(opts[CLOP_HUMAN].set);;
break;
case CLCM_SHOW_SYSTEM_POLICY:
rv = cmd_show_system_policy();
break;
default:
rv = 1;
break;
}
return rv;
}
int main(int argc, char *argv[])
{
int rv;
// Initialize variables
rv = 1;
// Parse options
rv = options_parse(argc, argv);
if (rv != 0)
{
fprintf(stderr, "Error: Failed to parse command line parameters: %d\n", rv);
goto end;
}
// Verify command was specified
if (opts[CLOP_CMD].set == 0)
{
fprintf(stderr, "Error: No command specified\n");
rv = 1;
goto err;
}
// Execute command
rv = run();
if (rv != 0)
fprintf(stderr, "Error: Command failed: %d\n", rv);
err:
options_free();
end:
return rv;
}
Reference in New Issue Copy Permalink