lei.chen/myxce
1
0
Fork 1
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

save works

Browse source
This commit is contained in:
Rongsong Shen 2026-03-04 18:18:53 +08:00
parent acfbec875b
commit 3f74f14687
38 changed files with 751 additions and 448 deletions
Download patch file Download diff file Expand all files Collapse all files

14
src/lib/configobj.c
View file

@ -48,13 +48,14 @@ static typeinfo_t xconfig_type = {
.destroy = (obj_destroy_fn_t)xconfig_destroy,
};
xce_config_t* makeConfig(var configmgr, xce_config_t* c)
static xce_config_t* makeConfig_(var configmgr, xce_config_t* c)
{
xce_config_t* c1 = NULL;
int rc = 0;
rc = key_find(configmgr, (void*)c->name, (void**)&c1);
if ((rc < 0) && (rc != -ENOENT)) {
errno = -rc;
return NULL;
}
@ -77,3 +78,14 @@ xce_config_t* makeConfig(var configmgr, xce_config_t* c)
return c1;
}
xce_config_t* makeConfig(var configmgr, xce_config_t* c)
{
xce_config_t* c1 = NULL;
lock(configmgr, RTTI_LOCK_WRITE);
c1 = makeConfig_(configmgr, c);
unlock(configmgr);
return c1;
}

116
src/lib/group.c
View file

