void slcfg_init_resm(struct sl_resm *m) { struct resm_mds_info *rmmi; rmmi = resm2rmmi(m); psc_atomic32_set(&rmmi->rmmi_refcnt, 0); }
/* * Lookup and optionally create a new bmap structure. * @f: file's bmap tree to search. * @n: bmap index number to search for. * @new_bmap: whether to allow creation and also value-result of whether * it was newly created or not. */ struct bmap * bmap_lookup_cache(struct fidc_membh *f, sl_bmapno_t n, int bmaprw, int *new_bmap) { struct bmap lb, *b, *bnew = NULL; int doalloc; doalloc = *new_bmap; lb.bcm_bmapno = n; restart: if (bnew) pfl_rwlock_wrlock(&f->fcmh_rwlock); else pfl_rwlock_rdlock(&f->fcmh_rwlock); b = RB_FIND(bmaptree, &f->fcmh_bmaptree, &lb); if (b) { if (!BMAP_TRYLOCK(b)) { pfl_rwlock_unlock(&f->fcmh_rwlock); usleep(10); goto restart; } if (b->bcm_flags & BMAPF_TOFREE) { /* * This bmap is going away; wait for it so we * can reload it back. */ DEBUG_BMAP(PLL_DIAG, b, "wait on to-free bmap"); BMAP_ULOCK(b); /* * We don't want to spin if we are waiting for a * flush to clear. */ psc_waitq_waitrelf_us(&f->fcmh_waitq, PFL_LOCKPRIMT_RWLOCK, &f->fcmh_rwlock, 100); goto restart; } bmap_op_start_type(b, BMAP_OPCNT_LOOKUP); } if (doalloc == 0 || b) { pfl_rwlock_unlock(&f->fcmh_rwlock); if (bnew) psc_pool_return(bmap_pool, bnew); *new_bmap = 0; OPSTAT_INCR("bmapcache.hit"); return (b); } if (bnew == NULL) { pfl_rwlock_unlock(&f->fcmh_rwlock); if (sl_bmap_ops.bmo_reapf) sl_bmap_ops.bmo_reapf(); bnew = psc_pool_get(bmap_pool); goto restart; } b = bnew; OPSTAT_INCR("bmapcache.miss"); *new_bmap = 1; memset(b, 0, bmap_pool->ppm_master->pms_entsize); INIT_PSC_LISTENTRY(&b->bcm_lentry); INIT_SPINLOCK(&b->bcm_lock); psc_atomic32_set(&b->bcm_opcnt, 0); b->bcm_fcmh = f; b->bcm_bmapno = n; /* * Signify that the bmap is newly initialized and therefore may * not contain certain structures. */ psc_assert(bmaprw == BMAPF_RD || bmaprw == BMAPF_WR); b->bcm_flags = bmaprw; bmap_op_start_type(b, BMAP_OPCNT_LOOKUP); /* * Perform app-specific substructure initialization, which is * msl_bmap_init(), iod_bmap_init(), or mds_bmap_init(). */ sl_bmap_ops.bmo_init_privatef(b); /* Add to the fcmh's bmap cache */ PSC_RB_XINSERT(bmaptree, &f->fcmh_bmaptree, b); pfl_rwlock_unlock(&f->fcmh_rwlock); fcmh_op_start_type(f, FCMH_OPCNT_BMAP); BMAP_LOCK(b); return (b); }
int main(int argc, char *argv[]) { struct thr *thr; pthread_t pthr; int c, rc, i; pfl_init(); progname = argv[0]; while ((c = getopt(argc, argv, "i:n:")) != -1) switch (c) { case 'i': niter = atoi(optarg); break; case 'n': nthr = atoi(optarg); break; default: usage(); } argc -= optind; if (argc) usage(); psc_assert(psc_atomic64_read(&v64) == UINT64_C(100000000000)); TEST(psc_atomic64, set, &v64, &v64, UINT64_C(2000000000000), UINT64_C(2000000000000)); TEST(psc_atomic64, add, &v64, &v64, 15, UINT64_C(2000000000015)); TEST(psc_atomic64, sub, &v64, &v64, 9, UINT64_C(2000000000006)); TEST1(psc_atomic64, inc, &v64, UINT64_C(2000000000007)); TEST1(psc_atomic64, dec, &v64, UINT64_C(2000000000006)); psc_atomic16_set(&v16, 2); TEST(psc_atomic16, set, &v16, &v16, 200, 200); TEST(psc_atomic16, add, &v16, &v16, 15, 215); TEST(psc_atomic16, sub, &v16, &v16, 9, 206); TEST1(psc_atomic16, inc, &v16, 207); TEST1(psc_atomic16, dec, &v16, 206); TEST1V(psc_atomic16, dec_and_test0, &v16, 205, 0); TEST(psc_atomic16, set, &v16, &v16, 1, 1); TEST1V(psc_atomic16, dec_and_test0, &v16, 0, 1); TEST(psc_atomic16, setmask, &v16, &v16, 0x75, 0x75); TEST(psc_atomic16, clearmask, &v16, &v16, 0x41, 0x34); TEST(psc_atomic16, set, &v16, &v16, 0, 0); psc_atomic32_set(&v32, 2); TEST(psc_atomic32, set, &v32, &v32, 200, 200); TEST(psc_atomic32, add, &v32, &v32, 15, 215); TEST(psc_atomic32, sub, &v32, &v32, 9, 206); TEST1(psc_atomic32, inc, &v32, 207); TEST1(psc_atomic32, dec, &v32, 206); TEST1V(psc_atomic32, dec_and_test0, &v32, 205, 0); TEST(psc_atomic32, set, &v32, &v32, 1, 1); TEST1V(psc_atomic32, dec_and_test0, &v32, 0, 1); TEST(psc_atomic32, setmask, &v32, &v32, 0x75, 0x75); TEST(psc_atomic32, clearmask, &v32, &v32, 0x41, 0x34); TEST(psc_atomic32, set, &v32, &v32, 0, 0); psc_atomic64_set(&v64, 2); TEST(psc_atomic64, set, &v64, &v64, 200, 200); TEST(psc_atomic64, add, &v64, &v64, 15, 215); TEST(psc_atomic64, sub, &v64, &v64, 9, 206); TEST1(psc_atomic64, inc, &v64, 207); TEST1(psc_atomic64, dec, &v64, 206); TEST1V(psc_atomic64, dec_and_test0, &v64, 205, 0); TEST(psc_atomic64, set, &v64, &v64, 1, 1); TEST1V(psc_atomic64, dec_and_test0, &v64, 0, 1); TEST(psc_atomic64, setmask, &v64, &v64, 0x75, 0x75); TEST(psc_atomic64, clearmask, &v64, &v64, 0x41, 0x34); TEST(psc_atomic64, set, &v64, &v64, 0, 0); TEST1(psc_atomic16, inc, &v16, 1); TEST1V(psc_atomic16, dec_and_test0, &v16, 0, 1); rc = pthread_barrier_init(&barrier, NULL, nthr + 1); if (rc) psc_fatalx("pthread_barrier_init: %s", strerror(rc)); for (i = 0; i < nthr; i++) { thr = PSCALLOC(sizeof(*thr)); thr->pos = i; rc = pthread_create(&pthr, NULL, startf, thr); if (rc) psc_fatalx("pthread_create: %s", strerror(rc)); } pthread_barrier_wait(&barrier); pthread_barrier_wait(&barrier); exit(0); }