17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate * CDDL HEADER START
37c478bd9Sstevel@tonic-gate *
47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the
50ef0bcfbSyz147064 * Common Development and Distribution License (the "License").
60ef0bcfbSyz147064 * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate *
87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate * and limitations under the License.
127c478bd9Sstevel@tonic-gate *
137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate *
197c478bd9Sstevel@tonic-gate * CDDL HEADER END
207c478bd9Sstevel@tonic-gate */
217c478bd9Sstevel@tonic-gate /*
22005d3febSMarek Pospisil * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
237c478bd9Sstevel@tonic-gate * Use is subject to license terms.
247c478bd9Sstevel@tonic-gate */
257c478bd9Sstevel@tonic-gate /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
267c478bd9Sstevel@tonic-gate /* All Rights Reserved */
277c478bd9Sstevel@tonic-gate
287c478bd9Sstevel@tonic-gate
297c478bd9Sstevel@tonic-gate /*
307c478bd9Sstevel@tonic-gate * Transport Interface Library cooperating module - issue 2
317c478bd9Sstevel@tonic-gate */
327c478bd9Sstevel@tonic-gate
337c478bd9Sstevel@tonic-gate #include <sys/param.h>
347c478bd9Sstevel@tonic-gate #include <sys/types.h>
357c478bd9Sstevel@tonic-gate #include <sys/stream.h>
367c478bd9Sstevel@tonic-gate #include <sys/stropts.h>
377c478bd9Sstevel@tonic-gate #include <sys/strsubr.h>
387c478bd9Sstevel@tonic-gate #define _SUN_TPI_VERSION 2
397c478bd9Sstevel@tonic-gate #include <sys/tihdr.h>
407c478bd9Sstevel@tonic-gate #include <sys/timod.h>
417c478bd9Sstevel@tonic-gate #include <sys/suntpi.h>
427c478bd9Sstevel@tonic-gate #include <sys/debug.h>
437c478bd9Sstevel@tonic-gate #include <sys/strlog.h>
447c478bd9Sstevel@tonic-gate #include <sys/errno.h>
457c478bd9Sstevel@tonic-gate #include <sys/cred.h>
467c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h>
477c478bd9Sstevel@tonic-gate #include <sys/kmem.h>
487c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h>
497c478bd9Sstevel@tonic-gate #include <sys/ddi.h>
507c478bd9Sstevel@tonic-gate #include <sys/sunddi.h>
517c478bd9Sstevel@tonic-gate #include <sys/strsun.h>
527c478bd9Sstevel@tonic-gate #include <c2/audit.h>
537c478bd9Sstevel@tonic-gate
547c478bd9Sstevel@tonic-gate /*
557c478bd9Sstevel@tonic-gate * This is the loadable module wrapper.
567c478bd9Sstevel@tonic-gate */
577c478bd9Sstevel@tonic-gate #include <sys/conf.h>
587c478bd9Sstevel@tonic-gate #include <sys/modctl.h>
597c478bd9Sstevel@tonic-gate
607c478bd9Sstevel@tonic-gate static struct streamtab timinfo;
617c478bd9Sstevel@tonic-gate
627c478bd9Sstevel@tonic-gate static struct fmodsw fsw = {
637c478bd9Sstevel@tonic-gate "timod",
647c478bd9Sstevel@tonic-gate &timinfo,
657c478bd9Sstevel@tonic-gate D_MTQPAIR | D_MP,
667c478bd9Sstevel@tonic-gate };
677c478bd9Sstevel@tonic-gate
687c478bd9Sstevel@tonic-gate /*
697c478bd9Sstevel@tonic-gate * Module linkage information for the kernel.
707c478bd9Sstevel@tonic-gate */
717c478bd9Sstevel@tonic-gate
727c478bd9Sstevel@tonic-gate static struct modlstrmod modlstrmod = {
737c478bd9Sstevel@tonic-gate &mod_strmodops, "transport interface str mod", &fsw
747c478bd9Sstevel@tonic-gate };
757c478bd9Sstevel@tonic-gate
767c478bd9Sstevel@tonic-gate static struct modlinkage modlinkage = {
777c478bd9Sstevel@tonic-gate MODREV_1, &modlstrmod, NULL
787c478bd9Sstevel@tonic-gate };
797c478bd9Sstevel@tonic-gate
807c478bd9Sstevel@tonic-gate static krwlock_t tim_list_rwlock;
817c478bd9Sstevel@tonic-gate
827c478bd9Sstevel@tonic-gate /*
837c478bd9Sstevel@tonic-gate * This module keeps track of capabilities of underlying transport. Information
847c478bd9Sstevel@tonic-gate * is persistent through module invocations (open/close). Currently it remembers
857c478bd9Sstevel@tonic-gate * whether underlying transport supports TI_GET{MY,PEER}NAME ioctls and
867c478bd9Sstevel@tonic-gate * T_CAPABILITY_REQ message. This module either passes ioctl/messages to the
877c478bd9Sstevel@tonic-gate * transport or emulates it when transport doesn't understand these
887c478bd9Sstevel@tonic-gate * ioctl/messages.
897c478bd9Sstevel@tonic-gate *
907c478bd9Sstevel@tonic-gate * It is assumed that transport supports T_CAPABILITY_REQ when timod receives
917c478bd9Sstevel@tonic-gate * T_CAPABILITY_ACK from the transport. There is no current standard describing
927c478bd9Sstevel@tonic-gate * transport behaviour when it receives unknown message type, so following
937c478bd9Sstevel@tonic-gate * reactions are expected and handled:
947c478bd9Sstevel@tonic-gate *
957c478bd9Sstevel@tonic-gate * 1) Transport drops unknown T_CAPABILITY_REQ message type. In this case timod
967c478bd9Sstevel@tonic-gate * will wait for tcap_wait time and assume that transport doesn't provide
977c478bd9Sstevel@tonic-gate * this message type. T_CAPABILITY_REQ should never travel over the wire, so
987c478bd9Sstevel@tonic-gate * timeout value should only take into consideration internal processing time
997c478bd9Sstevel@tonic-gate * for the message. From user standpoint it may mean that an application will
1007c478bd9Sstevel@tonic-gate * hang for TCAP_WAIT time in the kernel the first time this message is used
1017c478bd9Sstevel@tonic-gate * with some particular transport (e.g. TCP/IP) during system uptime.
1027c478bd9Sstevel@tonic-gate *
1037c478bd9Sstevel@tonic-gate * 2) Transport responds with T_ERROR_ACK specifying T_CAPABILITY_REQ as
1047c478bd9Sstevel@tonic-gate * original message type. In this case it is assumed that transport doesn't
1057c478bd9Sstevel@tonic-gate * support it (which may not always be true - some transports return
1067c478bd9Sstevel@tonic-gate * T_ERROR_ACK in other cases like lack of system memory).
1077c478bd9Sstevel@tonic-gate *
1087c478bd9Sstevel@tonic-gate * 3) Transport responds with M_ERROR, effectively shutting down the
1097c478bd9Sstevel@tonic-gate * stream. Unfortunately there is no standard way to pass the reason of
1107c478bd9Sstevel@tonic-gate * M_ERROR message back to the caller, so it is assumed that if M_ERROR was
1117c478bd9Sstevel@tonic-gate * sent in response to T_CAPABILITY_REQ message, transport doesn't support
1127c478bd9Sstevel@tonic-gate * it.
1137c478bd9Sstevel@tonic-gate *
1147c478bd9Sstevel@tonic-gate * It is possible under certain circumstances that timod will incorrectly assume
1157c478bd9Sstevel@tonic-gate * that underlying transport doesn't provide T_CAPABILITY_REQ message type. In
1167c478bd9Sstevel@tonic-gate * this "worst-case" scenario timod will emulate its functionality by itself and
1177c478bd9Sstevel@tonic-gate * will provide only TC1_INFO capability. All other bits in CAP_bits1 field are
1187c478bd9Sstevel@tonic-gate * cleaned. TC1_INFO is emulated by sending T_INFO_REQ down to transport
1197c478bd9Sstevel@tonic-gate * provider.
1207c478bd9Sstevel@tonic-gate */
1217c478bd9Sstevel@tonic-gate
1227c478bd9Sstevel@tonic-gate /*
1237c478bd9Sstevel@tonic-gate * Notes about locking:
1247c478bd9Sstevel@tonic-gate *
1257c478bd9Sstevel@tonic-gate * tim_list_rwlock protects the list of tim_tim structures itself. When this
1267c478bd9Sstevel@tonic-gate * lock is held, the list itself is stable, but the contents of the entries
1277c478bd9Sstevel@tonic-gate * themselves might not be.
1287c478bd9Sstevel@tonic-gate *
1297c478bd9Sstevel@tonic-gate * The rest of the members are generally protected by D_MTQPAIR, which
1307c478bd9Sstevel@tonic-gate * specifies a default exclusive inner perimeter. If you're looking at
1317c478bd9Sstevel@tonic-gate * q->q_ptr, then it's stable.
1327c478bd9Sstevel@tonic-gate *
1337c478bd9Sstevel@tonic-gate * There's one exception to this rule: tim_peer{maxlen,len,name}. These members
1347c478bd9Sstevel@tonic-gate * are touched without entering the associated STREAMS perimeter because we
1357c478bd9Sstevel@tonic-gate * get the pointer via tim_findlink() rather than q_ptr. These are protected
1367c478bd9Sstevel@tonic-gate * by tim_mutex instead. If you don't hold that lock, don't look at them.
1377c478bd9Sstevel@tonic-gate *
1387c478bd9Sstevel@tonic-gate * (It would be possible to separate out the 'set by T_CONN_RES' cases from the
1397c478bd9Sstevel@tonic-gate * others, but there appears to be no reason to do so.)
1407c478bd9Sstevel@tonic-gate */
1417c478bd9Sstevel@tonic-gate struct tim_tim {
1427c478bd9Sstevel@tonic-gate uint32_t tim_flags;
1437c478bd9Sstevel@tonic-gate t_uscalar_t tim_backlog;
1447c478bd9Sstevel@tonic-gate mblk_t *tim_iocsave;
1457c478bd9Sstevel@tonic-gate t_scalar_t tim_mymaxlen;
1467c478bd9Sstevel@tonic-gate t_scalar_t tim_mylen;
1477c478bd9Sstevel@tonic-gate caddr_t tim_myname;
1487c478bd9Sstevel@tonic-gate t_scalar_t tim_peermaxlen;
1497c478bd9Sstevel@tonic-gate t_scalar_t tim_peerlen;
1507c478bd9Sstevel@tonic-gate caddr_t tim_peername;
1517c478bd9Sstevel@tonic-gate cred_t *tim_peercred;
1527c478bd9Sstevel@tonic-gate mblk_t *tim_consave;
1537c478bd9Sstevel@tonic-gate bufcall_id_t tim_wbufcid;
1547c478bd9Sstevel@tonic-gate bufcall_id_t tim_rbufcid;
1557c478bd9Sstevel@tonic-gate timeout_id_t tim_wtimoutid;
1567c478bd9Sstevel@tonic-gate timeout_id_t tim_rtimoutid;
1577c478bd9Sstevel@tonic-gate /* Protected by the global tim_list_rwlock for all instances */
1587c478bd9Sstevel@tonic-gate struct tim_tim *tim_next;
1597c478bd9Sstevel@tonic-gate struct tim_tim **tim_ptpn;
1607c478bd9Sstevel@tonic-gate t_uscalar_t tim_acceptor;
1617c478bd9Sstevel@tonic-gate t_scalar_t tim_saved_prim; /* Primitive from message */
1627c478bd9Sstevel@tonic-gate /* part of ioctl. */
1637c478bd9Sstevel@tonic-gate timeout_id_t tim_tcap_timoutid; /* For T_CAP_REQ timeout */
1647c478bd9Sstevel@tonic-gate tpi_provinfo_t *tim_provinfo; /* Transport description */
1657c478bd9Sstevel@tonic-gate kmutex_t tim_mutex; /* protect tim_peer* */
1667c478bd9Sstevel@tonic-gate pid_t tim_cpid;
1677c478bd9Sstevel@tonic-gate };
1687c478bd9Sstevel@tonic-gate
1697c478bd9Sstevel@tonic-gate
1707c478bd9Sstevel@tonic-gate /*
1717c478bd9Sstevel@tonic-gate * Local flags used with tim_flags field in instance structure of
1727c478bd9Sstevel@tonic-gate * type 'struct _ti_user' declared above.
1737c478bd9Sstevel@tonic-gate * Historical note:
1747c478bd9Sstevel@tonic-gate * This namespace constants were previously declared in a
1757c478bd9Sstevel@tonic-gate * a very messed up namespace in timod.h
1767c478bd9Sstevel@tonic-gate *
1777c478bd9Sstevel@tonic-gate * There may be 3 states for transport:
1787c478bd9Sstevel@tonic-gate *
1797c478bd9Sstevel@tonic-gate * 1) It provides T_CAPABILITY_REQ
1807c478bd9Sstevel@tonic-gate * 2) It does not provide T_CAPABILITY_REQ
1817c478bd9Sstevel@tonic-gate * 3) It is not known yet whether transport provides T_CAPABILITY_REQ or not.
1827c478bd9Sstevel@tonic-gate *
1837c478bd9Sstevel@tonic-gate * It is assumed that the underlying transport either provides
1847c478bd9Sstevel@tonic-gate * T_CAPABILITY_REQ or not and this does not changes during the
1857c478bd9Sstevel@tonic-gate * system lifetime.
1867c478bd9Sstevel@tonic-gate *
1877c478bd9Sstevel@tonic-gate */
1887c478bd9Sstevel@tonic-gate #define PEEK_RDQ_EXPIND 0x0001 /* look for expinds on stream rd queues */
1897c478bd9Sstevel@tonic-gate #define WAITIOCACK 0x0002 /* waiting for info for ioctl act */
1907c478bd9Sstevel@tonic-gate #define CLTS 0x0004 /* connectionless transport */
1917c478bd9Sstevel@tonic-gate #define COTS 0x0008 /* connection-oriented transport */
1927c478bd9Sstevel@tonic-gate #define CONNWAIT 0x0010 /* waiting for connect confirmation */
1937c478bd9Sstevel@tonic-gate #define LOCORDREL 0x0020 /* local end has orderly released */
1947c478bd9Sstevel@tonic-gate #define REMORDREL 0x0040 /* remote end had orderly released */
1957c478bd9Sstevel@tonic-gate #define NAMEPROC 0x0080 /* processing a NAME ioctl */
1967c478bd9Sstevel@tonic-gate #define DO_MYNAME 0x0100 /* timod handles TI_GETMYNAME */
1977c478bd9Sstevel@tonic-gate #define DO_PEERNAME 0x0200 /* timod handles TI_GETPEERNAME */
1987c478bd9Sstevel@tonic-gate #define TI_CAP_RECVD 0x0400 /* TI_CAPABILITY received */
1997c478bd9Sstevel@tonic-gate #define CAP_WANTS_INFO 0x0800 /* TI_CAPABILITY has TC1_INFO set */
2007c478bd9Sstevel@tonic-gate #define WAIT_IOCINFOACK 0x1000 /* T_INFO_REQ generated from ioctl */
2017c478bd9Sstevel@tonic-gate #define WAIT_CONNRESACK 0x2000 /* waiting for T_OK_ACK to T_CONN_RES */
2027c478bd9Sstevel@tonic-gate
2037c478bd9Sstevel@tonic-gate
2047c478bd9Sstevel@tonic-gate /* Debugging facilities */
2057c478bd9Sstevel@tonic-gate /*
2067c478bd9Sstevel@tonic-gate * Logging needed for debugging timod should only appear in DEBUG kernel.
2077c478bd9Sstevel@tonic-gate */
2087c478bd9Sstevel@tonic-gate #ifdef DEBUG
2097c478bd9Sstevel@tonic-gate #define TILOG(msg, arg) tilog((msg), (arg))
2107c478bd9Sstevel@tonic-gate #define TILOGP(msg, arg) tilogp((msg), (arg))
2117c478bd9Sstevel@tonic-gate #else
2127c478bd9Sstevel@tonic-gate #define TILOG(msg, arg)
2137c478bd9Sstevel@tonic-gate #define TILOGP(msg, arg)
2147c478bd9Sstevel@tonic-gate #endif
2157c478bd9Sstevel@tonic-gate
2167c478bd9Sstevel@tonic-gate
2177c478bd9Sstevel@tonic-gate /*
2187c478bd9Sstevel@tonic-gate * Sleep timeout for T_CAPABILITY_REQ. This message never travels across
2197c478bd9Sstevel@tonic-gate * network, so timeout value should be enough to cover all internal processing
2207c478bd9Sstevel@tonic-gate * time.
2217c478bd9Sstevel@tonic-gate */
2227c478bd9Sstevel@tonic-gate clock_t tim_tcap_wait = 2;
2237c478bd9Sstevel@tonic-gate
2247c478bd9Sstevel@tonic-gate /* Sleep timeout in tim_recover() */
2257c478bd9Sstevel@tonic-gate #define TIMWAIT (1*hz)
2262cbe889aSgeorges /* Sleep timeout in tim_ioctl_retry() 0.2 seconds */
2272cbe889aSgeorges #define TIMIOCWAIT (200*hz/1000)
2287c478bd9Sstevel@tonic-gate
2297c478bd9Sstevel@tonic-gate /*
2307c478bd9Sstevel@tonic-gate * Return values for ti_doname().
2317c478bd9Sstevel@tonic-gate */
2327c478bd9Sstevel@tonic-gate #define DONAME_FAIL 0 /* failing ioctl (done) */
2337c478bd9Sstevel@tonic-gate #define DONAME_DONE 1 /* done processing */
2347c478bd9Sstevel@tonic-gate #define DONAME_CONT 2 /* continue proceesing (not done yet) */
2357c478bd9Sstevel@tonic-gate
2367c478bd9Sstevel@tonic-gate /*
2377c478bd9Sstevel@tonic-gate * Function prototypes
2387c478bd9Sstevel@tonic-gate */
2397c478bd9Sstevel@tonic-gate static int ti_doname(queue_t *, mblk_t *);
2407c478bd9Sstevel@tonic-gate static int ti_expind_on_rdqueues(queue_t *);
2417c478bd9Sstevel@tonic-gate static void tim_ioctl_send_reply(queue_t *, mblk_t *, mblk_t *);
2427c478bd9Sstevel@tonic-gate static void tim_send_ioc_error_ack(queue_t *, struct tim_tim *, mblk_t *);
2437c478bd9Sstevel@tonic-gate static void tim_tcap_timer(void *);
2447c478bd9Sstevel@tonic-gate static void tim_tcap_genreply(queue_t *, struct tim_tim *);
2457c478bd9Sstevel@tonic-gate static void tim_send_reply(queue_t *, mblk_t *, struct tim_tim *, t_scalar_t);
2467c478bd9Sstevel@tonic-gate static void tim_answer_ti_sync(queue_t *, mblk_t *, struct tim_tim *,
2477c478bd9Sstevel@tonic-gate mblk_t *, uint32_t);
2487c478bd9Sstevel@tonic-gate static void tim_send_ioctl_tpi_msg(queue_t *, mblk_t *, struct tim_tim *,
2497c478bd9Sstevel@tonic-gate struct iocblk *);
2507c478bd9Sstevel@tonic-gate static void tim_clear_peer(struct tim_tim *);
2517c478bd9Sstevel@tonic-gate
2527c478bd9Sstevel@tonic-gate int
_init(void)2537c478bd9Sstevel@tonic-gate _init(void)
2547c478bd9Sstevel@tonic-gate {
2557c478bd9Sstevel@tonic-gate int error;
2567c478bd9Sstevel@tonic-gate
2577c478bd9Sstevel@tonic-gate rw_init(&tim_list_rwlock, NULL, RW_DRIVER, NULL);
2587c478bd9Sstevel@tonic-gate error = mod_install(&modlinkage);
2597c478bd9Sstevel@tonic-gate if (error != 0) {
2607c478bd9Sstevel@tonic-gate rw_destroy(&tim_list_rwlock);
2617c478bd9Sstevel@tonic-gate return (error);
2627c478bd9Sstevel@tonic-gate }
2637c478bd9Sstevel@tonic-gate
2647c478bd9Sstevel@tonic-gate return (0);
2657c478bd9Sstevel@tonic-gate }
2667c478bd9Sstevel@tonic-gate
2677c478bd9Sstevel@tonic-gate int
_fini(void)2687c478bd9Sstevel@tonic-gate _fini(void)
2697c478bd9Sstevel@tonic-gate {
2707c478bd9Sstevel@tonic-gate int error;
2717c478bd9Sstevel@tonic-gate
2727c478bd9Sstevel@tonic-gate error = mod_remove(&modlinkage);
2737c478bd9Sstevel@tonic-gate if (error != 0)
2747c478bd9Sstevel@tonic-gate return (error);
2757c478bd9Sstevel@tonic-gate rw_destroy(&tim_list_rwlock);
2767c478bd9Sstevel@tonic-gate return (0);
2777c478bd9Sstevel@tonic-gate }
2787c478bd9Sstevel@tonic-gate
2797c478bd9Sstevel@tonic-gate int
_info(struct modinfo * modinfop)2807c478bd9Sstevel@tonic-gate _info(struct modinfo *modinfop)
2817c478bd9Sstevel@tonic-gate {
2827c478bd9Sstevel@tonic-gate return (mod_info(&modlinkage, modinfop));
2837c478bd9Sstevel@tonic-gate }
2847c478bd9Sstevel@tonic-gate
2857c478bd9Sstevel@tonic-gate
2867c478bd9Sstevel@tonic-gate /*
2877c478bd9Sstevel@tonic-gate * Hash list for all instances. Used to find tim_tim structure based on
2887c478bd9Sstevel@tonic-gate * ACCEPTOR_id in T_CONN_RES. Protected by tim_list_rwlock.
2897c478bd9Sstevel@tonic-gate */
2907c478bd9Sstevel@tonic-gate #define TIM_HASH_SIZE 256
2917c478bd9Sstevel@tonic-gate #ifdef _ILP32
2927c478bd9Sstevel@tonic-gate #define TIM_HASH(id) (((uintptr_t)(id) >> 8) % TIM_HASH_SIZE)
2937c478bd9Sstevel@tonic-gate #else
2947c478bd9Sstevel@tonic-gate #define TIM_HASH(id) ((uintptr_t)(id) % TIM_HASH_SIZE)
2957c478bd9Sstevel@tonic-gate #endif /* _ILP32 */
2967c478bd9Sstevel@tonic-gate static struct tim_tim *tim_hash[TIM_HASH_SIZE];
2977c478bd9Sstevel@tonic-gate int tim_cnt = 0;
2987c478bd9Sstevel@tonic-gate
2997c478bd9Sstevel@tonic-gate static void tilog(char *, t_scalar_t);
3007c478bd9Sstevel@tonic-gate static void tilogp(char *, uintptr_t);
3017c478bd9Sstevel@tonic-gate static mblk_t *tim_filladdr(queue_t *, mblk_t *, boolean_t);
3027c478bd9Sstevel@tonic-gate static void tim_addlink(struct tim_tim *);
3037c478bd9Sstevel@tonic-gate static void tim_dellink(struct tim_tim *);
3047c478bd9Sstevel@tonic-gate static struct tim_tim *tim_findlink(t_uscalar_t);
3057c478bd9Sstevel@tonic-gate static void tim_recover(queue_t *, mblk_t *, t_scalar_t);
3062cbe889aSgeorges static void tim_ioctl_retry(queue_t *);
3077c478bd9Sstevel@tonic-gate
3087c478bd9Sstevel@tonic-gate int dotilog = 0;
3097c478bd9Sstevel@tonic-gate
3107c478bd9Sstevel@tonic-gate #define TIMOD_ID 3
3117c478bd9Sstevel@tonic-gate
3127c478bd9Sstevel@tonic-gate static int timodopen(queue_t *, dev_t *, int, int, cred_t *);
3137c478bd9Sstevel@tonic-gate static int timodclose(queue_t *, int, cred_t *);
314*6caf82faSToomas Soome static int timodwput(queue_t *, mblk_t *);
315*6caf82faSToomas Soome static int timodrput(queue_t *, mblk_t *);
316*6caf82faSToomas Soome static int timodrsrv(queue_t *);
317*6caf82faSToomas Soome static int timodwsrv(queue_t *);
3187c478bd9Sstevel@tonic-gate static int timodrproc(queue_t *, mblk_t *);
3197c478bd9Sstevel@tonic-gate static int timodwproc(queue_t *, mblk_t *);
3207c478bd9Sstevel@tonic-gate
3217c478bd9Sstevel@tonic-gate /* stream data structure definitions */
3227c478bd9Sstevel@tonic-gate
3237c478bd9Sstevel@tonic-gate static struct module_info timod_info =
3247c478bd9Sstevel@tonic-gate {TIMOD_ID, "timod", 0, INFPSZ, 512, 128};
3257c478bd9Sstevel@tonic-gate static struct qinit timodrinit = {
326*6caf82faSToomas Soome timodrput,
327*6caf82faSToomas Soome timodrsrv,
3287c478bd9Sstevel@tonic-gate timodopen,
3297c478bd9Sstevel@tonic-gate timodclose,
3307c478bd9Sstevel@tonic-gate nulldev,
3317c478bd9Sstevel@tonic-gate &timod_info,
3327c478bd9Sstevel@tonic-gate NULL
3337c478bd9Sstevel@tonic-gate };
3347c478bd9Sstevel@tonic-gate static struct qinit timodwinit = {
335*6caf82faSToomas Soome timodwput,
336*6caf82faSToomas Soome timodwsrv,
3377c478bd9Sstevel@tonic-gate timodopen,
3387c478bd9Sstevel@tonic-gate timodclose,
3397c478bd9Sstevel@tonic-gate nulldev,
3407c478bd9Sstevel@tonic-gate &timod_info,
3417c478bd9Sstevel@tonic-gate NULL
3427c478bd9Sstevel@tonic-gate };
3437c478bd9Sstevel@tonic-gate static struct streamtab timinfo = { &timodrinit, &timodwinit, NULL, NULL };
3447c478bd9Sstevel@tonic-gate
3457c478bd9Sstevel@tonic-gate /*
3467c478bd9Sstevel@tonic-gate * timodopen - open routine gets called when the module gets pushed
3477c478bd9Sstevel@tonic-gate * onto the stream.
3487c478bd9Sstevel@tonic-gate */
3497c478bd9Sstevel@tonic-gate /*ARGSUSED*/
3507c478bd9Sstevel@tonic-gate static int
timodopen(queue_t * q,dev_t * devp,int flag,int sflag,cred_t * crp)3517c478bd9Sstevel@tonic-gate timodopen(
3527c478bd9Sstevel@tonic-gate queue_t *q,
3537c478bd9Sstevel@tonic-gate dev_t *devp,
3547c478bd9Sstevel@tonic-gate int flag,
3557c478bd9Sstevel@tonic-gate int sflag,
3567c478bd9Sstevel@tonic-gate cred_t *crp)
3577c478bd9Sstevel@tonic-gate {
3587c478bd9Sstevel@tonic-gate struct tim_tim *tp;
3597c478bd9Sstevel@tonic-gate struct stroptions *sop;
3607c478bd9Sstevel@tonic-gate mblk_t *bp;
3617c478bd9Sstevel@tonic-gate
3627c478bd9Sstevel@tonic-gate ASSERT(q != NULL);
3637c478bd9Sstevel@tonic-gate
3647c478bd9Sstevel@tonic-gate if (q->q_ptr) {
3657c478bd9Sstevel@tonic-gate return (0);
3667c478bd9Sstevel@tonic-gate }
3677c478bd9Sstevel@tonic-gate
3687c478bd9Sstevel@tonic-gate if ((bp = allocb(sizeof (struct stroptions), BPRI_MED)) == 0)
3697c478bd9Sstevel@tonic-gate return (ENOMEM);
3707c478bd9Sstevel@tonic-gate
3717c478bd9Sstevel@tonic-gate tp = kmem_zalloc(sizeof (struct tim_tim), KM_SLEEP);
3727c478bd9Sstevel@tonic-gate
3737c478bd9Sstevel@tonic-gate tp->tim_cpid = -1;
3747c478bd9Sstevel@tonic-gate tp->tim_saved_prim = -1;
3757c478bd9Sstevel@tonic-gate
3767c478bd9Sstevel@tonic-gate mutex_init(&tp->tim_mutex, NULL, MUTEX_DEFAULT, NULL);
3777c478bd9Sstevel@tonic-gate
3787c478bd9Sstevel@tonic-gate q->q_ptr = (caddr_t)tp;
3797c478bd9Sstevel@tonic-gate WR(q)->q_ptr = (caddr_t)tp;
3807c478bd9Sstevel@tonic-gate
3817c478bd9Sstevel@tonic-gate tilogp("timodopen: Allocated for tp %lx\n", (uintptr_t)tp);
3827c478bd9Sstevel@tonic-gate tilogp("timodopen: Allocated for q %lx\n", (uintptr_t)q);
3837c478bd9Sstevel@tonic-gate
3847c478bd9Sstevel@tonic-gate /* Must be done before tpi_findprov and _ILP32 q_next walk below */
3857c478bd9Sstevel@tonic-gate qprocson(q);
3867c478bd9Sstevel@tonic-gate
3877c478bd9Sstevel@tonic-gate tp->tim_provinfo = tpi_findprov(q);
3887c478bd9Sstevel@tonic-gate
3897c478bd9Sstevel@tonic-gate /*
3907c478bd9Sstevel@tonic-gate * Defer allocation of the buffers for the local address and
3917c478bd9Sstevel@tonic-gate * the peer's address until we need them.
3927c478bd9Sstevel@tonic-gate * Assume that timod has to handle getname until we here
3937c478bd9Sstevel@tonic-gate * an iocack from the transport provider or we know that
3947c478bd9Sstevel@tonic-gate * transport provider doesn't understand it.
3957c478bd9Sstevel@tonic-gate */
3967c478bd9Sstevel@tonic-gate if (tp->tim_provinfo->tpi_myname != PI_YES) {
3977c478bd9Sstevel@tonic-gate TILOG("timodopen: setting DO_MYNAME\n", 0);
3987c478bd9Sstevel@tonic-gate tp->tim_flags |= DO_MYNAME;
3997c478bd9Sstevel@tonic-gate }
4007c478bd9Sstevel@tonic-gate
4017c478bd9Sstevel@tonic-gate if (tp->tim_provinfo->tpi_peername != PI_YES) {
4027c478bd9Sstevel@tonic-gate TILOG("timodopen: setting DO_PEERNAME\n", 0);
4037c478bd9Sstevel@tonic-gate tp->tim_flags |= DO_PEERNAME;
4047c478bd9Sstevel@tonic-gate }
4057c478bd9Sstevel@tonic-gate
4067c478bd9Sstevel@tonic-gate #ifdef _ILP32
4077c478bd9Sstevel@tonic-gate {
4087c478bd9Sstevel@tonic-gate queue_t *driverq;
4097c478bd9Sstevel@tonic-gate
4107c478bd9Sstevel@tonic-gate /*
4117c478bd9Sstevel@tonic-gate * Find my driver's read queue (for T_CONN_RES handling)
4127c478bd9Sstevel@tonic-gate */
4137c478bd9Sstevel@tonic-gate driverq = WR(q);
4147c478bd9Sstevel@tonic-gate while (SAMESTR(driverq))
4157c478bd9Sstevel@tonic-gate driverq = driverq->q_next;
4167c478bd9Sstevel@tonic-gate
4177c478bd9Sstevel@tonic-gate tp->tim_acceptor = (t_uscalar_t)RD(driverq);
4187c478bd9Sstevel@tonic-gate }
4197c478bd9Sstevel@tonic-gate #else
4207c478bd9Sstevel@tonic-gate tp->tim_acceptor = (t_uscalar_t)getminor(*devp);
4217c478bd9Sstevel@tonic-gate #endif /* _ILP32 */
4227c478bd9Sstevel@tonic-gate
4237c478bd9Sstevel@tonic-gate /*
4247c478bd9Sstevel@tonic-gate * Add this one to the list.
4257c478bd9Sstevel@tonic-gate */
4267c478bd9Sstevel@tonic-gate tim_addlink(tp);
4277c478bd9Sstevel@tonic-gate
4287c478bd9Sstevel@tonic-gate /*
4297c478bd9Sstevel@tonic-gate * Send M_SETOPTS to stream head to make sure M_PCPROTO messages
4307c478bd9Sstevel@tonic-gate * are not flushed. This prevents application deadlocks.
4317c478bd9Sstevel@tonic-gate */
4327c478bd9Sstevel@tonic-gate bp->b_datap->db_type = M_SETOPTS;
4337c478bd9Sstevel@tonic-gate bp->b_wptr += sizeof (struct stroptions);
4347c478bd9Sstevel@tonic-gate sop = (struct stroptions *)bp->b_rptr;
4357c478bd9Sstevel@tonic-gate sop->so_flags = SO_READOPT;
4367c478bd9Sstevel@tonic-gate sop->so_readopt = RFLUSHPCPROT;
4377c478bd9Sstevel@tonic-gate
4387c478bd9Sstevel@tonic-gate putnext(q, bp);
4397c478bd9Sstevel@tonic-gate
4407c478bd9Sstevel@tonic-gate return (0);
4417c478bd9Sstevel@tonic-gate }
4427c478bd9Sstevel@tonic-gate
4437c478bd9Sstevel@tonic-gate static void
tim_timer(void * arg)4447c478bd9Sstevel@tonic-gate tim_timer(void *arg)
4457c478bd9Sstevel@tonic-gate {
4467c478bd9Sstevel@tonic-gate queue_t *q = arg;
4477c478bd9Sstevel@tonic-gate struct tim_tim *tp = (struct tim_tim *)q->q_ptr;
4487c478bd9Sstevel@tonic-gate
4497c478bd9Sstevel@tonic-gate ASSERT(tp);
4507c478bd9Sstevel@tonic-gate
4517c478bd9Sstevel@tonic-gate if (q->q_flag & QREADR) {
4527c478bd9Sstevel@tonic-gate ASSERT(tp->tim_rtimoutid);
4537c478bd9Sstevel@tonic-gate tp->tim_rtimoutid = 0;
4547c478bd9Sstevel@tonic-gate } else {
4557c478bd9Sstevel@tonic-gate ASSERT(tp->tim_wtimoutid);
4567c478bd9Sstevel@tonic-gate tp->tim_wtimoutid = 0;
4577c478bd9Sstevel@tonic-gate }
4587c478bd9Sstevel@tonic-gate enableok(q);
4597c478bd9Sstevel@tonic-gate qenable(q);
4607c478bd9Sstevel@tonic-gate }
4617c478bd9Sstevel@tonic-gate
4627c478bd9Sstevel@tonic-gate static void
tim_buffer(void * arg)4637c478bd9Sstevel@tonic-gate tim_buffer(void *arg)
4647c478bd9Sstevel@tonic-gate {
4657c478bd9Sstevel@tonic-gate queue_t *q = arg;
4667c478bd9Sstevel@tonic-gate struct tim_tim *tp = (struct tim_tim *)q->q_ptr;
4677c478bd9Sstevel@tonic-gate
4687c478bd9Sstevel@tonic-gate ASSERT(tp);
4697c478bd9Sstevel@tonic-gate
4707c478bd9Sstevel@tonic-gate if (q->q_flag & QREADR) {
4717c478bd9Sstevel@tonic-gate ASSERT(tp->tim_rbufcid);
4727c478bd9Sstevel@tonic-gate tp->tim_rbufcid = 0;
4737c478bd9Sstevel@tonic-gate } else {
4747c478bd9Sstevel@tonic-gate ASSERT(tp->tim_wbufcid);
4757c478bd9Sstevel@tonic-gate tp->tim_wbufcid = 0;
4767c478bd9Sstevel@tonic-gate }
4777c478bd9Sstevel@tonic-gate enableok(q);
4787c478bd9Sstevel@tonic-gate qenable(q);
4797c478bd9Sstevel@tonic-gate }
4807c478bd9Sstevel@tonic-gate
4817c478bd9Sstevel@tonic-gate /*
4827c478bd9Sstevel@tonic-gate * timodclose - This routine gets called when the module gets popped
4837c478bd9Sstevel@tonic-gate * off of the stream.
4847c478bd9Sstevel@tonic-gate */
4857c478bd9Sstevel@tonic-gate /*ARGSUSED*/
4867c478bd9Sstevel@tonic-gate static int
timodclose(queue_t * q,int flag,cred_t * crp)4877c478bd9Sstevel@tonic-gate timodclose(
4887c478bd9Sstevel@tonic-gate queue_t *q,
4897c478bd9Sstevel@tonic-gate int flag,
4907c478bd9Sstevel@tonic-gate cred_t *crp)
4917c478bd9Sstevel@tonic-gate {
4927c478bd9Sstevel@tonic-gate struct tim_tim *tp;
4937c478bd9Sstevel@tonic-gate mblk_t *mp;
4947c478bd9Sstevel@tonic-gate mblk_t *nmp;
4957c478bd9Sstevel@tonic-gate
4967c478bd9Sstevel@tonic-gate ASSERT(q != NULL);
4977c478bd9Sstevel@tonic-gate
4987c478bd9Sstevel@tonic-gate tp = (struct tim_tim *)q->q_ptr;
4997c478bd9Sstevel@tonic-gate q->q_ptr = NULL;
5007c478bd9Sstevel@tonic-gate
5017c478bd9Sstevel@tonic-gate ASSERT(tp != NULL);
5027c478bd9Sstevel@tonic-gate
5037c478bd9Sstevel@tonic-gate tilogp("timodclose: Entered for tp %lx\n", (uintptr_t)tp);
5047c478bd9Sstevel@tonic-gate tilogp("timodclose: Entered for q %lx\n", (uintptr_t)q);
5057c478bd9Sstevel@tonic-gate
5067c478bd9Sstevel@tonic-gate qprocsoff(q);
5077c478bd9Sstevel@tonic-gate tim_dellink(tp);
5087c478bd9Sstevel@tonic-gate
5097c478bd9Sstevel@tonic-gate /*
5107c478bd9Sstevel@tonic-gate * Cancel any outstanding bufcall
5117c478bd9Sstevel@tonic-gate * or timeout requests.
5127c478bd9Sstevel@tonic-gate */
5137c478bd9Sstevel@tonic-gate if (tp->tim_wbufcid) {
5147c478bd9Sstevel@tonic-gate qunbufcall(q, tp->tim_wbufcid);
5157c478bd9Sstevel@tonic-gate tp->tim_wbufcid = 0;
5167c478bd9Sstevel@tonic-gate }
5177c478bd9Sstevel@tonic-gate if (tp->tim_rbufcid) {
5187c478bd9Sstevel@tonic-gate qunbufcall(q, tp->tim_rbufcid);
5197c478bd9Sstevel@tonic-gate tp->tim_rbufcid = 0;
5207c478bd9Sstevel@tonic-gate }
5217c478bd9Sstevel@tonic-gate if (tp->tim_wtimoutid) {
5227c478bd9Sstevel@tonic-gate (void) quntimeout(q, tp->tim_wtimoutid);
5237c478bd9Sstevel@tonic-gate tp->tim_wtimoutid = 0;
5247c478bd9Sstevel@tonic-gate }
5257c478bd9Sstevel@tonic-gate if (tp->tim_rtimoutid) {
5267c478bd9Sstevel@tonic-gate (void) quntimeout(q, tp->tim_rtimoutid);
5277c478bd9Sstevel@tonic-gate tp->tim_rtimoutid = 0;
5287c478bd9Sstevel@tonic-gate }
5297c478bd9Sstevel@tonic-gate
5307c478bd9Sstevel@tonic-gate if (tp->tim_tcap_timoutid != 0) {
5317c478bd9Sstevel@tonic-gate (void) quntimeout(q, tp->tim_tcap_timoutid);
5327c478bd9Sstevel@tonic-gate tp->tim_tcap_timoutid = 0;
5337c478bd9Sstevel@tonic-gate }
5347c478bd9Sstevel@tonic-gate
5357c478bd9Sstevel@tonic-gate if (tp->tim_iocsave != NULL)
5367c478bd9Sstevel@tonic-gate freemsg(tp->tim_iocsave);
5377c478bd9Sstevel@tonic-gate mp = tp->tim_consave;
5387c478bd9Sstevel@tonic-gate while (mp) {
5397c478bd9Sstevel@tonic-gate nmp = mp->b_next;
5407c478bd9Sstevel@tonic-gate mp->b_next = NULL;
5417c478bd9Sstevel@tonic-gate freemsg(mp);
5427c478bd9Sstevel@tonic-gate mp = nmp;
5437c478bd9Sstevel@tonic-gate }
5447c478bd9Sstevel@tonic-gate ASSERT(tp->tim_mymaxlen >= 0);
5457c478bd9Sstevel@tonic-gate if (tp->tim_mymaxlen != 0)
5467c478bd9Sstevel@tonic-gate kmem_free(tp->tim_myname, (size_t)tp->tim_mymaxlen);
5477c478bd9Sstevel@tonic-gate ASSERT(tp->tim_peermaxlen >= 0);
5487c478bd9Sstevel@tonic-gate if (tp->tim_peermaxlen != 0)
5497c478bd9Sstevel@tonic-gate kmem_free(tp->tim_peername, (size_t)tp->tim_peermaxlen);
5507c478bd9Sstevel@tonic-gate
5517c478bd9Sstevel@tonic-gate q->q_ptr = WR(q)->q_ptr = NULL;
5527c478bd9Sstevel@tonic-gate
5537c478bd9Sstevel@tonic-gate mutex_destroy(&tp->tim_mutex);
5547c478bd9Sstevel@tonic-gate
5557c478bd9Sstevel@tonic-gate if (tp->tim_peercred != NULL)
5567c478bd9Sstevel@tonic-gate crfree(tp->tim_peercred);
5577c478bd9Sstevel@tonic-gate
5587c478bd9Sstevel@tonic-gate kmem_free(tp, sizeof (struct tim_tim));
5597c478bd9Sstevel@tonic-gate
5607c478bd9Sstevel@tonic-gate return (0);
5617c478bd9Sstevel@tonic-gate }
5627c478bd9Sstevel@tonic-gate
5637c478bd9Sstevel@tonic-gate /*
5647c478bd9Sstevel@tonic-gate * timodrput - Module read put procedure. This is called from
5657c478bd9Sstevel@tonic-gate * the module, driver, or stream head upstream/downstream.
5667c478bd9Sstevel@tonic-gate * Handles M_FLUSH, M_DATA and some M_PROTO (T_DATA_IND,
5677c478bd9Sstevel@tonic-gate * and T_UNITDATA_IND) messages. All others are queued to
5687c478bd9Sstevel@tonic-gate * be handled by the service procedures.
5697c478bd9Sstevel@tonic-gate */
570*6caf82faSToomas Soome static int
timodrput(queue_t * q,mblk_t * mp)5717c478bd9Sstevel@tonic-gate timodrput(queue_t *q, mblk_t *mp)
5727c478bd9Sstevel@tonic-gate {
5737c478bd9Sstevel@tonic-gate union T_primitives *pptr;
5747c478bd9Sstevel@tonic-gate
5757c478bd9Sstevel@tonic-gate /*
5767c478bd9Sstevel@tonic-gate * During flow control and other instances when messages
5777c478bd9Sstevel@tonic-gate * are on queue, queue up a non high priority message
5787c478bd9Sstevel@tonic-gate */
5797c478bd9Sstevel@tonic-gate if (q->q_first != 0 && mp->b_datap->db_type < QPCTL) {
5807c478bd9Sstevel@tonic-gate (void) putq(q, mp);
581*6caf82faSToomas Soome return (0);
5827c478bd9Sstevel@tonic-gate }
5837c478bd9Sstevel@tonic-gate
5847c478bd9Sstevel@tonic-gate /*
5857c478bd9Sstevel@tonic-gate * Inline processing of data (to avoid additional procedure call).
5867c478bd9Sstevel@tonic-gate * Rest is handled in timodrproc.
5877c478bd9Sstevel@tonic-gate */
5887c478bd9Sstevel@tonic-gate
5897c478bd9Sstevel@tonic-gate switch (mp->b_datap->db_type) {
5907c478bd9Sstevel@tonic-gate case M_DATA:
5917c478bd9Sstevel@tonic-gate if (bcanputnext(q, mp->b_band))
5927c478bd9Sstevel@tonic-gate putnext(q, mp);
5937c478bd9Sstevel@tonic-gate else
5947c478bd9Sstevel@tonic-gate (void) putq(q, mp);
5957c478bd9Sstevel@tonic-gate break;
5967c478bd9Sstevel@tonic-gate case M_PROTO:
5977c478bd9Sstevel@tonic-gate case M_PCPROTO:
5987c478bd9Sstevel@tonic-gate if (MBLKL(mp) < sizeof (t_scalar_t)) {
5997c478bd9Sstevel@tonic-gate if (mp->b_datap->db_type == M_PCPROTO ||
6007c478bd9Sstevel@tonic-gate bcanputnext(q, mp->b_band)) {
6017c478bd9Sstevel@tonic-gate putnext(q, mp);
6027c478bd9Sstevel@tonic-gate } else {
6037c478bd9Sstevel@tonic-gate (void) putq(q, mp);
6047c478bd9Sstevel@tonic-gate }
6057c478bd9Sstevel@tonic-gate break;
6067c478bd9Sstevel@tonic-gate }
6077c478bd9Sstevel@tonic-gate pptr = (union T_primitives *)mp->b_rptr;
6087c478bd9Sstevel@tonic-gate switch (pptr->type) {
6097c478bd9Sstevel@tonic-gate case T_EXDATA_IND:
6107c478bd9Sstevel@tonic-gate case T_DATA_IND:
6117c478bd9Sstevel@tonic-gate case T_UNITDATA_IND:
6127c478bd9Sstevel@tonic-gate if (bcanputnext(q, mp->b_band))
6137c478bd9Sstevel@tonic-gate putnext(q, mp);
6147c478bd9Sstevel@tonic-gate else
6157c478bd9Sstevel@tonic-gate (void) putq(q, mp);
6167c478bd9Sstevel@tonic-gate break;
6177c478bd9Sstevel@tonic-gate default:
6187c478bd9Sstevel@tonic-gate (void) timodrproc(q, mp);
6197c478bd9Sstevel@tonic-gate break;
6207c478bd9Sstevel@tonic-gate }
6217c478bd9Sstevel@tonic-gate break;
6227c478bd9Sstevel@tonic-gate default:
6237c478bd9Sstevel@tonic-gate (void) timodrproc(q, mp);
6247c478bd9Sstevel@tonic-gate break;
6257c478bd9Sstevel@tonic-gate }
626*6caf82faSToomas Soome return (0);
6277c478bd9Sstevel@tonic-gate }
6287c478bd9Sstevel@tonic-gate
6297c478bd9Sstevel@tonic-gate /*
6307c478bd9Sstevel@tonic-gate * timodrsrv - Module read queue service procedure. This is called when
6317c478bd9Sstevel@tonic-gate * messages are placed on an empty queue, when high priority
6327c478bd9Sstevel@tonic-gate * messages are placed on the queue, and when flow control
6337c478bd9Sstevel@tonic-gate * restrictions subside. This code used to be included in a
6347c478bd9Sstevel@tonic-gate * put procedure, but it was moved to a service procedure
6357c478bd9Sstevel@tonic-gate * because several points were added where memory allocation
6367c478bd9Sstevel@tonic-gate * could fail, and there is no reasonable recovery mechanism
6377c478bd9Sstevel@tonic-gate * from the put procedure.
6387c478bd9Sstevel@tonic-gate */
6397c478bd9Sstevel@tonic-gate /*ARGSUSED*/
640*6caf82faSToomas Soome static int
timodrsrv(queue_t * q)6417c478bd9Sstevel@tonic-gate timodrsrv(queue_t *q)
6427c478bd9Sstevel@tonic-gate {
6437c478bd9Sstevel@tonic-gate mblk_t *mp;
6447c478bd9Sstevel@tonic-gate struct tim_tim *tp;
6457c478bd9Sstevel@tonic-gate
6467c478bd9Sstevel@tonic-gate ASSERT(q != NULL);
6477c478bd9Sstevel@tonic-gate
6487c478bd9Sstevel@tonic-gate tp = (struct tim_tim *)q->q_ptr;
6497c478bd9Sstevel@tonic-gate if (!tp)
650*6caf82faSToomas Soome return (0);
6517c478bd9Sstevel@tonic-gate
6527c478bd9Sstevel@tonic-gate while ((mp = getq(q)) != NULL) {
6537c478bd9Sstevel@tonic-gate if (timodrproc(q, mp)) {
6547c478bd9Sstevel@tonic-gate /*
6557c478bd9Sstevel@tonic-gate * timodrproc did a putbq - stop processing
6567c478bd9Sstevel@tonic-gate * messages.
6577c478bd9Sstevel@tonic-gate */
658*6caf82faSToomas Soome return (0);
6597c478bd9Sstevel@tonic-gate }
6607c478bd9Sstevel@tonic-gate }
661*6caf82faSToomas Soome return (0);
6627c478bd9Sstevel@tonic-gate }
6637c478bd9Sstevel@tonic-gate
6647c478bd9Sstevel@tonic-gate /*
6657c478bd9Sstevel@tonic-gate * Perform common processing when a T_CAPABILITY_ACK or T_INFO_ACK
6667c478bd9Sstevel@tonic-gate * arrive. Set the queue properties and adjust the tim_flags according
6677c478bd9Sstevel@tonic-gate * to the service type.
6687c478bd9Sstevel@tonic-gate */
6697c478bd9Sstevel@tonic-gate static void
timodprocessinfo(queue_t * q,struct tim_tim * tp,struct T_info_ack * tia)6707c478bd9Sstevel@tonic-gate timodprocessinfo(queue_t *q, struct tim_tim *tp, struct T_info_ack *tia)
6717c478bd9Sstevel@tonic-gate {
6727c478bd9Sstevel@tonic-gate TILOG("timodprocessinfo: strqset(%d)\n", tia->TIDU_size);
6737c478bd9Sstevel@tonic-gate (void) strqset(q, QMAXPSZ, 0, tia->TIDU_size);
6747c478bd9Sstevel@tonic-gate (void) strqset(OTHERQ(q), QMAXPSZ, 0, tia->TIDU_size);
6757c478bd9Sstevel@tonic-gate
6767c478bd9Sstevel@tonic-gate if ((tia->SERV_type == T_COTS) || (tia->SERV_type == T_COTS_ORD))
6777c478bd9Sstevel@tonic-gate tp->tim_flags = (tp->tim_flags & ~CLTS) | COTS;
6787c478bd9Sstevel@tonic-gate else if (tia->SERV_type == T_CLTS)
6797c478bd9Sstevel@tonic-gate tp->tim_flags = (tp->tim_flags & ~COTS) | CLTS;
6807c478bd9Sstevel@tonic-gate }
6817c478bd9Sstevel@tonic-gate
6827c478bd9Sstevel@tonic-gate static int
timodrproc(queue_t * q,mblk_t * mp)6837c478bd9Sstevel@tonic-gate timodrproc(queue_t *q, mblk_t *mp)
6847c478bd9Sstevel@tonic-gate {
685005d3febSMarek Pospisil uint32_t auditing = AU_AUDITING();
6867c478bd9Sstevel@tonic-gate union T_primitives *pptr;
6877c478bd9Sstevel@tonic-gate struct tim_tim *tp;
6887c478bd9Sstevel@tonic-gate struct iocblk *iocbp;
6897c478bd9Sstevel@tonic-gate mblk_t *nbp;
6907c478bd9Sstevel@tonic-gate size_t blen;
6917c478bd9Sstevel@tonic-gate
6927c478bd9Sstevel@tonic-gate tp = (struct tim_tim *)q->q_ptr;
6937c478bd9Sstevel@tonic-gate
6947c478bd9Sstevel@tonic-gate switch (mp->b_datap->db_type) {
6957c478bd9Sstevel@tonic-gate default:
6967c478bd9Sstevel@tonic-gate putnext(q, mp);
6977c478bd9Sstevel@tonic-gate break;
6987c478bd9Sstevel@tonic-gate
6997c478bd9Sstevel@tonic-gate case M_ERROR:
7007c478bd9Sstevel@tonic-gate TILOG("timodrproc: Got M_ERROR, flags = %x\n", tp->tim_flags);
7017c478bd9Sstevel@tonic-gate /*
7027c478bd9Sstevel@tonic-gate * There is no specified standard response for driver when it
7037c478bd9Sstevel@tonic-gate * receives unknown message type and M_ERROR is one
7047c478bd9Sstevel@tonic-gate * possibility. If we send T_CAPABILITY_REQ down and transport
7057c478bd9Sstevel@tonic-gate * provider responds with M_ERROR we assume that it doesn't
7067c478bd9Sstevel@tonic-gate * understand this message type. This assumption may be
7077c478bd9Sstevel@tonic-gate * sometimes incorrect (transport may reply with M_ERROR for
7087c478bd9Sstevel@tonic-gate * some other reason) but there is no way for us to distinguish
7097c478bd9Sstevel@tonic-gate * between different cases. In the worst case timod and everyone
7107c478bd9Sstevel@tonic-gate * else sharing global transport description with it may end up
7117c478bd9Sstevel@tonic-gate * emulating T_CAPABILITY_REQ.
7127c478bd9Sstevel@tonic-gate */
7137c478bd9Sstevel@tonic-gate
7147c478bd9Sstevel@tonic-gate /*
7157c478bd9Sstevel@tonic-gate * Check that we are waiting for T_CAPABILITY_ACK and
7167c478bd9Sstevel@tonic-gate * T_CAPABILITY_REQ is not implemented by transport or emulated
7177c478bd9Sstevel@tonic-gate * by timod.
7187c478bd9Sstevel@tonic-gate */
7197c478bd9Sstevel@tonic-gate if ((tp->tim_provinfo->tpi_capability == PI_DONTKNOW) &&
7207c478bd9Sstevel@tonic-gate ((tp->tim_flags & TI_CAP_RECVD) != 0)) {
7217c478bd9Sstevel@tonic-gate /*
7227c478bd9Sstevel@tonic-gate * Good chances that this transport doesn't provide
7237c478bd9Sstevel@tonic-gate * T_CAPABILITY_REQ. Mark this information permanently
7247c478bd9Sstevel@tonic-gate * for the module + transport combination.
7257c478bd9Sstevel@tonic-gate */
7267c478bd9Sstevel@tonic-gate PI_PROVLOCK(tp->tim_provinfo);
7277c478bd9Sstevel@tonic-gate if (tp->tim_provinfo->tpi_capability == PI_DONTKNOW)
7287c478bd9Sstevel@tonic-gate tp->tim_provinfo->tpi_capability = PI_NO;
7297c478bd9Sstevel@tonic-gate PI_PROVUNLOCK(tp->tim_provinfo);
7307c478bd9Sstevel@tonic-gate if (tp->tim_tcap_timoutid != 0) {
7317c478bd9Sstevel@tonic-gate (void) quntimeout(q, tp->tim_tcap_timoutid);
7327c478bd9Sstevel@tonic-gate tp->tim_tcap_timoutid = 0;
7337c478bd9Sstevel@tonic-gate }
7347c478bd9Sstevel@tonic-gate }
7357c478bd9Sstevel@tonic-gate putnext(q, mp);
7367c478bd9Sstevel@tonic-gate break;
7377c478bd9Sstevel@tonic-gate case M_DATA:
7387c478bd9Sstevel@tonic-gate if (!bcanputnext(q, mp->b_band)) {
7397c478bd9Sstevel@tonic-gate (void) putbq(q, mp);
7407c478bd9Sstevel@tonic-gate return (1);
7417c478bd9Sstevel@tonic-gate }
7427c478bd9Sstevel@tonic-gate putnext(q, mp);
7437c478bd9Sstevel@tonic-gate break;
7447c478bd9Sstevel@tonic-gate
7457c478bd9Sstevel@tonic-gate case M_PROTO:
7467c478bd9Sstevel@tonic-gate case M_PCPROTO:
7477c478bd9Sstevel@tonic-gate blen = MBLKL(mp);
7487c478bd9Sstevel@tonic-gate if (blen < sizeof (t_scalar_t)) {
7497c478bd9Sstevel@tonic-gate /*
7507c478bd9Sstevel@tonic-gate * Note: it's not actually possible to get
7517c478bd9Sstevel@tonic-gate * here with db_type M_PCPROTO, because
7527c478bd9Sstevel@tonic-gate * timodrput has already checked MBLKL, and
7537c478bd9Sstevel@tonic-gate * thus the assertion below. If the length
7547c478bd9Sstevel@tonic-gate * was too short, then the message would have
7557c478bd9Sstevel@tonic-gate * already been putnext'd, and would thus
7567c478bd9Sstevel@tonic-gate * never appear here. Just the same, the code
7577c478bd9Sstevel@tonic-gate * below handles the impossible case since
7587c478bd9Sstevel@tonic-gate * it's easy to do and saves future
7597c478bd9Sstevel@tonic-gate * maintainers from unfortunate accidents.
7607c478bd9Sstevel@tonic-gate */
7617c478bd9Sstevel@tonic-gate ASSERT(mp->b_datap->db_type == M_PROTO);
7627c478bd9Sstevel@tonic-gate if (mp->b_datap->db_type == M_PROTO &&
7637c478bd9Sstevel@tonic-gate !bcanputnext(q, mp->b_band)) {
7647c478bd9Sstevel@tonic-gate (void) putbq(q, mp);
7657c478bd9Sstevel@tonic-gate return (1);
7667c478bd9Sstevel@tonic-gate }
7677c478bd9Sstevel@tonic-gate putnext(q, mp);
7687c478bd9Sstevel@tonic-gate break;
7697c478bd9Sstevel@tonic-gate }
7707c478bd9Sstevel@tonic-gate
7717c478bd9Sstevel@tonic-gate pptr = (union T_primitives *)mp->b_rptr;
7727c478bd9Sstevel@tonic-gate switch (pptr->type) {
7737c478bd9Sstevel@tonic-gate default:
7747c478bd9Sstevel@tonic-gate
775005d3febSMarek Pospisil if (auditing)
7767c478bd9Sstevel@tonic-gate audit_sock(T_UNITDATA_IND, q, mp, TIMOD_ID);
7777c478bd9Sstevel@tonic-gate putnext(q, mp);
7787c478bd9Sstevel@tonic-gate break;
7797c478bd9Sstevel@tonic-gate
7807c478bd9Sstevel@tonic-gate case T_ERROR_ACK:
7817c478bd9Sstevel@tonic-gate /* Restore db_type - recover() might have changed it */
7827c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_PCPROTO;
7837c478bd9Sstevel@tonic-gate if (blen < sizeof (struct T_error_ack)) {
7847c478bd9Sstevel@tonic-gate putnext(q, mp);
7857c478bd9Sstevel@tonic-gate break;
7867c478bd9Sstevel@tonic-gate }
7877c478bd9Sstevel@tonic-gate
7887c478bd9Sstevel@tonic-gate tilog("timodrproc: Got T_ERROR_ACK, flags = %x\n",
7897c478bd9Sstevel@tonic-gate tp->tim_flags);
7907c478bd9Sstevel@tonic-gate
7917c478bd9Sstevel@tonic-gate if ((tp->tim_flags & WAIT_CONNRESACK) &&
7927c478bd9Sstevel@tonic-gate tp->tim_saved_prim == pptr->error_ack.ERROR_prim) {
7937c478bd9Sstevel@tonic-gate tp->tim_flags &=
7947c478bd9Sstevel@tonic-gate ~(WAIT_CONNRESACK | WAITIOCACK);
7957c478bd9Sstevel@tonic-gate freemsg(tp->tim_iocsave);
7967c478bd9Sstevel@tonic-gate tp->tim_iocsave = NULL;
7977c478bd9Sstevel@tonic-gate tp->tim_saved_prim = -1;
7987c478bd9Sstevel@tonic-gate putnext(q, mp);
7997c478bd9Sstevel@tonic-gate } else if (tp->tim_flags & WAITIOCACK) {
8007c478bd9Sstevel@tonic-gate tim_send_ioc_error_ack(q, tp, mp);
8017c478bd9Sstevel@tonic-gate } else {
8027c478bd9Sstevel@tonic-gate putnext(q, mp);
8037c478bd9Sstevel@tonic-gate }
8047c478bd9Sstevel@tonic-gate break;
8057c478bd9Sstevel@tonic-gate
8067c478bd9Sstevel@tonic-gate case T_OK_ACK:
8077c478bd9Sstevel@tonic-gate if (blen < sizeof (pptr->ok_ack)) {
8087c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_PCPROTO;
8097c478bd9Sstevel@tonic-gate putnext(q, mp);
8107c478bd9Sstevel@tonic-gate break;
8117c478bd9Sstevel@tonic-gate }
8127c478bd9Sstevel@tonic-gate
8137c478bd9Sstevel@tonic-gate tilog("timodrproc: Got T_OK_ACK\n", 0);
8147c478bd9Sstevel@tonic-gate
8157c478bd9Sstevel@tonic-gate if (pptr->ok_ack.CORRECT_prim == T_UNBIND_REQ)
8167c478bd9Sstevel@tonic-gate tp->tim_mylen = 0;
8177c478bd9Sstevel@tonic-gate
8187c478bd9Sstevel@tonic-gate if ((tp->tim_flags & WAIT_CONNRESACK) &&
8197c478bd9Sstevel@tonic-gate tp->tim_saved_prim == pptr->ok_ack.CORRECT_prim) {
8207c478bd9Sstevel@tonic-gate struct T_conn_res *resp;
8217c478bd9Sstevel@tonic-gate struct T_conn_ind *indp;
8227c478bd9Sstevel@tonic-gate struct tim_tim *ntp;
8237c478bd9Sstevel@tonic-gate caddr_t ptr;
8247c478bd9Sstevel@tonic-gate
8257c478bd9Sstevel@tonic-gate rw_enter(&tim_list_rwlock, RW_READER);
8267c478bd9Sstevel@tonic-gate resp = (struct T_conn_res *)
8277c478bd9Sstevel@tonic-gate tp->tim_iocsave->b_rptr;
8287c478bd9Sstevel@tonic-gate ntp = tim_findlink(resp->ACCEPTOR_id);
8297c478bd9Sstevel@tonic-gate if (ntp == NULL)
8307c478bd9Sstevel@tonic-gate goto cresackout;
8317c478bd9Sstevel@tonic-gate
8327c478bd9Sstevel@tonic-gate mutex_enter(&ntp->tim_mutex);
8337c478bd9Sstevel@tonic-gate if (ntp->tim_peercred != NULL)
8347c478bd9Sstevel@tonic-gate crfree(ntp->tim_peercred);
8357c478bd9Sstevel@tonic-gate ntp->tim_peercred =
836de8c4a14SErik Nordmark msg_getcred(tp->tim_iocsave->b_cont,
837de8c4a14SErik Nordmark &ntp->tim_cpid);
8387c478bd9Sstevel@tonic-gate if (ntp->tim_peercred != NULL)
8397c478bd9Sstevel@tonic-gate crhold(ntp->tim_peercred);
8407c478bd9Sstevel@tonic-gate
8417c478bd9Sstevel@tonic-gate if (!(ntp->tim_flags & DO_PEERNAME)) {
8427c478bd9Sstevel@tonic-gate mutex_exit(&ntp->tim_mutex);
8437c478bd9Sstevel@tonic-gate goto cresackout;
8447c478bd9Sstevel@tonic-gate }
8457c478bd9Sstevel@tonic-gate
8467c478bd9Sstevel@tonic-gate indp = (struct T_conn_ind *)
8477c478bd9Sstevel@tonic-gate tp->tim_iocsave->b_cont->b_rptr;
8487c478bd9Sstevel@tonic-gate /* true as message is put on list */
8497c478bd9Sstevel@tonic-gate ASSERT(indp->SRC_length >= 0);
8507c478bd9Sstevel@tonic-gate
8517c478bd9Sstevel@tonic-gate if (indp->SRC_length > ntp->tim_peermaxlen) {
8527c478bd9Sstevel@tonic-gate ptr = kmem_alloc(indp->SRC_length,
8537c478bd9Sstevel@tonic-gate KM_NOSLEEP);
8547c478bd9Sstevel@tonic-gate if (ptr == NULL) {
8557c478bd9Sstevel@tonic-gate mutex_exit(&ntp->tim_mutex);
8567c478bd9Sstevel@tonic-gate rw_exit(&tim_list_rwlock);
8577c478bd9Sstevel@tonic-gate tilog("timodwproc: kmem_alloc "
8587c478bd9Sstevel@tonic-gate "failed, attempting "
8597c478bd9Sstevel@tonic-gate "recovery\n", 0);
8607c478bd9Sstevel@tonic-gate tim_recover(q, mp,
8617c478bd9Sstevel@tonic-gate indp->SRC_length);
8627c478bd9Sstevel@tonic-gate return (1);
8637c478bd9Sstevel@tonic-gate }
8647c478bd9Sstevel@tonic-gate if (ntp->tim_peermaxlen > 0)
8657c478bd9Sstevel@tonic-gate kmem_free(ntp->tim_peername,
8667c478bd9Sstevel@tonic-gate ntp->tim_peermaxlen);
8677c478bd9Sstevel@tonic-gate ntp->tim_peername = ptr;
8687c478bd9Sstevel@tonic-gate ntp->tim_peermaxlen = indp->SRC_length;
8697c478bd9Sstevel@tonic-gate }
8707c478bd9Sstevel@tonic-gate ntp->tim_peerlen = indp->SRC_length;
8717c478bd9Sstevel@tonic-gate ptr = (caddr_t)indp + indp->SRC_offset;
8727c478bd9Sstevel@tonic-gate bcopy(ptr, ntp->tim_peername, ntp->tim_peerlen);
8737c478bd9Sstevel@tonic-gate
8747c478bd9Sstevel@tonic-gate mutex_exit(&ntp->tim_mutex);
8757c478bd9Sstevel@tonic-gate
8767c478bd9Sstevel@tonic-gate cresackout:
8777c478bd9Sstevel@tonic-gate rw_exit(&tim_list_rwlock);
8787c478bd9Sstevel@tonic-gate tp->tim_flags &=
8797c478bd9Sstevel@tonic-gate ~(WAIT_CONNRESACK | WAITIOCACK);
8807c478bd9Sstevel@tonic-gate freemsg(tp->tim_iocsave);
8817c478bd9Sstevel@tonic-gate tp->tim_iocsave = NULL;
8827c478bd9Sstevel@tonic-gate tp->tim_saved_prim = -1;
8837c478bd9Sstevel@tonic-gate }
8847c478bd9Sstevel@tonic-gate
8857c478bd9Sstevel@tonic-gate tim_send_reply(q, mp, tp, pptr->ok_ack.CORRECT_prim);
8867c478bd9Sstevel@tonic-gate break;
8877c478bd9Sstevel@tonic-gate
8887c478bd9Sstevel@tonic-gate case T_BIND_ACK: {
8897c478bd9Sstevel@tonic-gate struct T_bind_ack *ackp =
8907c478bd9Sstevel@tonic-gate (struct T_bind_ack *)mp->b_rptr;
8917c478bd9Sstevel@tonic-gate
8927c478bd9Sstevel@tonic-gate /* Restore db_type - recover() might have changed it */
8937c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_PCPROTO;
8947c478bd9Sstevel@tonic-gate if (blen < sizeof (*ackp)) {
8957c478bd9Sstevel@tonic-gate putnext(q, mp);
8967c478bd9Sstevel@tonic-gate break;
8977c478bd9Sstevel@tonic-gate }
8987c478bd9Sstevel@tonic-gate
8997c478bd9Sstevel@tonic-gate /* save negotiated backlog */
9007c478bd9Sstevel@tonic-gate tp->tim_backlog = ackp->CONIND_number;
9017c478bd9Sstevel@tonic-gate
9027c478bd9Sstevel@tonic-gate if (((tp->tim_flags & WAITIOCACK) == 0) ||
9037c478bd9Sstevel@tonic-gate ((tp->tim_saved_prim != O_T_BIND_REQ) &&
9047c478bd9Sstevel@tonic-gate (tp->tim_saved_prim != T_BIND_REQ))) {
9057c478bd9Sstevel@tonic-gate putnext(q, mp);
9067c478bd9Sstevel@tonic-gate break;
9077c478bd9Sstevel@tonic-gate }
9087c478bd9Sstevel@tonic-gate ASSERT(tp->tim_iocsave != NULL);
9097c478bd9Sstevel@tonic-gate
9107c478bd9Sstevel@tonic-gate if (tp->tim_flags & DO_MYNAME) {
9117c478bd9Sstevel@tonic-gate caddr_t p;
9127c478bd9Sstevel@tonic-gate
9137c478bd9Sstevel@tonic-gate if (ackp->ADDR_length < 0 ||
9147c478bd9Sstevel@tonic-gate mp->b_rptr + ackp->ADDR_offset +
9157c478bd9Sstevel@tonic-gate ackp->ADDR_length > mp->b_wptr) {
9167c478bd9Sstevel@tonic-gate putnext(q, mp);
9177c478bd9Sstevel@tonic-gate break;
9187c478bd9Sstevel@tonic-gate }
9197c478bd9Sstevel@tonic-gate if (ackp->ADDR_length > tp->tim_mymaxlen) {
9207c478bd9Sstevel@tonic-gate p = kmem_alloc(ackp->ADDR_length,
9217c478bd9Sstevel@tonic-gate KM_NOSLEEP);
9227c478bd9Sstevel@tonic-gate if (p == NULL) {
9237c478bd9Sstevel@tonic-gate tilog("timodrproc: kmem_alloc "
9247c478bd9Sstevel@tonic-gate "failed attempt recovery",
9257c478bd9Sstevel@tonic-gate 0);
9267c478bd9Sstevel@tonic-gate
9277c478bd9Sstevel@tonic-gate tim_recover(q, mp,
9287c478bd9Sstevel@tonic-gate ackp->ADDR_length);
9297c478bd9Sstevel@tonic-gate return (1);
9307c478bd9Sstevel@tonic-gate }
9317c478bd9Sstevel@tonic-gate ASSERT(tp->tim_mymaxlen >= 0);
9325300f7b3SToomas Soome if (tp->tim_mymaxlen != 0) {
9337c478bd9Sstevel@tonic-gate kmem_free(tp->tim_myname,
9347c478bd9Sstevel@tonic-gate tp->tim_mymaxlen);
9357c478bd9Sstevel@tonic-gate }
9367c478bd9Sstevel@tonic-gate tp->tim_myname = p;
9377c478bd9Sstevel@tonic-gate tp->tim_mymaxlen = ackp->ADDR_length;
9387c478bd9Sstevel@tonic-gate }
9397c478bd9Sstevel@tonic-gate tp->tim_mylen = ackp->ADDR_length;
9407c478bd9Sstevel@tonic-gate bcopy(mp->b_rptr + ackp->ADDR_offset,
9417c478bd9Sstevel@tonic-gate tp->tim_myname, tp->tim_mylen);
9427c478bd9Sstevel@tonic-gate }
9437c478bd9Sstevel@tonic-gate tim_ioctl_send_reply(q, tp->tim_iocsave, mp);
9447c478bd9Sstevel@tonic-gate tp->tim_iocsave = NULL;
9457c478bd9Sstevel@tonic-gate tp->tim_saved_prim = -1;
9467c478bd9Sstevel@tonic-gate tp->tim_flags &= ~(WAITIOCACK | WAIT_IOCINFOACK |
9477c478bd9Sstevel@tonic-gate TI_CAP_RECVD | CAP_WANTS_INFO);
9487c478bd9Sstevel@tonic-gate break;
9497c478bd9Sstevel@tonic-gate }
9507c478bd9Sstevel@tonic-gate
9517c478bd9Sstevel@tonic-gate case T_OPTMGMT_ACK:
9527c478bd9Sstevel@tonic-gate
9537c478bd9Sstevel@tonic-gate tilog("timodrproc: Got T_OPTMGMT_ACK\n", 0);
9547c478bd9Sstevel@tonic-gate
9557c478bd9Sstevel@tonic-gate /* Restore db_type - recover() might have change it */
9567c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_PCPROTO;
9577c478bd9Sstevel@tonic-gate
9587c478bd9Sstevel@tonic-gate if (((tp->tim_flags & WAITIOCACK) == 0) ||
9597c478bd9Sstevel@tonic-gate ((tp->tim_saved_prim != T_SVR4_OPTMGMT_REQ) &&
9607c478bd9Sstevel@tonic-gate (tp->tim_saved_prim != T_OPTMGMT_REQ))) {
9617c478bd9Sstevel@tonic-gate putnext(q, mp);
9627c478bd9Sstevel@tonic-gate } else {
9637c478bd9Sstevel@tonic-gate ASSERT(tp->tim_iocsave != NULL);
9647c478bd9Sstevel@tonic-gate tim_ioctl_send_reply(q, tp->tim_iocsave, mp);
9657c478bd9Sstevel@tonic-gate tp->tim_iocsave = NULL;
9667c478bd9Sstevel@tonic-gate tp->tim_saved_prim = -1;
967005d3febSMarek Pospisil tp->tim_flags &= ~(WAITIOCACK |
968005d3febSMarek Pospisil WAIT_IOCINFOACK | TI_CAP_RECVD |
969005d3febSMarek Pospisil CAP_WANTS_INFO);
9707c478bd9Sstevel@tonic-gate }
9717c478bd9Sstevel@tonic-gate break;
9727c478bd9Sstevel@tonic-gate
9737c478bd9Sstevel@tonic-gate case T_INFO_ACK: {
9747c478bd9Sstevel@tonic-gate struct T_info_ack *tia = (struct T_info_ack *)pptr;
9757c478bd9Sstevel@tonic-gate
9767c478bd9Sstevel@tonic-gate /* Restore db_type - recover() might have changed it */
9777c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_PCPROTO;
9787c478bd9Sstevel@tonic-gate
9797c478bd9Sstevel@tonic-gate if (blen < sizeof (*tia)) {
9807c478bd9Sstevel@tonic-gate putnext(q, mp);
9817c478bd9Sstevel@tonic-gate break;
9827c478bd9Sstevel@tonic-gate }
9837c478bd9Sstevel@tonic-gate
9847c478bd9Sstevel@tonic-gate tilog("timodrproc: Got T_INFO_ACK, flags = %x\n",
9857c478bd9Sstevel@tonic-gate tp->tim_flags);
9867c478bd9Sstevel@tonic-gate
9877c478bd9Sstevel@tonic-gate timodprocessinfo(q, tp, tia);
9887c478bd9Sstevel@tonic-gate
9897c478bd9Sstevel@tonic-gate TILOG("timodrproc: flags = %x\n", tp->tim_flags);
9907c478bd9Sstevel@tonic-gate if ((tp->tim_flags & WAITIOCACK) != 0) {
9917c478bd9Sstevel@tonic-gate size_t expected_ack_size;
9927c478bd9Sstevel@tonic-gate ssize_t deficit;
9937c478bd9Sstevel@tonic-gate int ioc_cmd;
9947c478bd9Sstevel@tonic-gate struct T_capability_ack *tcap;
9957c478bd9Sstevel@tonic-gate
9967c478bd9Sstevel@tonic-gate /*
9977c478bd9Sstevel@tonic-gate * The only case when T_INFO_ACK may be received back
9987c478bd9Sstevel@tonic-gate * when we are waiting for ioctl to complete is when
9997c478bd9Sstevel@tonic-gate * this ioctl sent T_INFO_REQ down.
10007c478bd9Sstevel@tonic-gate */
10017c478bd9Sstevel@tonic-gate if (!(tp->tim_flags & WAIT_IOCINFOACK)) {
10027c478bd9Sstevel@tonic-gate putnext(q, mp);
10037c478bd9Sstevel@tonic-gate break;
10047c478bd9Sstevel@tonic-gate }
10057c478bd9Sstevel@tonic-gate ASSERT(tp->tim_iocsave != NULL);
10067c478bd9Sstevel@tonic-gate
10077c478bd9Sstevel@tonic-gate iocbp = (struct iocblk *)tp->tim_iocsave->b_rptr;
10087c478bd9Sstevel@tonic-gate ioc_cmd = iocbp->ioc_cmd;
10097c478bd9Sstevel@tonic-gate
10107c478bd9Sstevel@tonic-gate /*
10117c478bd9Sstevel@tonic-gate * Was it sent from TI_CAPABILITY emulation?
10127c478bd9Sstevel@tonic-gate */
10137c478bd9Sstevel@tonic-gate if (ioc_cmd == TI_CAPABILITY) {
10147c478bd9Sstevel@tonic-gate struct T_info_ack saved_info;
10157c478bd9Sstevel@tonic-gate
10167c478bd9Sstevel@tonic-gate /*
10177c478bd9Sstevel@tonic-gate * Perform sanity checks. The only case when we
10187c478bd9Sstevel@tonic-gate * send T_INFO_REQ from TI_CAPABILITY is when
10197c478bd9Sstevel@tonic-gate * timod emulates T_CAPABILITY_REQ and CAP_bits1
10207c478bd9Sstevel@tonic-gate * has TC1_INFO set.
10217c478bd9Sstevel@tonic-gate */
10227c478bd9Sstevel@tonic-gate if ((tp->tim_flags &
10237c478bd9Sstevel@tonic-gate (TI_CAP_RECVD | CAP_WANTS_INFO)) !=
10247c478bd9Sstevel@tonic-gate (TI_CAP_RECVD | CAP_WANTS_INFO)) {
10257c478bd9Sstevel@tonic-gate putnext(q, mp);
10267c478bd9Sstevel@tonic-gate break;
10277c478bd9Sstevel@tonic-gate }
10287c478bd9Sstevel@tonic-gate
10297c478bd9Sstevel@tonic-gate TILOG("timodrproc: emulating TI_CAPABILITY/"
10307c478bd9Sstevel@tonic-gate "info\n", 0);
10317c478bd9Sstevel@tonic-gate
10327c478bd9Sstevel@tonic-gate /* Save info & reuse mp for T_CAPABILITY_ACK */
10337c478bd9Sstevel@tonic-gate saved_info = *tia;
10347c478bd9Sstevel@tonic-gate
10357c478bd9Sstevel@tonic-gate mp = tpi_ack_alloc(mp,
10367c478bd9Sstevel@tonic-gate sizeof (struct T_capability_ack),
10377c478bd9Sstevel@tonic-gate M_PCPROTO, T_CAPABILITY_ACK);
10387c478bd9Sstevel@tonic-gate
10397c478bd9Sstevel@tonic-gate if (mp == NULL) {
10407c478bd9Sstevel@tonic-gate tilog("timodrproc: realloc failed, "
10417c478bd9Sstevel@tonic-gate "no recovery attempted\n", 0);
10427c478bd9Sstevel@tonic-gate return (1);
10437c478bd9Sstevel@tonic-gate }
10447c478bd9Sstevel@tonic-gate
10457c478bd9Sstevel@tonic-gate /*
10467c478bd9Sstevel@tonic-gate * Copy T_INFO information into T_CAPABILITY_ACK
10477c478bd9Sstevel@tonic-gate */
10487c478bd9Sstevel@tonic-gate tcap = (struct T_capability_ack *)mp->b_rptr;
10497c478bd9Sstevel@tonic-gate tcap->CAP_bits1 = TC1_INFO;
10507c478bd9Sstevel@tonic-gate tcap->INFO_ack = saved_info;
10517c478bd9Sstevel@tonic-gate tp->tim_flags &= ~(WAITIOCACK |
10527c478bd9Sstevel@tonic-gate WAIT_IOCINFOACK | TI_CAP_RECVD |
10537c478bd9Sstevel@tonic-gate CAP_WANTS_INFO);
10547c478bd9Sstevel@tonic-gate tim_ioctl_send_reply(q, tp->tim_iocsave, mp);
10557c478bd9Sstevel@tonic-gate tp->tim_iocsave = NULL;
10567c478bd9Sstevel@tonic-gate tp->tim_saved_prim = -1;
10577c478bd9Sstevel@tonic-gate break;
10587c478bd9Sstevel@tonic-gate }
10597c478bd9Sstevel@tonic-gate
10607c478bd9Sstevel@tonic-gate /*
10617c478bd9Sstevel@tonic-gate * The code for TI_SYNC/TI_GETINFO is left here only for
10627c478bd9Sstevel@tonic-gate * backward compatibility with staticaly linked old
10637c478bd9Sstevel@tonic-gate * applications. New TLI/XTI code should use
10647c478bd9Sstevel@tonic-gate * TI_CAPABILITY for getting transport info and should
10657c478bd9Sstevel@tonic-gate * not use TI_GETINFO/TI_SYNC for this purpose.
10667c478bd9Sstevel@tonic-gate */
10677c478bd9Sstevel@tonic-gate
10687c478bd9Sstevel@tonic-gate /*
10697c478bd9Sstevel@tonic-gate * make sure the message sent back is the size of
10707c478bd9Sstevel@tonic-gate * the "expected ack"
10717c478bd9Sstevel@tonic-gate * For TI_GETINFO, expected ack size is
10727c478bd9Sstevel@tonic-gate * sizeof (T_info_ack)
10737c478bd9Sstevel@tonic-gate * For TI_SYNC, expected ack size is
10747c478bd9Sstevel@tonic-gate * sizeof (struct ti_sync_ack);
10757c478bd9Sstevel@tonic-gate */
10767c478bd9Sstevel@tonic-gate if (ioc_cmd != TI_GETINFO && ioc_cmd != TI_SYNC) {
10777c478bd9Sstevel@tonic-gate putnext(q, mp);
10787c478bd9Sstevel@tonic-gate break;
10797c478bd9Sstevel@tonic-gate }
10807c478bd9Sstevel@tonic-gate
10817c478bd9Sstevel@tonic-gate expected_ack_size =
10827c478bd9Sstevel@tonic-gate sizeof (struct T_info_ack); /* TI_GETINFO */
10837c478bd9Sstevel@tonic-gate if (iocbp->ioc_cmd == TI_SYNC) {
10847c478bd9Sstevel@tonic-gate expected_ack_size = 2 * sizeof (uint32_t) +
10857c478bd9Sstevel@tonic-gate sizeof (struct ti_sync_ack);
10867c478bd9Sstevel@tonic-gate }
10877c478bd9Sstevel@tonic-gate deficit = expected_ack_size - blen;
10887c478bd9Sstevel@tonic-gate
10897c478bd9Sstevel@tonic-gate if (deficit != 0) {
10907c478bd9Sstevel@tonic-gate if (mp->b_datap->db_lim - mp->b_wptr <
10917c478bd9Sstevel@tonic-gate deficit) {
10927c478bd9Sstevel@tonic-gate mblk_t *tmp = allocb(expected_ack_size,
10937c478bd9Sstevel@tonic-gate BPRI_HI);
10947c478bd9Sstevel@tonic-gate if (tmp == NULL) {
10950ef0bcfbSyz147064 ASSERT(MBLKSIZE(mp) >=
10967c478bd9Sstevel@tonic-gate sizeof (struct T_error_ack));
10977c478bd9Sstevel@tonic-gate
10987c478bd9Sstevel@tonic-gate tilog("timodrproc: allocb failed no "
10997c478bd9Sstevel@tonic-gate "recovery attempt\n", 0);
11007c478bd9Sstevel@tonic-gate
11017c478bd9Sstevel@tonic-gate mp->b_rptr = mp->b_datap->db_base;
11027c478bd9Sstevel@tonic-gate pptr = (union T_primitives *)
11037c478bd9Sstevel@tonic-gate mp->b_rptr;
11040ef0bcfbSyz147064 pptr->error_ack.ERROR_prim = T_INFO_REQ;
11057c478bd9Sstevel@tonic-gate pptr->error_ack.TLI_error = TSYSERR;
11067c478bd9Sstevel@tonic-gate pptr->error_ack.UNIX_error = EAGAIN;
11077c478bd9Sstevel@tonic-gate pptr->error_ack.PRIM_type = T_ERROR_ACK;
11087c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_PCPROTO;
11097c478bd9Sstevel@tonic-gate tim_send_ioc_error_ack(q, tp, mp);
11107c478bd9Sstevel@tonic-gate break;
11117c478bd9Sstevel@tonic-gate } else {
11127c478bd9Sstevel@tonic-gate bcopy(mp->b_rptr, tmp->b_rptr, blen);
11137c478bd9Sstevel@tonic-gate tmp->b_wptr += blen;
11147c478bd9Sstevel@tonic-gate pptr = (union T_primitives *)
11157c478bd9Sstevel@tonic-gate tmp->b_rptr;
11167c478bd9Sstevel@tonic-gate freemsg(mp);
11177c478bd9Sstevel@tonic-gate mp = tmp;
11187c478bd9Sstevel@tonic-gate }
11197c478bd9Sstevel@tonic-gate }
11207c478bd9Sstevel@tonic-gate }
11217c478bd9Sstevel@tonic-gate /*
11227c478bd9Sstevel@tonic-gate * We now have "mp" which has enough space for an
11237c478bd9Sstevel@tonic-gate * appropriate ack and contains struct T_info_ack
11247c478bd9Sstevel@tonic-gate * that the transport provider returned. We now
11257c478bd9Sstevel@tonic-gate * stuff it with more stuff to fullfill
11267c478bd9Sstevel@tonic-gate * TI_SYNC ioctl needs, as necessary
11277c478bd9Sstevel@tonic-gate */
11287c478bd9Sstevel@tonic-gate if (iocbp->ioc_cmd == TI_SYNC) {
11297c478bd9Sstevel@tonic-gate /*
11307c478bd9Sstevel@tonic-gate * Assumes struct T_info_ack is first embedded
11317c478bd9Sstevel@tonic-gate * type in struct ti_sync_ack so it is
11327c478bd9Sstevel@tonic-gate * automatically there.
11337c478bd9Sstevel@tonic-gate */
11347c478bd9Sstevel@tonic-gate struct ti_sync_ack *tsap =
11357c478bd9Sstevel@tonic-gate (struct ti_sync_ack *)mp->b_rptr;
11367c478bd9Sstevel@tonic-gate
11377c478bd9Sstevel@tonic-gate /*
11387c478bd9Sstevel@tonic-gate * tsap->tsa_qlen needs to be set only if
11397c478bd9Sstevel@tonic-gate * TSRF_QLEN_REQ flag is set, but for
11407c478bd9Sstevel@tonic-gate * compatibility with statically linked
11417c478bd9Sstevel@tonic-gate * applications it is set here regardless of the
11427c478bd9Sstevel@tonic-gate * flag since old XTI library expected it to be
11437c478bd9Sstevel@tonic-gate * set.
11447c478bd9Sstevel@tonic-gate */
11457c478bd9Sstevel@tonic-gate tsap->tsa_qlen = tp->tim_backlog;
11467c478bd9Sstevel@tonic-gate tsap->tsa_flags = 0x0; /* intialize clear */
11477c478bd9Sstevel@tonic-gate if (tp->tim_flags & PEEK_RDQ_EXPIND) {
11487c478bd9Sstevel@tonic-gate /*
11497c478bd9Sstevel@tonic-gate * Request to peek for EXPIND in
11507c478bd9Sstevel@tonic-gate * rcvbuf.
11517c478bd9Sstevel@tonic-gate */
11527c478bd9Sstevel@tonic-gate if (ti_expind_on_rdqueues(q)) {
11537c478bd9Sstevel@tonic-gate /*
11547c478bd9Sstevel@tonic-gate * Expedited data is
11557c478bd9Sstevel@tonic-gate * queued on the stream
11567c478bd9Sstevel@tonic-gate * read side
11577c478bd9Sstevel@tonic-gate */
11587c478bd9Sstevel@tonic-gate tsap->tsa_flags |=
11597c478bd9Sstevel@tonic-gate TSAF_EXP_QUEUED;
11607c478bd9Sstevel@tonic-gate }
11617c478bd9Sstevel@tonic-gate tp->tim_flags &=
11627c478bd9Sstevel@tonic-gate ~PEEK_RDQ_EXPIND;
11637c478bd9Sstevel@tonic-gate }
11647c478bd9Sstevel@tonic-gate mp->b_wptr += 2*sizeof (uint32_t);
11657c478bd9Sstevel@tonic-gate }
11667c478bd9Sstevel@tonic-gate tim_ioctl_send_reply(q, tp->tim_iocsave, mp);
11677c478bd9Sstevel@tonic-gate tp->tim_iocsave = NULL;
11687c478bd9Sstevel@tonic-gate tp->tim_saved_prim = -1;
11697c478bd9Sstevel@tonic-gate tp->tim_flags &= ~(WAITIOCACK | WAIT_IOCINFOACK |
11707c478bd9Sstevel@tonic-gate TI_CAP_RECVD | CAP_WANTS_INFO);
11717c478bd9Sstevel@tonic-gate break;
11727c478bd9Sstevel@tonic-gate }
11737c478bd9Sstevel@tonic-gate }
11747c478bd9Sstevel@tonic-gate
11757c478bd9Sstevel@tonic-gate putnext(q, mp);
11767c478bd9Sstevel@tonic-gate break;
11777c478bd9Sstevel@tonic-gate
11787c478bd9Sstevel@tonic-gate case T_ADDR_ACK:
11797c478bd9Sstevel@tonic-gate tilog("timodrproc: Got T_ADDR_ACK\n", 0);
11807c478bd9Sstevel@tonic-gate tim_send_reply(q, mp, tp, T_ADDR_REQ);
11817c478bd9Sstevel@tonic-gate break;
11827c478bd9Sstevel@tonic-gate
11837c478bd9Sstevel@tonic-gate case T_CONN_IND: {
11847c478bd9Sstevel@tonic-gate struct T_conn_ind *tcip =
11857c478bd9Sstevel@tonic-gate (struct T_conn_ind *)mp->b_rptr;
11867c478bd9Sstevel@tonic-gate
11877c478bd9Sstevel@tonic-gate tilog("timodrproc: Got T_CONN_IND\n", 0);
11887c478bd9Sstevel@tonic-gate
11897c478bd9Sstevel@tonic-gate if (blen >= sizeof (*tcip) &&
11907c478bd9Sstevel@tonic-gate MBLKIN(mp, tcip->SRC_offset, tcip->SRC_length)) {
11917c478bd9Sstevel@tonic-gate if (((nbp = dupmsg(mp)) != NULL) ||
11927c478bd9Sstevel@tonic-gate ((nbp = copymsg(mp)) != NULL)) {
11937c478bd9Sstevel@tonic-gate nbp->b_next = tp->tim_consave;
11947c478bd9Sstevel@tonic-gate tp->tim_consave = nbp;
11957c478bd9Sstevel@tonic-gate } else {
11967c478bd9Sstevel@tonic-gate tim_recover(q, mp,
11977c478bd9Sstevel@tonic-gate (t_scalar_t)sizeof (mblk_t));
11987c478bd9Sstevel@tonic-gate return (1);
11997c478bd9Sstevel@tonic-gate }
12007c478bd9Sstevel@tonic-gate }
1201005d3febSMarek Pospisil if (auditing)
12027c478bd9Sstevel@tonic-gate audit_sock(T_CONN_IND, q, mp, TIMOD_ID);
12037c478bd9Sstevel@tonic-gate putnext(q, mp);
12047c478bd9Sstevel@tonic-gate break;
12057c478bd9Sstevel@tonic-gate }
12067c478bd9Sstevel@tonic-gate
12077c478bd9Sstevel@tonic-gate case T_CONN_CON:
12087c478bd9Sstevel@tonic-gate mutex_enter(&tp->tim_mutex);
12097c478bd9Sstevel@tonic-gate if (tp->tim_peercred != NULL)
12107c478bd9Sstevel@tonic-gate crfree(tp->tim_peercred);
1211de8c4a14SErik Nordmark tp->tim_peercred = msg_getcred(mp, &tp->tim_cpid);
12127c478bd9Sstevel@tonic-gate if (tp->tim_peercred != NULL)
12137c478bd9Sstevel@tonic-gate crhold(tp->tim_peercred);
12147c478bd9Sstevel@tonic-gate mutex_exit(&tp->tim_mutex);
12157c478bd9Sstevel@tonic-gate
12167c478bd9Sstevel@tonic-gate tilog("timodrproc: Got T_CONN_CON\n", 0);
12177c478bd9Sstevel@tonic-gate
12187c478bd9Sstevel@tonic-gate tp->tim_flags &= ~CONNWAIT;
12197c478bd9Sstevel@tonic-gate putnext(q, mp);
12207c478bd9Sstevel@tonic-gate break;
12217c478bd9Sstevel@tonic-gate
12227c478bd9Sstevel@tonic-gate case T_DISCON_IND: {
12237c478bd9Sstevel@tonic-gate struct T_discon_ind *disp;
12247c478bd9Sstevel@tonic-gate struct T_conn_ind *conp;
12257c478bd9Sstevel@tonic-gate mblk_t *pbp = NULL;
12267c478bd9Sstevel@tonic-gate
12277c478bd9Sstevel@tonic-gate if (q->q_first != 0)
12287c478bd9Sstevel@tonic-gate tilog("timodrput: T_DISCON_IND - flow control\n", 0);
12297c478bd9Sstevel@tonic-gate
12307c478bd9Sstevel@tonic-gate if (blen < sizeof (*disp)) {
12317c478bd9Sstevel@tonic-gate putnext(q, mp);
12327c478bd9Sstevel@tonic-gate break;
12337c478bd9Sstevel@tonic-gate }
12347c478bd9Sstevel@tonic-gate
12357c478bd9Sstevel@tonic-gate disp = (struct T_discon_ind *)mp->b_rptr;
12367c478bd9Sstevel@tonic-gate
12377c478bd9Sstevel@tonic-gate tilog("timodrproc: Got T_DISCON_IND Reason: %d\n",
12387c478bd9Sstevel@tonic-gate disp->DISCON_reason);
12397c478bd9Sstevel@tonic-gate
12407c478bd9Sstevel@tonic-gate tp->tim_flags &= ~(CONNWAIT|LOCORDREL|REMORDREL);
12417c478bd9Sstevel@tonic-gate tim_clear_peer(tp);
12427c478bd9Sstevel@tonic-gate for (nbp = tp->tim_consave; nbp; nbp = nbp->b_next) {
12437c478bd9Sstevel@tonic-gate conp = (struct T_conn_ind *)nbp->b_rptr;
12447c478bd9Sstevel@tonic-gate if (conp->SEQ_number == disp->SEQ_number)
12457c478bd9Sstevel@tonic-gate break;
12467c478bd9Sstevel@tonic-gate pbp = nbp;
12477c478bd9Sstevel@tonic-gate }
12487c478bd9Sstevel@tonic-gate if (nbp) {
12497c478bd9Sstevel@tonic-gate if (pbp)
12507c478bd9Sstevel@tonic-gate pbp->b_next = nbp->b_next;
12517c478bd9Sstevel@tonic-gate else
12527c478bd9Sstevel@tonic-gate tp->tim_consave = nbp->b_next;
12537c478bd9Sstevel@tonic-gate nbp->b_next = NULL;
12547c478bd9Sstevel@tonic-gate freemsg(nbp);
12557c478bd9Sstevel@tonic-gate }
12567c478bd9Sstevel@tonic-gate putnext(q, mp);
12577c478bd9Sstevel@tonic-gate break;
12587c478bd9Sstevel@tonic-gate }
12597c478bd9Sstevel@tonic-gate
12607c478bd9Sstevel@tonic-gate case T_ORDREL_IND:
12617c478bd9Sstevel@tonic-gate
12627c478bd9Sstevel@tonic-gate tilog("timodrproc: Got T_ORDREL_IND\n", 0);
12637c478bd9Sstevel@tonic-gate
12647c478bd9Sstevel@tonic-gate if (tp->tim_flags & LOCORDREL) {
12657c478bd9Sstevel@tonic-gate tp->tim_flags &= ~(LOCORDREL|REMORDREL);
12667c478bd9Sstevel@tonic-gate tim_clear_peer(tp);
12677c478bd9Sstevel@tonic-gate } else {
12687c478bd9Sstevel@tonic-gate tp->tim_flags |= REMORDREL;
12697c478bd9Sstevel@tonic-gate }
12707c478bd9Sstevel@tonic-gate putnext(q, mp);
12717c478bd9Sstevel@tonic-gate break;
12727c478bd9Sstevel@tonic-gate
12737c478bd9Sstevel@tonic-gate case T_EXDATA_IND:
12747c478bd9Sstevel@tonic-gate case T_DATA_IND:
12757c478bd9Sstevel@tonic-gate case T_UNITDATA_IND:
12767c478bd9Sstevel@tonic-gate if (pptr->type == T_EXDATA_IND)
12777c478bd9Sstevel@tonic-gate tilog("timodrproc: Got T_EXDATA_IND\n", 0);
12787c478bd9Sstevel@tonic-gate
12797c478bd9Sstevel@tonic-gate if (!bcanputnext(q, mp->b_band)) {
12807c478bd9Sstevel@tonic-gate (void) putbq(q, mp);
12817c478bd9Sstevel@tonic-gate return (1);
12827c478bd9Sstevel@tonic-gate }
12837c478bd9Sstevel@tonic-gate putnext(q, mp);
12847c478bd9Sstevel@tonic-gate break;
12857c478bd9Sstevel@tonic-gate
12867c478bd9Sstevel@tonic-gate case T_CAPABILITY_ACK: {
12877c478bd9Sstevel@tonic-gate struct T_capability_ack *tca;
12887c478bd9Sstevel@tonic-gate
12897c478bd9Sstevel@tonic-gate if (blen < sizeof (*tca)) {
12907c478bd9Sstevel@tonic-gate putnext(q, mp);
12917c478bd9Sstevel@tonic-gate break;
12927c478bd9Sstevel@tonic-gate }
12937c478bd9Sstevel@tonic-gate
12947c478bd9Sstevel@tonic-gate /* This transport supports T_CAPABILITY_REQ */
12957c478bd9Sstevel@tonic-gate tilog("timodrproc: Got T_CAPABILITY_ACK\n", 0);
12967c478bd9Sstevel@tonic-gate
12977c478bd9Sstevel@tonic-gate PI_PROVLOCK(tp->tim_provinfo);
12987c478bd9Sstevel@tonic-gate if (tp->tim_provinfo->tpi_capability != PI_YES)
12997c478bd9Sstevel@tonic-gate tp->tim_provinfo->tpi_capability = PI_YES;
13007c478bd9Sstevel@tonic-gate PI_PROVUNLOCK(tp->tim_provinfo);
13017c478bd9Sstevel@tonic-gate
13027c478bd9Sstevel@tonic-gate /* Reset possible pending timeout */
13037c478bd9Sstevel@tonic-gate if (tp->tim_tcap_timoutid != 0) {
13047c478bd9Sstevel@tonic-gate (void) quntimeout(q, tp->tim_tcap_timoutid);
13057c478bd9Sstevel@tonic-gate tp->tim_tcap_timoutid = 0;
13067c478bd9Sstevel@tonic-gate }
13077c478bd9Sstevel@tonic-gate
13087c478bd9Sstevel@tonic-gate tca = (struct T_capability_ack *)mp->b_rptr;
13097c478bd9Sstevel@tonic-gate
13107c478bd9Sstevel@tonic-gate if (tca->CAP_bits1 & TC1_INFO)
13117c478bd9Sstevel@tonic-gate timodprocessinfo(q, tp, &tca->INFO_ack);
13127c478bd9Sstevel@tonic-gate
13137c478bd9Sstevel@tonic-gate tim_send_reply(q, mp, tp, T_CAPABILITY_REQ);
13147c478bd9Sstevel@tonic-gate }
13157c478bd9Sstevel@tonic-gate break;
13167c478bd9Sstevel@tonic-gate }
13177c478bd9Sstevel@tonic-gate break;
13187c478bd9Sstevel@tonic-gate
13197c478bd9Sstevel@tonic-gate case M_FLUSH:
13207c478bd9Sstevel@tonic-gate
13217c478bd9Sstevel@tonic-gate tilog("timodrproc: Got M_FLUSH\n", 0);
13227c478bd9Sstevel@tonic-gate
13237c478bd9Sstevel@tonic-gate if (*mp->b_rptr & FLUSHR) {
13247c478bd9Sstevel@tonic-gate if (*mp->b_rptr & FLUSHBAND)
13257c478bd9Sstevel@tonic-gate flushband(q, *(mp->b_rptr + 1), FLUSHDATA);
13267c478bd9Sstevel@tonic-gate else
13277c478bd9Sstevel@tonic-gate flushq(q, FLUSHDATA);
13287c478bd9Sstevel@tonic-gate }
13297c478bd9Sstevel@tonic-gate putnext(q, mp);
13307c478bd9Sstevel@tonic-gate break;
13317c478bd9Sstevel@tonic-gate
13327c478bd9Sstevel@tonic-gate case M_IOCACK:
13337c478bd9Sstevel@tonic-gate iocbp = (struct iocblk *)mp->b_rptr;
13347c478bd9Sstevel@tonic-gate
13357c478bd9Sstevel@tonic-gate tilog("timodrproc: Got M_IOCACK\n", 0);
13367c478bd9Sstevel@tonic-gate
13377c478bd9Sstevel@tonic-gate if (iocbp->ioc_cmd == TI_GETMYNAME) {
13387c478bd9Sstevel@tonic-gate
13397c478bd9Sstevel@tonic-gate /*
13407c478bd9Sstevel@tonic-gate * Transport provider supports this ioctl,
13417c478bd9Sstevel@tonic-gate * so I don't have to.
13427c478bd9Sstevel@tonic-gate */
13437c478bd9Sstevel@tonic-gate if ((tp->tim_flags & DO_MYNAME) != 0) {
13447c478bd9Sstevel@tonic-gate tp->tim_flags &= ~DO_MYNAME;
13457c478bd9Sstevel@tonic-gate PI_PROVLOCK(tp->tim_provinfo);
13467c478bd9Sstevel@tonic-gate tp->tim_provinfo->tpi_myname = PI_YES;
13477c478bd9Sstevel@tonic-gate PI_PROVUNLOCK(tp->tim_provinfo);
13487c478bd9Sstevel@tonic-gate }
13497c478bd9Sstevel@tonic-gate
13507c478bd9Sstevel@tonic-gate ASSERT(tp->tim_mymaxlen >= 0);
13517c478bd9Sstevel@tonic-gate if (tp->tim_mymaxlen != 0) {
13527c478bd9Sstevel@tonic-gate kmem_free(tp->tim_myname, (size_t)tp->tim_mymaxlen);
13537c478bd9Sstevel@tonic-gate tp->tim_myname = NULL;
13547c478bd9Sstevel@tonic-gate tp->tim_mymaxlen = 0;
13557c478bd9Sstevel@tonic-gate }
13567c478bd9Sstevel@tonic-gate /* tim_iocsave may already be overwritten. */
13577c478bd9Sstevel@tonic-gate if (tp->tim_saved_prim == -1) {
13587c478bd9Sstevel@tonic-gate freemsg(tp->tim_iocsave);
13597c478bd9Sstevel@tonic-gate tp->tim_iocsave = NULL;
13607c478bd9Sstevel@tonic-gate }
13617c478bd9Sstevel@tonic-gate } else if (iocbp->ioc_cmd == TI_GETPEERNAME) {
13627c478bd9Sstevel@tonic-gate boolean_t clearit;
13637c478bd9Sstevel@tonic-gate
13647c478bd9Sstevel@tonic-gate /*
13657c478bd9Sstevel@tonic-gate * Transport provider supports this ioctl,
13667c478bd9Sstevel@tonic-gate * so I don't have to.
13677c478bd9Sstevel@tonic-gate */
13687c478bd9Sstevel@tonic-gate if ((tp->tim_flags & DO_PEERNAME) != 0) {
13697c478bd9Sstevel@tonic-gate tp->tim_flags &= ~DO_PEERNAME;
13707c478bd9Sstevel@tonic-gate PI_PROVLOCK(tp->tim_provinfo);
13717c478bd9Sstevel@tonic-gate tp->tim_provinfo->tpi_peername = PI_YES;
13727c478bd9Sstevel@tonic-gate PI_PROVUNLOCK(tp->tim_provinfo);
13737c478bd9Sstevel@tonic-gate }
13747c478bd9Sstevel@tonic-gate
13757c478bd9Sstevel@tonic-gate mutex_enter(&tp->tim_mutex);
13767c478bd9Sstevel@tonic-gate ASSERT(tp->tim_peermaxlen >= 0);
13777c478bd9Sstevel@tonic-gate clearit = tp->tim_peermaxlen != 0;
13787c478bd9Sstevel@tonic-gate if (clearit) {
13797c478bd9Sstevel@tonic-gate kmem_free(tp->tim_peername, tp->tim_peermaxlen);
13807c478bd9Sstevel@tonic-gate tp->tim_peername = NULL;
13817c478bd9Sstevel@tonic-gate tp->tim_peermaxlen = 0;
13827c478bd9Sstevel@tonic-gate tp->tim_peerlen = 0;
13837c478bd9Sstevel@tonic-gate }
13847c478bd9Sstevel@tonic-gate mutex_exit(&tp->tim_mutex);
13857c478bd9Sstevel@tonic-gate if (clearit) {
13867c478bd9Sstevel@tonic-gate mblk_t *bp;
13877c478bd9Sstevel@tonic-gate
13887c478bd9Sstevel@tonic-gate bp = tp->tim_consave;
13897c478bd9Sstevel@tonic-gate while (bp != NULL) {
13907c478bd9Sstevel@tonic-gate nbp = bp->b_next;
13917c478bd9Sstevel@tonic-gate bp->b_next = NULL;
13927c478bd9Sstevel@tonic-gate freemsg(bp);
13937c478bd9Sstevel@tonic-gate bp = nbp;
13947c478bd9Sstevel@tonic-gate }
13957c478bd9Sstevel@tonic-gate tp->tim_consave = NULL;
13967c478bd9Sstevel@tonic-gate }
13977c478bd9Sstevel@tonic-gate /* tim_iocsave may already be overwritten. */
13987c478bd9Sstevel@tonic-gate if (tp->tim_saved_prim == -1) {
13997c478bd9Sstevel@tonic-gate freemsg(tp->tim_iocsave);
14007c478bd9Sstevel@tonic-gate tp->tim_iocsave = NULL;
14017c478bd9Sstevel@tonic-gate }
14027c478bd9Sstevel@tonic-gate }
14037c478bd9Sstevel@tonic-gate putnext(q, mp);
14047c478bd9Sstevel@tonic-gate break;
14057c478bd9Sstevel@tonic-gate
14067c478bd9Sstevel@tonic-gate case M_IOCNAK:
14077c478bd9Sstevel@tonic-gate
14087c478bd9Sstevel@tonic-gate tilog("timodrproc: Got M_IOCNAK\n", 0);
14097c478bd9Sstevel@tonic-gate
14107c478bd9Sstevel@tonic-gate iocbp = (struct iocblk *)mp->b_rptr;
14117c478bd9Sstevel@tonic-gate if (((iocbp->ioc_cmd == TI_GETMYNAME) ||
14127c478bd9Sstevel@tonic-gate (iocbp->ioc_cmd == TI_GETPEERNAME)) &&
14137c478bd9Sstevel@tonic-gate ((iocbp->ioc_error == EINVAL) || (iocbp->ioc_error == 0))) {
14147c478bd9Sstevel@tonic-gate PI_PROVLOCK(tp->tim_provinfo);
14157c478bd9Sstevel@tonic-gate if (iocbp->ioc_cmd == TI_GETMYNAME) {
14167c478bd9Sstevel@tonic-gate if (tp->tim_provinfo->tpi_myname == PI_DONTKNOW)
14177c478bd9Sstevel@tonic-gate tp->tim_provinfo->tpi_myname = PI_NO;
14187c478bd9Sstevel@tonic-gate } else if (iocbp->ioc_cmd == TI_GETPEERNAME) {
14197c478bd9Sstevel@tonic-gate if (tp->tim_provinfo->tpi_peername == PI_DONTKNOW)
14207c478bd9Sstevel@tonic-gate tp->tim_provinfo->tpi_peername = PI_NO;
14217c478bd9Sstevel@tonic-gate }
14227c478bd9Sstevel@tonic-gate PI_PROVUNLOCK(tp->tim_provinfo);
14237c478bd9Sstevel@tonic-gate /* tim_iocsave may already be overwritten. */
14247c478bd9Sstevel@tonic-gate if ((tp->tim_iocsave != NULL) &&
14257c478bd9Sstevel@tonic-gate (tp->tim_saved_prim == -1)) {
14267c478bd9Sstevel@tonic-gate freemsg(mp);
14277c478bd9Sstevel@tonic-gate mp = tp->tim_iocsave;
14287c478bd9Sstevel@tonic-gate tp->tim_iocsave = NULL;
14297c478bd9Sstevel@tonic-gate tp->tim_flags |= NAMEPROC;
14307c478bd9Sstevel@tonic-gate if (ti_doname(WR(q), mp) != DONAME_CONT) {
14317c478bd9Sstevel@tonic-gate tp->tim_flags &= ~NAMEPROC;
14327c478bd9Sstevel@tonic-gate }
14337c478bd9Sstevel@tonic-gate break;
14347c478bd9Sstevel@tonic-gate }
14357c478bd9Sstevel@tonic-gate }
14367c478bd9Sstevel@tonic-gate putnext(q, mp);
14377c478bd9Sstevel@tonic-gate break;
14387c478bd9Sstevel@tonic-gate }
14397c478bd9Sstevel@tonic-gate
14407c478bd9Sstevel@tonic-gate return (0);
14417c478bd9Sstevel@tonic-gate }
14427c478bd9Sstevel@tonic-gate
14437c478bd9Sstevel@tonic-gate /*
14447c478bd9Sstevel@tonic-gate * timodwput - Module write put procedure. This is called from
14457c478bd9Sstevel@tonic-gate * the module, driver, or stream head upstream/downstream.
14467c478bd9Sstevel@tonic-gate * Handles M_FLUSH, M_DATA and some M_PROTO (T_DATA_REQ,
14477c478bd9Sstevel@tonic-gate * and T_UNITDATA_REQ) messages. All others are queued to
14487c478bd9Sstevel@tonic-gate * be handled by the service procedures.
14497c478bd9Sstevel@tonic-gate */
14507c478bd9Sstevel@tonic-gate
1451*6caf82faSToomas Soome static int
timodwput(queue_t * q,mblk_t * mp)14527c478bd9Sstevel@tonic-gate timodwput(queue_t *q, mblk_t *mp)
14537c478bd9Sstevel@tonic-gate {
14547c478bd9Sstevel@tonic-gate union T_primitives *pptr;
14557c478bd9Sstevel@tonic-gate struct tim_tim *tp;
14567c478bd9Sstevel@tonic-gate struct iocblk *iocbp;
14577c478bd9Sstevel@tonic-gate
14587c478bd9Sstevel@tonic-gate /*
14597c478bd9Sstevel@tonic-gate * Enqueue normal-priority messages if our queue already
14607c478bd9Sstevel@tonic-gate * holds some messages for deferred processing but don't
14617c478bd9Sstevel@tonic-gate * enqueue those M_IOCTLs which will result in an
14627c478bd9Sstevel@tonic-gate * M_PCPROTO (ie, high priority) message being created.
14637c478bd9Sstevel@tonic-gate */
14647c478bd9Sstevel@tonic-gate if (q->q_first != 0 && mp->b_datap->db_type < QPCTL) {
14657c478bd9Sstevel@tonic-gate if (mp->b_datap->db_type == M_IOCTL) {
14667c478bd9Sstevel@tonic-gate iocbp = (struct iocblk *)mp->b_rptr;
14677c478bd9Sstevel@tonic-gate switch (iocbp->ioc_cmd) {
14687c478bd9Sstevel@tonic-gate default:
14697c478bd9Sstevel@tonic-gate (void) putq(q, mp);
1470*6caf82faSToomas Soome return (0);
14717c478bd9Sstevel@tonic-gate
14727c478bd9Sstevel@tonic-gate case TI_GETINFO:
14737c478bd9Sstevel@tonic-gate case TI_SYNC:
14747c478bd9Sstevel@tonic-gate case TI_CAPABILITY:
14757c478bd9Sstevel@tonic-gate break;
14767c478bd9Sstevel@tonic-gate }
14777c478bd9Sstevel@tonic-gate } else {
14787c478bd9Sstevel@tonic-gate (void) putq(q, mp);
1479*6caf82faSToomas Soome return (0);
14807c478bd9Sstevel@tonic-gate }
14817c478bd9Sstevel@tonic-gate }
14827c478bd9Sstevel@tonic-gate /*
14837c478bd9Sstevel@tonic-gate * Inline processing of data (to avoid additional procedure call).
14847c478bd9Sstevel@tonic-gate * Rest is handled in timodwproc.
14857c478bd9Sstevel@tonic-gate */
14867c478bd9Sstevel@tonic-gate
14877c478bd9Sstevel@tonic-gate switch (mp->b_datap->db_type) {
14887c478bd9Sstevel@tonic-gate case M_DATA:
14897c478bd9Sstevel@tonic-gate tp = (struct tim_tim *)q->q_ptr;
14907c478bd9Sstevel@tonic-gate ASSERT(tp);
14917c478bd9Sstevel@tonic-gate if (tp->tim_flags & CLTS) {
14927c478bd9Sstevel@tonic-gate mblk_t *tmp;
14937c478bd9Sstevel@tonic-gate
14947c478bd9Sstevel@tonic-gate if ((tmp = tim_filladdr(q, mp, B_FALSE)) == NULL) {
14957c478bd9Sstevel@tonic-gate (void) putq(q, mp);
14967c478bd9Sstevel@tonic-gate break;
14977c478bd9Sstevel@tonic-gate } else {
14987c478bd9Sstevel@tonic-gate mp = tmp;
14997c478bd9Sstevel@tonic-gate }
15007c478bd9Sstevel@tonic-gate }
15017c478bd9Sstevel@tonic-gate if (bcanputnext(q, mp->b_band))
15027c478bd9Sstevel@tonic-gate putnext(q, mp);
15037c478bd9Sstevel@tonic-gate else
15047c478bd9Sstevel@tonic-gate (void) putq(q, mp);
15057c478bd9Sstevel@tonic-gate break;
15067c478bd9Sstevel@tonic-gate case M_PROTO:
15077c478bd9Sstevel@tonic-gate case M_PCPROTO:
15087c478bd9Sstevel@tonic-gate pptr = (union T_primitives *)mp->b_rptr;
15097c478bd9Sstevel@tonic-gate switch (pptr->type) {
15107c478bd9Sstevel@tonic-gate case T_UNITDATA_REQ:
15117c478bd9Sstevel@tonic-gate tp = (struct tim_tim *)q->q_ptr;
15127c478bd9Sstevel@tonic-gate ASSERT(tp);
15137c478bd9Sstevel@tonic-gate if (tp->tim_flags & CLTS) {
15147c478bd9Sstevel@tonic-gate mblk_t *tmp;
15157c478bd9Sstevel@tonic-gate
15167c478bd9Sstevel@tonic-gate tmp = tim_filladdr(q, mp, B_FALSE);
15177c478bd9Sstevel@tonic-gate if (tmp == NULL) {
15187c478bd9Sstevel@tonic-gate (void) putq(q, mp);
15197c478bd9Sstevel@tonic-gate break;
15207c478bd9Sstevel@tonic-gate } else {
15217c478bd9Sstevel@tonic-gate mp = tmp;
15227c478bd9Sstevel@tonic-gate }
15237c478bd9Sstevel@tonic-gate }
15247c478bd9Sstevel@tonic-gate if (bcanputnext(q, mp->b_band))
15257c478bd9Sstevel@tonic-gate putnext(q, mp);
15267c478bd9Sstevel@tonic-gate else
15277c478bd9Sstevel@tonic-gate (void) putq(q, mp);
15287c478bd9Sstevel@tonic-gate break;
15297c478bd9Sstevel@tonic-gate
15307c478bd9Sstevel@tonic-gate case T_DATA_REQ:
15317c478bd9Sstevel@tonic-gate case T_EXDATA_REQ:
15327c478bd9Sstevel@tonic-gate if (bcanputnext(q, mp->b_band))
15337c478bd9Sstevel@tonic-gate putnext(q, mp);
15347c478bd9Sstevel@tonic-gate else
15357c478bd9Sstevel@tonic-gate (void) putq(q, mp);
15367c478bd9Sstevel@tonic-gate break;
15377c478bd9Sstevel@tonic-gate default:
15387c478bd9Sstevel@tonic-gate (void) timodwproc(q, mp);
15397c478bd9Sstevel@tonic-gate break;
15407c478bd9Sstevel@tonic-gate }
15417c478bd9Sstevel@tonic-gate break;
15427c478bd9Sstevel@tonic-gate default:
15437c478bd9Sstevel@tonic-gate (void) timodwproc(q, mp);
15447c478bd9Sstevel@tonic-gate break;
15457c478bd9Sstevel@tonic-gate }
1546*6caf82faSToomas Soome return (0);
15477c478bd9Sstevel@tonic-gate }
15487c478bd9Sstevel@tonic-gate /*
15497c478bd9Sstevel@tonic-gate * timodwsrv - Module write queue service procedure.
15507c478bd9Sstevel@tonic-gate * This is called when messages are placed on an empty queue,
15517c478bd9Sstevel@tonic-gate * when high priority messages are placed on the queue, and
15527c478bd9Sstevel@tonic-gate * when flow control restrictions subside. This code used to
15537c478bd9Sstevel@tonic-gate * be included in a put procedure, but it was moved to a
15547c478bd9Sstevel@tonic-gate * service procedure because several points were added where
15557c478bd9Sstevel@tonic-gate * memory allocation could fail, and there is no reasonable
15567c478bd9Sstevel@tonic-gate * recovery mechanism from the put procedure.
15577c478bd9Sstevel@tonic-gate */
1558*6caf82faSToomas Soome static int
timodwsrv(queue_t * q)15597c478bd9Sstevel@tonic-gate timodwsrv(queue_t *q)
15607c478bd9Sstevel@tonic-gate {
15617c478bd9Sstevel@tonic-gate mblk_t *mp;
15627c478bd9Sstevel@tonic-gate
15637c478bd9Sstevel@tonic-gate ASSERT(q != NULL);
15647c478bd9Sstevel@tonic-gate if (q->q_ptr == NULL)
1565*6caf82faSToomas Soome return (0);
15667c478bd9Sstevel@tonic-gate
15677c478bd9Sstevel@tonic-gate while ((mp = getq(q)) != NULL) {
15687c478bd9Sstevel@tonic-gate if (timodwproc(q, mp)) {
15697c478bd9Sstevel@tonic-gate /*
15707c478bd9Sstevel@tonic-gate * timodwproc did a putbq - stop processing
15717c478bd9Sstevel@tonic-gate * messages.
15727c478bd9Sstevel@tonic-gate */
1573*6caf82faSToomas Soome return (0);
15747c478bd9Sstevel@tonic-gate }
15757c478bd9Sstevel@tonic-gate }
1576*6caf82faSToomas Soome return (0);
15777c478bd9Sstevel@tonic-gate }
15787c478bd9Sstevel@tonic-gate
15797c478bd9Sstevel@tonic-gate /*
15807c478bd9Sstevel@tonic-gate * Common routine to process write side messages
15817c478bd9Sstevel@tonic-gate */
15827c478bd9Sstevel@tonic-gate
15837c478bd9Sstevel@tonic-gate static int
timodwproc(queue_t * q,mblk_t * mp)15847c478bd9Sstevel@tonic-gate timodwproc(queue_t *q, mblk_t *mp)
15857c478bd9Sstevel@tonic-gate {
15867c478bd9Sstevel@tonic-gate union T_primitives *pptr;
15877c478bd9Sstevel@tonic-gate struct tim_tim *tp;
1588005d3febSMarek Pospisil uint32_t auditing = AU_AUDITING();
15897c478bd9Sstevel@tonic-gate mblk_t *tmp;
15907c478bd9Sstevel@tonic-gate struct iocblk *iocbp;
15917c478bd9Sstevel@tonic-gate int error;
15927c478bd9Sstevel@tonic-gate
15937c478bd9Sstevel@tonic-gate tp = (struct tim_tim *)q->q_ptr;
15947c478bd9Sstevel@tonic-gate
15957c478bd9Sstevel@tonic-gate switch (mp->b_datap->db_type) {
15967c478bd9Sstevel@tonic-gate default:
15977c478bd9Sstevel@tonic-gate putnext(q, mp);
15987c478bd9Sstevel@tonic-gate break;
15997c478bd9Sstevel@tonic-gate
16007c478bd9Sstevel@tonic-gate case M_DATA:
16017c478bd9Sstevel@tonic-gate if (tp->tim_flags & CLTS) {
16027c478bd9Sstevel@tonic-gate if ((tmp = tim_filladdr(q, mp, B_TRUE)) == NULL) {
16037c478bd9Sstevel@tonic-gate return (1);
16047c478bd9Sstevel@tonic-gate } else {
16057c478bd9Sstevel@tonic-gate mp = tmp;
16067c478bd9Sstevel@tonic-gate }
16077c478bd9Sstevel@tonic-gate }
16087c478bd9Sstevel@tonic-gate if (!bcanputnext(q, mp->b_band)) {
16097c478bd9Sstevel@tonic-gate (void) putbq(q, mp);
16107c478bd9Sstevel@tonic-gate return (1);
16117c478bd9Sstevel@tonic-gate }
16127c478bd9Sstevel@tonic-gate putnext(q, mp);
16137c478bd9Sstevel@tonic-gate break;
16147c478bd9Sstevel@tonic-gate
16157c478bd9Sstevel@tonic-gate case M_IOCTL:
16167c478bd9Sstevel@tonic-gate
16177c478bd9Sstevel@tonic-gate iocbp = (struct iocblk *)mp->b_rptr;
16187c478bd9Sstevel@tonic-gate TILOG("timodwproc: Got M_IOCTL(%d)\n", iocbp->ioc_cmd);
16197c478bd9Sstevel@tonic-gate
16207c478bd9Sstevel@tonic-gate ASSERT(MBLKL(mp) == sizeof (struct iocblk));
16217c478bd9Sstevel@tonic-gate
16227c478bd9Sstevel@tonic-gate /*
16237c478bd9Sstevel@tonic-gate * TPI requires we await response to a previously sent message
16242cbe889aSgeorges * before handling another, put it back on the head of queue.
16252cbe889aSgeorges * Since putbq() may see QWANTR unset when called from the
16262cbe889aSgeorges * service procedure, the queue must be explicitly scheduled
16272cbe889aSgeorges * for service, as no backenable will occur for this case.
16282cbe889aSgeorges * tim_ioctl_retry() sets a timer to handle the qenable.
16297c478bd9Sstevel@tonic-gate */
16307c478bd9Sstevel@tonic-gate if (tp->tim_flags & WAITIOCACK) {
16317c478bd9Sstevel@tonic-gate TILOG("timodwproc: putbq M_IOCTL(%d)\n",
16327c478bd9Sstevel@tonic-gate iocbp->ioc_cmd);
16337c478bd9Sstevel@tonic-gate (void) putbq(q, mp);
16342cbe889aSgeorges /* Called from timodwsrv() and messages on queue */
16352cbe889aSgeorges if (!(q->q_flag & QWANTR))
16362cbe889aSgeorges tim_ioctl_retry(q);
16377c478bd9Sstevel@tonic-gate return (1);
16387c478bd9Sstevel@tonic-gate }
16397c478bd9Sstevel@tonic-gate
16407c478bd9Sstevel@tonic-gate switch (iocbp->ioc_cmd) {
16417c478bd9Sstevel@tonic-gate default:
16427c478bd9Sstevel@tonic-gate putnext(q, mp);
16437c478bd9Sstevel@tonic-gate break;
16447c478bd9Sstevel@tonic-gate
16457c478bd9Sstevel@tonic-gate case _I_GETPEERCRED:
16467c478bd9Sstevel@tonic-gate if ((tp->tim_flags & COTS) == 0) {
16477c478bd9Sstevel@tonic-gate miocnak(q, mp, 0, ENOTSUP);
16487c478bd9Sstevel@tonic-gate } else {
16497c478bd9Sstevel@tonic-gate mblk_t *cmp = mp->b_cont;
16507c478bd9Sstevel@tonic-gate k_peercred_t *kp = NULL;
16517c478bd9Sstevel@tonic-gate
16527c478bd9Sstevel@tonic-gate mutex_enter(&tp->tim_mutex);
16537c478bd9Sstevel@tonic-gate if (cmp != NULL &&
16547c478bd9Sstevel@tonic-gate iocbp->ioc_flag == IOC_NATIVE &&
16557c478bd9Sstevel@tonic-gate (tp->tim_flags &
16567c478bd9Sstevel@tonic-gate (CONNWAIT|LOCORDREL|REMORDREL)) == 0 &&
16577c478bd9Sstevel@tonic-gate tp->tim_peercred != NULL &&
16587c478bd9Sstevel@tonic-gate DB_TYPE(cmp) == M_DATA &&
16597c478bd9Sstevel@tonic-gate MBLKL(cmp) == sizeof (k_peercred_t)) {
16607c478bd9Sstevel@tonic-gate kp = (k_peercred_t *)cmp->b_rptr;
16617c478bd9Sstevel@tonic-gate crhold(kp->pc_cr = tp->tim_peercred);
16627c478bd9Sstevel@tonic-gate kp->pc_cpid = tp->tim_cpid;
16637c478bd9Sstevel@tonic-gate }
16647c478bd9Sstevel@tonic-gate mutex_exit(&tp->tim_mutex);
16657c478bd9Sstevel@tonic-gate if (kp != NULL)
16667c478bd9Sstevel@tonic-gate miocack(q, mp, sizeof (*kp), 0);
16677c478bd9Sstevel@tonic-gate else
16687c478bd9Sstevel@tonic-gate miocnak(q, mp, 0, ENOTCONN);
16697c478bd9Sstevel@tonic-gate }
16707c478bd9Sstevel@tonic-gate break;
16717c478bd9Sstevel@tonic-gate case TI_BIND:
16727c478bd9Sstevel@tonic-gate case TI_UNBIND:
16737c478bd9Sstevel@tonic-gate case TI_OPTMGMT:
16747c478bd9Sstevel@tonic-gate case TI_GETADDRS:
16757c478bd9Sstevel@tonic-gate TILOG("timodwproc: TI_{BIND|UNBIND|OPTMGMT|GETADDRS}"
16767c478bd9Sstevel@tonic-gate "\n", 0);
16777c478bd9Sstevel@tonic-gate
16787c478bd9Sstevel@tonic-gate /*
16797c478bd9Sstevel@tonic-gate * We know that tim_send_ioctl_tpi_msg() is only
16807c478bd9Sstevel@tonic-gate * going to examine the `type' field, so we only
16817c478bd9Sstevel@tonic-gate * check that we can access that much data.
16827c478bd9Sstevel@tonic-gate */
16837c478bd9Sstevel@tonic-gate error = miocpullup(mp, sizeof (t_scalar_t));
16847c478bd9Sstevel@tonic-gate if (error != 0) {
16857c478bd9Sstevel@tonic-gate miocnak(q, mp, 0, error);
16867c478bd9Sstevel@tonic-gate break;
16877c478bd9Sstevel@tonic-gate }
16887c478bd9Sstevel@tonic-gate tim_send_ioctl_tpi_msg(q, mp, tp, iocbp);
16897c478bd9Sstevel@tonic-gate break;
16907c478bd9Sstevel@tonic-gate
16917c478bd9Sstevel@tonic-gate case TI_GETINFO:
16927c478bd9Sstevel@tonic-gate TILOG("timodwproc: TI_GETINFO\n", 0);
16937c478bd9Sstevel@tonic-gate error = miocpullup(mp, sizeof (struct T_info_req));
16947c478bd9Sstevel@tonic-gate if (error != 0) {
16957c478bd9Sstevel@tonic-gate miocnak(q, mp, 0, error);
16967c478bd9Sstevel@tonic-gate break;
16977c478bd9Sstevel@tonic-gate }
16987c478bd9Sstevel@tonic-gate tp->tim_flags |= WAIT_IOCINFOACK;
16997c478bd9Sstevel@tonic-gate tim_send_ioctl_tpi_msg(q, mp, tp, iocbp);
17007c478bd9Sstevel@tonic-gate break;
17017c478bd9Sstevel@tonic-gate
17027c478bd9Sstevel@tonic-gate case TI_SYNC: {
17037c478bd9Sstevel@tonic-gate mblk_t *tsr_mp;
17047c478bd9Sstevel@tonic-gate struct ti_sync_req *tsr;
17057c478bd9Sstevel@tonic-gate uint32_t tsr_flags;
17067c478bd9Sstevel@tonic-gate
17077c478bd9Sstevel@tonic-gate error = miocpullup(mp, sizeof (struct ti_sync_req));
17087c478bd9Sstevel@tonic-gate if (error != 0) {
17097c478bd9Sstevel@tonic-gate miocnak(q, mp, 0, error);
17107c478bd9Sstevel@tonic-gate break;
17117c478bd9Sstevel@tonic-gate }
17127c478bd9Sstevel@tonic-gate
17137c478bd9Sstevel@tonic-gate tsr_mp = mp->b_cont;
17147c478bd9Sstevel@tonic-gate tsr = (struct ti_sync_req *)tsr_mp->b_rptr;
17157c478bd9Sstevel@tonic-gate TILOG("timodwproc: TI_SYNC(%x)\n", tsr->tsr_flags);
17167c478bd9Sstevel@tonic-gate
17177c478bd9Sstevel@tonic-gate /*
17187c478bd9Sstevel@tonic-gate * Save out the value of tsr_flags, in case we
17197c478bd9Sstevel@tonic-gate * reallocb() tsr_mp (below).
17207c478bd9Sstevel@tonic-gate */
17217c478bd9Sstevel@tonic-gate tsr_flags = tsr->tsr_flags;
17227c478bd9Sstevel@tonic-gate if ((tsr_flags & TSRF_INFO_REQ) == 0) {
17237c478bd9Sstevel@tonic-gate mblk_t *ack_mp = reallocb(tsr_mp,
17247c478bd9Sstevel@tonic-gate sizeof (struct ti_sync_ack), 0);
17257c478bd9Sstevel@tonic-gate
17267c478bd9Sstevel@tonic-gate /* Can reply immediately. */
17277c478bd9Sstevel@tonic-gate mp->b_cont = NULL;
17287c478bd9Sstevel@tonic-gate if (ack_mp == NULL) {
17297c478bd9Sstevel@tonic-gate tilog("timodwproc: allocb failed no "
17307c478bd9Sstevel@tonic-gate "recovery attempt\n", 0);
17317c478bd9Sstevel@tonic-gate freemsg(tsr_mp);
17327c478bd9Sstevel@tonic-gate miocnak(q, mp, 0, ENOMEM);
17337c478bd9Sstevel@tonic-gate } else {
17347c478bd9Sstevel@tonic-gate tim_answer_ti_sync(q, mp, tp,
17357c478bd9Sstevel@tonic-gate ack_mp, tsr_flags);
17367c478bd9Sstevel@tonic-gate }
17377c478bd9Sstevel@tonic-gate break;
17387c478bd9Sstevel@tonic-gate }
17397c478bd9Sstevel@tonic-gate
17407c478bd9Sstevel@tonic-gate /*
17417c478bd9Sstevel@tonic-gate * This code is retained for compatibility with
17427c478bd9Sstevel@tonic-gate * old statically linked applications. New code
17437c478bd9Sstevel@tonic-gate * should use TI_CAPABILITY for all TPI
17447c478bd9Sstevel@tonic-gate * information and should not use TSRF_INFO_REQ
17457c478bd9Sstevel@tonic-gate * flag.
17467c478bd9Sstevel@tonic-gate *
17477c478bd9Sstevel@tonic-gate * defer processsing necessary to rput procedure
17487c478bd9Sstevel@tonic-gate * as we need to get information from transport
17497c478bd9Sstevel@tonic-gate * driver. Set flags that will tell the read
17507c478bd9Sstevel@tonic-gate * side the work needed on this request.
17517c478bd9Sstevel@tonic-gate */
17527c478bd9Sstevel@tonic-gate
17537c478bd9Sstevel@tonic-gate if (tsr_flags & TSRF_IS_EXP_IN_RCVBUF)
17547c478bd9Sstevel@tonic-gate tp->tim_flags |= PEEK_RDQ_EXPIND;
17557c478bd9Sstevel@tonic-gate
17567c478bd9Sstevel@tonic-gate /*
17577c478bd9Sstevel@tonic-gate * Convert message to a T_INFO_REQ message; relies
17587c478bd9Sstevel@tonic-gate * on sizeof (struct ti_sync_req) >= sizeof (struct
17597c478bd9Sstevel@tonic-gate * T_info_req)).
17607c478bd9Sstevel@tonic-gate */
17617c478bd9Sstevel@tonic-gate ASSERT(MBLKL(tsr_mp) >= sizeof (struct T_info_req));
17627c478bd9Sstevel@tonic-gate
17637c478bd9Sstevel@tonic-gate ((struct T_info_req *)tsr_mp->b_rptr)->PRIM_type =
17647c478bd9Sstevel@tonic-gate T_INFO_REQ;
17657c478bd9Sstevel@tonic-gate tsr_mp->b_wptr = tsr_mp->b_rptr +
17667c478bd9Sstevel@tonic-gate sizeof (struct T_info_req);
17677c478bd9Sstevel@tonic-gate tp->tim_flags |= WAIT_IOCINFOACK;
17687c478bd9Sstevel@tonic-gate tim_send_ioctl_tpi_msg(q, mp, tp, iocbp);
17697c478bd9Sstevel@tonic-gate }
17707c478bd9Sstevel@tonic-gate break;
17717c478bd9Sstevel@tonic-gate
17727c478bd9Sstevel@tonic-gate case TI_CAPABILITY: {
17737c478bd9Sstevel@tonic-gate mblk_t *tcsr_mp;
17747c478bd9Sstevel@tonic-gate struct T_capability_req *tcr;
17757c478bd9Sstevel@tonic-gate
17767c478bd9Sstevel@tonic-gate error = miocpullup(mp, sizeof (*tcr));
17777c478bd9Sstevel@tonic-gate if (error != 0) {
17787c478bd9Sstevel@tonic-gate miocnak(q, mp, 0, error);
17797c478bd9Sstevel@tonic-gate break;
17807c478bd9Sstevel@tonic-gate }
17817c478bd9Sstevel@tonic-gate
17827c478bd9Sstevel@tonic-gate tcsr_mp = mp->b_cont;
17837c478bd9Sstevel@tonic-gate tcr = (struct T_capability_req *)tcsr_mp->b_rptr;
17847c478bd9Sstevel@tonic-gate TILOG("timodwproc: TI_CAPABILITY(CAP_bits1 = %x)\n",
17857c478bd9Sstevel@tonic-gate tcr->CAP_bits1);
17867c478bd9Sstevel@tonic-gate
17877c478bd9Sstevel@tonic-gate if (tcr->PRIM_type != T_CAPABILITY_REQ) {
17887c478bd9Sstevel@tonic-gate TILOG("timodwproc: invalid msg type %d\n",
17897c478bd9Sstevel@tonic-gate tcr->PRIM_type);
17907c478bd9Sstevel@tonic-gate miocnak(q, mp, 0, EPROTO);
17917c478bd9Sstevel@tonic-gate break;
17927c478bd9Sstevel@tonic-gate }
17937c478bd9Sstevel@tonic-gate
17947c478bd9Sstevel@tonic-gate switch (tp->tim_provinfo->tpi_capability) {
17957c478bd9Sstevel@tonic-gate case PI_YES:
17967c478bd9Sstevel@tonic-gate /* Just send T_CAPABILITY_REQ down */
17977c478bd9Sstevel@tonic-gate tim_send_ioctl_tpi_msg(q, mp, tp, iocbp);
17987c478bd9Sstevel@tonic-gate break;
17997c478bd9Sstevel@tonic-gate
18007c478bd9Sstevel@tonic-gate case PI_DONTKNOW:
18017c478bd9Sstevel@tonic-gate /*
18027c478bd9Sstevel@tonic-gate * It is unknown yet whether transport provides
18037c478bd9Sstevel@tonic-gate * T_CAPABILITY_REQ or not. Send message down
18047c478bd9Sstevel@tonic-gate * and wait for reply.
18057c478bd9Sstevel@tonic-gate */
18067c478bd9Sstevel@tonic-gate
18077c478bd9Sstevel@tonic-gate ASSERT(tp->tim_tcap_timoutid == 0);
18087c478bd9Sstevel@tonic-gate if ((tcr->CAP_bits1 & TC1_INFO) == 0) {
18097c478bd9Sstevel@tonic-gate tp->tim_flags |= TI_CAP_RECVD;
18107c478bd9Sstevel@tonic-gate } else {
18117c478bd9Sstevel@tonic-gate tp->tim_flags |= (TI_CAP_RECVD |
18127c478bd9Sstevel@tonic-gate CAP_WANTS_INFO);
18137c478bd9Sstevel@tonic-gate }
18147c478bd9Sstevel@tonic-gate
18157c478bd9Sstevel@tonic-gate tp->tim_tcap_timoutid = qtimeout(q,
18167c478bd9Sstevel@tonic-gate tim_tcap_timer, q, tim_tcap_wait * hz);
18177c478bd9Sstevel@tonic-gate tim_send_ioctl_tpi_msg(q, mp, tp, iocbp);
18187c478bd9Sstevel@tonic-gate break;
18197c478bd9Sstevel@tonic-gate
18207c478bd9Sstevel@tonic-gate case PI_NO:
18217c478bd9Sstevel@tonic-gate /*
18227c478bd9Sstevel@tonic-gate * Transport doesn't support T_CAPABILITY_REQ.
18237c478bd9Sstevel@tonic-gate * Either reply immediately or send T_INFO_REQ
18247c478bd9Sstevel@tonic-gate * if needed.
18257c478bd9Sstevel@tonic-gate */
18267c478bd9Sstevel@tonic-gate if ((tcr->CAP_bits1 & TC1_INFO) != 0) {
18277c478bd9Sstevel@tonic-gate tp->tim_flags |= (TI_CAP_RECVD |
18287c478bd9Sstevel@tonic-gate CAP_WANTS_INFO | WAIT_IOCINFOACK);
18297c478bd9Sstevel@tonic-gate TILOG("timodwproc: sending down "
18307c478bd9Sstevel@tonic-gate "T_INFO_REQ, flags = %x\n",
18317c478bd9Sstevel@tonic-gate tp->tim_flags);
18327c478bd9Sstevel@tonic-gate
18337c478bd9Sstevel@tonic-gate /*
18347c478bd9Sstevel@tonic-gate * Generate T_INFO_REQ message and send
18357c478bd9Sstevel@tonic-gate * it down
18367c478bd9Sstevel@tonic-gate */
18377c478bd9Sstevel@tonic-gate ((struct T_info_req *)tcsr_mp->b_rptr)->
18387c478bd9Sstevel@tonic-gate PRIM_type = T_INFO_REQ;
18397c478bd9Sstevel@tonic-gate tcsr_mp->b_wptr = tcsr_mp->b_rptr +
18407c478bd9Sstevel@tonic-gate sizeof (struct T_info_req);
18417c478bd9Sstevel@tonic-gate tim_send_ioctl_tpi_msg(q, mp, tp,
18427c478bd9Sstevel@tonic-gate iocbp);
18437c478bd9Sstevel@tonic-gate break;
18447c478bd9Sstevel@tonic-gate }
18457c478bd9Sstevel@tonic-gate
18467c478bd9Sstevel@tonic-gate
18477c478bd9Sstevel@tonic-gate /*
18487c478bd9Sstevel@tonic-gate * Can reply immediately. Just send back
18497c478bd9Sstevel@tonic-gate * T_CAPABILITY_ACK with CAP_bits1 set to 0.
18507c478bd9Sstevel@tonic-gate */
18517c478bd9Sstevel@tonic-gate mp->b_cont = tcsr_mp = tpi_ack_alloc(mp->b_cont,
18527c478bd9Sstevel@tonic-gate sizeof (struct T_capability_ack), M_PCPROTO,
18537c478bd9Sstevel@tonic-gate T_CAPABILITY_ACK);
18547c478bd9Sstevel@tonic-gate
18557c478bd9Sstevel@tonic-gate if (tcsr_mp == NULL) {
18567c478bd9Sstevel@tonic-gate tilog("timodwproc: allocb failed no "
18577c478bd9Sstevel@tonic-gate "recovery attempt\n", 0);
18587c478bd9Sstevel@tonic-gate miocnak(q, mp, 0, ENOMEM);
18597c478bd9Sstevel@tonic-gate break;
18607c478bd9Sstevel@tonic-gate }
18617c478bd9Sstevel@tonic-gate
18627c478bd9Sstevel@tonic-gate tp->tim_flags &= ~(WAITIOCACK | TI_CAP_RECVD |
18637c478bd9Sstevel@tonic-gate WAIT_IOCINFOACK | CAP_WANTS_INFO);
18647c478bd9Sstevel@tonic-gate ((struct T_capability_ack *)
18657c478bd9Sstevel@tonic-gate tcsr_mp->b_rptr)->CAP_bits1 = 0;
18667c478bd9Sstevel@tonic-gate tim_ioctl_send_reply(q, mp, tcsr_mp);
18677c478bd9Sstevel@tonic-gate
18687c478bd9Sstevel@tonic-gate /*
18697c478bd9Sstevel@tonic-gate * It could happen when timod is awaiting ack
18707c478bd9Sstevel@tonic-gate * for TI_GETPEERNAME/TI_GETMYNAME.
18717c478bd9Sstevel@tonic-gate */
18727c478bd9Sstevel@tonic-gate if (tp->tim_iocsave != NULL) {
18737c478bd9Sstevel@tonic-gate freemsg(tp->tim_iocsave);
18747c478bd9Sstevel@tonic-gate tp->tim_iocsave = NULL;
18757c478bd9Sstevel@tonic-gate tp->tim_saved_prim = -1;
18767c478bd9Sstevel@tonic-gate }
18777c478bd9Sstevel@tonic-gate break;
18787c478bd9Sstevel@tonic-gate
18797c478bd9Sstevel@tonic-gate default:
18807c478bd9Sstevel@tonic-gate cmn_err(CE_PANIC,
18817c478bd9Sstevel@tonic-gate "timodwproc: unknown tpi_capability value "
18827c478bd9Sstevel@tonic-gate "%d\n", tp->tim_provinfo->tpi_capability);
18837c478bd9Sstevel@tonic-gate break;
18847c478bd9Sstevel@tonic-gate }
18857c478bd9Sstevel@tonic-gate }
18867c478bd9Sstevel@tonic-gate break;
18877c478bd9Sstevel@tonic-gate
18887c478bd9Sstevel@tonic-gate case TI_GETMYNAME:
18897c478bd9Sstevel@tonic-gate
18907c478bd9Sstevel@tonic-gate tilog("timodwproc: Got TI_GETMYNAME\n", 0);
18917c478bd9Sstevel@tonic-gate
18927c478bd9Sstevel@tonic-gate if (tp->tim_provinfo->tpi_myname == PI_YES) {
18937c478bd9Sstevel@tonic-gate putnext(q, mp);
18947c478bd9Sstevel@tonic-gate break;
18957c478bd9Sstevel@tonic-gate }
18967c478bd9Sstevel@tonic-gate goto getname;
18977c478bd9Sstevel@tonic-gate
18987c478bd9Sstevel@tonic-gate case TI_GETPEERNAME:
18997c478bd9Sstevel@tonic-gate
19007c478bd9Sstevel@tonic-gate tilog("timodwproc: Got TI_GETPEERNAME\n", 0);
19017c478bd9Sstevel@tonic-gate
19027c478bd9Sstevel@tonic-gate if (tp->tim_provinfo->tpi_peername == PI_YES) {
19037c478bd9Sstevel@tonic-gate putnext(q, mp);
19047c478bd9Sstevel@tonic-gate break;
19057c478bd9Sstevel@tonic-gate }
19067c478bd9Sstevel@tonic-gate getname:
19077c478bd9Sstevel@tonic-gate if ((tmp = copymsg(mp)) == NULL) {
19087c478bd9Sstevel@tonic-gate tim_recover(q, mp, msgsize(mp));
19097c478bd9Sstevel@tonic-gate return (1);
19107c478bd9Sstevel@tonic-gate }
19117c478bd9Sstevel@tonic-gate /*
19127c478bd9Sstevel@tonic-gate * tim_iocsave may be non-NULL when timod is awaiting
19137c478bd9Sstevel@tonic-gate * ack for another TI_GETPEERNAME/TI_GETMYNAME.
19147c478bd9Sstevel@tonic-gate */
19157c478bd9Sstevel@tonic-gate freemsg(tp->tim_iocsave);
19167c478bd9Sstevel@tonic-gate tp->tim_iocsave = mp;
19177c478bd9Sstevel@tonic-gate tp->tim_saved_prim = -1;
19187c478bd9Sstevel@tonic-gate putnext(q, tmp);
19197c478bd9Sstevel@tonic-gate break;
19207c478bd9Sstevel@tonic-gate }
19217c478bd9Sstevel@tonic-gate break;
19227c478bd9Sstevel@tonic-gate
19237c478bd9Sstevel@tonic-gate case M_IOCDATA:
19247c478bd9Sstevel@tonic-gate
19257c478bd9Sstevel@tonic-gate if (tp->tim_flags & NAMEPROC) {
19267c478bd9Sstevel@tonic-gate if (ti_doname(q, mp) != DONAME_CONT) {
19277c478bd9Sstevel@tonic-gate tp->tim_flags &= ~NAMEPROC;
19287c478bd9Sstevel@tonic-gate }
19297c478bd9Sstevel@tonic-gate } else
19307c478bd9Sstevel@tonic-gate putnext(q, mp);
19317c478bd9Sstevel@tonic-gate break;
19327c478bd9Sstevel@tonic-gate
19337c478bd9Sstevel@tonic-gate case M_PROTO:
19347c478bd9Sstevel@tonic-gate case M_PCPROTO:
19357c478bd9Sstevel@tonic-gate if (MBLKL(mp) < sizeof (t_scalar_t)) {
19367c478bd9Sstevel@tonic-gate merror(q, mp, EPROTO);
19377c478bd9Sstevel@tonic-gate return (1);
19387c478bd9Sstevel@tonic-gate }
19397c478bd9Sstevel@tonic-gate
19407c478bd9Sstevel@tonic-gate pptr = (union T_primitives *)mp->b_rptr;
19417c478bd9Sstevel@tonic-gate switch (pptr->type) {
19427c478bd9Sstevel@tonic-gate default:
19437c478bd9Sstevel@tonic-gate putnext(q, mp);
19447c478bd9Sstevel@tonic-gate break;
19457c478bd9Sstevel@tonic-gate
19467c478bd9Sstevel@tonic-gate case T_EXDATA_REQ:
19477c478bd9Sstevel@tonic-gate case T_DATA_REQ:
19487c478bd9Sstevel@tonic-gate if (pptr->type == T_EXDATA_REQ)
19497c478bd9Sstevel@tonic-gate tilog("timodwproc: Got T_EXDATA_REQ\n", 0);
19507c478bd9Sstevel@tonic-gate
19517c478bd9Sstevel@tonic-gate if (!bcanputnext(q, mp->b_band)) {
19527c478bd9Sstevel@tonic-gate (void) putbq(q, mp);
19537c478bd9Sstevel@tonic-gate return (1);
19547c478bd9Sstevel@tonic-gate }
19557c478bd9Sstevel@tonic-gate putnext(q, mp);
19567c478bd9Sstevel@tonic-gate break;
19577c478bd9Sstevel@tonic-gate
19587c478bd9Sstevel@tonic-gate case T_UNITDATA_REQ:
19597c478bd9Sstevel@tonic-gate if (tp->tim_flags & CLTS) {
19607c478bd9Sstevel@tonic-gate tmp = tim_filladdr(q, mp, B_TRUE);
19617c478bd9Sstevel@tonic-gate if (tmp == NULL) {
19627c478bd9Sstevel@tonic-gate return (1);
19637c478bd9Sstevel@tonic-gate } else {
19647c478bd9Sstevel@tonic-gate mp = tmp;
19657c478bd9Sstevel@tonic-gate }
19667c478bd9Sstevel@tonic-gate }
1967005d3febSMarek Pospisil if (auditing)
19687c478bd9Sstevel@tonic-gate audit_sock(T_UNITDATA_REQ, q, mp, TIMOD_ID);
19697c478bd9Sstevel@tonic-gate if (!bcanputnext(q, mp->b_band)) {
19707c478bd9Sstevel@tonic-gate (void) putbq(q, mp);
19717c478bd9Sstevel@tonic-gate return (1);
19727c478bd9Sstevel@tonic-gate }
19737c478bd9Sstevel@tonic-gate putnext(q, mp);
19747c478bd9Sstevel@tonic-gate break;
19757c478bd9Sstevel@tonic-gate
19767c478bd9Sstevel@tonic-gate case T_CONN_REQ: {
19777c478bd9Sstevel@tonic-gate struct T_conn_req *reqp = (struct T_conn_req *)
19787c478bd9Sstevel@tonic-gate mp->b_rptr;
19797c478bd9Sstevel@tonic-gate void *p;
19807c478bd9Sstevel@tonic-gate
19817c478bd9Sstevel@tonic-gate tilog("timodwproc: Got T_CONN_REQ\n", 0);
19827c478bd9Sstevel@tonic-gate
19837c478bd9Sstevel@tonic-gate if (MBLKL(mp) < sizeof (struct T_conn_req)) {
19847c478bd9Sstevel@tonic-gate merror(q, mp, EPROTO);
19857c478bd9Sstevel@tonic-gate return (1);
19867c478bd9Sstevel@tonic-gate }
19877c478bd9Sstevel@tonic-gate
19887c478bd9Sstevel@tonic-gate if (tp->tim_flags & DO_PEERNAME) {
19897c478bd9Sstevel@tonic-gate if (!MBLKIN(mp, reqp->DEST_offset,
19907c478bd9Sstevel@tonic-gate reqp->DEST_length)) {
19917c478bd9Sstevel@tonic-gate merror(q, mp, EPROTO);
19927c478bd9Sstevel@tonic-gate return (1);
19937c478bd9Sstevel@tonic-gate }
19947c478bd9Sstevel@tonic-gate ASSERT(reqp->DEST_length >= 0);
19957c478bd9Sstevel@tonic-gate mutex_enter(&tp->tim_mutex);
19967c478bd9Sstevel@tonic-gate if (reqp->DEST_length > tp->tim_peermaxlen) {
19977c478bd9Sstevel@tonic-gate p = kmem_alloc(reqp->DEST_length,
19987c478bd9Sstevel@tonic-gate KM_NOSLEEP);
19997c478bd9Sstevel@tonic-gate if (p == NULL) {
20007c478bd9Sstevel@tonic-gate mutex_exit(&tp->tim_mutex);
20017c478bd9Sstevel@tonic-gate tilog("timodwproc: kmem_alloc "
20027c478bd9Sstevel@tonic-gate "failed, attempting "
20037c478bd9Sstevel@tonic-gate "recovery\n", 0);
20047c478bd9Sstevel@tonic-gate tim_recover(q, mp,
20057c478bd9Sstevel@tonic-gate reqp->DEST_length);
20067c478bd9Sstevel@tonic-gate return (1);
20077c478bd9Sstevel@tonic-gate }
20087c478bd9Sstevel@tonic-gate if (tp->tim_peermaxlen)
20097c478bd9Sstevel@tonic-gate kmem_free(tp->tim_peername,
20107c478bd9Sstevel@tonic-gate tp->tim_peermaxlen);
20117c478bd9Sstevel@tonic-gate tp->tim_peername = p;
20127c478bd9Sstevel@tonic-gate tp->tim_peermaxlen = reqp->DEST_length;
20137c478bd9Sstevel@tonic-gate }
20147c478bd9Sstevel@tonic-gate tp->tim_peerlen = reqp->DEST_length;
20157c478bd9Sstevel@tonic-gate p = mp->b_rptr + reqp->DEST_offset;
20167c478bd9Sstevel@tonic-gate bcopy(p, tp->tim_peername, tp->tim_peerlen);
20177c478bd9Sstevel@tonic-gate mutex_exit(&tp->tim_mutex);
20187c478bd9Sstevel@tonic-gate }
20197c478bd9Sstevel@tonic-gate if (tp->tim_flags & COTS)
20207c478bd9Sstevel@tonic-gate tp->tim_flags |= CONNWAIT;
2021005d3febSMarek Pospisil if (auditing)
20227c478bd9Sstevel@tonic-gate audit_sock(T_CONN_REQ, q, mp, TIMOD_ID);
20237c478bd9Sstevel@tonic-gate putnext(q, mp);
20247c478bd9Sstevel@tonic-gate break;
20257c478bd9Sstevel@tonic-gate }
20267c478bd9Sstevel@tonic-gate
20277c478bd9Sstevel@tonic-gate case O_T_CONN_RES:
20287c478bd9Sstevel@tonic-gate case T_CONN_RES: {
20297c478bd9Sstevel@tonic-gate struct T_conn_res *resp;
20307c478bd9Sstevel@tonic-gate struct T_conn_ind *indp;
20317c478bd9Sstevel@tonic-gate mblk_t *pmp = NULL;
20327c478bd9Sstevel@tonic-gate mblk_t *nbp;
20337c478bd9Sstevel@tonic-gate
20347c478bd9Sstevel@tonic-gate if (MBLKL(mp) < sizeof (struct T_conn_res) ||
20357c478bd9Sstevel@tonic-gate (tp->tim_flags & WAITIOCACK)) {
20367c478bd9Sstevel@tonic-gate merror(q, mp, EPROTO);
20377c478bd9Sstevel@tonic-gate return (1);
20387c478bd9Sstevel@tonic-gate }
20397c478bd9Sstevel@tonic-gate
20407c478bd9Sstevel@tonic-gate resp = (struct T_conn_res *)mp->b_rptr;
20417c478bd9Sstevel@tonic-gate for (tmp = tp->tim_consave; tmp != NULL;
20427c478bd9Sstevel@tonic-gate tmp = tmp->b_next) {
20437c478bd9Sstevel@tonic-gate indp = (struct T_conn_ind *)tmp->b_rptr;
20447c478bd9Sstevel@tonic-gate if (indp->SEQ_number == resp->SEQ_number)
20457c478bd9Sstevel@tonic-gate break;
20467c478bd9Sstevel@tonic-gate pmp = tmp;
20477c478bd9Sstevel@tonic-gate }
20487c478bd9Sstevel@tonic-gate if (tmp == NULL)
20497c478bd9Sstevel@tonic-gate goto cresout;
20507c478bd9Sstevel@tonic-gate
20517c478bd9Sstevel@tonic-gate if ((nbp = dupb(mp)) == NULL &&
20527c478bd9Sstevel@tonic-gate (nbp = copyb(mp)) == NULL) {
20537c478bd9Sstevel@tonic-gate tim_recover(q, mp, msgsize(mp));
20547c478bd9Sstevel@tonic-gate return (1);
20557c478bd9Sstevel@tonic-gate }
20567c478bd9Sstevel@tonic-gate
20577c478bd9Sstevel@tonic-gate if (pmp != NULL)
20587c478bd9Sstevel@tonic-gate pmp->b_next = tmp->b_next;
20597c478bd9Sstevel@tonic-gate else
20607c478bd9Sstevel@tonic-gate tp->tim_consave = tmp->b_next;
20617c478bd9Sstevel@tonic-gate tmp->b_next = NULL;
20627c478bd9Sstevel@tonic-gate
20637c478bd9Sstevel@tonic-gate /*
20647c478bd9Sstevel@tonic-gate * Construct a list with:
20657c478bd9Sstevel@tonic-gate * nbp - copy of user's original request
20667c478bd9Sstevel@tonic-gate * tmp - the extracted T_conn_ind
20677c478bd9Sstevel@tonic-gate */
20687c478bd9Sstevel@tonic-gate nbp->b_cont = tmp;
20697c478bd9Sstevel@tonic-gate /*
20707c478bd9Sstevel@tonic-gate * tim_iocsave may be non-NULL when timod is awaiting
20717c478bd9Sstevel@tonic-gate * ack for TI_GETPEERNAME/TI_GETMYNAME.
20727c478bd9Sstevel@tonic-gate */
20737c478bd9Sstevel@tonic-gate freemsg(tp->tim_iocsave);
20747c478bd9Sstevel@tonic-gate tp->tim_iocsave = nbp;
20757c478bd9Sstevel@tonic-gate tp->tim_saved_prim = pptr->type;
20767c478bd9Sstevel@tonic-gate tp->tim_flags |= WAIT_CONNRESACK | WAITIOCACK;
20777c478bd9Sstevel@tonic-gate
20787c478bd9Sstevel@tonic-gate cresout:
20797c478bd9Sstevel@tonic-gate putnext(q, mp);
20807c478bd9Sstevel@tonic-gate break;
20817c478bd9Sstevel@tonic-gate }
20827c478bd9Sstevel@tonic-gate
20837c478bd9Sstevel@tonic-gate case T_DISCON_REQ: {
20847c478bd9Sstevel@tonic-gate struct T_discon_req *disp;
20857c478bd9Sstevel@tonic-gate struct T_conn_ind *conp;
20867c478bd9Sstevel@tonic-gate mblk_t *pmp = NULL;
20877c478bd9Sstevel@tonic-gate
20887c478bd9Sstevel@tonic-gate if (MBLKL(mp) < sizeof (struct T_discon_req)) {
20897c478bd9Sstevel@tonic-gate merror(q, mp, EPROTO);
20907c478bd9Sstevel@tonic-gate return (1);
20917c478bd9Sstevel@tonic-gate }
20927c478bd9Sstevel@tonic-gate
20937c478bd9Sstevel@tonic-gate disp = (struct T_discon_req *)mp->b_rptr;
20947c478bd9Sstevel@tonic-gate tp->tim_flags &= ~(CONNWAIT|LOCORDREL|REMORDREL);
20957c478bd9Sstevel@tonic-gate tim_clear_peer(tp);
20967c478bd9Sstevel@tonic-gate
20977c478bd9Sstevel@tonic-gate /*
20987c478bd9Sstevel@tonic-gate * If we are already connected, there won't
20997c478bd9Sstevel@tonic-gate * be any messages on tim_consave.
21007c478bd9Sstevel@tonic-gate */
21017c478bd9Sstevel@tonic-gate for (tmp = tp->tim_consave; tmp; tmp = tmp->b_next) {
21027c478bd9Sstevel@tonic-gate conp = (struct T_conn_ind *)tmp->b_rptr;
21037c478bd9Sstevel@tonic-gate if (conp->SEQ_number == disp->SEQ_number)
21047c478bd9Sstevel@tonic-gate break;
21057c478bd9Sstevel@tonic-gate pmp = tmp;
21067c478bd9Sstevel@tonic-gate }
21077c478bd9Sstevel@tonic-gate if (tmp) {
21087c478bd9Sstevel@tonic-gate if (pmp)
21097c478bd9Sstevel@tonic-gate pmp->b_next = tmp->b_next;
21107c478bd9Sstevel@tonic-gate else
21117c478bd9Sstevel@tonic-gate tp->tim_consave = tmp->b_next;
21127c478bd9Sstevel@tonic-gate tmp->b_next = NULL;
21137c478bd9Sstevel@tonic-gate freemsg(tmp);
21147c478bd9Sstevel@tonic-gate }
21157c478bd9Sstevel@tonic-gate putnext(q, mp);
21167c478bd9Sstevel@tonic-gate break;
21177c478bd9Sstevel@tonic-gate }
21187c478bd9Sstevel@tonic-gate
21197c478bd9Sstevel@tonic-gate case T_ORDREL_REQ:
21207c478bd9Sstevel@tonic-gate if (tp->tim_flags & REMORDREL) {
21217c478bd9Sstevel@tonic-gate tp->tim_flags &= ~(LOCORDREL|REMORDREL);
21227c478bd9Sstevel@tonic-gate tim_clear_peer(tp);
21237c478bd9Sstevel@tonic-gate } else {
21247c478bd9Sstevel@tonic-gate tp->tim_flags |= LOCORDREL;
21257c478bd9Sstevel@tonic-gate }
21267c478bd9Sstevel@tonic-gate putnext(q, mp);
21277c478bd9Sstevel@tonic-gate break;
21287c478bd9Sstevel@tonic-gate
21297c478bd9Sstevel@tonic-gate case T_CAPABILITY_REQ:
21307c478bd9Sstevel@tonic-gate tilog("timodwproc: Got T_CAPABILITY_REQ\n", 0);
21317c478bd9Sstevel@tonic-gate /*
21327c478bd9Sstevel@tonic-gate * XXX: We may know at this point whether transport
21337c478bd9Sstevel@tonic-gate * provides T_CAPABILITY_REQ or not and we may utilise
21347c478bd9Sstevel@tonic-gate * this knowledge here.
21357c478bd9Sstevel@tonic-gate */
21367c478bd9Sstevel@tonic-gate putnext(q, mp);
21377c478bd9Sstevel@tonic-gate break;
21387c478bd9Sstevel@tonic-gate }
21397c478bd9Sstevel@tonic-gate break;
21407c478bd9Sstevel@tonic-gate case M_FLUSH:
21417c478bd9Sstevel@tonic-gate
21427c478bd9Sstevel@tonic-gate tilog("timodwproc: Got M_FLUSH\n", 0);
21437c478bd9Sstevel@tonic-gate
21447c478bd9Sstevel@tonic-gate if (*mp->b_rptr & FLUSHW) {
21457c478bd9Sstevel@tonic-gate if (*mp->b_rptr & FLUSHBAND)
21467c478bd9Sstevel@tonic-gate flushband(q, *(mp->b_rptr + 1), FLUSHDATA);
21477c478bd9Sstevel@tonic-gate else
21487c478bd9Sstevel@tonic-gate flushq(q, FLUSHDATA);
21497c478bd9Sstevel@tonic-gate }
21507c478bd9Sstevel@tonic-gate putnext(q, mp);
21517c478bd9Sstevel@tonic-gate break;
21527c478bd9Sstevel@tonic-gate }
21537c478bd9Sstevel@tonic-gate
21547c478bd9Sstevel@tonic-gate return (0);
21557c478bd9Sstevel@tonic-gate }
21567c478bd9Sstevel@tonic-gate
21577c478bd9Sstevel@tonic-gate static void
tilog(char * str,t_scalar_t arg)21587c478bd9Sstevel@tonic-gate tilog(char *str, t_scalar_t arg)
21597c478bd9Sstevel@tonic-gate {
21607c478bd9Sstevel@tonic-gate if (dotilog) {
21617c478bd9Sstevel@tonic-gate if (dotilog & 2)
21627c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, str, arg);
21637c478bd9Sstevel@tonic-gate if (dotilog & 4)
21647c478bd9Sstevel@tonic-gate (void) strlog(TIMOD_ID, -1, 0, SL_TRACE | SL_ERROR,
21657c478bd9Sstevel@tonic-gate str, arg);
21667c478bd9Sstevel@tonic-gate else
21677c478bd9Sstevel@tonic-gate (void) strlog(TIMOD_ID, -1, 0, SL_TRACE, str, arg);
21687c478bd9Sstevel@tonic-gate }
21697c478bd9Sstevel@tonic-gate }
21707c478bd9Sstevel@tonic-gate
21717c478bd9Sstevel@tonic-gate static void
tilogp(char * str,uintptr_t arg)21727c478bd9Sstevel@tonic-gate tilogp(char *str, uintptr_t arg)
21737c478bd9Sstevel@tonic-gate {
21747c478bd9Sstevel@tonic-gate if (dotilog) {
21757c478bd9Sstevel@tonic-gate if (dotilog & 2)
21767c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, str, arg);
21777c478bd9Sstevel@tonic-gate if (dotilog & 4)
21787c478bd9Sstevel@tonic-gate (void) strlog(TIMOD_ID, -1, 0, SL_TRACE | SL_ERROR,
21797c478bd9Sstevel@tonic-gate str, arg);
21807c478bd9Sstevel@tonic-gate else
21817c478bd9Sstevel@tonic-gate (void) strlog(TIMOD_ID, -1, 0, SL_TRACE, str, arg);
21827c478bd9Sstevel@tonic-gate }
21837c478bd9Sstevel@tonic-gate }
21847c478bd9Sstevel@tonic-gate
21857c478bd9Sstevel@tonic-gate
21867c478bd9Sstevel@tonic-gate /*
21877c478bd9Sstevel@tonic-gate * Process the TI_GETNAME ioctl. If no name exists, return len = 0
21887c478bd9Sstevel@tonic-gate * in strbuf structures. The state transitions are determined by what
21897c478bd9Sstevel@tonic-gate * is hung of cq_private (cp_private) in the copyresp (copyreq) structure.
21907c478bd9Sstevel@tonic-gate * The high-level steps in the ioctl processing are as follows:
21917c478bd9Sstevel@tonic-gate *
21927c478bd9Sstevel@tonic-gate * 1) we recieve an transparent M_IOCTL with the arg in the second message
21937c478bd9Sstevel@tonic-gate * block of the message.
21947c478bd9Sstevel@tonic-gate * 2) we send up an M_COPYIN request for the strbuf structure pointed to
21957c478bd9Sstevel@tonic-gate * by arg. The block containing arg is hung off cq_private.
21967c478bd9Sstevel@tonic-gate * 3) we receive an M_IOCDATA response with cp->cp_private->b_cont == NULL.
21977c478bd9Sstevel@tonic-gate * This means that the strbuf structure is found in the message block
21987c478bd9Sstevel@tonic-gate * mp->b_cont.
21997c478bd9Sstevel@tonic-gate * 4) we send up an M_COPYOUT request with the strbuf message hung off
22007c478bd9Sstevel@tonic-gate * cq_private->b_cont. The address we are copying to is strbuf.buf.
22017c478bd9Sstevel@tonic-gate * we set strbuf.len to 0 to indicate that we should copy the strbuf
22027c478bd9Sstevel@tonic-gate * structure the next time. The message mp->b_cont contains the
22037c478bd9Sstevel@tonic-gate * address info.
22047c478bd9Sstevel@tonic-gate * 5) we receive an M_IOCDATA with cp_private->b_cont != NULL and
22057c478bd9Sstevel@tonic-gate * strbuf.len == 0. Restore strbuf.len to either tp->tim_mylen or
22067c478bd9Sstevel@tonic-gate * tp->tim_peerlen.
22077c478bd9Sstevel@tonic-gate * 6) we send up an M_COPYOUT request with a copy of the strbuf message
22087c478bd9Sstevel@tonic-gate * hung off mp->b_cont. In the strbuf structure in the message hung
22097c478bd9Sstevel@tonic-gate * off cq_private->b_cont, we set strbuf.len to 0 and strbuf.maxlen
22107c478bd9Sstevel@tonic-gate * to 0. This means that the next step is to ACK the ioctl.
22117c478bd9Sstevel@tonic-gate * 7) we receive an M_IOCDATA message with cp_private->b_cont != NULL and
22127c478bd9Sstevel@tonic-gate * strbuf.len == 0 and strbuf.maxlen == 0. Free up cp->private and
22137c478bd9Sstevel@tonic-gate * send an M_IOCACK upstream, and we are done.
22147c478bd9Sstevel@tonic-gate *
22157c478bd9Sstevel@tonic-gate */
22167c478bd9Sstevel@tonic-gate static int
ti_doname(queue_t * q,mblk_t * mp)22177c478bd9Sstevel@tonic-gate ti_doname(
22187c478bd9Sstevel@tonic-gate queue_t *q, /* queue message arrived at */
22197c478bd9Sstevel@tonic-gate mblk_t *mp) /* M_IOCTL or M_IOCDATA message only */
22207c478bd9Sstevel@tonic-gate {
22217c478bd9Sstevel@tonic-gate struct iocblk *iocp;
22227c478bd9Sstevel@tonic-gate struct copyreq *cqp;
22237c478bd9Sstevel@tonic-gate STRUCT_HANDLE(strbuf, sb);
22247c478bd9Sstevel@tonic-gate struct copyresp *csp;
22257c478bd9Sstevel@tonic-gate int ret;
22267c478bd9Sstevel@tonic-gate mblk_t *bp;
22277c478bd9Sstevel@tonic-gate struct tim_tim *tp = q->q_ptr;
22287c478bd9Sstevel@tonic-gate boolean_t getpeer;
22297c478bd9Sstevel@tonic-gate
22307c478bd9Sstevel@tonic-gate switch (mp->b_datap->db_type) {
22317c478bd9Sstevel@tonic-gate case M_IOCTL:
22327c478bd9Sstevel@tonic-gate iocp = (struct iocblk *)mp->b_rptr;
22337c478bd9Sstevel@tonic-gate if ((iocp->ioc_cmd != TI_GETMYNAME) &&
22347c478bd9Sstevel@tonic-gate (iocp->ioc_cmd != TI_GETPEERNAME)) {
22357c478bd9Sstevel@tonic-gate tilog("ti_doname: bad M_IOCTL command\n", 0);
22367c478bd9Sstevel@tonic-gate miocnak(q, mp, 0, EINVAL);
22377c478bd9Sstevel@tonic-gate ret = DONAME_FAIL;
22387c478bd9Sstevel@tonic-gate break;
22397c478bd9Sstevel@tonic-gate }
22407c478bd9Sstevel@tonic-gate if ((iocp->ioc_count != TRANSPARENT)) {
22417c478bd9Sstevel@tonic-gate miocnak(q, mp, 0, EINVAL);
22427c478bd9Sstevel@tonic-gate ret = DONAME_FAIL;
22437c478bd9Sstevel@tonic-gate break;
22447c478bd9Sstevel@tonic-gate }
22457c478bd9Sstevel@tonic-gate
22467c478bd9Sstevel@tonic-gate cqp = (struct copyreq *)mp->b_rptr;
22477c478bd9Sstevel@tonic-gate cqp->cq_private = mp->b_cont;
22487c478bd9Sstevel@tonic-gate cqp->cq_addr = (caddr_t)*(intptr_t *)mp->b_cont->b_rptr;
22497c478bd9Sstevel@tonic-gate mp->b_cont = NULL;
22507c478bd9Sstevel@tonic-gate cqp->cq_size = SIZEOF_STRUCT(strbuf, iocp->ioc_flag);
22517c478bd9Sstevel@tonic-gate cqp->cq_flag = 0;
22527c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_COPYIN;
22537c478bd9Sstevel@tonic-gate mp->b_wptr = mp->b_rptr + sizeof (struct copyreq);
22547c478bd9Sstevel@tonic-gate qreply(q, mp);
22557c478bd9Sstevel@tonic-gate ret = DONAME_CONT;
22567c478bd9Sstevel@tonic-gate break;
22577c478bd9Sstevel@tonic-gate
22587c478bd9Sstevel@tonic-gate case M_IOCDATA:
22597c478bd9Sstevel@tonic-gate csp = (struct copyresp *)mp->b_rptr;
22607c478bd9Sstevel@tonic-gate iocp = (struct iocblk *)mp->b_rptr;
22617c478bd9Sstevel@tonic-gate cqp = (struct copyreq *)mp->b_rptr;
22627c478bd9Sstevel@tonic-gate if ((csp->cp_cmd != TI_GETMYNAME) &&
22637c478bd9Sstevel@tonic-gate (csp->cp_cmd != TI_GETPEERNAME)) {
22647c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "ti_doname: bad M_IOCDATA command\n");
22657c478bd9Sstevel@tonic-gate miocnak(q, mp, 0, EINVAL);
22667c478bd9Sstevel@tonic-gate ret = DONAME_FAIL;
22677c478bd9Sstevel@tonic-gate break;
22687c478bd9Sstevel@tonic-gate }
22697c478bd9Sstevel@tonic-gate if (csp->cp_rval) { /* error */
22707c478bd9Sstevel@tonic-gate freemsg(csp->cp_private);
22717c478bd9Sstevel@tonic-gate freemsg(mp);
22727c478bd9Sstevel@tonic-gate ret = DONAME_FAIL;
22737c478bd9Sstevel@tonic-gate break;
22747c478bd9Sstevel@tonic-gate }
22757c478bd9Sstevel@tonic-gate ASSERT(csp->cp_private != NULL);
22767c478bd9Sstevel@tonic-gate getpeer = csp->cp_cmd == TI_GETPEERNAME;
22777c478bd9Sstevel@tonic-gate if (getpeer)
22787c478bd9Sstevel@tonic-gate mutex_enter(&tp->tim_mutex);
22797c478bd9Sstevel@tonic-gate if (csp->cp_private->b_cont == NULL) { /* got strbuf */
22807c478bd9Sstevel@tonic-gate ASSERT(mp->b_cont);
22817c478bd9Sstevel@tonic-gate STRUCT_SET_HANDLE(sb, iocp->ioc_flag,
22827c478bd9Sstevel@tonic-gate (void *)mp->b_cont->b_rptr);
22837c478bd9Sstevel@tonic-gate if (getpeer) {
22847c478bd9Sstevel@tonic-gate if (tp->tim_peerlen == 0) {
22857c478bd9Sstevel@tonic-gate /* copy just strbuf */
22867c478bd9Sstevel@tonic-gate STRUCT_FSET(sb, len, 0);
22877c478bd9Sstevel@tonic-gate } else if (tp->tim_peerlen >
22887c478bd9Sstevel@tonic-gate STRUCT_FGET(sb, maxlen)) {
22897c478bd9Sstevel@tonic-gate mutex_exit(&tp->tim_mutex);
22907c478bd9Sstevel@tonic-gate miocnak(q, mp, 0, ENAMETOOLONG);
22917c478bd9Sstevel@tonic-gate ret = DONAME_FAIL;
22927c478bd9Sstevel@tonic-gate break;
22937c478bd9Sstevel@tonic-gate } else {
22947c478bd9Sstevel@tonic-gate /* copy buffer */
22957c478bd9Sstevel@tonic-gate STRUCT_FSET(sb, len, tp->tim_peerlen);
22967c478bd9Sstevel@tonic-gate }
22977c478bd9Sstevel@tonic-gate } else {
22987c478bd9Sstevel@tonic-gate if (tp->tim_mylen == 0) {
22997c478bd9Sstevel@tonic-gate /* copy just strbuf */
23007c478bd9Sstevel@tonic-gate STRUCT_FSET(sb, len, 0);
23017c478bd9Sstevel@tonic-gate } else if (tp->tim_mylen >
23027c478bd9Sstevel@tonic-gate STRUCT_FGET(sb, maxlen)) {
23037c478bd9Sstevel@tonic-gate freemsg(csp->cp_private);
23047c478bd9Sstevel@tonic-gate miocnak(q, mp, 0, ENAMETOOLONG);
23057c478bd9Sstevel@tonic-gate ret = DONAME_FAIL;
23067c478bd9Sstevel@tonic-gate break;
23077c478bd9Sstevel@tonic-gate } else {
23087c478bd9Sstevel@tonic-gate /* copy buffer */
23097c478bd9Sstevel@tonic-gate STRUCT_FSET(sb, len, tp->tim_mylen);
23107c478bd9Sstevel@tonic-gate }
23117c478bd9Sstevel@tonic-gate }
23127c478bd9Sstevel@tonic-gate csp->cp_private->b_cont = mp->b_cont;
23137c478bd9Sstevel@tonic-gate mp->b_cont = NULL;
23147c478bd9Sstevel@tonic-gate }
23157c478bd9Sstevel@tonic-gate STRUCT_SET_HANDLE(sb, iocp->ioc_flag,
23167c478bd9Sstevel@tonic-gate (void *)csp->cp_private->b_cont->b_rptr);
23177c478bd9Sstevel@tonic-gate if (STRUCT_FGET(sb, len) == 0) {
23187c478bd9Sstevel@tonic-gate /*
23197c478bd9Sstevel@tonic-gate * restore strbuf.len
23207c478bd9Sstevel@tonic-gate */
23217c478bd9Sstevel@tonic-gate if (getpeer)
23227c478bd9Sstevel@tonic-gate STRUCT_FSET(sb, len, tp->tim_peerlen);
23237c478bd9Sstevel@tonic-gate else
23247c478bd9Sstevel@tonic-gate STRUCT_FSET(sb, len, tp->tim_mylen);
23257c478bd9Sstevel@tonic-gate
23267c478bd9Sstevel@tonic-gate if (getpeer)
23277c478bd9Sstevel@tonic-gate mutex_exit(&tp->tim_mutex);
23287c478bd9Sstevel@tonic-gate if (STRUCT_FGET(sb, maxlen) == 0) {
23297c478bd9Sstevel@tonic-gate
23307c478bd9Sstevel@tonic-gate /*
23317c478bd9Sstevel@tonic-gate * ack the ioctl
23327c478bd9Sstevel@tonic-gate */
23337c478bd9Sstevel@tonic-gate freemsg(csp->cp_private);
23347c478bd9Sstevel@tonic-gate tim_ioctl_send_reply(q, mp, NULL);
23357c478bd9Sstevel@tonic-gate ret = DONAME_DONE;
23367c478bd9Sstevel@tonic-gate break;
23377c478bd9Sstevel@tonic-gate }
23387c478bd9Sstevel@tonic-gate
23397c478bd9Sstevel@tonic-gate if ((bp = allocb(STRUCT_SIZE(sb), BPRI_MED)) == NULL) {
23407c478bd9Sstevel@tonic-gate
23417c478bd9Sstevel@tonic-gate tilog(
23427c478bd9Sstevel@tonic-gate "ti_doname: allocb failed no recovery attempt\n", 0);
23437c478bd9Sstevel@tonic-gate
23447c478bd9Sstevel@tonic-gate freemsg(csp->cp_private);
23457c478bd9Sstevel@tonic-gate miocnak(q, mp, 0, EAGAIN);
23467c478bd9Sstevel@tonic-gate ret = DONAME_FAIL;
23477c478bd9Sstevel@tonic-gate break;
23487c478bd9Sstevel@tonic-gate }
23497c478bd9Sstevel@tonic-gate bp->b_wptr += STRUCT_SIZE(sb);
23507c478bd9Sstevel@tonic-gate bcopy(STRUCT_BUF(sb), bp->b_rptr, STRUCT_SIZE(sb));
23517c478bd9Sstevel@tonic-gate cqp->cq_addr =
23527c478bd9Sstevel@tonic-gate (caddr_t)*(intptr_t *)csp->cp_private->b_rptr;
23537c478bd9Sstevel@tonic-gate cqp->cq_size = STRUCT_SIZE(sb);
23547c478bd9Sstevel@tonic-gate cqp->cq_flag = 0;
23557c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_COPYOUT;
23567c478bd9Sstevel@tonic-gate mp->b_cont = bp;
23577c478bd9Sstevel@tonic-gate STRUCT_FSET(sb, len, 0);
23587c478bd9Sstevel@tonic-gate STRUCT_FSET(sb, maxlen, 0); /* ack next time around */
23597c478bd9Sstevel@tonic-gate qreply(q, mp);
23607c478bd9Sstevel@tonic-gate ret = DONAME_CONT;
23617c478bd9Sstevel@tonic-gate break;
23627c478bd9Sstevel@tonic-gate }
23637c478bd9Sstevel@tonic-gate
23647c478bd9Sstevel@tonic-gate /*
23657c478bd9Sstevel@tonic-gate * copy the address to the user
23667c478bd9Sstevel@tonic-gate */
23677c478bd9Sstevel@tonic-gate if ((bp = allocb((size_t)STRUCT_FGET(sb, len), BPRI_MED))
23687c478bd9Sstevel@tonic-gate == NULL) {
23697c478bd9Sstevel@tonic-gate if (getpeer)
23707c478bd9Sstevel@tonic-gate mutex_exit(&tp->tim_mutex);
23717c478bd9Sstevel@tonic-gate
23727c478bd9Sstevel@tonic-gate tilog("ti_doname: allocb failed no recovery attempt\n",
23737c478bd9Sstevel@tonic-gate 0);
23747c478bd9Sstevel@tonic-gate
23757c478bd9Sstevel@tonic-gate freemsg(csp->cp_private);
23767c478bd9Sstevel@tonic-gate miocnak(q, mp, 0, EAGAIN);
23777c478bd9Sstevel@tonic-gate ret = DONAME_FAIL;
23787c478bd9Sstevel@tonic-gate break;
23797c478bd9Sstevel@tonic-gate }
23807c478bd9Sstevel@tonic-gate bp->b_wptr += STRUCT_FGET(sb, len);
23817c478bd9Sstevel@tonic-gate if (getpeer) {
23827c478bd9Sstevel@tonic-gate bcopy(tp->tim_peername, bp->b_rptr,
23837c478bd9Sstevel@tonic-gate STRUCT_FGET(sb, len));
23847c478bd9Sstevel@tonic-gate mutex_exit(&tp->tim_mutex);
23857c478bd9Sstevel@tonic-gate } else {
23867c478bd9Sstevel@tonic-gate bcopy(tp->tim_myname, bp->b_rptr, STRUCT_FGET(sb, len));
23877c478bd9Sstevel@tonic-gate }
23887c478bd9Sstevel@tonic-gate cqp->cq_addr = (caddr_t)STRUCT_FGETP(sb, buf);
23897c478bd9Sstevel@tonic-gate cqp->cq_size = STRUCT_FGET(sb, len);
23907c478bd9Sstevel@tonic-gate cqp->cq_flag = 0;
23917c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_COPYOUT;
23927c478bd9Sstevel@tonic-gate mp->b_cont = bp;
23937c478bd9Sstevel@tonic-gate STRUCT_FSET(sb, len, 0); /* copy the strbuf next time around */
23947c478bd9Sstevel@tonic-gate qreply(q, mp);
23957c478bd9Sstevel@tonic-gate ret = DONAME_CONT;
23967c478bd9Sstevel@tonic-gate break;
23977c478bd9Sstevel@tonic-gate
23987c478bd9Sstevel@tonic-gate default:
23997c478bd9Sstevel@tonic-gate tilog("ti_doname: freeing bad message type = %d\n",
24007c478bd9Sstevel@tonic-gate mp->b_datap->db_type);
24017c478bd9Sstevel@tonic-gate freemsg(mp);
24027c478bd9Sstevel@tonic-gate ret = DONAME_FAIL;
24037c478bd9Sstevel@tonic-gate break;
24047c478bd9Sstevel@tonic-gate }
24057c478bd9Sstevel@tonic-gate return (ret);
24067c478bd9Sstevel@tonic-gate }
24077c478bd9Sstevel@tonic-gate
24087c478bd9Sstevel@tonic-gate
24097c478bd9Sstevel@tonic-gate /*
24107c478bd9Sstevel@tonic-gate * Fill in the address of a connectionless data packet if a connect
24117c478bd9Sstevel@tonic-gate * had been done on this endpoint.
24127c478bd9Sstevel@tonic-gate */
24137c478bd9Sstevel@tonic-gate static mblk_t *
tim_filladdr(queue_t * q,mblk_t * mp,boolean_t dorecover)24147c478bd9Sstevel@tonic-gate tim_filladdr(queue_t *q, mblk_t *mp, boolean_t dorecover)
24157c478bd9Sstevel@tonic-gate {
24167c478bd9Sstevel@tonic-gate mblk_t *bp;
24177c478bd9Sstevel@tonic-gate struct tim_tim *tp;
24187c478bd9Sstevel@tonic-gate struct T_unitdata_req *up;
24197c478bd9Sstevel@tonic-gate struct T_unitdata_req *nup;
24207c478bd9Sstevel@tonic-gate size_t plen;
24217c478bd9Sstevel@tonic-gate
24227c478bd9Sstevel@tonic-gate tp = (struct tim_tim *)q->q_ptr;
24237c478bd9Sstevel@tonic-gate if (mp->b_datap->db_type == M_DATA) {
24247c478bd9Sstevel@tonic-gate mutex_enter(&tp->tim_mutex);
24257c478bd9Sstevel@tonic-gate bp = allocb(sizeof (struct T_unitdata_req) + tp->tim_peerlen,
24267c478bd9Sstevel@tonic-gate BPRI_MED);
24277c478bd9Sstevel@tonic-gate if (bp != NULL) {
24287c478bd9Sstevel@tonic-gate bp->b_datap->db_type = M_PROTO;
24297c478bd9Sstevel@tonic-gate up = (struct T_unitdata_req *)bp->b_rptr;
24307c478bd9Sstevel@tonic-gate up->PRIM_type = T_UNITDATA_REQ;
24317c478bd9Sstevel@tonic-gate up->DEST_length = tp->tim_peerlen;
24327c478bd9Sstevel@tonic-gate bp->b_wptr += sizeof (struct T_unitdata_req);
24337c478bd9Sstevel@tonic-gate up->DEST_offset = sizeof (struct T_unitdata_req);
24347c478bd9Sstevel@tonic-gate up->OPT_length = 0;
24357c478bd9Sstevel@tonic-gate up->OPT_offset = 0;
24367c478bd9Sstevel@tonic-gate if (tp->tim_peerlen > 0) {
24377c478bd9Sstevel@tonic-gate bcopy(tp->tim_peername, bp->b_wptr,
24387c478bd9Sstevel@tonic-gate tp->tim_peerlen);
24397c478bd9Sstevel@tonic-gate bp->b_wptr += tp->tim_peerlen;
24407c478bd9Sstevel@tonic-gate }
24417c478bd9Sstevel@tonic-gate bp->b_cont = mp;
24427c478bd9Sstevel@tonic-gate }
24437c478bd9Sstevel@tonic-gate } else {
24447c478bd9Sstevel@tonic-gate ASSERT(mp->b_datap->db_type == M_PROTO);
24457c478bd9Sstevel@tonic-gate up = (struct T_unitdata_req *)mp->b_rptr;
24467c478bd9Sstevel@tonic-gate ASSERT(up->PRIM_type == T_UNITDATA_REQ);
24477c478bd9Sstevel@tonic-gate if (up->DEST_length != 0)
24487c478bd9Sstevel@tonic-gate return (mp);
24497c478bd9Sstevel@tonic-gate mutex_enter(&tp->tim_mutex);
24507c478bd9Sstevel@tonic-gate bp = allocb(sizeof (struct T_unitdata_req) + up->OPT_length +
24517c478bd9Sstevel@tonic-gate tp->tim_peerlen, BPRI_MED);
24527c478bd9Sstevel@tonic-gate if (bp != NULL) {
24537c478bd9Sstevel@tonic-gate bp->b_datap->db_type = M_PROTO;
24547c478bd9Sstevel@tonic-gate nup = (struct T_unitdata_req *)bp->b_rptr;
24557c478bd9Sstevel@tonic-gate nup->PRIM_type = T_UNITDATA_REQ;
24567c478bd9Sstevel@tonic-gate nup->DEST_length = plen = tp->tim_peerlen;
24577c478bd9Sstevel@tonic-gate bp->b_wptr += sizeof (struct T_unitdata_req);
24587c478bd9Sstevel@tonic-gate nup->DEST_offset = sizeof (struct T_unitdata_req);
24597c478bd9Sstevel@tonic-gate if (plen > 0) {
24607c478bd9Sstevel@tonic-gate bcopy(tp->tim_peername, bp->b_wptr, plen);
24617c478bd9Sstevel@tonic-gate bp->b_wptr += plen;
24627c478bd9Sstevel@tonic-gate }
24637c478bd9Sstevel@tonic-gate mutex_exit(&tp->tim_mutex);
24647c478bd9Sstevel@tonic-gate if (up->OPT_length == 0) {
24657c478bd9Sstevel@tonic-gate nup->OPT_length = 0;
24667c478bd9Sstevel@tonic-gate nup->OPT_offset = 0;
24677c478bd9Sstevel@tonic-gate } else {
24687c478bd9Sstevel@tonic-gate nup->OPT_length = up->OPT_length;
24697c478bd9Sstevel@tonic-gate nup->OPT_offset =
24707c478bd9Sstevel@tonic-gate sizeof (struct T_unitdata_req) + plen;
24717c478bd9Sstevel@tonic-gate bcopy((mp->b_wptr + up->OPT_offset), bp->b_wptr,
24727c478bd9Sstevel@tonic-gate up->OPT_length);
24737c478bd9Sstevel@tonic-gate bp->b_wptr += up->OPT_length;
24747c478bd9Sstevel@tonic-gate }
24757c478bd9Sstevel@tonic-gate bp->b_cont = mp->b_cont;
24767c478bd9Sstevel@tonic-gate mp->b_cont = NULL;
24777c478bd9Sstevel@tonic-gate freeb(mp);
24787c478bd9Sstevel@tonic-gate return (bp);
24797c478bd9Sstevel@tonic-gate }
24807c478bd9Sstevel@tonic-gate }
24817c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&tp->tim_mutex));
24827c478bd9Sstevel@tonic-gate if (bp == NULL && dorecover) {
24837c478bd9Sstevel@tonic-gate tim_recover(q, mp,
24847c478bd9Sstevel@tonic-gate sizeof (struct T_unitdata_req) + tp->tim_peerlen);
24857c478bd9Sstevel@tonic-gate }
24867c478bd9Sstevel@tonic-gate mutex_exit(&tp->tim_mutex);
24877c478bd9Sstevel@tonic-gate return (bp);
24887c478bd9Sstevel@tonic-gate }
24897c478bd9Sstevel@tonic-gate
24907c478bd9Sstevel@tonic-gate static void
tim_addlink(struct tim_tim * tp)24917c478bd9Sstevel@tonic-gate tim_addlink(struct tim_tim *tp)
24927c478bd9Sstevel@tonic-gate {
24937c478bd9Sstevel@tonic-gate struct tim_tim **tpp;
24947c478bd9Sstevel@tonic-gate struct tim_tim *next;
24957c478bd9Sstevel@tonic-gate
24967c478bd9Sstevel@tonic-gate tpp = &tim_hash[TIM_HASH(tp->tim_acceptor)];
24977c478bd9Sstevel@tonic-gate rw_enter(&tim_list_rwlock, RW_WRITER);
24987c478bd9Sstevel@tonic-gate
24997c478bd9Sstevel@tonic-gate if ((next = *tpp) != NULL)
25007c478bd9Sstevel@tonic-gate next->tim_ptpn = &tp->tim_next;
25017c478bd9Sstevel@tonic-gate tp->tim_next = next;
25027c478bd9Sstevel@tonic-gate tp->tim_ptpn = tpp;
25037c478bd9Sstevel@tonic-gate *tpp = tp;
25047c478bd9Sstevel@tonic-gate
25057c478bd9Sstevel@tonic-gate tim_cnt++;
25067c478bd9Sstevel@tonic-gate
25077c478bd9Sstevel@tonic-gate rw_exit(&tim_list_rwlock);
25087c478bd9Sstevel@tonic-gate }
25097c478bd9Sstevel@tonic-gate
25107c478bd9Sstevel@tonic-gate static void
tim_dellink(struct tim_tim * tp)25117c478bd9Sstevel@tonic-gate tim_dellink(struct tim_tim *tp)
25127c478bd9Sstevel@tonic-gate {
25137c478bd9Sstevel@tonic-gate struct tim_tim *next;
25147c478bd9Sstevel@tonic-gate
25157c478bd9Sstevel@tonic-gate rw_enter(&tim_list_rwlock, RW_WRITER);
25167c478bd9Sstevel@tonic-gate
25177c478bd9Sstevel@tonic-gate if ((next = tp->tim_next) != NULL)
25187c478bd9Sstevel@tonic-gate next->tim_ptpn = tp->tim_ptpn;
25197c478bd9Sstevel@tonic-gate *(tp->tim_ptpn) = next;
25207c478bd9Sstevel@tonic-gate
25217c478bd9Sstevel@tonic-gate tim_cnt--;
25227c478bd9Sstevel@tonic-gate
25237c478bd9Sstevel@tonic-gate rw_exit(&tim_list_rwlock);
25247c478bd9Sstevel@tonic-gate }
25257c478bd9Sstevel@tonic-gate
25267c478bd9Sstevel@tonic-gate static struct tim_tim *
tim_findlink(t_uscalar_t id)25277c478bd9Sstevel@tonic-gate tim_findlink(t_uscalar_t id)
25287c478bd9Sstevel@tonic-gate {
25297c478bd9Sstevel@tonic-gate struct tim_tim *tp;
25307c478bd9Sstevel@tonic-gate
25317c478bd9Sstevel@tonic-gate ASSERT(rw_lock_held(&tim_list_rwlock));
25327c478bd9Sstevel@tonic-gate
25337c478bd9Sstevel@tonic-gate for (tp = tim_hash[TIM_HASH(id)]; tp != NULL; tp = tp->tim_next) {
25347c478bd9Sstevel@tonic-gate if (tp->tim_acceptor == id) {
25357c478bd9Sstevel@tonic-gate break;
25367c478bd9Sstevel@tonic-gate }
25377c478bd9Sstevel@tonic-gate }
25387c478bd9Sstevel@tonic-gate return (tp);
25397c478bd9Sstevel@tonic-gate }
25407c478bd9Sstevel@tonic-gate
25417c478bd9Sstevel@tonic-gate static void
tim_recover(queue_t * q,mblk_t * mp,t_scalar_t size)25427c478bd9Sstevel@tonic-gate tim_recover(queue_t *q, mblk_t *mp, t_scalar_t size)
25437c478bd9Sstevel@tonic-gate {
25447c478bd9Sstevel@tonic-gate struct tim_tim *tp;
25457c478bd9Sstevel@tonic-gate bufcall_id_t bid;
25467c478bd9Sstevel@tonic-gate timeout_id_t tid;
25477c478bd9Sstevel@tonic-gate
25487c478bd9Sstevel@tonic-gate tp = (struct tim_tim *)q->q_ptr;
25497c478bd9Sstevel@tonic-gate
25507c478bd9Sstevel@tonic-gate /*
25517c478bd9Sstevel@tonic-gate * Avoid re-enabling the queue.
25527c478bd9Sstevel@tonic-gate */
25537c478bd9Sstevel@tonic-gate if (mp->b_datap->db_type == M_PCPROTO)
25547c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_PROTO;
25557c478bd9Sstevel@tonic-gate noenable(q);
25567c478bd9Sstevel@tonic-gate (void) putbq(q, mp);
25577c478bd9Sstevel@tonic-gate
25587c478bd9Sstevel@tonic-gate /*
25597c478bd9Sstevel@tonic-gate * Make sure there is at most one outstanding request per queue.
25607c478bd9Sstevel@tonic-gate */
25617c478bd9Sstevel@tonic-gate if (q->q_flag & QREADR) {
25627c478bd9Sstevel@tonic-gate if (tp->tim_rtimoutid || tp->tim_rbufcid)
25637c478bd9Sstevel@tonic-gate return;
25647c478bd9Sstevel@tonic-gate } else {
25657c478bd9Sstevel@tonic-gate if (tp->tim_wtimoutid || tp->tim_wbufcid)
25667c478bd9Sstevel@tonic-gate return;
25677c478bd9Sstevel@tonic-gate }
25687c478bd9Sstevel@tonic-gate if (!(bid = qbufcall(RD(q), (size_t)size, BPRI_MED, tim_buffer, q))) {
25697c478bd9Sstevel@tonic-gate tid = qtimeout(RD(q), tim_timer, q, TIMWAIT);
25707c478bd9Sstevel@tonic-gate if (q->q_flag & QREADR)
25717c478bd9Sstevel@tonic-gate tp->tim_rtimoutid = tid;
25727c478bd9Sstevel@tonic-gate else
25737c478bd9Sstevel@tonic-gate tp->tim_wtimoutid = tid;
25747c478bd9Sstevel@tonic-gate } else {
25757c478bd9Sstevel@tonic-gate if (q->q_flag & QREADR)
25767c478bd9Sstevel@tonic-gate tp->tim_rbufcid = bid;
25777c478bd9Sstevel@tonic-gate else
25787c478bd9Sstevel@tonic-gate tp->tim_wbufcid = bid;
25797c478bd9Sstevel@tonic-gate }
25807c478bd9Sstevel@tonic-gate }
25817c478bd9Sstevel@tonic-gate
25827c478bd9Sstevel@tonic-gate /*
25832cbe889aSgeorges * Timod is waiting on a downstream ioctl reply, come back soon
25842cbe889aSgeorges * to reschedule the write side service routine, which will check
25852cbe889aSgeorges * if the ioctl is done and another can proceed.
25862cbe889aSgeorges */
25872cbe889aSgeorges static void
tim_ioctl_retry(queue_t * q)25882cbe889aSgeorges tim_ioctl_retry(queue_t *q)
25892cbe889aSgeorges {
25902cbe889aSgeorges struct tim_tim *tp;
25912cbe889aSgeorges
25922cbe889aSgeorges tp = (struct tim_tim *)q->q_ptr;
25932cbe889aSgeorges
25942cbe889aSgeorges /*
25952cbe889aSgeorges * Make sure there is at most one outstanding request per wqueue.
25962cbe889aSgeorges */
25972cbe889aSgeorges if (tp->tim_wtimoutid || tp->tim_wbufcid)
25982cbe889aSgeorges return;
25992cbe889aSgeorges
26002cbe889aSgeorges tp->tim_wtimoutid = qtimeout(RD(q), tim_timer, q, TIMIOCWAIT);
26012cbe889aSgeorges }
26022cbe889aSgeorges
26032cbe889aSgeorges /*
26047c478bd9Sstevel@tonic-gate * Inspect the data on read queues starting from read queues passed as
26057c478bd9Sstevel@tonic-gate * paramter (timod read queue) and traverse until
26067c478bd9Sstevel@tonic-gate * q_next is NULL (stream head). Look for a TPI T_EXDATA_IND message
26077c478bd9Sstevel@tonic-gate * reutrn 1 if found, 0 if not found.
26087c478bd9Sstevel@tonic-gate */
26097c478bd9Sstevel@tonic-gate static int
ti_expind_on_rdqueues(queue_t * rq)26107c478bd9Sstevel@tonic-gate ti_expind_on_rdqueues(queue_t *rq)
26117c478bd9Sstevel@tonic-gate {
26127c478bd9Sstevel@tonic-gate mblk_t *bp;
26137c478bd9Sstevel@tonic-gate queue_t *q;
26147c478bd9Sstevel@tonic-gate
26157c478bd9Sstevel@tonic-gate q = rq;
26167c478bd9Sstevel@tonic-gate /*
26177c478bd9Sstevel@tonic-gate * We are going to walk q_next, so protect stream from plumbing
26187c478bd9Sstevel@tonic-gate * changes.
26197c478bd9Sstevel@tonic-gate */
26207c478bd9Sstevel@tonic-gate claimstr(q);
26217c478bd9Sstevel@tonic-gate do {
26227c478bd9Sstevel@tonic-gate /*
26237c478bd9Sstevel@tonic-gate * Hold QLOCK while referencing data on queues
26247c478bd9Sstevel@tonic-gate */
26257c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(rq));
26267c478bd9Sstevel@tonic-gate bp = rq->q_first;
26277c478bd9Sstevel@tonic-gate while (bp != NULL) {
26287c478bd9Sstevel@tonic-gate /*
26297c478bd9Sstevel@tonic-gate * Walk the messages on the queue looking
26307c478bd9Sstevel@tonic-gate * for a possible T_EXDATA_IND
26317c478bd9Sstevel@tonic-gate */
26327c478bd9Sstevel@tonic-gate if ((bp->b_datap->db_type == M_PROTO) &&
26337c478bd9Sstevel@tonic-gate ((bp->b_wptr - bp->b_rptr) >=
26347c478bd9Sstevel@tonic-gate sizeof (struct T_exdata_ind)) &&
26357c478bd9Sstevel@tonic-gate (((struct T_exdata_ind *)bp->b_rptr)->PRIM_type
26367c478bd9Sstevel@tonic-gate == T_EXDATA_IND)) {
26377c478bd9Sstevel@tonic-gate /* bp is T_EXDATA_IND */
26387c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(rq));
26397c478bd9Sstevel@tonic-gate releasestr(q); /* decrement sd_refcnt */
26407c478bd9Sstevel@tonic-gate return (1); /* expdata is on a read queue */
26417c478bd9Sstevel@tonic-gate }
26427c478bd9Sstevel@tonic-gate bp = bp->b_next; /* next message */
26437c478bd9Sstevel@tonic-gate }
26447c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(rq));
26457c478bd9Sstevel@tonic-gate rq = rq->q_next; /* next upstream queue */
26467c478bd9Sstevel@tonic-gate } while (rq != NULL);
26477c478bd9Sstevel@tonic-gate releasestr(q);
26487c478bd9Sstevel@tonic-gate return (0); /* no expdata on read queues */
26497c478bd9Sstevel@tonic-gate }
26507c478bd9Sstevel@tonic-gate
26517c478bd9Sstevel@tonic-gate static void
tim_tcap_timer(void * q_ptr)26527c478bd9Sstevel@tonic-gate tim_tcap_timer(void *q_ptr)
26537c478bd9Sstevel@tonic-gate {
26547c478bd9Sstevel@tonic-gate queue_t *q = (queue_t *)q_ptr;
26557c478bd9Sstevel@tonic-gate struct tim_tim *tp = (struct tim_tim *)q->q_ptr;
26567c478bd9Sstevel@tonic-gate
26577c478bd9Sstevel@tonic-gate ASSERT(tp != NULL && tp->tim_tcap_timoutid != 0);
26587c478bd9Sstevel@tonic-gate ASSERT((tp->tim_flags & TI_CAP_RECVD) != 0);
26597c478bd9Sstevel@tonic-gate
26607c478bd9Sstevel@tonic-gate tp->tim_tcap_timoutid = 0;
26617c478bd9Sstevel@tonic-gate TILOG("tim_tcap_timer: fired\n", 0);
26627c478bd9Sstevel@tonic-gate tim_tcap_genreply(q, tp);
26637c478bd9Sstevel@tonic-gate }
26647c478bd9Sstevel@tonic-gate
26657c478bd9Sstevel@tonic-gate /*
26667c478bd9Sstevel@tonic-gate * tim_tcap_genreply() is called either from timeout routine or when
26677c478bd9Sstevel@tonic-gate * T_ERROR_ACK is received. In both cases it means that underlying
26687c478bd9Sstevel@tonic-gate * transport doesn't provide T_CAPABILITY_REQ.
26697c478bd9Sstevel@tonic-gate */
26707c478bd9Sstevel@tonic-gate static void
tim_tcap_genreply(queue_t * q,struct tim_tim * tp)26717c478bd9Sstevel@tonic-gate tim_tcap_genreply(queue_t *q, struct tim_tim *tp)
26727c478bd9Sstevel@tonic-gate {
26737c478bd9Sstevel@tonic-gate mblk_t *mp = tp->tim_iocsave;
26747c478bd9Sstevel@tonic-gate struct iocblk *iocbp;
26757c478bd9Sstevel@tonic-gate
26767c478bd9Sstevel@tonic-gate TILOG("timodrproc: tim_tcap_genreply\n", 0);
26777c478bd9Sstevel@tonic-gate
26787c478bd9Sstevel@tonic-gate ASSERT(tp == (struct tim_tim *)q->q_ptr);
26797c478bd9Sstevel@tonic-gate ASSERT(mp != NULL);
26807c478bd9Sstevel@tonic-gate
26817c478bd9Sstevel@tonic-gate iocbp = (struct iocblk *)mp->b_rptr;
26827c478bd9Sstevel@tonic-gate ASSERT(iocbp != NULL);
26837c478bd9Sstevel@tonic-gate ASSERT(MBLKL(mp) == sizeof (struct iocblk));
26847c478bd9Sstevel@tonic-gate ASSERT(iocbp->ioc_cmd == TI_CAPABILITY);
26857c478bd9Sstevel@tonic-gate ASSERT(mp->b_cont == NULL);
26867c478bd9Sstevel@tonic-gate
26877c478bd9Sstevel@tonic-gate /* Save this information permanently in the module */
26887c478bd9Sstevel@tonic-gate PI_PROVLOCK(tp->tim_provinfo);
26897c478bd9Sstevel@tonic-gate if (tp->tim_provinfo->tpi_capability == PI_DONTKNOW)
26907c478bd9Sstevel@tonic-gate tp->tim_provinfo->tpi_capability = PI_NO;
26917c478bd9Sstevel@tonic-gate PI_PROVUNLOCK(tp->tim_provinfo);
26927c478bd9Sstevel@tonic-gate
26937c478bd9Sstevel@tonic-gate if (tp->tim_tcap_timoutid != 0) {
26947c478bd9Sstevel@tonic-gate (void) quntimeout(q, tp->tim_tcap_timoutid);
26957c478bd9Sstevel@tonic-gate tp->tim_tcap_timoutid = 0;
26967c478bd9Sstevel@tonic-gate }
26977c478bd9Sstevel@tonic-gate
26987c478bd9Sstevel@tonic-gate if ((tp->tim_flags & CAP_WANTS_INFO) != 0) {
26997c478bd9Sstevel@tonic-gate /* Send T_INFO_REQ down */
27007c478bd9Sstevel@tonic-gate mblk_t *tirmp = tpi_ack_alloc(NULL,
27017c478bd9Sstevel@tonic-gate sizeof (struct T_info_req), M_PCPROTO, T_INFO_REQ);
27027c478bd9Sstevel@tonic-gate
27037c478bd9Sstevel@tonic-gate if (tirmp != NULL) {
27047c478bd9Sstevel@tonic-gate /* Emulate TC1_INFO */
27057c478bd9Sstevel@tonic-gate TILOG("emulate_tcap_ioc_req: sending T_INFO_REQ\n", 0);
27067c478bd9Sstevel@tonic-gate tp->tim_flags |= WAIT_IOCINFOACK;
27077c478bd9Sstevel@tonic-gate putnext(WR(q), tirmp);
27087c478bd9Sstevel@tonic-gate } else {
27097c478bd9Sstevel@tonic-gate tilog("emulate_tcap_req: allocb fail, "
27107c478bd9Sstevel@tonic-gate "no recovery attmpt\n", 0);
27117c478bd9Sstevel@tonic-gate tp->tim_iocsave = NULL;
27127c478bd9Sstevel@tonic-gate tp->tim_saved_prim = -1;
27137c478bd9Sstevel@tonic-gate tp->tim_flags &= ~(TI_CAP_RECVD | WAITIOCACK |
27147c478bd9Sstevel@tonic-gate CAP_WANTS_INFO | WAIT_IOCINFOACK);
27157c478bd9Sstevel@tonic-gate miocnak(q, mp, 0, ENOMEM);
27167c478bd9Sstevel@tonic-gate }
27177c478bd9Sstevel@tonic-gate } else {
27187c478bd9Sstevel@tonic-gate /* Reply immediately */
27197c478bd9Sstevel@tonic-gate mblk_t *ackmp = tpi_ack_alloc(NULL,
27207c478bd9Sstevel@tonic-gate sizeof (struct T_capability_ack), M_PCPROTO,
27217c478bd9Sstevel@tonic-gate T_CAPABILITY_ACK);
27227c478bd9Sstevel@tonic-gate
27237c478bd9Sstevel@tonic-gate mp->b_cont = ackmp;
27247c478bd9Sstevel@tonic-gate
27257c478bd9Sstevel@tonic-gate if (ackmp != NULL) {
27267c478bd9Sstevel@tonic-gate ((struct T_capability_ack *)
27277c478bd9Sstevel@tonic-gate ackmp->b_rptr)->CAP_bits1 = 0;
27287c478bd9Sstevel@tonic-gate tim_ioctl_send_reply(q, mp, ackmp);
27297c478bd9Sstevel@tonic-gate tp->tim_iocsave = NULL;
27307c478bd9Sstevel@tonic-gate tp->tim_saved_prim = -1;
27317c478bd9Sstevel@tonic-gate tp->tim_flags &= ~(WAITIOCACK | WAIT_IOCINFOACK |
27327c478bd9Sstevel@tonic-gate TI_CAP_RECVD | CAP_WANTS_INFO);
27337c478bd9Sstevel@tonic-gate } else {
27347c478bd9Sstevel@tonic-gate tilog("timodwproc:allocb failed no "
27357c478bd9Sstevel@tonic-gate "recovery attempt\n", 0);
27367c478bd9Sstevel@tonic-gate tp->tim_iocsave = NULL;
27377c478bd9Sstevel@tonic-gate tp->tim_saved_prim = -1;
27387c478bd9Sstevel@tonic-gate tp->tim_flags &= ~(TI_CAP_RECVD | WAITIOCACK |
27397c478bd9Sstevel@tonic-gate CAP_WANTS_INFO | WAIT_IOCINFOACK);
27407c478bd9Sstevel@tonic-gate miocnak(q, mp, 0, ENOMEM);
27417c478bd9Sstevel@tonic-gate }
27427c478bd9Sstevel@tonic-gate }
27437c478bd9Sstevel@tonic-gate }
27447c478bd9Sstevel@tonic-gate
27457c478bd9Sstevel@tonic-gate
27467c478bd9Sstevel@tonic-gate static void
tim_ioctl_send_reply(queue_t * q,mblk_t * ioc_mp,mblk_t * mp)27477c478bd9Sstevel@tonic-gate tim_ioctl_send_reply(queue_t *q, mblk_t *ioc_mp, mblk_t *mp)
27487c478bd9Sstevel@tonic-gate {
27497c478bd9Sstevel@tonic-gate struct iocblk *iocbp;
27507c478bd9Sstevel@tonic-gate
27517c478bd9Sstevel@tonic-gate ASSERT(q != NULL && ioc_mp != NULL);
27527c478bd9Sstevel@tonic-gate
27537c478bd9Sstevel@tonic-gate ioc_mp->b_datap->db_type = M_IOCACK;
27547c478bd9Sstevel@tonic-gate if (mp != NULL)
27557c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_DATA;
27567c478bd9Sstevel@tonic-gate
27577c478bd9Sstevel@tonic-gate if (ioc_mp->b_cont != mp) {
27587c478bd9Sstevel@tonic-gate /* It is safe to call freemsg for NULL pointers */
27597c478bd9Sstevel@tonic-gate freemsg(ioc_mp->b_cont);
27607c478bd9Sstevel@tonic-gate ioc_mp->b_cont = mp;
27617c478bd9Sstevel@tonic-gate }
27627c478bd9Sstevel@tonic-gate iocbp = (struct iocblk *)ioc_mp->b_rptr;
27637c478bd9Sstevel@tonic-gate iocbp->ioc_error = 0;
27647c478bd9Sstevel@tonic-gate iocbp->ioc_rval = 0;
27657c478bd9Sstevel@tonic-gate /*
27667c478bd9Sstevel@tonic-gate * All ioctl's may return more data than was specified by
27677c478bd9Sstevel@tonic-gate * count arg. For TI_CAPABILITY count is treated as maximum data size.
27687c478bd9Sstevel@tonic-gate */
27697c478bd9Sstevel@tonic-gate if (mp == NULL)
27707c478bd9Sstevel@tonic-gate iocbp->ioc_count = 0;
27717c478bd9Sstevel@tonic-gate else if (iocbp->ioc_cmd != TI_CAPABILITY)
27727c478bd9Sstevel@tonic-gate iocbp->ioc_count = msgsize(mp);
27737c478bd9Sstevel@tonic-gate else {
27747c478bd9Sstevel@tonic-gate iocbp->ioc_count = MIN(MBLKL(mp), iocbp->ioc_count);
27757c478bd9Sstevel@tonic-gate /* Truncate message if too large */
27767c478bd9Sstevel@tonic-gate mp->b_wptr = mp->b_rptr + iocbp->ioc_count;
27777c478bd9Sstevel@tonic-gate }
27787c478bd9Sstevel@tonic-gate
27797c478bd9Sstevel@tonic-gate TILOG("iosendreply: ioc_cmd = %d, ", iocbp->ioc_cmd);
27807c478bd9Sstevel@tonic-gate putnext(RD(q), ioc_mp);
27817c478bd9Sstevel@tonic-gate }
27827c478bd9Sstevel@tonic-gate
27837c478bd9Sstevel@tonic-gate /*
27847c478bd9Sstevel@tonic-gate * Send M_IOCACK for errors.
27857c478bd9Sstevel@tonic-gate */
27867c478bd9Sstevel@tonic-gate static void
tim_send_ioc_error_ack(queue_t * q,struct tim_tim * tp,mblk_t * mp)27877c478bd9Sstevel@tonic-gate tim_send_ioc_error_ack(queue_t *q, struct tim_tim *tp, mblk_t *mp)
27887c478bd9Sstevel@tonic-gate {
27897c478bd9Sstevel@tonic-gate struct T_error_ack *tea = (struct T_error_ack *)mp->b_rptr;
27907c478bd9Sstevel@tonic-gate t_scalar_t error_prim;
27917c478bd9Sstevel@tonic-gate
27927c478bd9Sstevel@tonic-gate mp->b_wptr = mp->b_rptr + sizeof (struct T_error_ack);
27937c478bd9Sstevel@tonic-gate ASSERT(mp->b_wptr <= mp->b_datap->db_lim);
27947c478bd9Sstevel@tonic-gate error_prim = tea->ERROR_prim;
27957c478bd9Sstevel@tonic-gate
27967c478bd9Sstevel@tonic-gate ASSERT(tp->tim_iocsave != NULL);
27977c478bd9Sstevel@tonic-gate ASSERT(tp->tim_iocsave->b_cont != mp);
27987c478bd9Sstevel@tonic-gate
27997c478bd9Sstevel@tonic-gate /* Always send this to the read side of the queue */
28007c478bd9Sstevel@tonic-gate q = RD(q);
28017c478bd9Sstevel@tonic-gate
28027c478bd9Sstevel@tonic-gate TILOG("tim_send_ioc_error_ack: prim = %d\n", tp->tim_saved_prim);
28037c478bd9Sstevel@tonic-gate
28047c478bd9Sstevel@tonic-gate if (tp->tim_saved_prim != error_prim) {
28057c478bd9Sstevel@tonic-gate putnext(q, mp);
28067c478bd9Sstevel@tonic-gate } else if (error_prim == T_CAPABILITY_REQ) {
28077c478bd9Sstevel@tonic-gate TILOG("timodrproc: T_ERROR_ACK/T_CAPABILITY_REQ\n", 0);
28087c478bd9Sstevel@tonic-gate ASSERT(tp->tim_iocsave->b_cont == NULL);
28097c478bd9Sstevel@tonic-gate
28107c478bd9Sstevel@tonic-gate tim_tcap_genreply(q, tp);
28117c478bd9Sstevel@tonic-gate freemsg(mp);
28127c478bd9Sstevel@tonic-gate } else {
28137c478bd9Sstevel@tonic-gate struct iocblk *iocbp = (struct iocblk *)tp->tim_iocsave->b_rptr;
28147c478bd9Sstevel@tonic-gate
28157c478bd9Sstevel@tonic-gate TILOG("tim_send_ioc_error_ack: T_ERROR_ACK: prim %d\n",
28167c478bd9Sstevel@tonic-gate error_prim);
28177c478bd9Sstevel@tonic-gate ASSERT(tp->tim_iocsave->b_cont == NULL);
28187c478bd9Sstevel@tonic-gate
28197c478bd9Sstevel@tonic-gate switch (error_prim) {
28207c478bd9Sstevel@tonic-gate default:
28217c478bd9Sstevel@tonic-gate TILOG("timodrproc: Unknown T_ERROR_ACK: tlierror %d\n",
28227c478bd9Sstevel@tonic-gate tea->TLI_error);
28237c478bd9Sstevel@tonic-gate
28247c478bd9Sstevel@tonic-gate putnext(q, mp);
28257c478bd9Sstevel@tonic-gate break;
28267c478bd9Sstevel@tonic-gate
28277c478bd9Sstevel@tonic-gate case T_INFO_REQ:
28287c478bd9Sstevel@tonic-gate case T_SVR4_OPTMGMT_REQ:
28297c478bd9Sstevel@tonic-gate case T_OPTMGMT_REQ:
28307c478bd9Sstevel@tonic-gate case O_T_BIND_REQ:
28317c478bd9Sstevel@tonic-gate case T_BIND_REQ:
28327c478bd9Sstevel@tonic-gate case T_UNBIND_REQ:
28337c478bd9Sstevel@tonic-gate case T_ADDR_REQ:
28347c478bd9Sstevel@tonic-gate case T_CAPABILITY_REQ:
28357c478bd9Sstevel@tonic-gate
28367c478bd9Sstevel@tonic-gate TILOG("ioc_err_ack: T_ERROR_ACK: tlierror %x\n",
28377c478bd9Sstevel@tonic-gate tea->TLI_error);
28387c478bd9Sstevel@tonic-gate
28397c478bd9Sstevel@tonic-gate /* get saved ioctl msg and set values */
28407c478bd9Sstevel@tonic-gate iocbp->ioc_count = 0;
28417c478bd9Sstevel@tonic-gate iocbp->ioc_error = 0;
28427c478bd9Sstevel@tonic-gate iocbp->ioc_rval = tea->TLI_error;
28437c478bd9Sstevel@tonic-gate if (iocbp->ioc_rval == TSYSERR)
28447c478bd9Sstevel@tonic-gate iocbp->ioc_rval |= tea->UNIX_error << 8;
28457c478bd9Sstevel@tonic-gate tp->tim_iocsave->b_datap->db_type = M_IOCACK;
28467c478bd9Sstevel@tonic-gate freemsg(mp);
28477c478bd9Sstevel@tonic-gate putnext(q, tp->tim_iocsave);
28487c478bd9Sstevel@tonic-gate tp->tim_iocsave = NULL;
28497c478bd9Sstevel@tonic-gate tp->tim_saved_prim = -1;
28507c478bd9Sstevel@tonic-gate tp->tim_flags &= ~(WAITIOCACK | TI_CAP_RECVD |
28517c478bd9Sstevel@tonic-gate CAP_WANTS_INFO | WAIT_IOCINFOACK);
28527c478bd9Sstevel@tonic-gate break;
28537c478bd9Sstevel@tonic-gate }
28547c478bd9Sstevel@tonic-gate }
28557c478bd9Sstevel@tonic-gate }
28567c478bd9Sstevel@tonic-gate
28577c478bd9Sstevel@tonic-gate /*
28587c478bd9Sstevel@tonic-gate * Send reply to a usual message or ioctl message upstream.
28597c478bd9Sstevel@tonic-gate * Should be called from the read side only.
28607c478bd9Sstevel@tonic-gate */
28617c478bd9Sstevel@tonic-gate static void
tim_send_reply(queue_t * q,mblk_t * mp,struct tim_tim * tp,t_scalar_t prim)28627c478bd9Sstevel@tonic-gate tim_send_reply(queue_t *q, mblk_t *mp, struct tim_tim *tp, t_scalar_t prim)
28637c478bd9Sstevel@tonic-gate {
28647c478bd9Sstevel@tonic-gate ASSERT(mp != NULL && q != NULL && tp != NULL);
28657c478bd9Sstevel@tonic-gate ASSERT(q == RD(q));
28667c478bd9Sstevel@tonic-gate
28677c478bd9Sstevel@tonic-gate /* Restore db_type - recover() might have changed it */
28687c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_PCPROTO;
28697c478bd9Sstevel@tonic-gate
28707c478bd9Sstevel@tonic-gate if (((tp->tim_flags & WAITIOCACK) == 0) || (tp->tim_saved_prim != prim))
28717c478bd9Sstevel@tonic-gate putnext(q, mp);
28727c478bd9Sstevel@tonic-gate else {
28737c478bd9Sstevel@tonic-gate ASSERT(tp->tim_iocsave != NULL);
28747c478bd9Sstevel@tonic-gate tim_ioctl_send_reply(q, tp->tim_iocsave, mp);
28757c478bd9Sstevel@tonic-gate tp->tim_iocsave = NULL;
28767c478bd9Sstevel@tonic-gate tp->tim_saved_prim = -1;
28777c478bd9Sstevel@tonic-gate tp->tim_flags &= ~(WAITIOCACK | WAIT_IOCINFOACK |
28787c478bd9Sstevel@tonic-gate TI_CAP_RECVD | CAP_WANTS_INFO);
28797c478bd9Sstevel@tonic-gate }
28807c478bd9Sstevel@tonic-gate }
28817c478bd9Sstevel@tonic-gate
28827c478bd9Sstevel@tonic-gate /*
28837c478bd9Sstevel@tonic-gate * Reply to TI_SYNC reequest without sending anything downstream.
28847c478bd9Sstevel@tonic-gate */
28857c478bd9Sstevel@tonic-gate static void
tim_answer_ti_sync(queue_t * q,mblk_t * mp,struct tim_tim * tp,mblk_t * ackmp,uint32_t tsr_flags)28867c478bd9Sstevel@tonic-gate tim_answer_ti_sync(queue_t *q, mblk_t *mp, struct tim_tim *tp,
28877c478bd9Sstevel@tonic-gate mblk_t *ackmp, uint32_t tsr_flags)
28887c478bd9Sstevel@tonic-gate {
28897c478bd9Sstevel@tonic-gate struct ti_sync_ack *tsap;
28907c478bd9Sstevel@tonic-gate
28917c478bd9Sstevel@tonic-gate ASSERT(q != NULL && q == WR(q) && ackmp != NULL);
28927c478bd9Sstevel@tonic-gate
28937c478bd9Sstevel@tonic-gate tsap = (struct ti_sync_ack *)ackmp->b_rptr;
28947c478bd9Sstevel@tonic-gate bzero(tsap, sizeof (struct ti_sync_ack));
28957c478bd9Sstevel@tonic-gate ackmp->b_wptr = ackmp->b_rptr + sizeof (struct ti_sync_ack);
28967c478bd9Sstevel@tonic-gate
28977c478bd9Sstevel@tonic-gate if (tsr_flags == 0 ||
28987c478bd9Sstevel@tonic-gate (tsr_flags & ~(TSRF_QLEN_REQ | TSRF_IS_EXP_IN_RCVBUF)) != 0) {
28997c478bd9Sstevel@tonic-gate /*
29007c478bd9Sstevel@tonic-gate * unsupported/bad flag setting
29017c478bd9Sstevel@tonic-gate * or no flag set.
29027c478bd9Sstevel@tonic-gate */
29037c478bd9Sstevel@tonic-gate TILOG("timodwproc: unsupported/bad flag setting %x\n",
29047c478bd9Sstevel@tonic-gate tsr_flags);
29057c478bd9Sstevel@tonic-gate freemsg(ackmp);
29067c478bd9Sstevel@tonic-gate miocnak(q, mp, 0, EINVAL);
29077c478bd9Sstevel@tonic-gate return;
29087c478bd9Sstevel@tonic-gate }
29097c478bd9Sstevel@tonic-gate
29107c478bd9Sstevel@tonic-gate if ((tsr_flags & TSRF_QLEN_REQ) != 0)
29117c478bd9Sstevel@tonic-gate tsap->tsa_qlen = tp->tim_backlog;
29127c478bd9Sstevel@tonic-gate
29137c478bd9Sstevel@tonic-gate if ((tsr_flags & TSRF_IS_EXP_IN_RCVBUF) != 0 &&
29147c478bd9Sstevel@tonic-gate ti_expind_on_rdqueues(RD(q))) {
29157c478bd9Sstevel@tonic-gate /*
29167c478bd9Sstevel@tonic-gate * Expedited data is queued on
29177c478bd9Sstevel@tonic-gate * the stream read side
29187c478bd9Sstevel@tonic-gate */
29197c478bd9Sstevel@tonic-gate tsap->tsa_flags |= TSAF_EXP_QUEUED;
29207c478bd9Sstevel@tonic-gate }
29217c478bd9Sstevel@tonic-gate
29227c478bd9Sstevel@tonic-gate tim_ioctl_send_reply(q, mp, ackmp);
29237c478bd9Sstevel@tonic-gate tp->tim_iocsave = NULL;
29247c478bd9Sstevel@tonic-gate tp->tim_saved_prim = -1;
29257c478bd9Sstevel@tonic-gate tp->tim_flags &= ~(WAITIOCACK | WAIT_IOCINFOACK |
29267c478bd9Sstevel@tonic-gate TI_CAP_RECVD | CAP_WANTS_INFO);
29277c478bd9Sstevel@tonic-gate }
29287c478bd9Sstevel@tonic-gate
29297c478bd9Sstevel@tonic-gate /*
29307c478bd9Sstevel@tonic-gate * Send TPI message from IOCTL message, ssave original ioctl header and TPI
29317c478bd9Sstevel@tonic-gate * message type. Should be called from write side only.
29327c478bd9Sstevel@tonic-gate */
29337c478bd9Sstevel@tonic-gate static void
tim_send_ioctl_tpi_msg(queue_t * q,mblk_t * mp,struct tim_tim * tp,struct iocblk * iocb)29347c478bd9Sstevel@tonic-gate tim_send_ioctl_tpi_msg(queue_t *q, mblk_t *mp, struct tim_tim *tp,
29357c478bd9Sstevel@tonic-gate struct iocblk *iocb)
29367c478bd9Sstevel@tonic-gate {
29377c478bd9Sstevel@tonic-gate mblk_t *tmp;
29387c478bd9Sstevel@tonic-gate int ioc_cmd = iocb->ioc_cmd;
29397c478bd9Sstevel@tonic-gate
29407c478bd9Sstevel@tonic-gate ASSERT(q != NULL && mp != NULL && tp != NULL);
29417c478bd9Sstevel@tonic-gate ASSERT(q == WR(q));
29427c478bd9Sstevel@tonic-gate ASSERT(mp->b_cont != NULL);
29437c478bd9Sstevel@tonic-gate
29447c478bd9Sstevel@tonic-gate tp->tim_iocsave = mp;
29457c478bd9Sstevel@tonic-gate tmp = mp->b_cont;
29467c478bd9Sstevel@tonic-gate
29477c478bd9Sstevel@tonic-gate mp->b_cont = NULL;
29487c478bd9Sstevel@tonic-gate tp->tim_flags |= WAITIOCACK;
29497c478bd9Sstevel@tonic-gate tp->tim_saved_prim = ((union T_primitives *)tmp->b_rptr)->type;
29507c478bd9Sstevel@tonic-gate
29517c478bd9Sstevel@tonic-gate /*
29527c478bd9Sstevel@tonic-gate * For TI_GETINFO, the attached message is a T_INFO_REQ
29537c478bd9Sstevel@tonic-gate * For TI_SYNC, we generate the T_INFO_REQ message above
29547c478bd9Sstevel@tonic-gate * For TI_CAPABILITY the attached message is either
29557c478bd9Sstevel@tonic-gate * T_CAPABILITY_REQ or T_INFO_REQ.
29567c478bd9Sstevel@tonic-gate * Among TPI request messages possible,
29577c478bd9Sstevel@tonic-gate * T_INFO_REQ/T_CAPABILITY_ACK messages are a M_PCPROTO, rest
29587c478bd9Sstevel@tonic-gate * are M_PROTO
29597c478bd9Sstevel@tonic-gate */
29607c478bd9Sstevel@tonic-gate if (ioc_cmd == TI_GETINFO || ioc_cmd == TI_SYNC ||
29617c478bd9Sstevel@tonic-gate ioc_cmd == TI_CAPABILITY) {
29627c478bd9Sstevel@tonic-gate tmp->b_datap->db_type = M_PCPROTO;
29637c478bd9Sstevel@tonic-gate } else {
29647c478bd9Sstevel@tonic-gate tmp->b_datap->db_type = M_PROTO;
29657c478bd9Sstevel@tonic-gate }
29667c478bd9Sstevel@tonic-gate
29677c478bd9Sstevel@tonic-gate /* Verify credentials in STREAM */
29687c478bd9Sstevel@tonic-gate ASSERT(iocb->ioc_cr == NULL || iocb->ioc_cr == DB_CRED(tmp));
29697c478bd9Sstevel@tonic-gate
2970de8c4a14SErik Nordmark ASSERT(DB_CRED(tmp) != NULL);
2971de8c4a14SErik Nordmark
29727c478bd9Sstevel@tonic-gate TILOG("timodwproc: sending down %d\n", tp->tim_saved_prim);
29737c478bd9Sstevel@tonic-gate putnext(q, tmp);
29747c478bd9Sstevel@tonic-gate }
29757c478bd9Sstevel@tonic-gate
29767c478bd9Sstevel@tonic-gate static void
tim_clear_peer(struct tim_tim * tp)29777c478bd9Sstevel@tonic-gate tim_clear_peer(struct tim_tim *tp)
29787c478bd9Sstevel@tonic-gate {
29797c478bd9Sstevel@tonic-gate mutex_enter(&tp->tim_mutex);
29807c478bd9Sstevel@tonic-gate if (tp->tim_peercred != NULL) {
29817c478bd9Sstevel@tonic-gate crfree(tp->tim_peercred);
29827c478bd9Sstevel@tonic-gate tp->tim_peercred = NULL;
29837c478bd9Sstevel@tonic-gate }
29847c478bd9Sstevel@tonic-gate tp->tim_peerlen = 0;
29857c478bd9Sstevel@tonic-gate mutex_exit(&tp->tim_mutex);
29867c478bd9Sstevel@tonic-gate }
2987