@ -156,7 +156,10 @@ static int group_init(meta_obj_t* obj, va_list ap)
return -EINVAL;
}
lock(mgr, RTTI_LOCK_WRITE);
rc = key_add(mgr, (void*)g_name, (void*)g);
unlock(mgr);
if (rc < 0) {
return rc;
}
@ -210,7 +213,10 @@ xce_group_t* makeGroup(var mgr, xce_group_config_t* config,
return NULL;
}
lock(mgr, RTTI_LOCK_READ);
rc = key_find(mgr, (void*)g_name, (void**)&g);
unlock(mgr);
if ((rc < 0) && (rc != -ENOENT)) {
errno = -rc;
return NULL;
@ -262,7 +268,6 @@ int groupmgr_init(var* mgr, int nslots, int delta)
xce_group_config_t empty = { .name = "empty" };
xce_group_t* g = NULL;
kvmgr_params_t params = { .key_type = KVMGR_KEY_STRING,
.dynamic = 1,
.nslots = nslots,
.delta = delta,
.datakiller = destroy };
@ -291,7 +296,9 @@ int groupmgr_add(var mgr, xce_group_t* g)
{
int rc = 0;
lock(mgr, RTTI_LOCK_WRITE);
rc = key_add(mgr, (void*)g->name, (void*)g);
unlock(mgr);
return rc;
}
@ -301,7 +308,10 @@ xce_group_t* groupmgr_lock(var mgr, char* name, int op)
int rc;
xce_group_t* g = NULL;
lock(mgr, RTTI_LOCK_READ);
rc = key_find(mgr, (void*)name, (void**)&g);
unlock(mgr);
if (rc <= 0) {
return NULL;
}
@ -311,7 +321,9 @@ xce_group_t* groupmgr_lock(var mgr, char* name, int op)
void groupmgr_del(var mgr, xce_group_t* g)
{
lock(mgr, RTTI_LOCK_WRITE);
key_del(mgr, (void*)g->name);
unlock(mgr);
return;
}
@ -325,7 +337,10 @@ xce_group_t* get_group(var mgr, char* name)
return NULL;
}
lock(mgr, RTTI_LOCK_READ);
rc = key_find(mgr, (void*)name, (void**)&g);
unlock(mgr);
if (rc <= 0) {
return NULL;
}
@ -381,105 +396,6 @@ int fmt_group(char* buf, int len, xce_group_t* g)
return strlen(buf);
}
xce_group_t* build_group(var mgr, xce_group_config_t* g_config,
char* default_group_name)
{
xce_group_t* g = NULL;
char* g_name;
int i;
if ((mgr == NULL) || (g_config == NULL)) {
errno = EINVAL;
return NULL;
}
g_name = g_config->name;
if ((g_name == NULL) || (strlen(g_name) == 0)) {
g_name = default_group_name;
}
if (g_name == NULL) {
return NULL;
}
g = get_group(mgr, g_name);
if (g != NULL) {
for (i = 0; i < g->members.count; i++) {
xce_g_member_t* m = (xce_g_member_t*)xlist_get(&(g->members), i);
if (m == NULL) {
continue;
}
if (m->is_group == 0) {
FREEUP(m->u.name);
}
FREEUP(m);
}
g->members.count = 0;
for (i = 0; i < g->ex_members.count; i++) {
xce_g_member_t* m = (xce_g_member_t*)xlist_get(&(g->ex_members), i);
if (m == NULL) {
continue;
}
if (m->is_group == 0) {
FREEUP(m->u.name);
}
FREEUP(m);
}
g->ex_members.count = 0;
g->dirty = 1;
} else {
g = (xce_group_t*)calloc(1, sizeof(*g));
if (g == NULL) {
return NULL;
}
xlist_init(&(g->affecteds), 4);
xlist_init(&(g->members), 4);
xlist_init(&(g->ex_members), 4);
g->name = makeString(g_name);
g->dirty = 0;
}
for (i = 0; i < g_config->members.count; i++) {
char* g_name = g_config->members.data[i];
xce_g_member_t* m = make_g_member(mgr, g_name);
if (m == NULL) {
continue;
}
xlist_store(&(g->members), m);
if (m->is_group) {
xlist_store(&(m->u.g->affecteds), g);
}
}
for (i = 0; i < g_config->ex_members.count; i++) {
char* g_name = g_config->ex_members.data[i];
xce_g_member_t* m = make_g_member(mgr, g_name);
if (m == NULL) {
continue;
}
xlist_store(&(g->ex_members), m);
if (m->is_group) {
xlist_store(&(m->u.g->affecteds), g);
}
}
groupmgr_add(mgr, g);
if (g->dirty) {
update_group_dirty(g);
}
return g;
}
static int check_in_member(xce_g_member_t* m, va_list ap)
{
char* name = va_arg(ap, char*);

77
src/lib/jobj.c
View file

@ -1,6 +1,7 @@
#include <errno.h>
#include <rtti.h>
#include <stdarg.h>
#include <stdatomic.h>
#include <stdlib.h>
#include <string.h>
@ -103,8 +104,7 @@ static void jobsub_table_fini()
}
typedef struct {
mylock_t lock;
uint64_t refcount;
atomic_ulong refcount;
} job_submit_private_t;
static size_t jobsub_datasize(va_list ap)
@ -154,7 +154,6 @@ static int jobsub_init(meta_obj_t* obj, va_list ap)
return -ENOMEM;
}
mylock_init(&(priv->lock));
priv->refcount = 1;
return 1;
@ -176,7 +175,6 @@ static void jobsub_destroy(meta_obj_t* obj)
dereference(jobsub->start_info);
}
mylock_fini(&(priv->lock));
memset(priv, 0x0, sizeof(*priv));
}
@ -184,9 +182,7 @@ static int jobsub_reference(meta_obj_t* obj)
{
job_submit_private_t* priv = (job_submit_private_t*)RTTI_OBJ_TO_PRIV(obj);
mylock_lock(&(priv->lock));
priv->refcount++;
mylock_unlock(&(priv->lock));
atomic_fetch_add(&(priv->refcount), 1);
return 1;
}
@ -197,12 +193,9 @@ static void jobsub_dereference(meta_obj_t* obj)
job_submit_data_t* data = RTTI_OBJ_TO_DATA(job_submit_data_t, obj);
uint64_t count;
mylock_lock(&(priv->lock));
priv->refcount--;
count = priv->refcount;
mylock_unlock(&(priv->lock));
count = atomic_fetch_sub(&(priv->refcount), 1);
if (count == 0) {
if (count == 1) {
mylock_lock(&(jobsub_table.lock));
key_del(jobsub_table.sub_table, data);
mylock_unlock(&(jobsub_table.lock));
@ -268,8 +261,7 @@ job_submit_data_t* makeJobsub(job_submit_data_t* subdata)
}
typedef struct {
mylock_t lock;
uint64_t refcount;
atomic_ulong refcount;
} startinfo_private_t;
static void startinfo_destroy(meta_obj_t* obj)
@ -305,7 +297,6 @@ static void startinfo_destroy(meta_obj_t* obj)
dereference(startinfo->job_post_exec);
}
mylock_fini(&(priv->lock));
memset(priv, 0x0, sizeof(*priv));
return;
}
@ -327,7 +318,6 @@ static int startinfo_init(meta_obj_t* obj, va_list ap)
return -EINVAL;
}
mylock_init(&(priv->lock));
priv->refcount = 1;
dst->exechome = makeString(src->exechome);
@ -371,9 +361,7 @@ static int startinfo_reference(meta_obj_t* obj)
{
startinfo_private_t* priv = (startinfo_private_t*)RTTI_OBJ_TO_PRIV(obj);
mylock_lock(&(priv->lock));
priv->refcount++;
mylock_unlock(&(priv->lock));
atomic_fetch_add(&(priv->refcount), 1);
return 1;
}
@ -384,16 +372,14 @@ static void startinfo_dereference(meta_obj_t* obj)
startinfo_private_t* priv = (startinfo_private_t*)RTTI_OBJ_TO_PRIV(obj);
uint64_t count;
mylock_lock(&(priv->lock));
priv->refcount--;
count = priv->refcount;
mylock_unlock(&(priv->lock));
count = atomic_fetch_sub(&(priv->refcount), 1);
if (count == 0) {
if (count == 1) {
mylock_lock(&(startinfo_table.lock));
key_del(startinfo_table.startinfo_table, startinfo);
mylock_unlock(&(startinfo_table.lock));
}
return;
}
@ -531,8 +517,8 @@ static void startinfo_table_fini()
}
typedef struct {
my_rwlock_t lock;
uint64_t refcount;
my_rwlock_t lock;
atomic_ulong refcount;
} job_private_t;
static size_t job_datasize(va_list ap)
@ -606,9 +592,7 @@ static int job_reference(meta_obj_t* obj)
{
job_private_t* priv = (job_private_t*)RTTI_OBJ_TO_PRIV(obj);
my_rwlock_wlock(&(priv->lock));
priv->refcount++;
my_rwlock_unlock(&(priv->lock));
atomic_fetch_add(&(priv->refcount), 1);
return 1;
}
@ -619,12 +603,9 @@ static void job_dereference(meta_obj_t* obj)
job_t* j = RTTI_OBJ_TO_DATA(job_t, obj);
uint64_t count;
my_rwlock_wlock(&(priv->lock));
priv->refcount--;
count = priv->refcount;
my_rwlock_unlock(&(priv->lock));
count = atomic_fetch_sub(&(priv->refcount), 1);
if (count == 0) {
if (count == 1) {
destroy_(j, (obj_destroy_fn_t)job_destroy);
}
@ -674,12 +655,13 @@ static typeinfo_t job_type = {
.unlock = (unlock_fn_t)job_unlock } }
};
job_t* makeJob(var jobmgr, xce_job_t* j)
static job_t* makeJob_(var jobmgr, xce_job_t* j)
{
job_t* job = NULL;
int rc = 0;
int rc = 0;
rc = key_find(jobmgr, (void*)j->jobid, (void**)&job);
rc = key_find(jobmgr, (void *)j->jobid, (void **)&job);
if ((rc < 0) && (rc != -ENOENT)) {
errno = -rc;
return NULL;
@ -689,10 +671,11 @@ job_t* makeJob(var jobmgr, xce_job_t* j)
errno = EEXIST;
return NULL;
}
job = makeInstance(&job_type, j);
if (job != NULL) {
rc = key_add(jobmgr, (void *)job->job.jobid, (void **)job);
rc = key_add(jobmgr, (void*)job->job.jobid, (void**)job);
if (rc < 0) {
destroy(job);
@ -700,6 +683,22 @@ job_t* makeJob(var jobmgr, xce_job_t* j)
return NULL;
}
}
return job;
}
job_t* makeJob(var jobmgr, xce_job_t* j)
{
job_t* job = NULL;
int rc = 0;
lock(jobmgr, RTTI_LOCK_WRITE);
job = makeJob_(jobmgr, j);
rc = errno;
unlock(jobmgr);
errno = rc;
return job;
}

