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, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 #include <sys/types.h>
30 #include <sys/kmem.h>
31 #include <sys/bitmap.h>
32 #include <sys/stream.h>
33 #include <sys/strsubr.h>
34 #define _SUN_TPI_VERSION 2
35 #include <sys/tihdr.h>
36 #include <sys/suntpi.h>
37
38 /*
39 * Hash table parameters for tpi_provinfo_table.
40 */
41 #define TPI_HASH_BITS 4
42 #define TPI_NHASH (1 << TPI_HASH_BITS)
43
44 /*
45 * Use the first element in the key for the hash.
46 */
47 #define TPI_HASH(p) ((((uintptr_t *)p)[0] >> tpi_hashshift) % TPI_NHASH)
48 /*
49 * SAMESTR is a very confusing name. LAST_QUEUE is introduced for readability.
50 */
51 #define LAST_QUEUE(q) (!SAMESTR(q))
52
53 static tpi_provinfo_t *tpi_provinfo_table[TPI_NHASH];
54 static kmutex_t tpi_provinfo_lock;
55 static int tpi_hashshift;
56
57 /*
58 * In most cases there is some transport provider (like tcp or udp) below
59 * transport user (like timod or sockets). However, it is possible to construct
60 * stream without transport provider (e.g. by pushing timod into FIFO). It is
61 * hardly of any use, but this condition was observed with sparcv9 abi tests.
62 * To count for such special case, a special tpi_nullprov static data is
63 * provided to cache information about such degenerated null-transport case.
64 */
65 static tpi_provinfo_t tpi_nullprov; /* Placeholder for null transport */
66
67 /*
68 * Initialise the TPI support routines. Called from strinit().
69 */
70 void
tpi_init()71 tpi_init()
72 {
73 mutex_init(&tpi_provinfo_lock, NULL, MUTEX_DEFAULT, NULL);
74
75 /*
76 * Calculate the right shift for hashing a tpi_provinfo_t.
77 */
78 tpi_hashshift = highbit(sizeof (tpi_provinfo_t));
79 }
80
81 /*
82 * Generate a downstream signature given the write-side queue. It
83 * passes back the size of the generated key in *keylenp. This routine
84 * cannot multithread as it returns a pointer to a static data item.
85 *
86 * There is no way (in the current module loading infrastructure) to
87 * _absolutely_ guarantee that the key below uniquely identifies an
88 * arrangement of modules and drivers. A module _might_ be unloaded and
89 * another module _might_ be loaded such that the qi_minfo is at _exactly_
90 * same kernel address, and then it _might_ be placed in a transport
91 * provider stream in exactly the same configuration (modules above and
92 * below all identical) - but it would take quite a few coincidences
93 * and modules loading and unloading does not usually happen n times a
94 * second...
95 */
96 static void *
tpi_makekey(queue_t * q,size_t * keylenp)97 tpi_makekey(queue_t *q, size_t *keylenp)
98 {
99 static uintptr_t *key = NULL;
100 int i;
101
102 ASSERT(q != NULL);
103 ASSERT(MUTEX_HELD(&tpi_provinfo_lock));
104
105 /* assert this queue is write queue and qprocson() is called before */
106 ASSERT((q->q_flag & QREADR) == 0);
107 ASSERT(q->q_next != NULL);
108
109 /*
110 * This can be global because tpi_makekey is called with
111 * tpi_provinfo_lock.
112 */
113 if (key == NULL)
114 key = kmem_alloc((nstrpush + 1) * sizeof (uintptr_t), KM_SLEEP);
115
116 ASSERT(key != NULL);
117
118 /*
119 * Go down q_next to the driver, but no further. We use the qi_minfo
120 * because we can find in from the queue and it is a stable part of
121 * any driver/module infrastructure.
122 */
123 for (i = 0; !LAST_QUEUE(q) && (q = q->q_next) != NULL; ++i) {
124 ASSERT(i < nstrpush + 1);
125 key[i] = (uintptr_t)q->q_qinfo->qi_minfo;
126 }
127
128 /*
129 * Allocate the actual key with the proper length, and pass it
130 * all back.
131 */
132 *keylenp = i * sizeof (uintptr_t);
133 return ((void *)key);
134 }
135
136 /*
137 * Find an existing provider entry given a queue pointer, or allocate a
138 * new empty entry if not found. Because this routine calls kmem_alloc
139 * with KM_SLEEP, and because it traverses the q_next pointers of a stream
140 * it must be called with a proper user context and within a perimeter
141 * which protects the STREAM e.g. an open routine. This routine always
142 * returns a valid pointer.
143 */
144 tpi_provinfo_t *
tpi_findprov(queue_t * q)145 tpi_findprov(queue_t *q)
146 {
147 void *key;
148 size_t keylen;
149 tpi_provinfo_t **tpp;
150
151 mutex_enter(&tpi_provinfo_lock);
152
153 /*
154 * Must hold tpi_provinfo_lock since tpi_makekey() returns a pointer
155 * to static data.
156 */
157 key = tpi_makekey(WR(q), &keylen);
158
159 if (keylen == 0) {
160 /* there is nothing below us, return special nullprov entry */
161 mutex_exit(&tpi_provinfo_lock);
162 return (&tpi_nullprov);
163 }
164
165 /*
166 * Look for an existing entry, or the place to put a new one.
167 */
168 for (tpp = &tpi_provinfo_table[TPI_HASH(key)]; *tpp != NULL;
169 tpp = &(*tpp)->tpi_next) {
170 if ((*tpp)->tpi_keylen == keylen &&
171 bcmp((*tpp)->tpi_key, key, keylen) == 0) {
172 mutex_exit(&tpi_provinfo_lock);
173 return (*tpp);
174 }
175 }
176
177 /*
178 * Allocate and fill in the new tpi_provinfo_t.
179 */
180 *tpp = kmem_zalloc(sizeof (tpi_provinfo_t), KM_SLEEP);
181 (*tpp)->tpi_key = kmem_alloc(keylen, KM_SLEEP);
182 bcopy(key, (*tpp)->tpi_key, keylen);
183 (*tpp)->tpi_keylen = keylen;
184 mutex_init(&(*tpp)->tpi_lock, NULL, MUTEX_DEFAULT, NULL);
185
186 mutex_exit(&tpi_provinfo_lock);
187 return (*tpp);
188 }
189
190 /*
191 * Allocate a TPI ACK reusing the old message if possible.
192 */
193 mblk_t *
tpi_ack_alloc(mblk_t * mp,size_t size,uchar_t db_type,t_scalar_t prim)194 tpi_ack_alloc(mblk_t *mp, size_t size, uchar_t db_type, t_scalar_t prim)
195 {
196 mblk_t *omp = mp;
197
198 if ((mp = reallocb(mp, size, 0)) == NULL) {
199 freemsg(omp);
200 return (NULL);
201 }
202 if (mp->b_cont != NULL) {
203 freemsg(mp->b_cont);
204 mp->b_cont = NULL;
205 }
206 mp->b_datap->db_type = db_type;
207 mp->b_wptr = mp->b_rptr + size;
208 ((union T_primitives *)mp->b_rptr)->type = prim;
209 return (mp);
210 }
211