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; }