108
src/lib/kvmgr.c
View file

@ -19,7 +19,6 @@ typedef struct {
typedef struct {
kvmgr_key_type_t key_type;
unsigned int dynamic : 1;
uint32_t nslots;
var kvtab;
var data;
@ -34,10 +33,11 @@ static size_t xkvmgr_datasize(va_list ap)
static int xkvmgr_init(meta_obj_t* obj, va_list ap)
{
xkvmgr_t* kvm = RTTI_OBJ_TO_DATA(xkvmgr_t, obj);
kvmgr_params_t* params = va_arg(ap, kvmgr_params_t*);
kv_params_t kv_params;
xzarray_params_t data_params;
xkvmgr_t* kvm = RTTI_OBJ_TO_DATA(xkvmgr_t, obj);
kvmgr_params_t* params = va_arg(ap, kvmgr_params_t*);
kv_params_t kv_params;
xzarray_params_t data_params;
xkvmgr_private_t* priv = RTTI_OBJ_TO_PRIV(obj);
if ((params == NULL)
|| ((params->key_type != KVMGR_KEY_INT)
@ -76,20 +76,16 @@ static int xkvmgr_init(meta_obj_t* obj, va_list ap)
kvm->nslots = params->nslots;
kvm->key_type = params->key_type;
kvm->dynamic = params->dynamic;
if (params->dynamic) {
xkvmgr_private_t* priv = RTTI_OBJ_TO_PRIV(obj);
my_rwlock_init(&(priv->lock));
}
my_rwlock_init(&(priv->lock));
return 1;
}
static void xkvmgr_destroy(meta_obj_t* obj)
{
xkvmgr_t* kvm = RTTI_OBJ_TO_DATA(xkvmgr_t, obj);
xkvmgr_t* kvm = RTTI_OBJ_TO_DATA(xkvmgr_t, obj);
xkvmgr_private_t* priv = RTTI_OBJ_TO_PRIV(obj);
if (kvm->data != NULL) {
destroy(kvm->data);
@ -99,11 +95,7 @@ static void xkvmgr_destroy(meta_obj_t* obj)
destroy(kvm->kvtab);
}
if (kvm->dynamic) {
xkvmgr_private_t* priv = RTTI_OBJ_TO_PRIV(obj);
my_rwlock_fini(&(priv->lock));
}
my_rwlock_fini(&(priv->lock));
memset(kvm, 0x0, sizeof(*kvm));
return;
@ -116,10 +108,6 @@ static int xkvmgr_add(meta_obj_t* obj, void* key, void* value)
xkvmgr_private_t* priv = RTTI_OBJ_TO_PRIV(obj);
int idx;
if (kvm->dynamic) {
my_rwlock_wlock(&(priv->lock));
}
rc = vstore(kvm->data, value);
if (rc >= 0) {
@ -134,10 +122,6 @@ static int xkvmgr_add(meta_obj_t* obj, void* key, void* value)
}
}
if (kvm->dynamic) {
my_rwlock_unlock(&(priv->lock));
}
return rc;
}
@ -150,10 +134,6 @@ static int xkvmgr_find(meta_obj_t* obj, void* key, void** value)
*value = NULL;
if (kvm->dynamic) {
my_rwlock_rlock(&(priv->lock));
}
rc = key_find(kvm->kvtab, key, &data);
if (rc >= 0) {
int idx = (int)(long)data;
@ -165,10 +145,6 @@ static int xkvmgr_find(meta_obj_t* obj, void* key, void** value)
}
}
if (kvm->dynamic) {
my_rwlock_unlock(&(priv->lock));
}
return rc;
}
@ -184,15 +160,9 @@ static int xkvmgr_make_iter(iterator_t* iter, va_list ap)
return -ENOMEM;
}
if (kvm->dynamic) {
my_rwlock_rlock(&(priv->lock));
}
rc = iter_make(it, kvm->data);
if (rc < 0) {
FREEUP(it);
if (kvm->dynamic) {
my_rwlock_unlock(&(priv->lock));
}
return rc;
}
@ -230,10 +200,6 @@ static void xkvmgr_iter_destroy(iterator_t* iter)
iter->data = NULL;
if (kvm->dynamic) {
my_rwlock_unlock(&(priv->lock));
}
return;
}
@ -243,15 +209,8 @@ static int xkvmgr_get_vec(meta_obj_t* obj, int count, int* idxs, void** data)
xkvmgr_private_t* priv = RTTI_OBJ_TO_PRIV(obj);
int rc = 0;
if (kvm->dynamic) {
my_rwlock_rlock(&(priv->lock));
}
rc = vget_vec(kvm->data, count, idxs, data);
if (kvm->dynamic) {
my_rwlock_unlock(&(priv->lock));
}
return rc;
}
@ -261,15 +220,8 @@ static int xkvmgr_get(meta_obj_t* obj, int idx, void** data)
xkvmgr_private_t* priv = RTTI_OBJ_TO_PRIV(obj);
int rc = 0;
if (kvm->dynamic) {
my_rwlock_rlock(&(priv->lock));
}
rc = vget(kvm->data, idx, data);
if (kvm->dynamic) {
my_rwlock_unlock(&(priv->lock));
}
return rc;
}
@ -279,15 +231,8 @@ static int xkvmgr_put_vec(meta_obj_t* obj, int count, int* idxs, void** data)
xkvmgr_private_t* priv = RTTI_OBJ_TO_PRIV(obj);
int rc = 0;
if (kvm->dynamic) {
my_rwlock_wlock(&(priv->lock));
}
rc = vput_vec(kvm->data, count, idxs, data);
if (kvm->dynamic) {
my_rwlock_unlock(&(priv->lock));
}
return rc;
}
@ -297,18 +242,39 @@ static int xkvmgr_put(meta_obj_t* obj, int idx, void* data)
xkvmgr_private_t* priv = RTTI_OBJ_TO_PRIV(obj);
int rc = 0;
if (kvm->dynamic) {
my_rwlock_wlock(&(priv->lock));
}
rc = vput(kvm->data, idx, data);
if (kvm->dynamic) {
my_rwlock_unlock(&(priv->lock));
return rc;
}
static int xkvmgr_lock(meta_obj_t* obj, uint64_t option)
{
xkvmgr_private_t* priv = (xkvmgr_private_t*)RTTI_OBJ_TO_PRIV(obj);
int rc = -EINVAL;
switch (option) {
case RTTI_LOCK_READ:
rc = my_rwlock_rlock(&(priv->lock));
break;
case RTTI_LOCK_WRITE:
rc = my_rwlock_wlock(&(priv->lock));
break;
default:
break;
}
return rc;
}
static void xkvmgr_unlock(meta_obj_t* obj)
{
xkvmgr_private_t* priv = (xkvmgr_private_t*)RTTI_OBJ_TO_PRIV(obj);
my_rwlock_unlock(&(priv->lock));
return;
}
typeinfo_t xkvmgr_type = {
.name = "xkvmgr",
.privateSize = sizeof(xkvmgr_private_t),
@ -330,5 +296,7 @@ typeinfo_t xkvmgr_type = {
.next = (iter_next_fn_t)xkvmgr_iter_next,
.reset = (iter_reset_fn_t)xkvmgr_iter_reset,
.destroy
= (iter_destroy_fn_t)xkvmgr_iter_destroy } }
= (iter_destroy_fn_t)xkvmgr_iter_destroy },
.lock = &(intf_lock_t) { .lock = (lock_fn_t)xkvmgr_lock,
.unlock = (unlock_fn_t)xkvmgr_unlock } }
};

