int sr_cset(src *c, srcstmt *stmt, char *value)
{
int type = c->flags & ~SR_CRO;
if (c->flags & SR_CRO) {
sr_error(stmt->r->e, "%s is read-only", stmt->path);
return -1;
}
switch (type) {
case SR_CU32:
*((uint32_t*)c->value) = sr_atoi(value);
break;
case SR_CU64:
*((uint64_t*)c->value) = sr_atoi(value);
break;
case SR_CSZREF: {
char *nsz = NULL;
if (value) {
nsz = sr_strdup(stmt->r->a, value);
if (srunlikely(nsz == NULL)) {
sr_error(stmt->r->e, "%s", "memory allocation failed");
return -1;
}
}
char **sz = (char**)c->value;
if (*sz)
sr_free(stmt->r->a, *sz);
*sz = nsz;
break;
}
default: assert(0);
}
return 0;
}
int so_scheduler_del(soscheduler *s, void *db)
{
if (srunlikely(s->i == NULL))
return 0;
sr_mutexlock(&s->lock);
so *e = s->env;
int count = s->count - 1;
if (srunlikely(count == 0)) {
s->count = 0;
sr_free(&e->a, s->i);
s->i = NULL;
sr_mutexunlock(&s->lock);
return 0;
}
void **i = sr_malloc(&e->a, count * sizeof(void*));
if (srunlikely(i == NULL)) {
sr_mutexunlock(&s->lock);
return -1;
}
int j = 0;
int k = 0;
while (j < s->count) {
if (s->i[j] == db) {
j++;
continue;
}
i[k] = s->i[j];
k++;
j++;
}
void *iprev = s->i;
s->i = i;
s->count = count;
if (srunlikely(s->rr >= s->count))
s->rr = 0;
sr_mutexunlock(&s->lock);
sr_free(&e->a, iprev);
return 0;
}
int so_scheduler_shutdown(soscheduler *s)
{
so *e = s->env;
int rcret = 0;
int rc = so_workersshutdown(&s->workers, &e->r);
if (srunlikely(rc == -1))
rcret = -1;
if (s->i) {
sr_free(&e->a, s->i);
s->i = NULL;
}
sr_mutexfree(&s->lock);
return rcret;
}
int si_nodefree(sinode *n, sr *r, int gc)
{
int rcret = 0;
int rc;
if (gc && n->file.file) {
rc = sr_fileunlink(n->file.file);
if (srunlikely(rc == -1)) {
sr_malfunction(r->e, "db file '%s' unlink error: %s",
n->file.file, strerror(errno));
rcret = -1;
}
}
si_nodefree_branches(n, r);
rc = si_nodeclose(n, r);
if (srunlikely(rc == -1))
rcret = -1;
sr_free(r->a, n);
return rcret;
}
int so_scheduler_add(soscheduler *s , void *db)
{
sr_mutexlock(&s->lock);
so *e = s->env;
int count = s->count + 1;
void **i = sr_malloc(&e->a, count * sizeof(void*));
if (srunlikely(i == NULL)) {
sr_mutexunlock(&s->lock);
return -1;
}
memcpy(i, s->i, s->count * sizeof(void*));
i[s->count] = db;
void *iprev = s->i;
s->i = i;
s->count = count;
sr_mutexunlock(&s->lock);
if (iprev)
sr_free(&e->a, iprev);
return 0;
}
