sfmmu/vm/hat_sfmmu.c

170  * after the initial phase of removing an hmeblk from the hash chain, see
328  * This hash algorithm is based upon the knowledge that sfmmu_t's come from a
563 struct hmehash_bucket *uhme_hash;	/* user hmeblk hash table */
564 struct hmehash_bucket *khme_hash;	/* kernel hmeblk hash table */
567 int 		uhmehash_num;		/* # of buckets in user hash table */
568 int 		khmehash_num;		/* # of buckets in kernel hash table */
1079 	/* Initialize the hash locks */
2022 	 * the hash looking for hme_blks to free up.  Not only do we free up
2605 		 * Acquire the hash bucket.
2651 		 * Release the hash bucket.
2928 	 * Acquire the hash bucket.
2947 	 * Release the hash bucket.
2955  * Function locks and returns a pointer to the hash bucket for vaddr and size.
2977  * Function returns a pointer to an hmeblk in the hash bucket, hmebp. If the
3403  * Function unlocks hash bucket.
4125  * Should be called with the hash lock held.
4314  * deletion significantly quicker by avoiding a potentially lengthy hash
5005  * It should be called with the hash lock held.
5345  * It should be called with the hash lock held.
5540  * hash table to find and remove mappings.
5574 	 * Loop through all the hash buckets of HME blocks looking for matches.
5735 	 *	UHMEHASH_SZ is number of hash buckets to examine
5771 	 * we don't use shadow hmeblks and hash starting from the smallest
5889 			 * Decrement the hash size and rehash.
6026  * It should be called with the hash lock held.
7080 	 * take care of updating the hash table, since we still
7318 		 * Note that we have p_mapping lock, but no hash lock here.
7319 		 * hblk_unload() has to have both hash lock AND p_mapping
9154  * is running low in memory.  We traverse the hash and free up all unused but
10662  * pp (this also assumes that the caller holds hme hash bucket lock so that
10898 	 * acquire hash bucket lock.
10909 	 * add new to hash chain
10914 	 * search hash chain for hblk_reserve; this needs to be performed
10916 	 * is prior to old in hash chain when we call sfmmu_hblk_hash_rm to
10966 	 * remove old from hash chain
10995  * low refers to the mutex residing in the lower bin of the mlist hash, while
10996  * high refers to the mutex residing in the higher bin of the mlist hash.  This
11000  * If both pages hash to the same mutex, only grab that single mutex, and
11002  * If the pages hash to different bins in the hash, grab the lower addressed
11437 				 * we just hit hblk_reserve in the hash and
11540  * Steal a hmeblk from user or kernel hme hash lists.
11627 		 * hash table.
11648 						 * hash lock.
13851 	uint_t hash = SRD_HASH_FUNCTION(evp);
13864 	if (srd_buckets[hash].srdb_srdp != NULL) {
13865 		mutex_enter(&srd_buckets[hash].srdb_lock);
13866 		for (srdp = srd_buckets[hash].srdb_srdp; srdp != NULL;
13873 				mutex_exit(&srd_buckets[hash].srdb_lock);
13877 		mutex_exit(&srd_buckets[hash].srdb_lock);
13887 	mutex_enter(&srd_buckets[hash].srdb_lock);
13888 	for (srdp = srd_buckets[hash].srdb_srdp; srdp != NULL;
13894 			mutex_exit(&srd_buckets[hash].srdb_lock);
13899 	newsrdp->srd_hash = srd_buckets[hash].srdb_srdp;
13900 	srd_buckets[hash].srdb_srdp = newsrdp;
13903 	mutex_exit(&srd_buckets[hash].srdb_lock);
13912 	uint_t hash;
13936 	hash = SRD_HASH_FUNCTION(evp);
13937 	mutex_enter(&srd_buckets[hash].srdb_lock);
13938 	for (prev_srdpp = &srd_buckets[hash].srdb_srdp;
13945 		mutex_exit(&srd_buckets[hash].srdb_lock);
13950 	mutex_exit(&srd_buckets[hash].srdb_lock);
15711  * Add an hmeblk to the the hash list.
15726 	 * Since the TSB miss handler now does not lock the hash chain before
15729 	 * pointer in the hash bucket.
15740  * from the hash chain. In this phase we unlink the hmeblk from the hash chain
15758  *	 hmebp - hme hash bucket pointer
15762  *	 free_now flag - indicates that a complete removal from the hash chains
15766  * remove a single hmeblk from the hash chain but is necessary when hmeblks are