size_t list_modules(const struct module **p_arr, size_t arr_size, size_t offset)
{
int ret = 0;
int iter_cnt = 0;
struct ns_iter iter;
ns_init_iterator(&iter, NS_TYPE_MODULE);
while (1) {
struct module *module = (struct module *) ns_next(&iter);
if (!module)
break;
if (iter_cnt++ < offset)
continue;
if (ret >= arr_size)
break;
p_arr[ret++] = module;
}
ns_release_iterator(&iter);
return ret;
}
size_t list_mclasses(const struct mclass **p_arr, size_t arr_size,
size_t offset)
{
int ret = 0;
int iter_cnt = 0;
struct ns_iter iter;
ns_init_iterator(&iter, NS_TYPE_MCLASS);
while (1) {
struct mclass *mc_obj = (struct mclass *) ns_next(&iter);
if (!mc_obj)
break;
if (iter_cnt++ < offset)
continue;
if (ret >= arr_size)
break;
p_arr[ret++] = mc_obj;
}
ns_release_iterator(&iter);
return ret;
}
size_t list_drivers(const struct driver **p_arr, size_t arr_size, size_t offset)
{
int ret = 0;
int iter_cnt = 0;
struct ns_iter iter;
ns_init_iterator(&iter, NS_TYPE_DRIVER);
while (1) {
struct driver* driver = (struct driver *) ns_next(&iter);
if (!driver)
break;
if (iter_cnt++ < offset)
continue;
if (ret >= arr_size)
break;
p_arr[ret++] = driver;
}
ns_release_iterator(&iter);
return ret;
}
static struct snobj *handle_reset_tcs(struct snobj *q)
{
struct ns_iter iter;
struct tc *c;
struct tc **c_arr;
size_t arr_slots = 1024;
int n = 0;
c_arr = malloc(arr_slots * sizeof(struct tc *));
ns_init_iterator(&iter, NS_TYPE_TC);
while ((c = (struct tc *)ns_next(&iter)) != NULL) {
if (n >= arr_slots) {
arr_slots *= 2;
c_arr = realloc(c_arr, arr_slots * sizeof(struct tc *));
}
c_arr[n] = c;
n++;
}
ns_release_iterator(&iter);
for (int i = 0; i < n; i++) {
c = c_arr[i];
if (c->num_tasks) {
free(c_arr);
return snobj_err(EBUSY, "TC %s still has %d tasks",
c->name, c->num_tasks);
}
if (c->auto_free)
continue;
tc_leave(c);
tc_dec_refcnt(c);
}
free(c_arr);
return NULL;
}
static struct snobj *handle_list_tcs(struct snobj *q)
{
struct snobj *r;
struct snobj *t;
unsigned int wid_filter = MAX_WORKERS;
struct ns_iter iter;
struct tc *c;
t = snobj_eval(q, "wid");
if (t) {
wid_filter = snobj_uint_get(t);
if (wid_filter >= MAX_WORKERS)
return snobj_err(EINVAL,
"'wid' must be between 0 and %d",
MAX_WORKERS - 1);
if (!is_worker_active(wid_filter))
return snobj_err(EINVAL, "worker:%d does not exist",
wid_filter);
}
r = snobj_list();
ns_init_iterator(&iter, NS_TYPE_TC);
while ((c = (struct tc *)ns_next(&iter)) != NULL) {
int wid;
if (wid_filter < MAX_WORKERS) {
if (workers[wid_filter]->s != c->s)
continue;
wid = wid_filter;
} else {
for (wid = 0; wid < MAX_WORKERS; wid++)
if (is_worker_active(wid) &&
workers[wid]->s == c->s)
break;
}
struct snobj *elem = snobj_map();
snobj_map_set(elem, "name", snobj_str(c->name));
snobj_map_set(elem, "tasks", snobj_int(c->num_tasks));
snobj_map_set(elem, "parent", snobj_str(c->parent->name));
snobj_map_set(elem, "priority", snobj_int(c->priority));
if (wid < MAX_WORKERS)
snobj_map_set(elem, "wid", snobj_uint(wid));
else
snobj_map_set(elem, "wid", snobj_int(-1));
snobj_list_add(r, elem);
}
ns_release_iterator(&iter);
return r;
}
