/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <sys/types.h>
#include <sys/kmem.h>
#include <sys/bitmap.h>
#include <sys/stream.h>
#include <sys/strsubr.h>
#define _SUN_TPI_VERSION 2
#include <sys/tihdr.h>
#include <sys/suntpi.h>
/*
* Hash table parameters for tpi_provinfo_table.
*/
#define TPI_HASH_BITS 4
#define TPI_NHASH (1 << TPI_HASH_BITS)
/*
* Use the first element in the key for the hash.
*/
#define TPI_HASH(p) ((((uintptr_t *)p)[0] >> tpi_hashshift) % TPI_NHASH)
/*
* SAMESTR is a very confusing name. LAST_QUEUE is introduced for readability.
*/
#define LAST_QUEUE(q) (!SAMESTR(q))
static tpi_provinfo_t *tpi_provinfo_table[TPI_NHASH];
static kmutex_t tpi_provinfo_lock;
static int tpi_hashshift;
/*
* In most cases there is some transport provider (like tcp or udp) below
* transport user (like timod or sockets). However, it is possible to construct
* stream without transport provider (e.g. by pushing timod into FIFO). It is
* hardly of any use, but this condition was observed with sparcv9 abi tests.
* To count for such special case, a special tpi_nullprov static data is
* provided to cache information about such degenerated null-transport case.
*/
static tpi_provinfo_t tpi_nullprov; /* Placeholder for null transport */
/*
* Initialise the TPI support routines. Called from strinit().
*/
void
tpi_init()
{
mutex_init(&tpi_provinfo_lock, NULL, MUTEX_DEFAULT, NULL);
/*
* Calculate the right shift for hashing a tpi_provinfo_t.
*/
tpi_hashshift = highbit(sizeof (tpi_provinfo_t));
}
/*
* Generate a downstream signature given the write-side queue. It
* passes back the size of the generated key in *keylenp. This routine
* cannot multithread as it returns a pointer to a static data item.
*
* There is no way (in the current module loading infrastructure) to
* _absolutely_ guarantee that the key below uniquely identifies an
* arrangement of modules and drivers. A module _might_ be unloaded and
* another module _might_ be loaded such that the qi_minfo is at _exactly_
* same kernel address, and then it _might_ be placed in a transport
* provider stream in exactly the same configuration (modules above and
* below all identical) - but it would take quite a few coincidences
* and modules loading and unloading does not usually happen n times a
* second...
*/
static void *
tpi_makekey(queue_t *q, size_t *keylenp)
{
static uintptr_t *key = NULL;
int i;
ASSERT(q != NULL);
ASSERT(MUTEX_HELD(&tpi_provinfo_lock));
/* assert this queue is write queue and qprocson() is called before */
ASSERT((q->q_flag & QREADR) == 0);
ASSERT(q->q_next != NULL);
/*
* This can be global because tpi_makekey is called with
* tpi_provinfo_lock.
*/
if (key == NULL)
key = kmem_alloc((nstrpush + 1) * sizeof (uintptr_t), KM_SLEEP);
ASSERT(key != NULL);
/*
* Go down q_next to the driver, but no further. We use the qi_minfo
* because we can find in from the queue and it is a stable part of
* any driver/module infrastructure.
*/
for (i = 0; !LAST_QUEUE(q) && (q = q->q_next) != NULL; ++i) {
ASSERT(i < nstrpush + 1);
key[i] = (uintptr_t)q->q_qinfo->qi_minfo;
}
/*
* Allocate the actual key with the proper length, and pass it
* all back.
*/
*keylenp = i * sizeof (uintptr_t);
return ((void *)key);
}
/*
* Find an existing provider entry given a queue pointer, or allocate a
* new empty entry if not found. Because this routine calls kmem_alloc
* with KM_SLEEP, and because it traverses the q_next pointers of a stream
* it must be called with a proper user context and within a perimeter
* which protects the STREAM e.g. an open routine. This routine always
* returns a valid pointer.
*/
tpi_provinfo_t *
tpi_findprov(queue_t *q)
{
void *key;
size_t keylen;
tpi_provinfo_t **tpp;
mutex_enter(&tpi_provinfo_lock);
/*
* Must hold tpi_provinfo_lock since tpi_makekey() returns a pointer
* to static data.
*/
key = tpi_makekey(WR(q), &keylen);
if (keylen == 0) {
/* there is nothing below us, return special nullprov entry */
mutex_exit(&tpi_provinfo_lock);
return (&tpi_nullprov);
}
/*
* Look for an existing entry, or the place to put a new one.
*/
for (tpp = &tpi_provinfo_table[TPI_HASH(key)]; *tpp != NULL;
tpp = &(*tpp)->tpi_next) {
if ((*tpp)->tpi_keylen == keylen &&
bcmp((*tpp)->tpi_key, key, keylen) == 0) {
mutex_exit(&tpi_provinfo_lock);
return (*tpp);
}
}
/*
* Allocate and fill in the new tpi_provinfo_t.
*/
*tpp = kmem_zalloc(sizeof (tpi_provinfo_t), KM_SLEEP);
(*tpp)->tpi_key = kmem_alloc(keylen, KM_SLEEP);
bcopy(key, (*tpp)->tpi_key, keylen);
(*tpp)->tpi_keylen = keylen;
mutex_init(&(*tpp)->tpi_lock, NULL, MUTEX_DEFAULT, NULL);
mutex_exit(&tpi_provinfo_lock);
return (*tpp);
}
/*
* Allocate a TPI ACK reusing the old message if possible.
*/
mblk_t *
tpi_ack_alloc(mblk_t *mp, size_t size, uchar_t db_type, t_scalar_t prim)
{
mblk_t *omp = mp;
if ((mp = reallocb(mp, size, 0)) == NULL) {
freemsg(omp);
return (NULL);
}
if (mp->b_cont != NULL) {
freemsg(mp->b_cont);
mp->b_cont = NULL;
}
mp->b_datap->db_type = db_type;
mp->b_wptr = mp->b_rptr + size;
((union T_primitives *)mp->b_rptr)->type = prim;
return (mp);
}