int sx_get(sx *t, sxindex *index, sv *key, sv *result)
{
sxmanager *m = t->manager;
ssrbnode *n = NULL;
int rc = sx_match(&index->i, index->scheme,
sv_pointer(key),
sv_size(key), &n);
if (! (rc == 0 && n)) {
rc = 0;
goto done;
}
sxv *head = sscast(n, sxv, node);
sxv *v = sx_vmatch(head, t->id);
if (v == NULL) {
rc = 0;
goto done;
}
if (ssunlikely((v->v->flags & SVDELETE) > 0)) {
rc = 2;
goto done;
}
sv vv;
sv_init(&vv, &sv_vif, v->v, NULL);
svv *ret = sv_vdup(m->a, &vv);
if (ssunlikely(ret == NULL)) {
rc = sr_oom(index->r->e);
} else {
sv_init(result, &sv_vif, ret, NULL);
rc = 1;
}
done:
return rc;
}
int sv_test(void)
{
spinlock_t s = SPIN_LOCK_UNLOCKED;
sv_init(&sv, &s, SV_MON_SPIN);
printk("sv_test: starting sv_test_1_w.\n");
kernel_thread(sv_test_1_w, &s, 0);
printk("sv_test: starting sv_test_1_s.\n");
kernel_thread(sv_test_1_s, &s, 0);
printk("sv_test: waiting for talkback.\n");
down(&talkback); down(&talkback);
printk("sv_test: talkback happened, sv_destroying.\n");
sv_destroy(&sv);
count = 0;
printk("sv_test: beginning big_test on sv.\n");
sv_init(&sv, &monitor, SV_MON_SEMA);
big_test(&sv);
sv_destroy(&sv);
printk("sv_test: beginning big_test on sv_filo.\n");
sv_init(&sv_filo, &monitor, SV_MON_SEMA | SV_ORDER_FILO);
big_test(&sv_filo);
sv_destroy(&sv_filo);
interrupt_test();
printk("sv_test: done.\n");
return 0;
}
/*
* Allocate the map needed to allocate the ATE entries.
*/
struct map *
atemapalloc(ulong_t mapsiz)
{
struct map *mp;
ulong_t size;
struct a {
spinlock_t lock;
sv_t sema;
} *sync;
if (mapsiz == 0)
return(NULL);
size = sizeof(struct map) * (mapsiz + 2);
if ((mp = (struct map *) kmalloc(size, GFP_KERNEL)) == NULL)
return(NULL);
memset(mp, 0x0, size);
sync = kmalloc(sizeof(struct a), GFP_KERNEL);
if (sync == NULL) {
kfree(mp);
return(NULL);
}
memset(sync, 0x0, sizeof(struct a));
mutex_spinlock_init(&sync->lock);
sv_init( &(sync->sema), &(sync->lock), SV_MON_SPIN | SV_ORDER_FIFO /*| SV_INTS*/);
mp[1].m_size = (unsigned long) &sync->lock;
mp[1].m_addr = (unsigned long) &sync->sema;
mapsize(mp) = mapsiz - 1;
return(mp);
}
static inline void
sx_rollback_index(sx *t, int translate)
{
ssiter i;
ss_iterinit(ss_bufiter, &i);
ss_iteropen(ss_bufiter, &i, &t->log.buf, sizeof(svlogv));
for (; ss_iterhas(ss_bufiter, &i); ss_iternext(ss_bufiter, &i))
{
svlogv *lv = ss_iterof(ss_bufiter, &i);
sxv *v = lv->v.v;
/* remove from index and replace head with
* a first waiter */
if (v->prev)
goto unlink;
sxindex *i = v->index;
if (v->next == NULL)
ss_rbremove(&i->i, &v->node);
else
ss_rbreplace(&i->i, &v->node, &v->next->node);
unlink:
sx_vunlink(v);
/* translate log version from sxv to svv */
if (translate) {
sv_init(&lv->v, &sv_vif, v->v, NULL);
lv->vgc = v;
}
}
}
sxstate sx_set_autocommit(sxmanager *m, sxindex *index, sx *x, svv *v)
{
if (sslikely(m->count_rw == 0)) {
sx_init(m, x);
svlogv lv;
lv.id = index->dsn;
lv.next = UINT32_MAX;
sv_init(&lv.v, &sv_vif, v, NULL);
sv_logadd(&x->log, m->r->a, &lv, index->ptr);
sr_seq(m->r->seq, SR_TSNNEXT);
return SXCOMMIT;
}
sx_begin(m, x, SXRW, 0);
int rc = sx_set(x, index, v);
if (ssunlikely(rc == -1)) {
sx_rollback(x);
return SXROLLBACK;
}
sxstate s = sx_prepare(x, NULL, NULL);
if (sslikely(s == SXPREPARE))
sx_commit(x);
else
if (s == SXLOCK)
sx_rollback(x);
return s;
}
static inline int
si_qgetindex(siquery *q, sinode *node)
{
svindex *second;
svindex *first = si_nodeindex_priority(node, &second);
ssiter i;
ss_iterinit(sv_indexiter, &i);
int rc;
if (first->count > 0) {
rc = ss_iteropen(sv_indexiter, &i, q->r, first,
SS_GTE, q->key, q->keysize);
if (rc) {
goto result;
}
}
if (sslikely(second == NULL || !second->count))
return 0;
rc = ss_iteropen(sv_indexiter, &i, q->r, second,
SS_GTE, q->key, q->keysize);
if (! rc) {
return 0;
}
result:;
sv *v = ss_iterof(sv_indexiter, &i);
assert(v != NULL);
svv *visible = v->v;
if (sslikely(! q->has)) {
visible = sv_visible((svv*)v->v, q->vlsn);
if (visible == NULL)
return 0;
}
sv vret;
sv_init(&vret, &sv_vif, visible, NULL);
return si_qgetresult(q, &vret, 0);
}
sxstate sx_commit(sx *t)
{
assert(t->s == SXPREPARE);
if (t->complete)
goto complete;
ssiter i;
ss_iterinit(ss_bufiter, &i);
ss_iteropen(ss_bufiter, &i, &t->log.buf, sizeof(svlogv));
for (; ss_iterhas(ss_bufiter, &i); ss_iternext(ss_bufiter, &i))
{
svlogv *lv = ss_iterof(ss_bufiter, &i);
sxv *v = lv->v.v;
/* mark waiters as aborted */
sx_vabortwaiters(v);
/* remove from concurrent index and replace
* head with a first waiter */
sxindex *i = v->index;
if (v->next == NULL)
ss_rbremove(&i->i, &v->node);
else
ss_rbreplace(&i->i, &v->node, &v->next->node);
/* unlink version */
sx_vunlink(v);
/* translate log version from sxv to svv */
sv_init(&lv->v, &sv_vif, v->v, NULL);
lv->vgc = v;
}
complete:
t->s = SXCOMMIT;
sx_end(t);
return SXCOMMIT;
}
/*
* Allocate and initialize a dquot. We don't always allocate fresh memory;
* we try to reclaim a free dquot if the number of incore dquots are above
* a threshold.
* The only field inside the core that gets initialized at this point
* is the d_id field. The idea is to fill in the entire q_core
* when we read in the on disk dquot.
*/
STATIC xfs_dquot_t *
xfs_qm_dqinit(
xfs_mount_t *mp,
xfs_dqid_t id,
uint type)
{
xfs_dquot_t *dqp;
boolean_t brandnewdquot;
brandnewdquot = xfs_qm_dqalloc_incore(&dqp);
dqp->dq_flags = type;
dqp->q_core.d_id = cpu_to_be32(id);
dqp->q_mount = mp;
/*
* No need to re-initialize these if this is a reclaimed dquot.
*/
if (brandnewdquot) {
dqp->dq_flnext = dqp->dq_flprev = dqp;
mutex_init(&dqp->q_qlock);
initnsema(&dqp->q_flock, 1, "fdq");
sv_init(&dqp->q_pinwait, SV_DEFAULT, "pdq");
#ifdef XFS_DQUOT_TRACE
dqp->q_trace = ktrace_alloc(DQUOT_TRACE_SIZE, KM_SLEEP);
xfs_dqtrace_entry(dqp, "DQINIT");
#endif
} else {
/*
* Only the q_core portion was zeroed in dqreclaim_one().
* So, we need to reset others.
*/
dqp->q_nrefs = 0;
dqp->q_blkno = 0;
dqp->MPL_NEXT = dqp->HL_NEXT = NULL;
dqp->HL_PREVP = dqp->MPL_PREVP = NULL;
dqp->q_bufoffset = 0;
dqp->q_fileoffset = 0;
dqp->q_transp = NULL;
dqp->q_gdquot = NULL;
dqp->q_res_bcount = 0;
dqp->q_res_icount = 0;
dqp->q_res_rtbcount = 0;
dqp->q_pincount = 0;
dqp->q_hash = NULL;
ASSERT(dqp->dq_flnext == dqp->dq_flprev);
#ifdef XFS_DQUOT_TRACE
ASSERT(dqp->q_trace);
xfs_dqtrace_entry(dqp, "DQRECLAIMED_INIT");
#endif
}
/*
* log item gets initialized later
*/
return (dqp);
}
static inline int
si_readdup(siread *q, sv *result)
{
svv *v = sv_vdup(q->r, result);
if (ssunlikely(v == NULL))
return sr_oom(q->r->e);
sv_init(&q->result, &sv_vif, v, NULL);
return 1;
}
static int
sl_iternext_of(sliter *i, slv *next, int validate)
{
if (next == NULL)
return 0;
char *eof = (char*)i->map.p + i->map.size;
char *start = (char*)next;
/* eof */
if (ssunlikely(start == eof)) {
if (i->count != i->pos) {
sr_malfunction(i->r->e, "corrupted log file '%s': transaction is incomplete",
i->log->file);
sl_iterseterror(i);
return -1;
}
i->v = NULL;
i->next = NULL;
return 0;
}
char *end = start + next->size;
if (ssunlikely((start > eof || (end > eof)))) {
sr_malfunction(i->r->e, "corrupted log file '%s': bad record size",
i->log->file);
sl_iterseterror(i);
return -1;
}
if (validate && i->validate)
{
uint32_t crc = 0;
if (! (next->flags & SVBEGIN)) {
crc = ss_crcp(i->r->crc, start + sizeof(slv), next->size, 0);
}
crc = ss_crcs(i->r->crc, start, sizeof(slv), crc);
if (ssunlikely(crc != next->crc)) {
sr_malfunction(i->r->e, "corrupted log file '%s': bad record crc",
i->log->file);
sl_iterseterror(i);
return -1;
}
}
i->pos++;
if (i->pos > i->count) {
/* next transaction */
i->v = NULL;
i->pos = 0;
i->count = 0;
i->next = next;
return 0;
}
i->v = next;
sv_init(&i->current, &sl_vif, i->v, NULL);
return 1;
}
static inline int
se_txwrite(setx *t, sev *o, uint8_t flags)
{
se *e = se_of(&t->o);
sedb *db = se_cast(o->o.parent, sedb*, SEDB);
/* validate req */
if (ssunlikely(t->t.state == SXPREPARE)) {
sr_error(&e->error, "%s", "transaction is in 'prepare' state (read-only)");
goto error;
}
/* validate database status */
int status = se_status(&db->status);
switch (status) {
case SE_SHUTDOWN:
if (ssunlikely(! se_dbvisible(db, t->t.id))) {
sr_error(&e->error, "%s", "database is invisible for the transaction");
goto error;
}
break;
case SE_RECOVER:
case SE_ONLINE: break;
default: goto error;
}
if (flags == SVUPDATE && !sf_updatehas(&db->scheme.fmt_update))
flags = 0;
/* prepare object */
svv *v;
int rc = se_dbv(db, o, 0, &v);
if (ssunlikely(rc == -1))
goto error;
v->flags = flags;
v->log = o->log;
sv vp;
sv_init(&vp, &sv_vif, v, NULL);
so_destroy(&o->o);
/* ensure quota */
int size = sizeof(svv) + sv_size(&vp);
ss_quota(&e->quota, SS_QADD, size);
/* concurrent index only */
rc = sx_set(&t->t, &db->coindex, v);
if (ssunlikely(rc == -1)) {
ss_quota(&e->quota, SS_QREMOVE, size);
return -1;
}
return 0;
error:
so_destroy(&o->o);
return -1;
}
int sx_get(sx *x, sxindex *index, sv *key, sv *result)
{
sxmanager *m = x->manager;
ssrbnode *n = NULL;
int rc;
rc = sx_match(&index->i, index->r->scheme,
sv_pointer(key),
sv_size(key),
&n);
if (! (rc == 0 && n))
goto add;
sxv *head = sscast(n, sxv, node);
sxv *v = sx_vmatch(head, x->id);
if (v == NULL)
goto add;
if (ssunlikely((v->v->flags & SVGET) > 0))
return 0;
if (ssunlikely((v->v->flags & SVDELETE) > 0))
return 2;
sv vv;
sv_init(&vv, &sv_vif, v->v, NULL);
svv *ret = sv_vdup(m->r, &vv);
if (ssunlikely(ret == NULL)) {
rc = sr_oom(m->r->e);
} else {
sv_init(result, &sv_vif, ret, NULL);
rc = 1;
}
return rc;
add:
/* track a start of the latest read sequence in the
* transactional log */
if (x->log_read == -1)
x->log_read = sv_logcount(&x->log);
rc = sx_set(x, index, key->v);
if (ssunlikely(rc == -1))
return -1;
sv_vref((svv*)key->v);
return 0;
}
static void interrupt_test(void)
{
int i;
printk("interrupt_test: initing sv.\n");
sv_init(&int_test_sv, &int_test_spin, SV_MON_SPIN | SV_INTS);
for(i = 0; i < SV_INTERRUPT_TEST_WORKERS; i++) {
printk("interrupt_test: starting test thread %d.\n", i);
kernel_thread(interrupt_test_worker, 0, 0);
}
printk("interrupt_test: done with init part.\n");
int_test_ready = 1;
}
static void
addv(sdbuild *b, sr *r, uint64_t lsn, uint8_t flags, int *key)
{
svlocal l;
l.lsn = lsn;
l.flags = flags;
l.key = key;
l.keysize = sizeof(int);
l.value = NULL;
l.valuesize = 0;
sv lv;
sv_init(&lv, &sv_localif, &l, NULL);
sd_buildadd(b, r, &lv, flags & SVDUP);
}
static void
addv(sdbuild *b, sr *r, uint64_t lsn, uint8_t flags, int *key)
{
sfv pv;
pv.key = (char*)key;
pv.r.size = sizeof(uint32_t);
pv.r.offset = 0;
svv *v = sv_vbuild(r, &pv, 1, (char*)key, sizeof(uint32_t));
v->lsn = lsn;
v->flags = flags;
sv vv;
sv_init(&vv, &sv_vif, v, NULL);
sd_buildadd(b, r, &vv, flags & SVDUP);
sv_vfree(r->a, v);
}
static void
alloclogv(svlog *log, sr *r, uint8_t flags, int key)
{
sfv pv[2];
pv[0].pointer = (char*)&key;
pv[0].size = sizeof(uint32_t);
pv[1].pointer = NULL;
pv[1].size = 0;
svv *v = sv_vbuild(r, pv);
v->flags = flags;
svlogv logv;
logv.id = 0;
logv.next = 0;
sv_init(&logv.v, &sv_vif, v, NULL);
sv_logadd(log, r->a, &logv, NULL);
}
static void
addv(sdbuild *b, sr *r, uint64_t lsn, uint8_t flags, int *key)
{
sfv pv[2];
pv[0].pointer = (char*)key;
pv[0].size = sizeof(uint32_t);
pv[1].pointer = NULL;
pv[1].size = 0;
svv *v = sv_vbuild(r, pv, 0);
v->lsn = lsn;
v->flags = flags;
sv vv;
sv_init(&vv, &sv_vif, v, NULL);
sd_buildadd(b, r, &vv, flags & SVDUP);
sv_vunref(r, v);
}
static void
alloclogv(svlog *log, sr *r, uint64_t lsn, uint8_t flags, int key)
{
sfv pv;
pv.key = (char*)&key;
pv.r.size = sizeof(uint32_t);
pv.r.offset = 0;
svv *v = sv_vbuild(r, &pv, 1, NULL, 0);
v->lsn = lsn;
v->flags = flags;
svlogv logv;
logv.id = 0;
logv.next = 0;
sv_init(&logv.v, &sv_vif, v, NULL);
sv_logadd(log, r->a, &logv, NULL);
}
sxstate sx_commit(sx *x)
{
assert(x->state == SXPREPARE);
sxmanager *m = x->manager;
ssiter i;
ss_iterinit(ss_bufiter, &i);
ss_iteropen(ss_bufiter, &i, &x->log.buf, sizeof(svlogv));
uint64_t csn = ++m->csn;
for (; ss_iterhas(ss_bufiter, &i); ss_iternext(ss_bufiter, &i))
{
svlogv *lv = ss_iterof(ss_bufiter, &i);
sxv *v = lv->v.v;
if ((int)v->lo == x->log_read)
break;
/* abort conflict reader */
if (v->prev && !sx_vcommitted(v->prev)) {
assert(v->prev->v->flags & SVGET);
sx_vabort(v->prev);
}
/* abort waiters */
sx_vabort_all(v->next);
/* mark stmt as commited */
sx_vcommit(v, csn);
/* translate log version from sxv to svv */
sv_init(&lv->v, &sv_vif, v->v, NULL);
/* schedule read stmt for gc */
if (v->v->flags & SVGET) {
sv_vref(v->v);
v->gc = m->gc;
m->gc = v;
m->count_gc++;
} else {
sx_untrack(v);
ss_free(m->asxv, v);
}
}
/* rollback latest reads */
sx_rollback_svp(x, &i, 0);
sx_promote(x, SXCOMMIT);
sx_end(x);
return SXCOMMIT;
}
/*
* Setup pio structures needed for a particular hub.
*/
static void
hub_pio_init(devfs_handle_t hubv)
{
xwidgetnum_t widget;
hubinfo_t hubinfo;
nasid_t nasid;
int bigwin;
hub_piomap_t hub_piomap;
hubinfo_get(hubv, &hubinfo);
nasid = hubinfo->h_nasid;
/* Initialize small window piomaps for this hub */
for (widget=0; widget <= HUB_WIDGET_ID_MAX; widget++) {
hub_piomap = hubinfo_swin_piomap_get(hubinfo, (int)widget);
hub_piomap->hpio_xtalk_info.xp_target = widget;
hub_piomap->hpio_xtalk_info.xp_xtalk_addr = 0;
hub_piomap->hpio_xtalk_info.xp_mapsz = SWIN_SIZE;
hub_piomap->hpio_xtalk_info.xp_kvaddr = (caddr_t)NODE_SWIN_BASE(nasid, widget);
hub_piomap->hpio_hub = hubv;
hub_piomap->hpio_flags = HUB_PIOMAP_IS_VALID;
}
/* Initialize big window piomaps for this hub */
for (bigwin=0; bigwin < HUB_NUM_BIG_WINDOW; bigwin++) {
hub_piomap = hubinfo_bwin_piomap_get(hubinfo, bigwin);
hub_piomap->hpio_xtalk_info.xp_mapsz = BWIN_SIZE;
hub_piomap->hpio_hub = hubv;
hub_piomap->hpio_holdcnt = 0;
hub_piomap->hpio_flags = HUB_PIOMAP_IS_BIGWINDOW;
IIO_ITTE_DISABLE(nasid, bigwin);
}
#ifdef BRINGUP
hub_set_piomode(nasid, HUB_PIO_CONVEYOR);
#else
/* Set all the xwidgets in fire-and-forget mode
* by default
*/
hub_set_piomode(nasid, HUB_PIO_FIRE_N_FORGET);
#endif /* BRINGUP */
sv_init(&hubinfo->h_bwwait, SV_FIFO, "bigwin");
spinlock_init(&hubinfo->h_bwlock, "bigwin");
}
int main(int argc, char *argv[]){
// before any gtk, gdk or glib setup
sv_init();
//g_thread_init (NULL);
//gtk_init (&argc, &argv);
//gdk_threads_init ();
// "name:label(arg,arg,arg...)"
sv_dim_new("rc:Re\\(c\\)");
sv_dim_scale("-2.25, -0.75, 0, 0.25, 0.75");
sv_dim_new("ic:Im\\(c\\)");
sv_dim_scale("-2,-1,0,1,2");
sv_dim_new("rz:Re\\(z0\\)");
sv_dim_scale("-2.25, -1, 0, 1, 2.25");
sv_dim_new("iz:Im\\(z0\\)");
sv_dim_scale("-2.25, -1, 0, 1, 2.25");
sv_dim_new("it:Max Iterations(picklist)");
sv_dim_scale("100:one hundred,"
"1000:one thousand,"
"10000:ten thousand,"
"100000:one hundred thousand");
sv_dim_value(10000);
sv_obj_new("fractal",fractal_objective,"rc,ic,rz,iz,it", "outer,inner");
sv_obj_scale("outer","0, .001, .01, .1, 1.0");
sv_obj_scale("inner","0, .001, .01, .1, 1.0");
sv_panel_new("Mandel/Julia Fractal",
"fractal(2d,Z=inner), fractal(2d)",
"rc(X,Y), ic(X,Y), rz(X,Y), iz(X,Y), it");
sv_go();
sv_join();
return 0;
}
static void
svv_kv(stc *cx)
{
sra a;
sr_aopen(&a, &sr_stda);
srkey cmp;
sr_keyinit(&cmp);
srkeypart *part = sr_keyadd(&cmp, &a);
t( sr_keypart_setname(part, &a, "key") == 0 );
t( sr_keypart_set(part, &a, "u32") == 0 );
sr r;
sr_init(&r, NULL, &a, NULL, SR_FKV, &cmp, NULL, NULL, NULL);
uint32_t key = 123;
uint32_t value = 321;
srformatv pv;
pv.key = (char*)&key;
pv.r.size = sizeof(key);
pv.r.offset = 0;
svv *vv = sv_vbuild(&r, &pv, 1, (char*)&value, sizeof(value));
t( vv != NULL );
vv->flags = SVSET;
vv->lsn = 10;
sv v;
sv_init(&v, &sv_vif, vv, NULL);
t( sv_flags(&v) == SVSET );
t( sv_lsn(&v) == 10 );
sv_lsnset(&v, 8);
t( sv_lsn(&v) == 8 );
t( *(uint32_t*)sr_formatkey(sv_pointer(&v), 0) == key );
t( sr_formatkey_size(sv_pointer(&v), 0) == sizeof(key) );
t( *(uint32_t*)sr_formatvalue(SR_FKV, &cmp, sv_pointer(&v)) == value );
t( sr_formatvalue_size(SR_FKV, &cmp, sv_pointer(&v), sv_size(&v) ) == sizeof(value) );
sv_vfree(&a, vv);
sr_keyfree(&cmp, &a);
}
static inline void
sx_rollback_svp(sx *x, ssiter *i, int free)
{
sxmanager *m = x->manager;
int gc = 0;
for (; ss_iterhas(ss_bufiter, i); ss_iternext(ss_bufiter, i))
{
svlogv *lv = ss_iterof(ss_bufiter, i);
sxv *v = lv->v.v;
/* remove from index and replace head with
* a first waiter */
sx_untrack(v);
/* translate log version from sxv to svv */
sv_init(&lv->v, &sv_vif, v->v, NULL);
if (free) {
if (sslikely(! (v->v->flags & SVGET)))
gc += sv_vsize((svv*)v->v);
sx_vfree(m->r, m->asxv, v);
}
}
ss_quota(m->r->quota, SS_QREMOVE, gc);
}
so *se_read(sedb *db, sedocument *o, sx *x, uint64_t vlsn,
sicache *cache)
{
se *e = se_of(&db->o);
uint64_t start = ss_utime();
/* prepare the key */
int auto_close = o->created <= 1;
int rc = se_document_createkey(o);
if (ssunlikely(rc == -1))
goto error;
rc = se_document_validate_ro(o, &db->o);
if (ssunlikely(rc == -1))
goto error;
if (ssunlikely(! se_active(e)))
goto error;
sv vup;
sv_init(&vup, &sv_vif, NULL, NULL);
sedocument *ret = NULL;
/* concurrent */
if (x && o->order == SS_EQ) {
/* note: prefix is ignored during concurrent
* index search */
int rc = sx_get(x, &db->coindex, &o->v, &vup);
if (ssunlikely(rc == -1 || rc == 2 /* delete */))
goto error;
if (rc == 1 && !sv_is(&vup, SVUPSERT)) {
ret = (sedocument*)se_document_new(e, &db->o, &vup);
if (sslikely(ret)) {
ret->cold_only = o->cold_only;
ret->created = 1;
ret->orderset = 1;
ret->flagset = 1;
} else {
sv_vunref(db->r, vup.v);
}
if (auto_close)
so_destroy(&o->o);
return &ret->o;
}
} else {
sx_get_autocommit(&e->xm, &db->coindex);
}
/* prepare read cache */
int cachegc = 0;
if (cache == NULL) {
cachegc = 1;
cache = si_cachepool_pop(&e->cachepool);
if (ssunlikely(cache == NULL)) {
if (vup.v)
sv_vunref(db->r, vup.v);
sr_oom(&e->error);
goto error;
}
}
sv_vref(o->v.v);
/* do read */
siread rq;
si_readopen(&rq, db->index, cache, o->order,
vlsn,
sv_pointer(&o->v),
vup.v,
o->prefix_copy,
o->prefix_size,
o->cold_only,
0,
start);
rc = si_read(&rq);
si_readclose(&rq);
/* prepare result */
if (rc == 1) {
ret = (sedocument*)se_readresult(e, &rq);
if (ret)
o->prefix_copy = NULL;
}
/* cleanup */
if (o->v.v)
sv_vunref(db->r, o->v.v);
if (vup.v)
sv_vunref(db->r, vup.v);
if (ret == NULL && rq.result.v)
sv_vunref(db->r, rq.result.v);
if (cachegc && cache)
si_cachepool_push(cache);
if (auto_close)
so_destroy(&o->o);
return &ret->o;
error:
if (auto_close)
so_destroy(&o->o);
return NULL;
}
int sx_set(sx *t, sxindex *index, svv *version)
{
sxmanager *m = t->manager;
/* allocate mvcc container */
sxv *v = sx_valloc(m->asxv, version);
if (ssunlikely(v == NULL)) {
sv_vfree(m->a, version);
return -1;
}
v->id = t->id;
v->index = index;
svlogv lv;
lv.id = index->dsn;
lv.vgc = NULL;
lv.next = UINT32_MAX;
sv_init(&lv.v, &sx_vif, v, NULL);
/* update concurrent index */
ssrbnode *n = NULL;
int rc = sx_match(&index->i, index->scheme, sv_vpointer(version),
version->size, &n);
if (ssunlikely(rc == 0 && n)) {
/* exists */
} else {
/* unique */
v->lo = sv_logcount(&t->log);
if (ssunlikely((sv_logadd(&t->log, m->a, &lv, index->ptr)) == -1)) {
rc = sr_oom(index->r->e);
} else {
ss_rbset(&index->i, n, rc, &v->node);
rc = 0;
}
return rc;
}
sxv *head = sscast(n, sxv, node);
/* match previous update made by current
* transaction */
sxv *own = sx_vmatch(head, t->id);
if (ssunlikely(own))
{
if (ssunlikely(version->flags & SVUPDATE)) {
sr_error(index->r->e, "%s", "only one update statement is "
"allowed per a transaction key");
sx_vfree(m->a, m->asxv, v);
return -1;
}
/* replace old object with the new one */
lv.next = sv_logat(&t->log, own->lo)->next;
v->lo = own->lo;
sx_vreplace(own, v);
if (sslikely(head == own))
ss_rbreplace(&index->i, &own->node, &v->node);
/* update log */
sv_logreplace(&t->log, v->lo, &lv);
sx_vfree(m->a, m->asxv, own);
return 0;
}
/* update log */
rc = sv_logadd(&t->log, m->a, &lv, index->ptr);
if (ssunlikely(rc == -1)) {
sx_vfree(m->a, m->asxv, v);
return sr_oom(index->r->e);
}
/* add version */
sx_vlink(head, v);
return 0;
}
int sx_set(sx *x, sxindex *index, svv *version)
{
sxmanager *m = x->manager;
sr *r = m->r;
if (! (version->flags & SVGET)) {
x->log_read = -1;
}
/* allocate mvcc container */
sxv *v = sx_valloc(m->asxv, version);
if (ssunlikely(v == NULL)) {
ss_quota(r->quota, SS_QREMOVE, sv_vsize(version));
sv_vfree(r, version);
return -1;
}
v->id = x->id;
v->index = index;
svlogv lv;
lv.id = index->dsn;
lv.next = UINT32_MAX;
sv_init(&lv.v, &sx_vif, v, NULL);
/* update concurrent index */
ssrbnode *n = NULL;
int rc = sx_match(&index->i, index->r->scheme,
sv_vpointer(version),
version->size,
&n);
if (ssunlikely(rc == 0 && n)) {
/* exists */
} else {
int pos = rc;
/* unique */
v->lo = sv_logcount(&x->log);
rc = sv_logadd(&x->log, r->a, &lv, index->ptr);
if (ssunlikely(rc == -1)) {
sr_oom(r->e);
goto error;
}
ss_rbset(&index->i, n, pos, &v->node);
return 0;
}
sxv *head = sscast(n, sxv, node);
/* match previous update made by current
* transaction */
sxv *own = sx_vmatch(head, x->id);
if (ssunlikely(own))
{
if (ssunlikely(version->flags & SVUPDATE)) {
sr_error(r->e, "%s", "only one update statement is "
"allowed per a transaction key");
goto error;
}
/* replace old document with the new one */
lv.next = sv_logat(&x->log, own->lo)->next;
v->lo = own->lo;
if (ssunlikely(sx_vaborted(own)))
sx_vabort(v);
sx_vreplace(own, v);
if (sslikely(head == own))
ss_rbreplace(&index->i, &own->node, &v->node);
/* update log */
sv_logreplace(&x->log, v->lo, &lv);
ss_quota(r->quota, SS_QREMOVE, sv_vsize(own->v));
sx_vfree(r, m->asxv, own);
return 0;
}
/* update log */
v->lo = sv_logcount(&x->log);
rc = sv_logadd(&x->log, r->a, &lv, index->ptr);
if (ssunlikely(rc == -1)) {
sr_oom(r->e);
goto error;
}
/* add version */
sx_vlink(head, v);
return 0;
error:
ss_quota(r->quota, SS_QREMOVE, sv_vsize(v->v));
sx_vfree(r, m->asxv, v);
return -1;
}
int
dm_add_fsys_entry(
vfs_t *vfsp,
dm_tokevent_t *tevp)
{
dm_fsreg_t *fsrp;
int msgsize;
void *msg;
int lc; /* lock cookie */
/* Allocate and initialize a dm_fsreg_t structure for the filesystem. */
msgsize = tevp->te_allocsize - offsetof(dm_tokevent_t, te_event);
msg = kmem_alloc(msgsize, KM_SLEEP);
bcopy(&tevp->te_event, msg, msgsize);
fsrp = kmem_zalloc(sizeof(*fsrp), KM_SLEEP);
fsrp->fr_vfsp = vfsp;
fsrp->fr_tevp = tevp;
fsrp->fr_fsid = *vfsp->vfs_altfsid;
fsrp->fr_msg = msg;
fsrp->fr_msgsize = msgsize;
fsrp->fr_state = DM_STATE_MOUNTING;
sv_init(&fsrp->fr_dispq, SV_DEFAULT, "fr_dispq");
sv_init(&fsrp->fr_queue, SV_DEFAULT, "fr_queue");
spinlock_init(&fsrp->fr_lock, "fr_lock");
/* If no other mounted DMAPI filesystem already has this same
fsid_t, then add this filesystem to the list.
*/
lc = mutex_spinlock(&dm_reg_lock);
if (!dm_find_fsreg(vfsp->vfs_altfsid)) {
fsrp->fr_next = dm_registers;
dm_registers = fsrp;
dm_fsys_cnt++;
#ifdef CONFIG_PROC_FS
{
char buf[100];
struct proc_dir_entry *entry;
sprintf(buf, DMAPI_DBG_PROCFS "/fsreg/0x%p", fsrp);
entry = create_proc_read_entry(buf, 0, 0, fsreg_read_pfs, fsrp);
entry->owner = THIS_MODULE;
}
#endif
mutex_spinunlock(&dm_reg_lock, lc);
return(0);
}
/* A fsid_t collision occurred, so prevent this new filesystem from
mounting.
*/
mutex_spinunlock(&dm_reg_lock, lc);
sv_destroy(&fsrp->fr_dispq);
sv_destroy(&fsrp->fr_queue);
spinlock_destroy(&fsrp->fr_lock);
kmem_free(fsrp->fr_msg, fsrp->fr_msgsize);
kmem_free(fsrp, sizeof(*fsrp));
return(EBUSY);
}
int
main(int argc, char *argv[])
{
int rc = 0;
const char* data_file = NULL;
FILE *fh = NULL;
sv *t = NULL;
sv2c_data c;
size_t data_file_len;
char sep = '\t'; /* default is TSV */
program = "example";
if(argc != 2) {
fprintf(stderr, "USAGE: %s [SV FILE]\n", program);
rc = 1;
goto tidy;
}
data_file = (const char*)argv[1];
if(access(data_file, R_OK)) {
fprintf(stderr, "%s: Failed to find data file %s\n",
program, data_file);
rc = 1;
goto tidy;
}
fh = fopen(data_file, "r");
if(!fh) {
fprintf(stderr, "%s: Failed to read data file %s: %s\n",
program, data_file, strerror(errno));
rc = 1;
goto tidy;
}
memset(&c, '\0', sizeof(c));
c.filename = data_file;
c.count = 0;
c.line = NULL;
c.out = stdout;
data_file_len = strlen(data_file);
if(data_file_len > 4) {
if(!strcmp(data_file + data_file_len - 3, "csv"))
sep = ',';
else if(!strcmp(data_file + data_file_len - 3, "tsv"))
sep = '\t';
}
c.sep = sep;
t = sv_init(&c, NULL, sv2c_fields_callback, sep);
if(!t) {
fprintf(stderr, "%s: Failed to init SV library", program);
rc = 1;
goto tidy;
}
sv_set_option(t, SV_OPTION_LINE_CALLBACK, sv2c_line_callback);
while(!feof(fh)) {
char buffer[1024];
size_t len = fread(buffer, 1, sizeof(buffer), fh);
if(sv_parse_chunk(t, buffer, len))
break;
}
fclose(fh);
fh = NULL;
if(c.line)
free(c.line);
tidy:
if(t)
sv_free(t);
if(fh) {
fclose(fh);
fh = NULL;
}
return rc;
}
