Date: Thu, 20 Jun 2013 19:08:13 +0000 (UTC) From: Jeff Roberson <jeff@FreeBSD.org> To: src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-head@freebsd.org Subject: svn commit: r252040 - head/sys/vm Message-ID: <201306201908.r5KJ8D9E038632@svn.freebsd.org>
next in thread | raw e-mail | index | archive | help
Author: jeff Date: Thu Jun 20 19:08:12 2013 New Revision: 252040 URL: http://svnweb.freebsd.org/changeset/base/252040 Log: - Add a per-zone lock for zones without kegs. - Be more explicit about zone vs keg locking. This functionally changes almost nothing. - Add a size parameter to uma_zcache_create() so we can size the buckets. - Pass the zone to bucket_alloc() so it can modify allocation flags as appropriate. - Fix a bug in zone_alloc_bucket() where I missed an address of operator in a failure case. (Found by pho) Sponsored by: EMC / Isilon Storage Division Modified: head/sys/vm/uma.h head/sys/vm/uma_core.c head/sys/vm/uma_dbg.c head/sys/vm/uma_int.h Modified: head/sys/vm/uma.h ============================================================================== --- head/sys/vm/uma.h Thu Jun 20 18:25:10 2013 (r252039) +++ head/sys/vm/uma.h Thu Jun 20 19:08:12 2013 (r252040) @@ -234,7 +234,7 @@ int uma_zsecond_add(uma_zone_t zone, uma * zones. The 'arg' parameter is passed to import/release and is caller * specific. */ -uma_zone_t uma_zcache_create(char *name, uma_ctor ctor, uma_dtor dtor, +uma_zone_t uma_zcache_create(char *name, int size, uma_ctor ctor, uma_dtor dtor, uma_init zinit, uma_fini zfini, uma_import zimport, uma_release zrelease, void *arg, int flags); Modified: head/sys/vm/uma_core.c ============================================================================== --- head/sys/vm/uma_core.c Thu Jun 20 18:25:10 2013 (r252039) +++ head/sys/vm/uma_core.c Thu Jun 20 19:08:12 2013 (r252040) @@ -246,8 +246,8 @@ static void *zone_alloc_item(uma_zone_t, static void zone_free_item(uma_zone_t, void *, void *, enum zfreeskip); static void bucket_enable(void); static void bucket_init(void); -static uma_bucket_t bucket_alloc(int, int); -static void bucket_free(uma_bucket_t); +static uma_bucket_t bucket_alloc(uma_zone_t zone, int); +static void bucket_free(uma_zone_t zone, uma_bucket_t); static void bucket_zone_drain(void); static uma_bucket_t zone_alloc_bucket(uma_zone_t zone, int flags); static uma_slab_t zone_fetch_slab(uma_zone_t zone, uma_keg_t last, int flags); @@ -256,8 +256,6 @@ static void *slab_alloc_item(uma_keg_t k static void slab_free_item(uma_keg_t keg, uma_slab_t slab, void *item); static uma_keg_t uma_kcreate(uma_zone_t zone, size_t size, uma_init uminit, uma_fini fini, int align, uint32_t flags); -static inline void zone_relock(uma_zone_t zone, uma_keg_t keg); -static inline void keg_relock(uma_keg_t keg, uma_zone_t zone); static int zone_import(uma_zone_t zone, void **bucket, int max, int flags); static void zone_release(uma_zone_t zone, void **bucket, int cnt); @@ -352,7 +350,7 @@ bucket_select(int size) } static uma_bucket_t -bucket_alloc(int entries, int bflags) +bucket_alloc(uma_zone_t zone, int flags) { struct uma_bucket_zone *ubz; uma_bucket_t bucket; @@ -366,8 +364,10 @@ bucket_alloc(int entries, int bflags) if (bucketdisable) return (NULL); - ubz = bucket_zone_lookup(entries); - bucket = uma_zalloc(ubz->ubz_zone, bflags); + if (zone->uz_flags & UMA_ZFLAG_CACHEONLY) + flags |= M_NOVM; + ubz = bucket_zone_lookup(zone->uz_count); + bucket = uma_zalloc(ubz->ubz_zone, flags); if (bucket) { #ifdef INVARIANTS bzero(bucket->ub_bucket, sizeof(void *) * ubz->ubz_entries); @@ -380,7 +380,7 @@ bucket_alloc(int entries, int bflags) } static void -bucket_free(uma_bucket_t bucket) +bucket_free(uma_zone_t zone, uma_bucket_t bucket) { struct uma_bucket_zone *ubz; @@ -662,9 +662,9 @@ cache_drain(uma_zone_t zone) bucket_drain(zone, cache->uc_allocbucket); bucket_drain(zone, cache->uc_freebucket); if (cache->uc_allocbucket != NULL) - bucket_free(cache->uc_allocbucket); + bucket_free(zone, cache->uc_allocbucket); if (cache->uc_freebucket != NULL) - bucket_free(cache->uc_freebucket); + bucket_free(zone, cache->uc_freebucket); cache->uc_allocbucket = cache->uc_freebucket = NULL; } ZONE_LOCK(zone); @@ -688,7 +688,7 @@ bucket_cache_drain(uma_zone_t zone) LIST_REMOVE(bucket, ub_link); ZONE_UNLOCK(zone); bucket_drain(zone, bucket); - bucket_free(bucket); + bucket_free(zone, bucket); ZONE_LOCK(zone); } } @@ -801,7 +801,7 @@ zone_drain_wait(uma_zone_t zone, int wai if (waitok == M_NOWAIT) goto out; mtx_unlock(&uma_mtx); - msleep(zone, zone->uz_lock, PVM, "zonedrain", 1); + msleep(zone, zone->uz_lockptr, PVM, "zonedrain", 1); mtx_lock(&uma_mtx); } zone->uz_flags |= UMA_ZFLAG_DRAINING; @@ -1375,12 +1375,9 @@ keg_ctor(void *mem, int size, void *udat keg->uk_allocf = startup_alloc; /* - * Initialize keg's lock (shared among zones). + * Initialize keg's lock */ - if (arg->flags & UMA_ZONE_MTXCLASS) - KEG_LOCK_INIT(keg, 1); - else - KEG_LOCK_INIT(keg, 0); + KEG_LOCK_INIT(keg, (arg->flags & UMA_ZONE_MTXCLASS)); /* * If we're putting the slab header in the actual page we need to @@ -1469,15 +1466,18 @@ zone_ctor(void *mem, int size, void *uda timevalclear(&zone->uz_ratecheck); keg = arg->keg; + ZONE_LOCK_INIT(zone, (arg->flags & UMA_ZONE_MTXCLASS)); + /* * This is a pure cache zone, no kegs. */ if (arg->import) { + zone->uz_size = arg->size; zone->uz_import = arg->import; zone->uz_release = arg->release; zone->uz_arg = arg->arg; - zone->uz_count = BUCKET_MAX; - return (0); + zone->uz_lockptr = &zone->uz_lock; + goto out; } /* @@ -1491,7 +1491,7 @@ zone_ctor(void *mem, int size, void *uda KASSERT(arg->keg != NULL, ("Secondary zone on zero'd keg")); zone->uz_init = arg->uminit; zone->uz_fini = arg->fini; - zone->uz_lock = &keg->uk_lock; + zone->uz_lockptr = &keg->uk_lock; zone->uz_flags |= UMA_ZONE_SECONDARY; mtx_lock(&uma_mtx); ZONE_LOCK(zone); @@ -1529,7 +1529,7 @@ zone_ctor(void *mem, int size, void *uda */ zone->uz_klink.kl_keg = keg; LIST_INSERT_HEAD(&zone->uz_kegs, &zone->uz_klink, kl_link); - zone->uz_lock = &keg->uk_lock; + zone->uz_lockptr = &keg->uk_lock; zone->uz_size = keg->uk_size; zone->uz_flags |= (keg->uk_flags & (UMA_ZONE_INHERIT | UMA_ZFLAG_INHERIT)); @@ -1544,8 +1544,9 @@ zone_ctor(void *mem, int size, void *uda return (0); } - if ((keg->uk_flags & UMA_ZONE_MAXBUCKET) == 0) - zone->uz_count = bucket_select(keg->uk_rsize); +out: + if ((arg->flags & UMA_ZONE_MAXBUCKET) == 0) + zone->uz_count = bucket_select(zone->uz_size); else zone->uz_count = BUCKET_MAX; @@ -1626,6 +1627,7 @@ zone_dtor(void *arg, int size, void *uda mtx_unlock(&uma_mtx); zone_free_item(kegs, keg, NULL, SKIP_NONE); } + ZONE_LOCK_FINI(zone); } /* @@ -1849,15 +1851,15 @@ uma_zsecond_create(char *name, uma_ctor /* See uma.h */ uma_zone_t -uma_zcache_create(char *name, uma_ctor ctor, uma_dtor dtor, uma_init zinit, - uma_fini zfini, uma_import zimport, uma_release zrelease, - void *arg, int flags) +uma_zcache_create(char *name, int size, uma_ctor ctor, uma_dtor dtor, + uma_init zinit, uma_fini zfini, uma_import zimport, + uma_release zrelease, void *arg, int flags) { struct uma_zctor_args args; memset(&args, 0, sizeof(args)); args.name = name; - args.size = 0; + args.size = size; args.ctor = ctor; args.dtor = dtor; args.uminit = zinit; @@ -1876,10 +1878,10 @@ zone_lock_pair(uma_zone_t a, uma_zone_t { if (a < b) { ZONE_LOCK(a); - mtx_lock_flags(b->uz_lock, MTX_DUPOK); + mtx_lock_flags(b->uz_lockptr, MTX_DUPOK); } else { ZONE_LOCK(b); - mtx_lock_flags(a->uz_lock, MTX_DUPOK); + mtx_lock_flags(a->uz_lockptr, MTX_DUPOK); } } @@ -2071,7 +2073,7 @@ zalloc_start: cache->uc_allocbucket = NULL; critical_exit(); if (bucket != NULL) - bucket_free(bucket); + bucket_free(zone, bucket); /* Short-circuit for zones without buckets and low memory. */ if (zone->uz_count == 0 || bucketdisable) @@ -2241,31 +2243,15 @@ keg_fetch_slab(uma_keg_t keg, uma_zone_t return (slab); } -static inline void -zone_relock(uma_zone_t zone, uma_keg_t keg) -{ - if (zone->uz_lock != &keg->uk_lock) { - KEG_UNLOCK(keg); - ZONE_LOCK(zone); - } -} - -static inline void -keg_relock(uma_keg_t keg, uma_zone_t zone) -{ - if (zone->uz_lock != &keg->uk_lock) { - ZONE_UNLOCK(zone); - KEG_LOCK(keg); - } -} - static uma_slab_t zone_fetch_slab(uma_zone_t zone, uma_keg_t keg, int flags) { uma_slab_t slab; - if (keg == NULL) + if (keg == NULL) { keg = zone_first_keg(zone); + KEG_LOCK(keg); + } for (;;) { slab = keg_fetch_slab(keg, zone, flags); @@ -2274,13 +2260,13 @@ zone_fetch_slab(uma_zone_t zone, uma_keg if (flags & (M_NOWAIT | M_NOVM)) break; } + KEG_UNLOCK(keg); return (NULL); } /* * uma_zone_fetch_slab_multi: Fetches a slab from one available keg. Returns - * with the keg locked. Caller must call zone_relock() afterwards if the - * zone lock is required. On NULL the zone lock is held. + * with the keg locked. On NULL no lock is held. * * The last pointer is used to seed the search. It is not required. */ @@ -2304,12 +2290,11 @@ zone_fetch_slab_multi(uma_zone_t zone, u * Use the last slab allocated as a hint for where to start * the search. */ - if (last) { + if (last != NULL) { slab = keg_fetch_slab(last, zone, flags); if (slab) return (slab); - zone_relock(zone, last); - last = NULL; + KEG_UNLOCK(last); } /* * Loop until we have a slab incase of transient failures @@ -2325,7 +2310,7 @@ zone_fetch_slab_multi(uma_zone_t zone, u */ LIST_FOREACH(klink, &zone->uz_kegs, kl_link) { keg = klink->kl_keg; - keg_relock(keg, zone); + KEG_LOCK(keg); if ((keg->uk_flags & UMA_ZFLAG_FULL) == 0) { slab = keg_fetch_slab(keg, zone, flags); if (slab) @@ -2335,7 +2320,7 @@ zone_fetch_slab_multi(uma_zone_t zone, u full++; else empty++; - zone_relock(zone, keg); + KEG_UNLOCK(keg); } if (rflags & (M_NOWAIT | M_NOVM)) break; @@ -2345,11 +2330,14 @@ zone_fetch_slab_multi(uma_zone_t zone, u * and sleep so just sleep for a short period and retry. */ if (full && !empty) { + ZONE_LOCK(zone); zone->uz_flags |= UMA_ZFLAG_FULL; zone->uz_sleeps++; zone_log_warning(zone); - msleep(zone, zone->uz_lock, PVM, "zonelimit", hz/100); + msleep(zone, zone->uz_lockptr, PVM, + "zonelimit", hz/100); zone->uz_flags &= ~UMA_ZFLAG_FULL; + ZONE_UNLOCK(zone); continue; } } @@ -2387,15 +2375,14 @@ zone_import(uma_zone_t zone, void **buck uma_keg_t keg; int i; - ZONE_LOCK(zone); - /* Try to keep the buckets totally full */ slab = NULL; keg = NULL; + /* Try to keep the buckets totally full */ for (i = 0; i < max; ) { if ((slab = zone->uz_slab(zone, keg, flags)) == NULL) break; keg = slab->us_keg; - while (slab->us_freecount && i < max) + while (slab->us_freecount && i < max) bucket[i++] = slab_alloc_item(keg, slab); /* Don't block on the next fill */ @@ -2404,8 +2391,6 @@ zone_import(uma_zone_t zone, void **buck } if (slab != NULL) KEG_UNLOCK(keg); - else - ZONE_UNLOCK(zone); return i; } @@ -2414,18 +2399,13 @@ static uma_bucket_t zone_alloc_bucket(uma_zone_t zone, int flags) { uma_bucket_t bucket; - int bflags; int max; - max = zone->uz_count; - bflags = (flags & ~M_WAITOK) | M_NOWAIT; - if (zone->uz_flags & UMA_ZFLAG_CACHEONLY) - bflags |= M_NOVM; - bucket = bucket_alloc(zone->uz_count, bflags); + bucket = bucket_alloc(zone, M_NOWAIT | (flags & M_NOVM)); if (bucket == NULL) goto out; - max = MIN(bucket->ub_entries, max); + max = MIN(bucket->ub_entries, zone->uz_count); bucket->ub_cnt = zone->uz_import(zone->uz_arg, bucket->ub_bucket, max, flags); @@ -2444,7 +2424,7 @@ zone_alloc_bucket(uma_zone_t zone, int f * rest back onto the freelist. */ if (i != bucket->ub_cnt) { - zone->uz_release(zone->uz_arg, bucket->ub_bucket[i], + zone->uz_release(zone->uz_arg, &bucket->ub_bucket[i], bucket->ub_cnt - i); #ifdef INVARIANTS bzero(&bucket->ub_bucket[i], @@ -2457,7 +2437,7 @@ zone_alloc_bucket(uma_zone_t zone, int f out: if (bucket == NULL || bucket->ub_cnt == 0) { if (bucket != NULL) - bucket_free(bucket); + bucket_free(zone, bucket); atomic_add_long(&zone->uz_fails, 1); return (NULL); } @@ -2529,7 +2509,6 @@ uma_zfree_arg(uma_zone_t zone, void *ite { uma_cache_t cache; uma_bucket_t bucket; - int bflags; int cpu; #ifdef UMA_DEBUG_ALLOC_1 @@ -2654,10 +2633,7 @@ zfree_start: #ifdef UMA_DEBUG_ALLOC printf("uma_zfree: Allocating new free bucket.\n"); #endif - bflags = M_NOWAIT; - if (zone->uz_flags & UMA_ZFLAG_CACHEONLY) - bflags |= M_NOVM; - bucket = bucket_alloc(zone->uz_count, bflags); + bucket = bucket_alloc(zone, M_NOWAIT); if (bucket) { critical_enter(); cpu = curcpu; @@ -2671,7 +2647,7 @@ zfree_start: * critical section to free the bucket. */ critical_exit(); - bucket_free(bucket); + bucket_free(zone, bucket); goto zfree_restart; } @@ -2721,8 +2697,8 @@ zone_release(uma_zone_t zone, void **buc int i; clearfull = 0; - ZONE_LOCK(zone); keg = zone_first_keg(zone); + KEG_LOCK(keg); for (i = 0; i < cnt; i++) { item = bucket[i]; if (!(zone->uz_flags & UMA_ZONE_VTOSLAB)) { @@ -2758,12 +2734,13 @@ zone_release(uma_zone_t zone, void **buc wakeup(keg); } } - zone_relock(zone, keg); + KEG_UNLOCK(keg); if (clearfull) { + ZONE_LOCK(zone); zone->uz_flags &= ~UMA_ZFLAG_FULL; wakeup(zone); + ZONE_UNLOCK(zone); } - ZONE_UNLOCK(zone); } @@ -2807,12 +2784,12 @@ uma_zone_set_max(uma_zone_t zone, int ni keg = zone_first_keg(zone); if (keg == NULL) return (0); - ZONE_LOCK(zone); + KEG_LOCK(keg); keg->uk_maxpages = (nitems / keg->uk_ipers) * keg->uk_ppera; if (keg->uk_maxpages * keg->uk_ipers < nitems) keg->uk_maxpages += keg->uk_ppera; nitems = keg->uk_maxpages * keg->uk_ipers; - ZONE_UNLOCK(zone); + KEG_UNLOCK(keg); return (nitems); } @@ -2827,9 +2804,9 @@ uma_zone_get_max(uma_zone_t zone) keg = zone_first_keg(zone); if (keg == NULL) return (0); - ZONE_LOCK(zone); + KEG_LOCK(keg); nitems = keg->uk_maxpages * keg->uk_ipers; - ZONE_UNLOCK(zone); + KEG_UNLOCK(keg); return (nitems); } @@ -2873,13 +2850,13 @@ uma_zone_set_init(uma_zone_t zone, uma_i { uma_keg_t keg; - ZONE_LOCK(zone); keg = zone_first_keg(zone); KASSERT(keg != NULL, ("uma_zone_set_init: Invalid zone type")); + KEG_LOCK(keg); KASSERT(keg->uk_pages == 0, ("uma_zone_set_init on non-empty keg")); keg->uk_init = uminit; - ZONE_UNLOCK(zone); + KEG_UNLOCK(keg); } /* See uma.h */ @@ -2888,19 +2865,20 @@ uma_zone_set_fini(uma_zone_t zone, uma_f { uma_keg_t keg; - ZONE_LOCK(zone); keg = zone_first_keg(zone); KASSERT(keg != NULL, ("uma_zone_set_init: Invalid zone type")); + KEG_LOCK(keg); KASSERT(keg->uk_pages == 0, ("uma_zone_set_fini on non-empty keg")); keg->uk_fini = fini; - ZONE_UNLOCK(zone); + KEG_UNLOCK(keg); } /* See uma.h */ void uma_zone_set_zinit(uma_zone_t zone, uma_init zinit) { + ZONE_LOCK(zone); KASSERT(zone_first_keg(zone)->uk_pages == 0, ("uma_zone_set_zinit on non-empty keg")); @@ -2912,6 +2890,7 @@ uma_zone_set_zinit(uma_zone_t zone, uma_ void uma_zone_set_zfini(uma_zone_t zone, uma_fini zfini) { + ZONE_LOCK(zone); KASSERT(zone_first_keg(zone)->uk_pages == 0, ("uma_zone_set_zfini on non-empty keg")); @@ -2926,11 +2905,11 @@ uma_zone_set_freef(uma_zone_t zone, uma_ { uma_keg_t keg; - ZONE_LOCK(zone); keg = zone_first_keg(zone); KASSERT(keg != NULL, ("uma_zone_set_init: Invalid zone type")); + KEG_LOCK(keg); keg->uk_freef = freef; - ZONE_UNLOCK(zone); + KEG_UNLOCK(keg); } /* See uma.h */ @@ -2940,11 +2919,11 @@ uma_zone_set_allocf(uma_zone_t zone, uma { uma_keg_t keg; - ZONE_LOCK(zone); keg = zone_first_keg(zone); + KEG_LOCK(keg); keg->uk_flags |= UMA_ZFLAG_PRIVALLOC; keg->uk_allocf = allocf; - ZONE_UNLOCK(zone); + KEG_UNLOCK(keg); } /* See uma.h */ @@ -2973,7 +2952,7 @@ uma_zone_reserve_kva(uma_zone_t zone, in return (0); } else kva = 0; - ZONE_LOCK(zone); + KEG_LOCK(keg); keg->uk_kva = kva; keg->uk_offset = 0; keg->uk_maxpages = pages; @@ -2983,7 +2962,8 @@ uma_zone_reserve_kva(uma_zone_t zone, in keg->uk_allocf = noobj_alloc; #endif keg->uk_flags |= UMA_ZONE_NOFREE | UMA_ZFLAG_PRIVALLOC; - ZONE_UNLOCK(zone); + KEG_UNLOCK(keg); + return (1); } @@ -2998,7 +2978,7 @@ uma_prealloc(uma_zone_t zone, int items) keg = zone_first_keg(zone); if (keg == NULL) return; - ZONE_LOCK(zone); + KEG_LOCK(keg); slabs = items / keg->uk_ipers; if (slabs * keg->uk_ipers < items) slabs++; @@ -3010,7 +2990,7 @@ uma_prealloc(uma_zone_t zone, int items) LIST_INSERT_HEAD(&keg->uk_free_slab, slab, us_link); slabs--; } - ZONE_UNLOCK(zone); + KEG_UNLOCK(keg); } /* See uma.h */ Modified: head/sys/vm/uma_dbg.c ============================================================================== --- head/sys/vm/uma_dbg.c Thu Jun 20 18:25:10 2013 (r252039) +++ head/sys/vm/uma_dbg.c Thu Jun 20 19:08:12 2013 (r252040) @@ -231,6 +231,8 @@ uma_dbg_alloc(uma_zone_t zone, uma_slab_ uma_keg_t keg; int freei; + if (zone_first_keg(zone) == NULL) + return; if (slab == NULL) { slab = uma_dbg_getslab(zone, item); if (slab == NULL) @@ -259,6 +261,8 @@ uma_dbg_free(uma_zone_t zone, uma_slab_t uma_keg_t keg; int freei; + if (zone_first_keg(zone) == NULL) + return; if (slab == NULL) { slab = uma_dbg_getslab(zone, item); if (slab == NULL) Modified: head/sys/vm/uma_int.h ============================================================================== --- head/sys/vm/uma_int.h Thu Jun 20 18:25:10 2013 (r252039) +++ head/sys/vm/uma_int.h Thu Jun 20 19:08:12 2013 (r252040) @@ -189,7 +189,7 @@ typedef struct uma_cache * uma_cache_t; * */ struct uma_keg { - struct mtx uk_lock; /* Lock for the keg */ + struct mtx_padalign uk_lock; /* Lock for the keg */ struct uma_hash uk_hash; LIST_HEAD(,uma_zone) uk_zones; /* Keg's zones */ @@ -281,8 +281,9 @@ typedef struct uma_klink *uma_klink_t; * */ struct uma_zone { - const char *uz_name; /* Text name of the zone */ - struct mtx *uz_lock; /* Lock for the zone (keg's lock) */ + struct mtx_padalign uz_lock; /* Lock for the zone */ + struct mtx_padalign *uz_lockptr; + const char *uz_name; /* Text name of the zone */ LIST_ENTRY(uma_zone) uz_link; /* List of all zones in keg */ LIST_HEAD(,uma_bucket) uz_buckets; /* full buckets */ @@ -334,8 +335,10 @@ struct uma_zone { static inline uma_keg_t zone_first_keg(uma_zone_t zone) { + uma_klink_t klink; - return (LIST_FIRST(&zone->uz_kegs)->kl_keg); + klink = LIST_FIRST(&zone->uz_kegs); + return (klink != NULL) ? klink->kl_keg : NULL; } #undef UMA_ALIGN @@ -357,13 +360,25 @@ void uma_large_free(uma_slab_t slab); mtx_init(&(k)->uk_lock, (k)->uk_name, \ "UMA zone", MTX_DEF | MTX_DUPOK); \ } while (0) - + #define KEG_LOCK_FINI(k) mtx_destroy(&(k)->uk_lock) #define KEG_LOCK(k) mtx_lock(&(k)->uk_lock) #define KEG_UNLOCK(k) mtx_unlock(&(k)->uk_lock) -#define ZONE_LOCK(z) mtx_lock((z)->uz_lock) -#define ZONE_TRYLOCK(z) mtx_trylock((z)->uz_lock) -#define ZONE_UNLOCK(z) mtx_unlock((z)->uz_lock) + +#define ZONE_LOCK_INIT(z, lc) \ + do { \ + if ((lc)) \ + mtx_init(&(z)->uz_lock, (z)->uz_name, \ + (z)->uz_name, MTX_DEF | MTX_DUPOK); \ + else \ + mtx_init(&(z)->uz_lock, (z)->uz_name, \ + "UMA zone", MTX_DEF | MTX_DUPOK); \ + } while (0) + +#define ZONE_LOCK(z) mtx_lock((z)->uz_lockptr) +#define ZONE_TRYLOCK(z) mtx_trylock((z)->uz_lockptr) +#define ZONE_UNLOCK(z) mtx_unlock((z)->uz_lockptr) +#define ZONE_LOCK_FINI(z) mtx_destroy(&(z)->uz_lock) /* * Find a slab within a hash table. This is used for OFFPAGE zones to lookup
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?201306201908.r5KJ8D9E038632>