36
src/lib/qobj.c
View file

@ -1,6 +1,7 @@
#include <errno.h>
#include <rtti.h>
#include <stdarg.h>
#include <stdatomic.h>
#include <stdlib.h>
#include <string.h>
@ -10,8 +11,8 @@
#include "xstring.h"
typedef struct {
my_rwlock_t lock;
uint64_t refcount;
my_rwlock_t lock;
atomic_ulong refcount;
} queue_private_t;
static size_t queue_datasize(va_list ap)
@ -42,6 +43,7 @@ static int queue_init(meta_obj_t* obj, va_list ap)
MOVE_PTR(dst->queue.hosts, src->hosts);
dst->queue.nthresholds = src->nthresholds;
MOVE_PTR(dst->queue.thresholds, src->thresholds);
src->nthresholds = 0;
MOVE_PTR(dst->queue.runwindow, src->runwindow);
MOVE_PTR(dst->queue.dispatchwindow, src->dispatchwindow);
@ -95,9 +97,7 @@ static int queue_reference(meta_obj_t* obj)
{
queue_private_t* priv = (queue_private_t*)RTTI_OBJ_TO_PRIV(obj);
my_rwlock_wlock(&(priv->lock));
priv->refcount++;
my_rwlock_unlock(&(priv->lock));
atomic_fetch_add(&(priv->refcount), 1);
return 1;
}
@ -108,12 +108,9 @@ static void queue_dereference(meta_obj_t* obj)
queue_t* w = RTTI_OBJ_TO_DATA(queue_t, obj);
uint64_t count = 0;
my_rwlock_wlock(&(priv->lock));
priv->refcount--;
count = priv->refcount;
my_rwlock_unlock(&(priv->lock));
count = atomic_fetch_sub(&(priv->refcount), 1);
if (count == 0) {
if (count == 1) {
destroy_(w, (obj_destroy_fn_t)queue_destroy);
}
@ -163,12 +160,13 @@ static typeinfo_t queue_type = {
.unlock = (unlock_fn_t)queue_unlock } }
};
queue_t* makeQueue(var qmgr, xce_queue_t* q)
static queue_t* makeQueue_(var qmgr, xce_queue_t* q)
{
queue_t* queue = NULL;
int rc = 0;
rc = key_find(qmgr, (void*)q->queue, (void**)&queue);
if ((rc < 0) && (rc != -ENOENT)) {
errno = -rc;
return NULL;
@ -181,8 +179,8 @@ queue_t* makeQueue(var qmgr, xce_queue_t* q)
queue = makeInstance(&queue_type, q);
if (queue != NULL) {
reference(queue);
rc = key_add(qmgr, (void*)q->queue, (void*)queue);
if (rc < 0) {
destroy(queue);
@ -193,3 +191,17 @@ queue_t* makeQueue(var qmgr, xce_queue_t* q)
return queue;
}
queue_t* makeQueue(var qmgr, xce_queue_t* q)
{
queue_t* queue = NULL;
int rc;
lock(qmgr, RTTI_LOCK_WRITE);
queue = makeQueue_(qmgr, q);
rc = errno;
unlock(qmgr);
errno = rc;
return queue;
}

33
src/lib/resobj.c
View file

@ -1,6 +1,7 @@
#include <errno.h>
#include <rtti.h>
#include <stdarg.h>
#include <stdatomic.h>
#include <stdlib.h>
#include <string.h>
@ -10,8 +11,7 @@
#include "xstring.h"
typedef struct {
mylock_t lock;
uint64_t refcount;
atomic_ulong refcount;
} resobj_private_t;
static size_t resobj_datasize(va_list ap)
@ -52,7 +52,6 @@ static int resobj_init(meta_obj_t* obj, va_list ap)
dst->hbased_defined = NULL;
#endif
mylock_init(&(priv->lock));
priv->refcount = 1;
return 1;
@ -66,7 +65,6 @@ static void resobj_destroy(meta_obj_t* obj)
dereference(r->name);
dereference(r->desc);
mylock_fini(&(priv->lock));
memset(priv, 0x0, sizeof(*priv));
return;
@ -76,9 +74,7 @@ static int resobj_reference(meta_obj_t* obj)
{
resobj_private_t* priv = (resobj_private_t*)RTTI_OBJ_TO_PRIV(obj);
mylock_lock(&(priv->lock));
priv->refcount++;
mylock_unlock(&(priv->lock));
atomic_fetch_add(&(priv->refcount), 1);
return 1;
}
@ -89,12 +85,9 @@ static void resobj_dereference(meta_obj_t* obj)
xce_resource_t* w = RTTI_OBJ_TO_DATA(xce_resource_t, obj);
uint64_t count = 0;
mylock_lock(&(priv->lock));
priv->refcount--;
count = priv->refcount;
mylock_unlock(&(priv->lock));
count = atomic_fetch_sub(&(priv->refcount), 1);
if (count == 0) {
if (count == 1) {
destroy_(w, (obj_destroy_fn_t)resobj_destroy);
}
@ -112,12 +105,13 @@ static typeinfo_t resobj_type
.reference = (reference_fn_t)resobj_reference,
.dereference = (dereference_fn_t)resobj_dereference } } };
xce_resource_t* makeResource(var resmgr, xce_resource_t* r)
static xce_resource_t* makeResource_(var resmgr, xce_resource_t* r)
{
xce_resource_t* resobj = NULL;
int rc;
rc = key_find(resmgr, (void*)r->name, (void**)&resobj);
if ((rc < 0) && (rc != -ENOENT)) {
errno = -rc;
@ -131,8 +125,8 @@ xce_resource_t* makeResource(var resmgr, xce_resource_t* r)
resobj = makeInstance(&resobj_type, r);
if (resobj != NULL) {
reference(resobj);
rc = key_add(resmgr, (void*)resobj->name, (void*)resobj);
if (rc < 0) {
destroy(resobj);
@ -142,3 +136,14 @@ xce_resource_t* makeResource(var resmgr, xce_resource_t* r)
}
return resobj;
}
xce_resource_t* makeResource(var resmgr, xce_resource_t* r)
{
xce_resource_t* r1 = NULL;
lock(resmgr, RTTI_LOCK_WRITE);
r1 = makeResource_(resmgr, r);
unlock(resmgr);
return r1;
}

17
src/lib/resreq.c
View file

@ -169,11 +169,14 @@ int parse_resreq_primary(xce_primary_resreq_t* primary, char* resreqString,
}
xlist_init(&(primary->rusages), 8);
rc = parse_rusage(&(primary->rusages), data.rusageString, errmsg);
if (rc < 0) {
kill_resreq_data(&data);
return rc;
if ((data.rusageString != NULL) && (strlen(data.rusageString) != 0)) {
rc = parse_rusage(&(primary->rusages), data.rusageString, errmsg);
if (rc < 0) {
kill_resreq_data(&data);
return rc;
}
}
/* FIXME: add others later */
@ -451,7 +454,10 @@ int calc_wanted_global_resvals(xvec_idval_t* resvals, var resmgr,
continue;
}
lock(resmgr, RTTI_LOCK_READ);
rc = key_find(resmgr, (void*)v->res, (void**)&r);
unlock(resmgr);
if (rc <= 0) {
continue;
}
@ -507,7 +513,10 @@ int calc_wanted_host_resvals(xvec_idval_t* resvals, var resmgr,
continue;
}
lock(resmgr, RTTI_LOCK_READ);
rc = key_find(resmgr, (void*)v->res, (void**)&r);
unlock(resmgr);
if (rc <= 0) {
continue;
}

1
src/lib/testsuite/test_jobj.c
View file

@ -208,7 +208,6 @@ static void test_job_create(void)
{
int rc;
kvmgr_params_t jobmgr_params = { .key_type = KVMGR_KEY_INT,
.dynamic = 1,
.nslots = 32,
.delta = 32,
.datakiller = destroy };

5
src/lib/testsuite/test_kvmgr.c
View file

@ -15,7 +15,6 @@ typedef struct {
static void test_kvmgr_create(void)
{
kvmgr_params_t params = { .key_type = KVMGR_KEY_STRING,
.dynamic = 0,
.nslots = 4,
.delta = 4,
.datakiller = NULL };
@ -46,7 +45,6 @@ static void my_user_killer(void* data)
static void test_kvmgr_add(void)
{
kvmgr_params_t params = { .key_type = KVMGR_KEY_STRING,
.dynamic = 0,
.nslots = 4,
.delta = 4,
.datakiller = my_user_killer };
@ -79,7 +77,6 @@ static void test_kvmgr_add(void)
static void test_kvmgr_iter(void)
{
kvmgr_params_t params = { .key_type = KVMGR_KEY_INT,
.dynamic = 0,
.nslots = 4,
.delta = 4,
.datakiller = NULL };
@ -116,7 +113,7 @@ static void test_kvmgr_iter(void)
TEST_ASSERT_TRUE(i == 10);
iter_destroy(&it);
destroy(kvmgr);
}

21
src/lib/testsuite/test_resreq.c
View file

@ -212,6 +212,26 @@ void test_resreq_primary(void)
}
}
void test_resreq_primary2(void)
{
char* resreqString
= "select[type==any] ";
char* errmsg = NULL;
int rc = 0;
xce_primary_resreq_t resreq;
rc = parse_resreq_primary(&resreq, resreqString, &errmsg);
TEST_ASSERT_TRUE(rc >= 0);
if (rc >= 0) {
int i;
xlist_t* rusages = &(resreq.rusages);
TEST_ASSERT_TRUE(rusages->count == 0);
xlist_fini(rusages);
}
}
void test_resreq1(void)
{
char* resreqString
@ -337,6 +357,7 @@ void test_resreq(void)
RUN_TEST(test_parse_rusage1);
RUN_TEST(test_parse_rusage2);
RUN_TEST(test_resreq_primary);
RUN_TEST(test_resreq_primary2);
RUN_TEST(test_resreq1);
RUN_TEST(test_resreq2);
RUN_TEST(test_resreq3);

33
src/lib/wobj.c
View file

@ -1,6 +1,7 @@
#include <errno.h>
#include <rtti.h>
#include <stdarg.h>
#include <stdatomic.h>
#include <stdlib.h>
#include <string.h>
@ -10,8 +11,8 @@
#include "xstring.h"
typedef struct {
my_rwlock_t lock;
uint64_t refcount;
my_rwlock_t lock;
atomic_ulong refcount;
} worker_private_t;
static size_t worker_datasize(va_list ap)
@ -91,9 +92,7 @@ static int worker_reference(meta_obj_t* obj)
{
worker_private_t* priv = (worker_private_t*)RTTI_OBJ_TO_PRIV(obj);
my_rwlock_wlock(&(priv->lock));
priv->refcount++;
my_rwlock_unlock(&(priv->lock));
atomic_fetch_add(&(priv->refcount), 1);
return 1;
}
@ -104,12 +103,9 @@ static void worker_dereference(meta_obj_t* obj)
worker_t* w = RTTI_OBJ_TO_DATA(worker_t, obj);
uint64_t count = 0;
my_rwlock_wlock(&(priv->lock));
priv->refcount--;
count = priv->refcount;
my_rwlock_unlock(&(priv->lock));
count = atomic_fetch_sub(&(priv->refcount), 1);
if (count == 0) {
if (count == 1) {
destroy_(w, (obj_destroy_fn_t)worker_destroy);
}
@ -159,12 +155,13 @@ static typeinfo_t worker_type = {
.unlock = (unlock_fn_t)worker_unlock } }
};
worker_t* makeWorker(var workermgr, xce_worker_t* w)
static worker_t* makeWorker_(var workermgr, xce_worker_t* w)
{
worker_t* worker = NULL;
int rc = 0;
rc = key_find(workermgr, (void*)w->name, (void**)&worker);
if ((rc < 0) && (rc != -ENOENT)) {
errno = -rc;
@ -178,8 +175,8 @@ worker_t* makeWorker(var workermgr, xce_worker_t* w)
worker = makeInstance(&worker_type, w);
if (worker != NULL) {
reference(worker);
rc = key_add(workermgr, (void*)worker->host.name, (void*)worker);
if (rc < 0) {
destroy(worker);
@ -187,5 +184,17 @@ worker_t* makeWorker(var workermgr, xce_worker_t* w)
return NULL;
}
}
return worker;
}
worker_t* makeWorker(var workermgr, xce_worker_t* w)
{
worker_t* worker = NULL;
lock(workermgr, RTTI_LOCK_WRITE);
worker = makeWorker_(workermgr, w);
unlock(workermgr);
return worker;
}

12
src/lib/xcelimit.c
View file

@ -377,7 +377,10 @@ int is_host_based_limit(var resmgr, xce_limit_t* limit)
return -EINVAL;
}
lock(resmgr, RTTI_LOCK_READ);
rc = key_find(resmgr, (void*)limit->val.resname, (void**)&r);
unlock(resmgr);
if (rc <= 0) {
return -ENOENT;
}
@ -420,7 +423,10 @@ int add_vres(xce_resource_t** pvres, var resmgr, char* name, int global)
vres->flags |= XCE_RESF_DEFAULT_HOST;
}
lock(resmgr, RTTI_LOCK_WRITE);
rc = key_add(resmgr, (void*)vres->name, (void*)vres);
unlock(resmgr);
if (rc < 0) {
return rc;
}
@ -460,7 +466,10 @@ int instantiate_limit(xce_vres_t** pvres, var resmgr, xce_limit_t* limit,
return rc;
}
lock(resmgr, RTTI_LOCK_READ);
rc = key_find(resmgr, (void*)vresname, (void**)&(vres->vres));
unlock(resmgr);
if (rc < 0) {
return rc;
}
@ -475,7 +484,10 @@ int instantiate_limit(xce_vres_t** pvres, var resmgr, xce_limit_t* limit,
FREEUP(vresname);
lock(resmgr, RTTI_LOCK_READ);
rc = key_find(resmgr, (void*)limit->val.resname, (void**)&(vres->res));
unlock(resmgr);
if (rc < 0) {
return rc;
}

22
src/lib/xstring.c
View file

@ -1,6 +1,7 @@
#include <errno.h>
#include <rtti.h>
#include <stdarg.h>
#include <stdatomic.h>
#include <stdlib.h>
#include <string.h>
@ -16,10 +17,9 @@ static struct {
} xstring_table;
typedef struct {
mylock_t lock;
uint64_t refcount;
uint32_t hashcode;
size_t len;
atomic_ulong refcount;
uint32_t hashcode;
size_t len;
} xstring_private_t;
static typeinfo_t xstring_type;
@ -78,7 +78,6 @@ static int xstring_init(meta_obj_t* obj, va_list ap)
strcpy(dest, src);
mylock_init(&(priv->lock));
priv->refcount = 1;
priv->hashcode = hash_string(src);
priv->len = strlen(src);
@ -90,7 +89,6 @@ static void xstring_destroy(meta_obj_t* obj)
{
xstring_private_t* priv = (xstring_private_t*)RTTI_OBJ_TO_PRIV(obj);
mylock_fini(&(priv->lock));
memset(priv, 0x0, sizeof(*priv));
return;
@ -100,9 +98,7 @@ static int xstring_reference(meta_obj_t* obj)
{
xstring_private_t* priv = (xstring_private_t*)RTTI_OBJ_TO_PRIV(obj);
mylock_lock(&(priv->lock));
priv->refcount++;
mylock_unlock(&(priv->lock));
atomic_fetch_add(&(priv->refcount), 1);
return 0;
}
@ -113,13 +109,9 @@ static void xstring_dereference(meta_obj_t* obj)
char* v = RTTI_OBJ_TO_DATA(char, obj);
uint64_t count;
mylock_lock(&(priv->lock));
priv->refcount--;
count = atomic_fetch_sub(&(priv->refcount), 1);
count = priv->refcount;
mylock_unlock(&(priv->lock));
if (count == 0) {
if (count == 1) {
mylock_lock(&(xstring_table.lock));
key_del(xstring_table.xstr_table, v);
mylock_unlock(&(xstring_table.lock));

32
src/lib/zarray.c
View file

@ -456,7 +456,6 @@ static int xzarray_store(meta_obj_t* obj, void* data)
xzarray_private_t* priv = (xzarray_private_t*)RTTI_OBJ_TO_PRIV(obj);
int rc = 0;
mylock_lock(&(priv->lock));
rc = xzarray_ensure_items(a, a->count + 1);
if (rc >= 0) {
int idx, i;
@ -484,7 +483,6 @@ static int xzarray_store(meta_obj_t* obj, void* data)
a->pos = (rc + 1) % a->caps;
}
}
mylock_unlock(&(priv->lock));
return rc;
}
@ -499,7 +497,6 @@ static int xzarray_get_vec(meta_obj_t* obj, int count, int* idxs, void** data)
return -EINVAL;
}
mylock_lock(&(priv->lock));
for (i = 0; i < count; i++) {
int idx = idxs[i];
@ -516,7 +513,6 @@ static int xzarray_get_vec(meta_obj_t* obj, int count, int* idxs, void** data)
data[i] = a->data[idx].data;
}
}
mylock_unlock(&(priv->lock));
return rc;
}
@ -537,7 +533,6 @@ static int xzarray_put_vec(meta_obj_t* obj, int count, int* idxs, void** data)
return -EINVAL;
}
mylock_lock(&(priv->lock));
maxid = 0;
rc = 0;
@ -570,8 +565,6 @@ static int xzarray_put_vec(meta_obj_t* obj, int count, int* idxs, void** data)
}
}
mylock_unlock(&(priv->lock));
return rc;
}
@ -588,7 +581,6 @@ static int xzarray_clear(meta_obj_t* obj, int idx)
xzarray_private_t* priv = (xzarray_private_t*)RTTI_OBJ_TO_PRIV(obj);
int rc = -EINVAL;
mylock_lock(&(priv->lock));
if (idx < a->caps) {
rc = 0;
if (a->data[idx].inuse) {
@ -601,7 +593,6 @@ static int xzarray_clear(meta_obj_t* obj, int idx)
a->data[idx].data = NULL;
a->pos = idx; /* we can find the available idx next time */
}
mylock_unlock(&(priv->lock));
return rc;
}
@ -610,7 +601,6 @@ static int xzarray_make_iter(iterator_t* iter, va_list ap)
{
xzarray_private_t* priv = (xzarray_private_t*)RTTI_OBJ_TO_PRIV(iter->obj);
mylock_lock(&(priv->lock));
iter->data = (void*)(long)0;
return RTTI_ITER_OK;
@ -640,12 +630,26 @@ static int xzarray_iter_reset(iterator_t* iter)
return RTTI_ITER_OK;
}
static int xzarray_lock(meta_obj_t* obj, uint64_t option)
{
xzarray_private_t* priv = (xzarray_private_t*)RTTI_OBJ_TO_PRIV(obj);
return mylock_lock(&(priv->lock));
}
static void xzarray_unlock(meta_obj_t* obj)
{
xzarray_private_t* priv = (xzarray_private_t*)RTTI_OBJ_TO_PRIV(obj);
mylock_unlock(&(priv->lock));
return;
}
static void xzarray_iter_destroy(iterator_t* iter)
{
xzarray_private_t* priv = (xzarray_private_t*)RTTI_OBJ_TO_PRIV(iter->obj);
mylock_unlock(&(priv->lock));
return;
}
@ -667,5 +671,7 @@ typeinfo_t xzarray_type = {
.next = (iter_next_fn_t)xzarray_iter_next,
.reset = (iter_reset_fn_t)xzarray_iter_reset,
.destroy
= (iter_destroy_fn_t)xzarray_iter_destroy } }
= (iter_destroy_fn_t)xzarray_iter_destroy },
.lock = &(intf_lock_t) { .lock = (lock_fn_t)xzarray_lock,
.unlock = (unlock_fn_t)xzarray_unlock } }
};