include/sys/lwpchan_impl.h

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #ifndef _SYS_LCHAN_IMPL_H
  28 #define _SYS_LCHAN_IMPL_H
  29
  30 #ifdef  __cplusplus
  31 extern "C" {
  32 #endif
  33
  34 #define LWPCHAN_CVPOOL  0
  35 #define LWPCHAN_MPPOOL  1
  36
  37 #define LWPCHAN_INITIAL_BITS    2       /* initially: 4 hash buckets */
  38 #define LWPCHAN_MAX_BITS        16      /* finally: up to 64K hash buckets */
  39
  40 /*
  41  * An lwpchan entry translates a process-shared lwp sync object's
  42  * virtual address into its logical address, an lwpchan, previously
  43  * computed via as_getmemid().
  44  */
  45 typedef struct lwpchan_entry {
  46         caddr_t lwpchan_addr;           /* virtual address */
  47         caddr_t lwpchan_uaddr;          /* address of lock registration */
  48         uint16_t lwpchan_type;          /* sync object type field */
  49         uint16_t lwpchan_pool;          /* LWPCHAN_CVPOOL/LWPCHAN_MPPOOL */
  50         lwpchan_t lwpchan_lwpchan;      /* unique logical address */
  51         struct lwpchan_entry *lwpchan_next;     /* hash chain */
  52 } lwpchan_entry_t;
  53
  54 /*
  55  * Hash bucket head.  The mutex protects the consistency of the hash chain.
  56  * Also, p->p_lcp cannot be changed while any one hash bucket lock is held.
  57  * (The resizing thread must acquire all of the hash bucket locks.)
  58  */
  59 typedef struct lwpchan_hashbucket {
  60         kmutex_t lwpchan_lock;
  61         lwpchan_entry_t *lwpchan_chain;
  62 } lwpchan_hashbucket_t;
  63
  64 /*
  65  * Each process maintains a cache of lwpchan translations for sync objects
  66  * (lwp_mutex_t, lwp_cond_t, lwp_sema_t) that are shared between processes.
  67  * The lwpchan cache is a hash table used to look up previously-computed
  68  * lwpchan_t's by process virtual address.  We keep this cache because we
  69  * believe that as_getmemid() is slow and we only need to call it once,
  70  * then remember the results.  The hashing function is very simple, and
  71  * assumes an even distribution of sync objects within the process's
  72  * address space.  When hash chains become too long, the cache is resized
  73  * on the fly.  The cache is freed when the process exits or execs.
  74  */
  75 typedef struct lwpchan_data {
  76         uint_t  lwpchan_bits;           /* number of bits */
  77         uint_t  lwpchan_size;           /* 1 << lwpchan_bits */
  78         uint_t  lwpchan_mask;           /* lwpchan_size - 1 */
  79         uint_t  lwpchan_entries;        /* number of entries in the cache */
  80         lwpchan_hashbucket_t *lwpchan_cache;
  81         struct lwpchan_data *lwpchan_next_data;
  82 } lwpchan_data_t;
  83
  84 /*
  85  * exported functions
  86  */
  87 void lwpchan_delete_mapping(proc_t *, caddr_t start, caddr_t end);
  88 void lwpchan_destroy_cache(int);
  89
  90 #ifdef  __cplusplus
  91 }
  92 #endif
  93
  94 #endif  /* _SYS_LCHAN_IMPL_H */