[Accel-config] [PATCH 1/3] accel-config: Add support for new attributes related to read buffers
Ramesh Thomas <ramesh.thomas at intel.com> Thu, 16 Dec 2021 10:01:12 -0800
| Newsgroups | dev.linux.lists.accel-config |
|---|---|
| Message-ID | <[email protected]> |
This change is to match the driver change of attribute names. The bw
"token" attribute names are deprecated and are renamed as "read
buffers".
Add new libarary APIs to read and write the new attributes related to
read buffers. All internal implementation uses the "read buffer" name.
The external API will continue to support the "token" name and will be
deprecated. Writes to sysfs will attempt to read/write to "read buffer"
attributes and if not found in the case of older drivers, will fall back
to "token" attribute names.
Change internal implemenations to use read_buffer name instead of token.
Signed-off-by: Ramesh Thomas <ramesh.thomas(a)intel.com>
---
accfg/config.c | 64 +++++++++++++++----------
accfg/config_attr.c | 66 ++++++++++++-------------
accfg/lib/libaccel-config.sym | 13 +++++
accfg/lib/libaccfg.c | 90 ++++++++++++++++++++++++++---------
accfg/lib/private.h | 10 ++--
accfg/libaccel_config.h | 13 +++++
accfg/list.c | 12 ++---
test/libaccfg.c | 52 ++++++++++----------
util/json.c | 8 ++--
9 files changed, 208 insertions(+), 120 deletions(-)
diff --git a/accfg/config.c b/accfg/config.c
index e96d3fb..41c2a34 100644
--- a/accfg/config.c
+++ b/accfg/config.c
@@ -75,23 +75,30 @@ struct engine_set_table {
};
static const struct device_set_table device_table[] = {
- { "token_limit", accfg_device_set_token_limit, NULL }
+ { "token_limit", accfg_device_set_read_buffer_limit, NULL },
+ { "read_buffer_limit", accfg_device_set_read_buffer_limit, NULL }
};
static bool is_group_traffic_class_writable(struct accfg_group *group,
int val);
-static bool is_group_token_attribs_writable(struct accfg_group *group,
+static bool is_group_read_buffer_attribs_writable(struct accfg_group *group,
int val);
-static bool is_group_token_limit_writable(struct accfg_group *group,
+static bool is_group_read_buffer_limit_writable(struct accfg_group *group,
int val);
static const struct group_set_table group_table[] = {
- { "tokens_reserved", accfg_group_set_tokens_reserved, NULL,
- is_group_token_attribs_writable },
- { "use_token_limit", accfg_group_set_use_token_limit, NULL,
- is_group_token_limit_writable },
- { "tokens_allowed", accfg_group_set_tokens_allowed, NULL,
- is_group_token_attribs_writable },
+ { "tokens_reserved", accfg_group_set_read_buffers_reserved, NULL,
+ is_group_read_buffer_attribs_writable },
+ { "read_buffers_reserved", accfg_group_set_read_buffers_reserved, NULL,
+ is_group_read_buffer_attribs_writable },
+ { "use_token_limit", accfg_group_set_use_read_buffer_limit, NULL,
+ is_group_read_buffer_limit_writable },
+ { "use_read_buffer_limit", accfg_group_set_use_read_buffer_limit, NULL,
+ is_group_read_buffer_limit_writable },
+ { "tokens_allowed", accfg_group_set_read_buffers_allowed, NULL,
+ is_group_read_buffer_attribs_writable },
+ { "read_buffers_allowed", accfg_group_set_read_buffers_allowed, NULL,
+ is_group_read_buffer_attribs_writable },
{ "traffic_class_a", accfg_group_set_traffic_class_a, NULL,
is_group_traffic_class_writable},
{ "traffic_class_b", accfg_group_set_traffic_class_b, NULL,
@@ -127,22 +134,22 @@ static int configure_json_value(struct accfg_ctx *ctx,
static int read_config_file(struct accfg_ctx *ctx, struct config *to_config,
struct util_filter_params *util_param);
-static bool is_group_token_limit_writable(struct accfg_group *group,
+static bool is_group_read_buffer_limit_writable(struct accfg_group *group,
int val)
{
struct accfg_device *dev;
- unsigned int token_limit;
+ unsigned int read_buffer_limit;
dev = accfg_group_get_device(group);
- token_limit = accfg_device_get_token_limit(dev);
- if (token_limit)
+ read_buffer_limit = accfg_device_get_read_buffer_limit(dev);
+ if (read_buffer_limit)
return true;
return false;
}
-static bool is_group_token_attribs_writable(struct accfg_group *group,
+static bool is_group_read_buffer_attribs_writable(struct accfg_group *group,
int val)
{
if (val == -1)
@@ -343,11 +350,20 @@ static int group_json_set_val(struct accfg_group *group,
return -EINVAL;
if ((accfg_device_get_type(dev) == ACCFG_DEVICE_IAX)
- && ((!strcmp(group_table[i].name, "tokens_reserved"))
- || (!strcmp(group_table[i].name, "use_token_limit"))
- || (!strcmp(group_table[i].name, "tokens_allowed")))) {
+ && ((!strcmp(group_table[i].name,
+ "tokens_reserved"))
+ || (!strcmp(group_table[i].name,
+ "use_token_limit"))
+ || (!strcmp(group_table[i].name,
+ "tokens_allowed"))
+ || (!strcmp(group_table[i].name,
+ "read_buffers_reserved"))
+ || (!strcmp(group_table[i].name,
+ "use_read_buffer_limit"))
+ || (!strcmp(group_table[i].name,
+ "read_buffers_allowed"))))
return 0;
- }
+
if (group_table[i].is_writable &&
!group_table[i].is_writable(group,
val))
@@ -665,21 +681,21 @@ static struct json_object *config_group_to_json(struct accfg_group *group,
goto err;
json_object_object_add(jgroup, "dev", jobj);
- jobj = json_object_new_int(accfg_group_get_tokens_reserved(group));
+ jobj = json_object_new_int(accfg_group_get_read_buffers_reserved(group));
if (!jobj)
goto err;
- json_object_object_add(jgroup, "tokens_reserved", jobj);
- jobj = json_object_new_int(accfg_group_get_use_token_limit(group));
+ json_object_object_add(jgroup, "read_buffers_reserved", jobj);
+ jobj = json_object_new_int(accfg_group_get_use_read_buffer_limit(group));
if (!jobj)
goto err;
- json_object_object_add(jgroup, "use_token_limit", jobj);
- jobj = json_object_new_int(accfg_group_get_tokens_allowed(group));
+ json_object_object_add(jgroup, "use_read_buffer_limit", jobj);
+ jobj = json_object_new_int(accfg_group_get_read_buffers_allowed(group));
if (!jobj)
goto err;
- json_object_object_add(jgroup, "tokens_allowed", jobj);
+ json_object_object_add(jgroup, "read_buffers_allowed", jobj);
jobj = json_object_new_int(accfg_group_get_traffic_class_a(
group));
if (!jobj)
diff --git a/accfg/config_attr.c b/accfg/config_attr.c
index 2617b98..f9186d6 100644
--- a/accfg/config_attr.c
+++ b/accfg/config_attr.c
@@ -22,9 +22,9 @@
static struct dev_parameters dev_param;
static struct group_parameters group_param = {
- .tokens_reserved = UINT_MAX,
- .tokens_allowed = UINT_MAX,
- .use_token_limit = UINT_MAX,
+ .read_buffers_reserved = UINT_MAX,
+ .read_buffers_allowed = UINT_MAX,
+ .use_read_buffer_limit = UINT_MAX,
.traffic_class_a = INT_MAX,
.traffic_class_b = INT_MAX
};
@@ -47,7 +47,7 @@ static int accel_config_parse_device_attribs(struct accfg_device *dev,
{
int rc = 0;
- rc = accfg_device_set_token_limit(dev, device_param->token_limit);
+ rc = accfg_device_set_read_buffer_limit(dev, device_param->read_buffer_limit);
if (rc < 0)
return rc;
@@ -68,22 +68,22 @@ static int accel_config_parse_group_attribs(struct accfg_group *group,
return -EINVAL;
}
- if (group_params->tokens_reserved != UINT_MAX &&
- group_params->tokens_reserved >= UCHAR_MAX) {
+ if (group_params->read_buffers_reserved != UINT_MAX &&
+ group_params->read_buffers_reserved >= UCHAR_MAX) {
fprintf(stderr,
- "configured tokens_reserved for group is not within range\n");
+ "configured read-buffers-reserved for group is not within range\n");
return -EINVAL;
}
- if (group_params->tokens_allowed != UINT_MAX &&
- group_params->tokens_allowed >= UCHAR_MAX) {
- fprintf(stderr, "invalid tokens-allowed value\n");
+ if (group_params->read_buffers_allowed != UINT_MAX &&
+ group_params->read_buffers_allowed >= UCHAR_MAX) {
+ fprintf(stderr, "invalid read-buffers-allowed value\n");
return -EINVAL;
}
- if (group_params->use_token_limit > 1 &&
- group_params->use_token_limit != UINT_MAX) {
- fprintf(stderr, "valid use-token-limit should be either 0 or 1\n");
+ if (group_params->use_read_buffer_limit > 1 &&
+ group_params->use_read_buffer_limit != UINT_MAX) {
+ fprintf(stderr, "valid use-read-buffer-limit should be either 0 or 1\n");
return -EINVAL;
}
@@ -103,23 +103,23 @@ static int accel_config_parse_group_attribs(struct accfg_group *group,
return -EINVAL;
}
- if (group_params->use_token_limit != UINT_MAX) {
- rc = accfg_group_set_use_token_limit(group,
- group_params->use_token_limit);
+ if (group_params->use_read_buffer_limit != UINT_MAX) {
+ rc = accfg_group_set_use_read_buffer_limit(group,
+ group_params->use_read_buffer_limit);
if (rc < 0)
return rc;
}
- if (group_params->tokens_reserved != UINT_MAX) {
- rc = accfg_group_set_tokens_reserved(group,
- group_params->tokens_reserved);
+ if (group_params->read_buffers_reserved != UINT_MAX) {
+ rc = accfg_group_set_read_buffers_reserved(group,
+ group_params->read_buffers_reserved);
if (rc < 0)
return rc;
}
- if (group_params->tokens_allowed != UINT_MAX) {
- rc = accfg_group_set_tokens_allowed(group,
- group_params->tokens_allowed);
+ if (group_params->read_buffers_allowed != UINT_MAX) {
+ rc = accfg_group_set_read_buffers_allowed(group,
+ group_params->read_buffers_allowed);
if (rc < 0)
return rc;
}
@@ -308,8 +308,8 @@ int cmd_config_device(int argc, const char **argv, void *ctx)
int i, rc = 0;
const struct option options[] = {
- OPT_UINTEGER('l', "token-limit", &dev_param.token_limit,
- "specify token limit by device"),
+ OPT_UINTEGER('l', "read-buffer-limit", &dev_param.read_buffer_limit,
+ "specify read buffer limit by device"),
OPT_END(),
};
@@ -355,15 +355,15 @@ int cmd_config_group(int argc, const char **argv, void *ctx)
int i, rc = 0;
const struct option options[] = {
- OPT_UINTEGER('r', "tokens-reserved",
- &group_param.tokens_reserved,
- "specify tokens reserved by group"),
- OPT_UINTEGER('t', "tokens-allowed",
- &group_param.tokens_allowed,
- "specify tokens allowed by group"),
- OPT_UINTEGER('l', "use-token-limit",
- &group_param.use_token_limit,
- "specify token limit by group"),
+ OPT_UINTEGER('r', "read-buffers-reserved",
+ &group_param.read_buffers_reserved,
+ "specify read buffers reserved by group"),
+ OPT_UINTEGER('t', "read-buffers-allowed",
+ &group_param.read_buffers_allowed,
+ "specify read buffers allowed by group"),
+ OPT_UINTEGER('l', "use-read-buffer-limit",
+ &group_param.use_read_buffer_limit,
+ "specify read buffer limit by group"),
OPT_INTEGER('a', "traffic-class-a",
&group_param.traffic_class_a,
"specify traffic-class-a by group"),
diff --git a/accfg/lib/libaccel-config.sym b/accfg/lib/libaccel-config.sym
index 7d6b396..560883a 100644
--- a/accfg/lib/libaccel-config.sym
+++ b/accfg/lib/libaccel-config.sym
@@ -166,3 +166,16 @@ LIBACCFG_11 {
global:
accfg_wq_get_occupancy;
} LIBACCFG_10;
+
+LIBACCFG_12 {
+global:
+ accfg_device_get_max_read_buffers;
+ accfg_device_get_read_buffer_limit;
+ accfg_device_set_read_buffer_limit;
+ accfg_group_get_read_buffers_reserved;
+ accfg_group_get_read_buffers_allowed;
+ accfg_group_get_use_read_buffer_limit;
+ accfg_group_set_read_buffers_reserved;
+ accfg_group_set_read_buffers_allowed;
+ accfg_group_set_use_read_buffer_limit;
+} LIBACCFG_11;
diff --git a/accfg/lib/libaccfg.c b/accfg/lib/libaccfg.c
index 51086b7..86ee517 100644
--- a/accfg/lib/libaccfg.c
+++ b/accfg/lib/libaccfg.c
@@ -91,7 +91,7 @@ const char *accfg_device_cmd_status[] = {
[0x15] = "Invalid group config: lack of wq or engines",
[0x16] = "Invalid group config: wq misconfigured",
[0x17] = "Invalid group config: engine misconfigured",
- [0x18] = "Invalid group config: invalid bandwith tokens config",
+ [0x18] = "Invalid group config: invalid read buffers config",
[0x20] = "Device not enabled",
[0x21] = "WQ is not disabled",
[0x22] = "WQ size is 0",
@@ -132,6 +132,29 @@ const char *accfg_sw_cmd_status[] = {
[SCMD_STAT(IDXD_SCMD_WQ_NO_SIZE)] = "wq error - size not set",
};
+struct attr_dict_entry {
+ char *key;
+ char *val;
+};
+
+static const struct attr_dict_entry attr_dict[] = {
+ {"read_buffers_allowed", "tokens_allowed"},
+ {"read_buffers_reserved", "tokens_reserved"},
+ {"use_read_buffer_limit", "use_token_limit"},
+ {"max_read_buffers", "max_tokens"},
+ {"read_buffer_limit", "token_limit"}};
+
+static const char *deprecated_attr(char *attr)
+{
+ int i;
+
+ for (i = 0; i < (int) ARRAY_SIZE(attr_dict); i++)
+ if (!strcmp(attr, attr_dict[i].key))
+ return attr_dict[i].val;
+
+ return NULL;
+}
+
static void save_last_error(struct accfg_device *device, struct accfg_wq *wq,
struct accfg_group *group, struct accfg_engine *engine)
{
@@ -176,7 +199,14 @@ static long accfg_get_param_long(struct accfg_ctx *ctx, int dfd, char *name)
int fd = openat(dfd, name, O_RDONLY);
char buf[MAX_PARAM_LEN + 1];
int n;
+ const char *p;
+ if (fd == -1 && errno == ENOENT) {
+ p = deprecated_attr(name);
+ if (!p)
+ return -errno;
+ fd = openat(dfd, p, O_RDONLY);
+ }
if (fd == -1)
return -errno;
@@ -646,8 +676,8 @@ static void *add_device(void *parent, int id, const char *ctl_base,
"configurable");
device->pasid_enabled = accfg_get_param_str(ctx, dfd,
"pasid_enabled");
- device->max_tokens = accfg_get_param_long(ctx, dfd, "max_tokens");
- device->token_limit = accfg_get_param_long(ctx, dfd, "token_limit");
+ device->max_read_buffers = accfg_get_param_long(ctx, dfd, "max_read_buffers");
+ device->read_buffer_limit = accfg_get_param_long(ctx, dfd, "read_buffer_limit");
device->cdev_major = accfg_get_param_long(ctx, dfd, "cdev_major");
device->version = accfg_get_param_unsigned_llong(ctx, dfd, "version");
device->device_path = realpath(ctl_base, NULL);
@@ -884,12 +914,12 @@ static void *add_group(void *parent, int id, const char *group_base,
group->id = group_id;
group->group_engines = accfg_get_param_str(ctx, dfd, "engines");
group->group_wqs = accfg_get_param_str(ctx, dfd, "work_queues");
- group->tokens_reserved = accfg_get_param_long(ctx, dfd,
- "tokens_reserved");
- group->tokens_allowed = accfg_get_param_long(ctx, dfd,
- "tokens_allowed");
- group->use_token_limit = accfg_get_param_long(ctx, dfd,
- "use_token_limit");
+ group->read_buffers_reserved = accfg_get_param_long(ctx, dfd,
+ "read_buffers_reserved");
+ group->read_buffers_allowed = accfg_get_param_long(ctx, dfd,
+ "read_buffers_allowed");
+ group->use_read_buffer_limit = accfg_get_param_long(ctx, dfd,
+ "use_read_buffer_limit");
group->traffic_class_a = accfg_get_param_long(ctx, dfd,
"traffic_class_a");
group->traffic_class_b = accfg_get_param_long(ctx, dfd,
@@ -1436,16 +1466,16 @@ ACCFG_EXPORT enum accfg_device_state accfg_device_get_state(
return ACCFG_DEVICE_UNKNOWN;
}
-ACCFG_EXPORT unsigned int accfg_device_get_max_tokens(
+ACCFG_EXPORT unsigned int accfg_device_get_max_read_buffers(
struct accfg_device *device)
{
- return device->max_tokens;
+ return device->max_read_buffers;
}
-ACCFG_EXPORT unsigned int accfg_device_get_token_limit(
+ACCFG_EXPORT unsigned int accfg_device_get_read_buffer_limit(
struct accfg_device *device)
{
- return device->token_limit;
+ return device->read_buffer_limit;
}
ACCFG_EXPORT unsigned int accfg_device_get_cdev_major(
@@ -1491,7 +1521,7 @@ ACCFG_EXPORT int accfg_device_get_clients(struct accfg_device *device)
return atoi(buf);
}
-ACCFG_EXPORT int accfg_device_set_token_limit(struct accfg_device *dev, int val)
+ACCFG_EXPORT int accfg_device_set_read_buffer_limit(struct accfg_device *dev, int val)
{
struct accfg_ctx *ctx;
char *path;
@@ -1503,13 +1533,23 @@ ACCFG_EXPORT int accfg_device_set_token_limit(struct accfg_device *dev, int val)
path = dev->device_buf;
ctx = accfg_device_get_ctx(dev);
- if (sprintf(path, "%s/token_limit", dev->device_path) >=
+ if (sprintf(path, "%s/read_buffer_limit", dev->device_path) >=
(int)dev->buf_len) {
err(ctx, "%s; buf len exceeded.\n",
accfg_device_get_devname(dev));
return -errno;
}
+ if (access(path, F_OK)) {
+ if (sprintf(path, "%s/%s", dev->device_path,
+ deprecated_attr("read_buffer_limit")) >=
+ (int)dev->buf_len) {
+ err(ctx, "%s; buf len exceeded.\n",
+ accfg_device_get_devname(dev));
+ return -errno;
+ }
+ }
+
if (sprintf(buf, "%d", val) < 0) {
err(ctx, "%s: sprintf to buf failed: %s\n",
accfg_device_get_devname(dev), strerror(errno));
@@ -1523,7 +1563,7 @@ ACCFG_EXPORT int accfg_device_set_token_limit(struct accfg_device *dev, int val)
return -errno;
}
- dev->token_limit = val;
+ dev->read_buffer_limit = val;
return 0;
}
@@ -1879,6 +1919,12 @@ ACCFG_EXPORT int accfg_group_set_##field( \
rc = sprintf(group->group_buf, "%s/%s", group->group_path, #field); \
if (rc < 0) \
return -errno; \
+ if (access(path, F_OK)) { \
+ rc = sprintf(group->group_buf, "%s/%s", \
+ group->group_path, deprecated_attr(#field)); \
+ if (rc < 0) \
+ return -errno; \
+ } \
if (sprintf(buf, "%d", val) < 0) { \
err(ctx, "%s: sprintf to buf failed: %s\n", \
accfg_group_get_devname(group), \
@@ -1896,9 +1942,9 @@ ACCFG_EXPORT int accfg_group_set_##field( \
return 0; \
}
-accfg_group_set_field(group, val, tokens_reserved)
-accfg_group_set_field(group, val, tokens_allowed)
-accfg_group_set_field(group, val, use_token_limit)
+accfg_group_set_field(group, val, read_buffers_reserved)
+accfg_group_set_field(group, val, read_buffers_allowed)
+accfg_group_set_field(group, val, use_read_buffer_limit)
accfg_group_set_field(group, val, traffic_class_a)
accfg_group_set_field(group, val, traffic_class_b)
@@ -1909,9 +1955,9 @@ ACCFG_EXPORT int accfg_group_get_##field( \
return group->field; \
}
-accfg_group_get_field(group, tokens_reserved);
-accfg_group_get_field(group, tokens_allowed);
-accfg_group_get_field(group, use_token_limit);
+accfg_group_get_field(group, read_buffers_reserved);
+accfg_group_get_field(group, read_buffers_allowed);
+accfg_group_get_field(group, use_read_buffer_limit);
accfg_group_get_field(group, traffic_class_a);
accfg_group_get_field(group, traffic_class_b);
diff --git a/accfg/lib/private.h b/accfg/lib/private.h
index d3a8bee..b09297e 100644
--- a/accfg/lib/private.h
+++ b/accfg/lib/private.h
@@ -47,8 +47,8 @@ struct accfg_device {
int ims_size;
int max_batch_size;
int configurable;
- int max_tokens;
- unsigned int token_limit;
+ int max_read_buffers;
+ unsigned int read_buffer_limit;
unsigned int cdev_major;
unsigned int version;
uint64_t max_transfer_size;
@@ -82,9 +82,9 @@ struct accfg_group {
int engines_init;
/* Group Attributes */
- unsigned int tokens_reserved;
- unsigned int tokens_allowed;
- unsigned int use_token_limit;
+ unsigned int read_buffers_reserved;
+ unsigned int read_buffers_allowed;
+ unsigned int use_read_buffer_limit;
int traffic_class_a;
int traffic_class_b;
};
diff --git a/accfg/libaccel_config.h b/accfg/libaccel_config.h
index 92b1da5..5d346d5 100644
--- a/accfg/libaccel_config.h
+++ b/accfg/libaccel_config.h
@@ -91,6 +91,7 @@ struct accfg_op_cap {
/* parameters read from sysfs of accfg driver */
struct dev_parameters {
unsigned int token_limit;
+ unsigned int read_buffer_limit;
};
extern char *accfg_basenames[];
@@ -100,6 +101,9 @@ struct group_parameters {
unsigned int tokens_reserved;
unsigned int tokens_allowed;
unsigned int use_token_limit;
+ unsigned int read_buffers_reserved;
+ unsigned int read_buffers_allowed;
+ unsigned int use_read_buffer_limit;
int traffic_class_a;
int traffic_class_b;
};
@@ -187,12 +191,15 @@ bool accfg_device_get_mdev_enabled(struct accfg_device *device);
int accfg_device_get_errors(struct accfg_device *device, struct accfg_error *error);
enum accfg_device_state accfg_device_get_state(struct accfg_device *device);
unsigned int accfg_device_get_max_tokens(struct accfg_device *device);
+unsigned int accfg_device_get_max_read_buffers(struct accfg_device *device);
unsigned int accfg_device_get_max_batch_size(struct accfg_device *device);
unsigned int accfg_device_get_token_limit(struct accfg_device *device);
+unsigned int accfg_device_get_read_buffer_limit(struct accfg_device *device);
unsigned int accfg_device_get_cdev_major(struct accfg_device *device);
unsigned int accfg_device_get_version(struct accfg_device *device);
int accfg_device_get_clients(struct accfg_device *device);
int accfg_device_set_token_limit(struct accfg_device *dev, int val);
+int accfg_device_set_read_buffer_limit(struct accfg_device *dev, int val);
int accfg_device_is_active(struct accfg_device *device);
unsigned int accfg_device_get_cmd_status(struct accfg_device *device);
const char *accfg_device_get_cmd_status_str(struct accfg_device *device);
@@ -234,13 +241,19 @@ uint64_t accfg_group_get_available_size(struct accfg_group *group);
struct accfg_device *accfg_group_get_device(struct accfg_group *group);
struct accfg_ctx *accfg_group_get_ctx(struct accfg_group *group);
int accfg_group_get_tokens_reserved(struct accfg_group *group);
+int accfg_group_get_read_buffers_reserved(struct accfg_group *group);
int accfg_group_get_tokens_allowed(struct accfg_group *group);
+int accfg_group_get_read_buffers_allowed(struct accfg_group *group);
int accfg_group_get_use_token_limit(struct accfg_group *group);
+int accfg_group_get_use_read_buffer_limit(struct accfg_group *group);
int accfg_group_get_traffic_class_a(struct accfg_group *group);
int accfg_group_get_traffic_class_b(struct accfg_group *group);
int accfg_group_set_tokens_reserved(struct accfg_group *group, int val);
+int accfg_group_set_read_buffers_reserved(struct accfg_group *group, int val);
int accfg_group_set_tokens_allowed(struct accfg_group *group, int val);
+int accfg_group_set_read_buffers_allowed(struct accfg_group *group, int val);
int accfg_group_set_use_token_limit(struct accfg_group *group, int val);
+int accfg_group_set_use_read_buffer_limit(struct accfg_group *group, int val);
int accfg_group_set_traffic_class_a(struct accfg_group *group, int val);
int accfg_group_set_traffic_class_b(struct accfg_group *group, int val);
diff --git a/accfg/list.c b/accfg/list.c
index 7fec813..c2c6798 100644
--- a/accfg/list.c
+++ b/accfg/list.c
@@ -68,21 +68,21 @@ static struct json_object *group_to_json(struct accfg_group *group,
json_object_object_add(jgroup, "dev", jobj);
if (accfg_device_get_type(dev) != ACCFG_DEVICE_IAX) {
- jobj = json_object_new_int(accfg_group_get_tokens_reserved(group));
+ jobj = json_object_new_int(accfg_group_get_read_buffers_reserved(group));
if (!jobj)
goto err;
- json_object_object_add(jgroup, "tokens_reserved", jobj);
- jobj = json_object_new_int(accfg_group_get_use_token_limit(group));
+ json_object_object_add(jgroup, "read_buffers_reserved", jobj);
+ jobj = json_object_new_int(accfg_group_get_use_read_buffer_limit(group));
if (!jobj)
goto err;
- json_object_object_add(jgroup, "use_token_limit", jobj);
- jobj = json_object_new_int(accfg_group_get_tokens_allowed(group));
+ json_object_object_add(jgroup, "use_read_buffer_limit", jobj);
+ jobj = json_object_new_int(accfg_group_get_read_buffers_allowed(group));
if (!jobj)
goto err;
- json_object_object_add(jgroup, "tokens_allowed", jobj);
+ json_object_object_add(jgroup, "read_buffers_allowed", jobj);
}
jobj = json_object_new_int(accfg_group_get_traffic_class_a(
diff --git a/test/libaccfg.c b/test/libaccfg.c
index 9b65dc0..b804d9e 100644
--- a/test/libaccfg.c
+++ b/test/libaccfg.c
@@ -35,21 +35,21 @@
static bool mdev_disabled;
static struct dev_parameters device0_param = {
- .token_limit = 10,
+ .read_buffer_limit = 10,
};
static struct group_parameters group00_param = {
- .tokens_reserved = 1,
- .tokens_allowed = 8,
- .use_token_limit = 1,
+ .read_buffers_reserved = 1,
+ .read_buffers_allowed = 8,
+ .use_read_buffer_limit = 1,
.traffic_class_a = 2,
.traffic_class_b = 3
};
static struct group_parameters group01_param = {
- .tokens_reserved = 1,
- .tokens_allowed = 8,
- .use_token_limit = 0,
+ .read_buffers_reserved = 1,
+ .read_buffers_allowed = 8,
+ .use_read_buffer_limit = 0,
.traffic_class_a = 4,
.traffic_class_b = 5
};
@@ -157,16 +157,16 @@ static struct config_test_ctx {
static int config_device(struct accfg_ctx *ctx, struct accfg_device *device,
struct dev_parameters *dev_param)
{
- return accfg_device_set_token_limit(device,
- dev_param->token_limit);
+ return accfg_device_set_read_buffer_limit(device,
+ dev_param->read_buffer_limit);
}
static int check_device(struct accfg_ctx *ctx, struct accfg_device *device,
struct dev_parameters *dev_param)
{
- if (dev_param->token_limit != accfg_device_get_token_limit(device)) {
- fprintf(stderr, "%s failed on token_limit\n", __func__);
+ if (dev_param->read_buffer_limit != accfg_device_get_read_buffer_limit(device)) {
+ fprintf(stderr, "%s failed on read_buffer_limit\n", __func__);
return -EINVAL;
}
@@ -179,12 +179,12 @@ static int config_group(struct accfg_ctx *ctx, struct accfg_device *device,
{
int rc = 0;
- SET_ERR(rc, accfg_group_set_tokens_reserved(group,
- group_param->tokens_reserved));
- SET_ERR(rc, accfg_group_set_tokens_allowed(group,
- group_param->tokens_allowed));
- SET_ERR(rc, accfg_group_set_use_token_limit(group,
- group_param->use_token_limit));
+ SET_ERR(rc, accfg_group_set_read_buffers_reserved(group,
+ group_param->read_buffers_reserved));
+ SET_ERR(rc, accfg_group_set_read_buffers_allowed(group,
+ group_param->read_buffers_allowed));
+ SET_ERR(rc, accfg_group_set_use_read_buffer_limit(group,
+ group_param->use_read_buffer_limit));
if (accfg_device_get_version(device) < ACCFG_DEVICE_VERSION_2)
return rc;
@@ -202,21 +202,21 @@ static int check_group(struct accfg_ctx *ctx, struct accfg_device *device,
struct group_parameters *group_param)
{
- if (group_param->tokens_reserved !=
- (unsigned int) accfg_group_get_tokens_reserved(group)) {
- fprintf(stderr, "%s failed on tokens_reserved\n", __func__);
+ if (group_param->read_buffers_reserved !=
+ (unsigned int) accfg_group_get_read_buffers_reserved(group)) {
+ fprintf(stderr, "%s failed on read_buffers_reserved\n", __func__);
return -EINVAL;
}
- if (group_param->tokens_allowed !=
- (unsigned int) accfg_group_get_tokens_allowed(group)) {
- fprintf(stderr, "%s failed on tokens_allowed\n", __func__);
+ if (group_param->read_buffers_allowed !=
+ (unsigned int) accfg_group_get_read_buffers_allowed(group)) {
+ fprintf(stderr, "%s failed on read_buffers_allowed\n", __func__);
return -EINVAL;
}
- if (group_param->use_token_limit !=
- (unsigned int) accfg_group_get_use_token_limit(group)) {
- fprintf(stderr, "%s failed on use_token_limit\n", __func__);
+ if (group_param->use_read_buffer_limit !=
+ (unsigned int) accfg_group_get_use_read_buffer_limit(group)) {
+ fprintf(stderr, "%s failed on use_read_buffer_limit\n", __func__);
return -EINVAL;
}
diff --git a/util/json.c b/util/json.c
index 09d3a10..1a768bc 100644
--- a/util/json.c
+++ b/util/json.c
@@ -165,11 +165,11 @@ struct json_object *util_device_to_json(struct accfg_device *device,
goto err;
json_object_object_add(jdevice, "dev", jobj);
- jobj = json_object_new_int(accfg_device_get_token_limit(device));
+ jobj = json_object_new_int(accfg_device_get_read_buffer_limit(device));
if (!jobj)
goto err;
if (accfg_device_get_type(device) != ACCFG_DEVICE_IAX)
- json_object_object_add(jdevice, "token_limit", jobj);
+ json_object_object_add(jdevice, "read_buffer_limit", jobj);
if (flags & UTIL_JSON_SAVE) {
free(error);
@@ -270,11 +270,11 @@ struct json_object *util_device_to_json(struct accfg_device *device,
goto err;
json_object_object_add(jdevice, "state", jobj);
- jobj = json_object_new_int(accfg_device_get_max_tokens(device));
+ jobj = json_object_new_int(accfg_device_get_max_read_buffers(device));
if (!jobj)
goto err;
if (accfg_device_get_type(device) != ACCFG_DEVICE_IAX)
- json_object_object_add(jdevice, "max_tokens", jobj);
+ json_object_object_add(jdevice, "max_read_buffers", jobj);
ulong_val = accfg_device_get_max_batch_size(device);
if (ulong_val > 0) {
--
2.31.1