17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * sppp.c - Solaris STREAMS PPP multiplexing pseudo-driver 37c478bd9Sstevel@tonic-gate * 4f53eecf5SJames Carlson * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 57c478bd9Sstevel@tonic-gate * Use is subject to license terms. 648bbca81SDaniel Hoffman * Copyright (c) 2016 by Delphix. All rights reserved. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * Permission to use, copy, modify, and distribute this software and its 97c478bd9Sstevel@tonic-gate * documentation is hereby granted, provided that the above copyright 107c478bd9Sstevel@tonic-gate * notice appears in all copies. 117c478bd9Sstevel@tonic-gate * 127c478bd9Sstevel@tonic-gate * SUN MAKES NO REPRESENTATION OR WARRANTIES ABOUT THE SUITABILITY OF 137c478bd9Sstevel@tonic-gate * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED 147c478bd9Sstevel@tonic-gate * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 157c478bd9Sstevel@tonic-gate * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR 167c478bd9Sstevel@tonic-gate * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR 177c478bd9Sstevel@tonic-gate * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * Copyright (c) 1994 The Australian National University. 207c478bd9Sstevel@tonic-gate * All rights reserved. 217c478bd9Sstevel@tonic-gate * 227c478bd9Sstevel@tonic-gate * Permission to use, copy, modify, and distribute this software and its 237c478bd9Sstevel@tonic-gate * documentation is hereby granted, provided that the above copyright 247c478bd9Sstevel@tonic-gate * notice appears in all copies. This software is provided without any 257c478bd9Sstevel@tonic-gate * warranty, express or implied. The Australian National University 267c478bd9Sstevel@tonic-gate * makes no representations about the suitability of this software for 277c478bd9Sstevel@tonic-gate * any purpose. 287c478bd9Sstevel@tonic-gate * 297c478bd9Sstevel@tonic-gate * IN NO EVENT SHALL THE AUSTRALIAN NATIONAL UNIVERSITY BE LIABLE TO ANY 307c478bd9Sstevel@tonic-gate * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES 317c478bd9Sstevel@tonic-gate * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF 327c478bd9Sstevel@tonic-gate * THE AUSTRALIAN NATIONAL UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY 337c478bd9Sstevel@tonic-gate * OF SUCH DAMAGE. 347c478bd9Sstevel@tonic-gate * 357c478bd9Sstevel@tonic-gate * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, 367c478bd9Sstevel@tonic-gate * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 377c478bd9Sstevel@tonic-gate * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS 387c478bd9Sstevel@tonic-gate * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO 397c478bd9Sstevel@tonic-gate * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, 407c478bd9Sstevel@tonic-gate * OR MODIFICATIONS. 417c478bd9Sstevel@tonic-gate * 427c478bd9Sstevel@tonic-gate * This driver is derived from the original SVR4 STREAMS PPP driver 437c478bd9Sstevel@tonic-gate * originally written by Paul Mackerras <paul.mackerras@cs.anu.edu.au>. 447c478bd9Sstevel@tonic-gate * 457c478bd9Sstevel@tonic-gate * Adi Masputra <adi.masputra@sun.com> rewrote and restructured the code 467c478bd9Sstevel@tonic-gate * for improved performance and scalability. 477c478bd9Sstevel@tonic-gate */ 487c478bd9Sstevel@tonic-gate 497c478bd9Sstevel@tonic-gate #define RCSID "$Id: sppp.c,v 1.0 2000/05/08 01:10:12 masputra Exp $" 507c478bd9Sstevel@tonic-gate 517c478bd9Sstevel@tonic-gate #include <sys/types.h> 527c478bd9Sstevel@tonic-gate #include <sys/debug.h> 537c478bd9Sstevel@tonic-gate #include <sys/param.h> 547c478bd9Sstevel@tonic-gate #include <sys/stat.h> 557c478bd9Sstevel@tonic-gate #include <sys/stream.h> 567c478bd9Sstevel@tonic-gate #include <sys/stropts.h> 577c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 587c478bd9Sstevel@tonic-gate #include <sys/errno.h> 597c478bd9Sstevel@tonic-gate #include <sys/time.h> 607c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h> 617c478bd9Sstevel@tonic-gate #include <sys/kmem.h> 627c478bd9Sstevel@tonic-gate #include <sys/conf.h> 637c478bd9Sstevel@tonic-gate #include <sys/dlpi.h> 647c478bd9Sstevel@tonic-gate #include <sys/ddi.h> 657c478bd9Sstevel@tonic-gate #include <sys/kstat.h> 667c478bd9Sstevel@tonic-gate #include <sys/strsun.h> 677c478bd9Sstevel@tonic-gate #include <sys/ethernet.h> 687c478bd9Sstevel@tonic-gate #include <sys/policy.h> 69f53eecf5SJames Carlson #include <sys/zone.h> 707c478bd9Sstevel@tonic-gate #include <net/ppp_defs.h> 717c478bd9Sstevel@tonic-gate #include <net/pppio.h> 727c478bd9Sstevel@tonic-gate #include "sppp.h" 737c478bd9Sstevel@tonic-gate #include "s_common.h" 747c478bd9Sstevel@tonic-gate 757c478bd9Sstevel@tonic-gate /* 767c478bd9Sstevel@tonic-gate * This is used to tag official Solaris sources. Please do not define 777c478bd9Sstevel@tonic-gate * "INTERNAL_BUILD" when building this software outside of Sun Microsystems. 787c478bd9Sstevel@tonic-gate */ 797c478bd9Sstevel@tonic-gate #ifdef INTERNAL_BUILD 807c478bd9Sstevel@tonic-gate /* MODINFO is limited to 32 characters. */ 81002c70ffScarlsonj const char sppp_module_description[] = "PPP 4.0 mux"; 827c478bd9Sstevel@tonic-gate #else /* INTERNAL_BUILD */ 8319397407SSherry Moore const char sppp_module_description[] = "ANU PPP mux"; 847c478bd9Sstevel@tonic-gate 857c478bd9Sstevel@tonic-gate /* LINTED */ 867c478bd9Sstevel@tonic-gate static const char buildtime[] = "Built " __DATE__ " at " __TIME__ 877c478bd9Sstevel@tonic-gate #ifdef DEBUG 887c478bd9Sstevel@tonic-gate " DEBUG" 897c478bd9Sstevel@tonic-gate #endif 907c478bd9Sstevel@tonic-gate "\n"; 917c478bd9Sstevel@tonic-gate #endif /* INTERNAL_BUILD */ 927c478bd9Sstevel@tonic-gate 937c478bd9Sstevel@tonic-gate static void sppp_inner_ioctl(queue_t *, mblk_t *); 947c478bd9Sstevel@tonic-gate static void sppp_outer_ioctl(queue_t *, mblk_t *); 957c478bd9Sstevel@tonic-gate static queue_t *sppp_send(queue_t *, mblk_t **, spppstr_t *); 967c478bd9Sstevel@tonic-gate static queue_t *sppp_recv(queue_t *, mblk_t **, spppstr_t *); 977c478bd9Sstevel@tonic-gate static void sppp_recv_nondata(queue_t *, mblk_t *, spppstr_t *); 987c478bd9Sstevel@tonic-gate static queue_t *sppp_outpkt(queue_t *, mblk_t **, int, spppstr_t *); 997c478bd9Sstevel@tonic-gate static spppstr_t *sppp_inpkt(queue_t *, mblk_t *, spppstr_t *); 1007c478bd9Sstevel@tonic-gate static int sppp_kstat_update(kstat_t *, int); 1017c478bd9Sstevel@tonic-gate static void sppp_release_pkts(sppa_t *, uint16_t); 1027c478bd9Sstevel@tonic-gate 1037c478bd9Sstevel@tonic-gate /* 1047c478bd9Sstevel@tonic-gate * sps_list contains the list of active per-stream instance state structures 1057c478bd9Sstevel@tonic-gate * ordered on the minor device number (see sppp.h for details). All streams 1067c478bd9Sstevel@tonic-gate * opened to this driver are threaded together in this list. 1077c478bd9Sstevel@tonic-gate */ 1087c478bd9Sstevel@tonic-gate static spppstr_t *sps_list = NULL; 1097c478bd9Sstevel@tonic-gate /* 1107c478bd9Sstevel@tonic-gate * ppa_list contains the list of active per-attachment instance state 1117c478bd9Sstevel@tonic-gate * structures ordered on the ppa id number (see sppp.h for details). All of 1127c478bd9Sstevel@tonic-gate * the ppa structures created once per PPPIO_NEWPPA ioctl are threaded together 1137c478bd9Sstevel@tonic-gate * in this list. There is exactly one ppa structure for a given PPP interface, 1147c478bd9Sstevel@tonic-gate * and multiple sps streams (upper streams) may share a ppa by performing 1157c478bd9Sstevel@tonic-gate * an attachment explicitly (PPPIO_ATTACH) or implicitly (DL_ATTACH_REQ). 1167c478bd9Sstevel@tonic-gate */ 1177c478bd9Sstevel@tonic-gate static sppa_t *ppa_list = NULL; 1187c478bd9Sstevel@tonic-gate 1197c478bd9Sstevel@tonic-gate static const char *kstats_names[] = { SPPP_KSTATS_NAMES }; 1207c478bd9Sstevel@tonic-gate static const char *kstats64_names[] = { SPPP_KSTATS64_NAMES }; 1217c478bd9Sstevel@tonic-gate 1227c478bd9Sstevel@tonic-gate /* 1237c478bd9Sstevel@tonic-gate * map proto (which is an IANA defined ppp network protocol) to 1247c478bd9Sstevel@tonic-gate * a bit position indicated by NP_* in ppa_npflag 1257c478bd9Sstevel@tonic-gate */ 1267c478bd9Sstevel@tonic-gate static uint32_t 1277c478bd9Sstevel@tonic-gate sppp_ppp2np(uint16_t proto) 1287c478bd9Sstevel@tonic-gate { 1297c478bd9Sstevel@tonic-gate switch (proto) { 1307c478bd9Sstevel@tonic-gate case PPP_IP: 1317c478bd9Sstevel@tonic-gate return (NP_IP); 1327c478bd9Sstevel@tonic-gate case PPP_IPV6: 1337c478bd9Sstevel@tonic-gate return (NP_IPV6); 1347c478bd9Sstevel@tonic-gate default: 1357c478bd9Sstevel@tonic-gate return (0); 1367c478bd9Sstevel@tonic-gate } 1377c478bd9Sstevel@tonic-gate } 1387c478bd9Sstevel@tonic-gate 1397c478bd9Sstevel@tonic-gate /* 1407c478bd9Sstevel@tonic-gate * sppp_open() 1417c478bd9Sstevel@tonic-gate * 1427c478bd9Sstevel@tonic-gate * MT-Perimeters: 1437c478bd9Sstevel@tonic-gate * exclusive inner, exclusive outer. 1447c478bd9Sstevel@tonic-gate * 1457c478bd9Sstevel@tonic-gate * Description: 1467c478bd9Sstevel@tonic-gate * Common open procedure for module. 1477c478bd9Sstevel@tonic-gate */ 1487c478bd9Sstevel@tonic-gate /* ARGSUSED */ 1497c478bd9Sstevel@tonic-gate int 1507c478bd9Sstevel@tonic-gate sppp_open(queue_t *q, dev_t *devp, int oflag, int sflag, cred_t *credp) 1517c478bd9Sstevel@tonic-gate { 1527c478bd9Sstevel@tonic-gate spppstr_t *sps; 1537c478bd9Sstevel@tonic-gate spppstr_t **nextmn; 1547c478bd9Sstevel@tonic-gate minor_t mn; 1557c478bd9Sstevel@tonic-gate 1567c478bd9Sstevel@tonic-gate ASSERT(q != NULL && devp != NULL); 1577c478bd9Sstevel@tonic-gate ASSERT(sflag != MODOPEN); 1587c478bd9Sstevel@tonic-gate 1597c478bd9Sstevel@tonic-gate if (q->q_ptr != NULL) { 1607c478bd9Sstevel@tonic-gate return (0); /* already open */ 1617c478bd9Sstevel@tonic-gate } 1627c478bd9Sstevel@tonic-gate if (sflag != CLONEOPEN) { 1637c478bd9Sstevel@tonic-gate return (OPENFAIL); 1647c478bd9Sstevel@tonic-gate } 1657c478bd9Sstevel@tonic-gate /* 1667c478bd9Sstevel@tonic-gate * The sps list is sorted using the minor number as the key. The 1677c478bd9Sstevel@tonic-gate * following code walks the list to find the lowest valued minor 1687c478bd9Sstevel@tonic-gate * number available to be used. 1697c478bd9Sstevel@tonic-gate */ 1707c478bd9Sstevel@tonic-gate mn = 0; 1717c478bd9Sstevel@tonic-gate for (nextmn = &sps_list; (sps = *nextmn) != NULL; 1727c478bd9Sstevel@tonic-gate nextmn = &sps->sps_nextmn) { 1737c478bd9Sstevel@tonic-gate if (sps->sps_mn_id != mn) { 1747c478bd9Sstevel@tonic-gate break; 1757c478bd9Sstevel@tonic-gate } 1767c478bd9Sstevel@tonic-gate ++mn; 1777c478bd9Sstevel@tonic-gate } 1787c478bd9Sstevel@tonic-gate sps = (spppstr_t *)kmem_zalloc(sizeof (spppstr_t), KM_SLEEP); 1797c478bd9Sstevel@tonic-gate ASSERT(sps != NULL); /* KM_SLEEP must never return NULL */ 1807c478bd9Sstevel@tonic-gate sps->sps_nextmn = *nextmn; /* insert stream in global list */ 1817c478bd9Sstevel@tonic-gate *nextmn = sps; 1827c478bd9Sstevel@tonic-gate sps->sps_mn_id = mn; /* save minor id for this stream */ 1837c478bd9Sstevel@tonic-gate sps->sps_rq = q; /* save read queue pointer */ 1847c478bd9Sstevel@tonic-gate sps->sps_sap = -1; /* no sap bound to stream */ 1857c478bd9Sstevel@tonic-gate sps->sps_dlstate = DL_UNATTACHED; /* dlpi state is unattached */ 1867c478bd9Sstevel@tonic-gate sps->sps_npmode = NPMODE_DROP; /* drop all packets initially */ 187f53eecf5SJames Carlson sps->sps_zoneid = crgetzoneid(credp); 1887c478bd9Sstevel@tonic-gate q->q_ptr = WR(q)->q_ptr = (caddr_t)sps; 1897c478bd9Sstevel@tonic-gate /* 1907c478bd9Sstevel@tonic-gate * We explicitly disable the automatic queue scheduling for the 1917c478bd9Sstevel@tonic-gate * write-side to obtain complete control over queuing during transmit. 1927c478bd9Sstevel@tonic-gate * Packets will be queued at the upper write queue and the service 1937c478bd9Sstevel@tonic-gate * routine will not be called until it gets scheduled by having the 1947c478bd9Sstevel@tonic-gate * lower write service routine call the qenable(WR(uq)) for all streams 1957c478bd9Sstevel@tonic-gate * attached to the same ppa instance. 1967c478bd9Sstevel@tonic-gate */ 1977c478bd9Sstevel@tonic-gate noenable(WR(q)); 1987c478bd9Sstevel@tonic-gate *devp = makedevice(getmajor(*devp), mn); 1997c478bd9Sstevel@tonic-gate qprocson(q); 2007c478bd9Sstevel@tonic-gate return (0); 2017c478bd9Sstevel@tonic-gate } 2027c478bd9Sstevel@tonic-gate 2037c478bd9Sstevel@tonic-gate /* 2047c478bd9Sstevel@tonic-gate * Free storage used by a PPA. This is not called until the last PPA 20548bbca81SDaniel Hoffman * user closes their connection or reattaches to a different PPA. 2067c478bd9Sstevel@tonic-gate */ 2077c478bd9Sstevel@tonic-gate static void 2087c478bd9Sstevel@tonic-gate sppp_free_ppa(sppa_t *ppa) 2097c478bd9Sstevel@tonic-gate { 2107c478bd9Sstevel@tonic-gate sppa_t **nextppa; 2117c478bd9Sstevel@tonic-gate 2127c478bd9Sstevel@tonic-gate ASSERT(ppa->ppa_refcnt == 1); 2137c478bd9Sstevel@tonic-gate if (ppa->ppa_kstats != NULL) { 2147c478bd9Sstevel@tonic-gate kstat_delete(ppa->ppa_kstats); 2157c478bd9Sstevel@tonic-gate ppa->ppa_kstats = NULL; 2167c478bd9Sstevel@tonic-gate } 2177c478bd9Sstevel@tonic-gate mutex_destroy(&ppa->ppa_sta_lock); 2187c478bd9Sstevel@tonic-gate mutex_destroy(&ppa->ppa_npmutex); 2197c478bd9Sstevel@tonic-gate rw_destroy(&ppa->ppa_sib_lock); 2207c478bd9Sstevel@tonic-gate nextppa = &ppa_list; 2217c478bd9Sstevel@tonic-gate while (*nextppa != NULL) { 2227c478bd9Sstevel@tonic-gate if (*nextppa == ppa) { 2237c478bd9Sstevel@tonic-gate *nextppa = ppa->ppa_nextppa; 2247c478bd9Sstevel@tonic-gate break; 2257c478bd9Sstevel@tonic-gate } 2267c478bd9Sstevel@tonic-gate nextppa = &(*nextppa)->ppa_nextppa; 2277c478bd9Sstevel@tonic-gate } 2287c478bd9Sstevel@tonic-gate kmem_free(ppa, sizeof (*ppa)); 2297c478bd9Sstevel@tonic-gate } 2307c478bd9Sstevel@tonic-gate 2317c478bd9Sstevel@tonic-gate /* 2327c478bd9Sstevel@tonic-gate * Create a new PPA. Caller must be exclusive on outer perimeter. 2337c478bd9Sstevel@tonic-gate */ 2347c478bd9Sstevel@tonic-gate sppa_t * 235f53eecf5SJames Carlson sppp_create_ppa(uint32_t ppa_id, zoneid_t zoneid) 2367c478bd9Sstevel@tonic-gate { 2377c478bd9Sstevel@tonic-gate sppa_t *ppa; 2387c478bd9Sstevel@tonic-gate sppa_t *curppa; 2397c478bd9Sstevel@tonic-gate sppa_t **availppa; 2407c478bd9Sstevel@tonic-gate char unit[32]; /* Unit name */ 2417c478bd9Sstevel@tonic-gate const char **cpp; 2427c478bd9Sstevel@tonic-gate kstat_t *ksp; 2437c478bd9Sstevel@tonic-gate kstat_named_t *knt; 2447c478bd9Sstevel@tonic-gate 2457c478bd9Sstevel@tonic-gate /* 2467c478bd9Sstevel@tonic-gate * NOTE: unit *must* be named for the driver 2477c478bd9Sstevel@tonic-gate * name plus the ppa number so that netstat 2487c478bd9Sstevel@tonic-gate * can find the statistics. 2497c478bd9Sstevel@tonic-gate */ 250002c70ffScarlsonj (void) sprintf(unit, "%s" "%d", PPP_DRV_NAME, ppa_id); 2517c478bd9Sstevel@tonic-gate /* 2527c478bd9Sstevel@tonic-gate * Make sure we can allocate a buffer to 2537c478bd9Sstevel@tonic-gate * contain the ppa to be sent upstream, as 2547c478bd9Sstevel@tonic-gate * well as the actual ppa structure and its 2557c478bd9Sstevel@tonic-gate * associated kstat structure. 2567c478bd9Sstevel@tonic-gate */ 2577c478bd9Sstevel@tonic-gate ppa = (sppa_t *)kmem_zalloc(sizeof (sppa_t), 2587c478bd9Sstevel@tonic-gate KM_NOSLEEP); 2597c478bd9Sstevel@tonic-gate ksp = kstat_create(PPP_DRV_NAME, ppa_id, unit, "net", KSTAT_TYPE_NAMED, 2607c478bd9Sstevel@tonic-gate sizeof (sppp_kstats_t) / sizeof (kstat_named_t), 0); 2617c478bd9Sstevel@tonic-gate 2627c478bd9Sstevel@tonic-gate if (ppa == NULL || ksp == NULL) { 2637c478bd9Sstevel@tonic-gate if (ppa != NULL) { 2647c478bd9Sstevel@tonic-gate kmem_free(ppa, sizeof (sppa_t)); 2657c478bd9Sstevel@tonic-gate } 2667c478bd9Sstevel@tonic-gate if (ksp != NULL) { 2677c478bd9Sstevel@tonic-gate kstat_delete(ksp); 2687c478bd9Sstevel@tonic-gate } 2697c478bd9Sstevel@tonic-gate return (NULL); 2707c478bd9Sstevel@tonic-gate } 2717c478bd9Sstevel@tonic-gate ppa->ppa_kstats = ksp; /* chain kstat structure */ 2727c478bd9Sstevel@tonic-gate ppa->ppa_ppa_id = ppa_id; /* record ppa id */ 273f53eecf5SJames Carlson ppa->ppa_zoneid = zoneid; /* zone that owns this PPA */ 2747c478bd9Sstevel@tonic-gate ppa->ppa_mtu = PPP_MAXMTU; /* 65535-(PPP_HDRLEN+PPP_FCSLEN) */ 2757c478bd9Sstevel@tonic-gate ppa->ppa_mru = PPP_MAXMRU; /* 65000 */ 2767c478bd9Sstevel@tonic-gate 2777c478bd9Sstevel@tonic-gate mutex_init(&ppa->ppa_sta_lock, NULL, MUTEX_DRIVER, NULL); 2787c478bd9Sstevel@tonic-gate mutex_init(&ppa->ppa_npmutex, NULL, MUTEX_DRIVER, NULL); 2797c478bd9Sstevel@tonic-gate rw_init(&ppa->ppa_sib_lock, NULL, RW_DRIVER, NULL); 2807c478bd9Sstevel@tonic-gate 2817c478bd9Sstevel@tonic-gate /* 2827c478bd9Sstevel@tonic-gate * Prepare and install kstat counters. Note that for netstat 2837c478bd9Sstevel@tonic-gate * -i to work, there needs to be "ipackets", "opackets", 2847c478bd9Sstevel@tonic-gate * "ierrors", and "oerrors" kstat named variables. 2857c478bd9Sstevel@tonic-gate */ 2867c478bd9Sstevel@tonic-gate knt = (kstat_named_t *)ksp->ks_data; 2877c478bd9Sstevel@tonic-gate for (cpp = kstats_names; cpp < kstats_names + Dim(kstats_names); 2887c478bd9Sstevel@tonic-gate cpp++) { 289d624471bSelowe kstat_named_init(knt, *cpp, KSTAT_DATA_UINT32); 2907c478bd9Sstevel@tonic-gate knt++; 2917c478bd9Sstevel@tonic-gate } 2927c478bd9Sstevel@tonic-gate for (cpp = kstats64_names; cpp < kstats64_names + Dim(kstats64_names); 2937c478bd9Sstevel@tonic-gate cpp++) { 294d624471bSelowe kstat_named_init(knt, *cpp, KSTAT_DATA_UINT64); 2957c478bd9Sstevel@tonic-gate knt++; 2967c478bd9Sstevel@tonic-gate } 2977c478bd9Sstevel@tonic-gate ksp->ks_update = sppp_kstat_update; 2987c478bd9Sstevel@tonic-gate ksp->ks_private = (void *)ppa; 2997c478bd9Sstevel@tonic-gate kstat_install(ksp); 3007c478bd9Sstevel@tonic-gate 3017c478bd9Sstevel@tonic-gate /* link to the next ppa and insert into global list */ 3027c478bd9Sstevel@tonic-gate availppa = &ppa_list; 3037c478bd9Sstevel@tonic-gate while ((curppa = *availppa) != NULL) { 3047c478bd9Sstevel@tonic-gate if (ppa_id < curppa->ppa_ppa_id) 3057c478bd9Sstevel@tonic-gate break; 3067c478bd9Sstevel@tonic-gate availppa = &curppa->ppa_nextppa; 3077c478bd9Sstevel@tonic-gate } 3087c478bd9Sstevel@tonic-gate ppa->ppa_nextppa = *availppa; 3097c478bd9Sstevel@tonic-gate *availppa = ppa; 3107c478bd9Sstevel@tonic-gate return (ppa); 3117c478bd9Sstevel@tonic-gate } 3127c478bd9Sstevel@tonic-gate 3137c478bd9Sstevel@tonic-gate /* 3147c478bd9Sstevel@tonic-gate * sppp_close() 3157c478bd9Sstevel@tonic-gate * 3167c478bd9Sstevel@tonic-gate * MT-Perimeters: 3177c478bd9Sstevel@tonic-gate * exclusive inner, exclusive outer. 3187c478bd9Sstevel@tonic-gate * 3197c478bd9Sstevel@tonic-gate * Description: 3207c478bd9Sstevel@tonic-gate * Common close procedure for module. 3217c478bd9Sstevel@tonic-gate */ 322*5e1743f0SToomas Soome /* ARGSUSED */ 3237c478bd9Sstevel@tonic-gate int 324*5e1743f0SToomas Soome sppp_close(queue_t *q, int flags __unused, cred_t *credp __unused) 3257c478bd9Sstevel@tonic-gate { 3267c478bd9Sstevel@tonic-gate spppstr_t *sps; 3277c478bd9Sstevel@tonic-gate spppstr_t **nextmn; 3287c478bd9Sstevel@tonic-gate spppstr_t *sib; 3297c478bd9Sstevel@tonic-gate sppa_t *ppa; 3307c478bd9Sstevel@tonic-gate mblk_t *mp; 3317c478bd9Sstevel@tonic-gate 3327c478bd9Sstevel@tonic-gate ASSERT(q != NULL && q->q_ptr != NULL); 3337c478bd9Sstevel@tonic-gate sps = (spppstr_t *)q->q_ptr; 3347c478bd9Sstevel@tonic-gate qprocsoff(q); 3357c478bd9Sstevel@tonic-gate 3367c478bd9Sstevel@tonic-gate ppa = sps->sps_ppa; 3377c478bd9Sstevel@tonic-gate if (ppa == NULL) { 3387c478bd9Sstevel@tonic-gate ASSERT(!IS_SPS_CONTROL(sps)); 3397c478bd9Sstevel@tonic-gate goto close_unattached; 3407c478bd9Sstevel@tonic-gate } 3417c478bd9Sstevel@tonic-gate if (IS_SPS_CONTROL(sps)) { 3427c478bd9Sstevel@tonic-gate uint32_t cnt = 0; 3437c478bd9Sstevel@tonic-gate 3447c478bd9Sstevel@tonic-gate ASSERT(ppa != NULL); 3457c478bd9Sstevel@tonic-gate ASSERT(ppa->ppa_ctl == sps); 3467c478bd9Sstevel@tonic-gate ppa->ppa_ctl = NULL; 3477c478bd9Sstevel@tonic-gate /* 3487c478bd9Sstevel@tonic-gate * STREAMS framework always issues I_UNLINK prior to close, 3497c478bd9Sstevel@tonic-gate * since we only allow I_LINK under the control stream. 3507c478bd9Sstevel@tonic-gate * A given ppa structure has at most one lower stream pointed 3517c478bd9Sstevel@tonic-gate * by the ppa_lower_wq field, because we only allow a single 3527c478bd9Sstevel@tonic-gate * linkage (I_LINK) to be done on the control stream. 3537c478bd9Sstevel@tonic-gate */ 3547c478bd9Sstevel@tonic-gate ASSERT(ppa->ppa_lower_wq == NULL); 3557c478bd9Sstevel@tonic-gate /* 3567c478bd9Sstevel@tonic-gate * Walk through all of sibling streams attached to this ppa, 3577c478bd9Sstevel@tonic-gate * and remove all references to this ppa. We have exclusive 3587c478bd9Sstevel@tonic-gate * access for the entire driver here, so there's no need 3597c478bd9Sstevel@tonic-gate * to hold ppa_sib_lock. 3607c478bd9Sstevel@tonic-gate */ 3617c478bd9Sstevel@tonic-gate cnt++; 3627c478bd9Sstevel@tonic-gate sib = ppa->ppa_streams; 3637c478bd9Sstevel@tonic-gate while (sib != NULL) { 3647c478bd9Sstevel@tonic-gate ASSERT(ppa == sib->sps_ppa); 3657c478bd9Sstevel@tonic-gate sib->sps_npmode = NPMODE_DROP; 3667c478bd9Sstevel@tonic-gate sib->sps_flags &= ~(SPS_PIOATTACH | SPS_CACHED); 3677c478bd9Sstevel@tonic-gate /* 3687c478bd9Sstevel@tonic-gate * There should be a preallocated hangup 3697c478bd9Sstevel@tonic-gate * message here. Fetch it and send it up to 3707c478bd9Sstevel@tonic-gate * the stream head. This will cause IP to 3717c478bd9Sstevel@tonic-gate * mark the interface as "down." 3727c478bd9Sstevel@tonic-gate */ 3737c478bd9Sstevel@tonic-gate if ((mp = sib->sps_hangup) != NULL) { 3747c478bd9Sstevel@tonic-gate sib->sps_hangup = NULL; 3757c478bd9Sstevel@tonic-gate /* 3767c478bd9Sstevel@tonic-gate * M_HANGUP works with IP, but snoop 3777c478bd9Sstevel@tonic-gate * is lame and requires M_ERROR. Send 3787c478bd9Sstevel@tonic-gate * up a clean error code instead. 3797c478bd9Sstevel@tonic-gate * 3807c478bd9Sstevel@tonic-gate * XXX if snoop is fixed, fix this, too. 3817c478bd9Sstevel@tonic-gate */ 3827c478bd9Sstevel@tonic-gate MTYPE(mp) = M_ERROR; 3837c478bd9Sstevel@tonic-gate *mp->b_wptr++ = ENXIO; 3847c478bd9Sstevel@tonic-gate putnext(sib->sps_rq, mp); 3857c478bd9Sstevel@tonic-gate } 3867c478bd9Sstevel@tonic-gate qenable(WR(sib->sps_rq)); 3877c478bd9Sstevel@tonic-gate cnt++; 3887c478bd9Sstevel@tonic-gate sib = sib->sps_nextsib; 3897c478bd9Sstevel@tonic-gate } 3907c478bd9Sstevel@tonic-gate ASSERT(ppa->ppa_refcnt == cnt); 3917c478bd9Sstevel@tonic-gate } else { 3927c478bd9Sstevel@tonic-gate ASSERT(ppa->ppa_streams != NULL); 3937c478bd9Sstevel@tonic-gate ASSERT(ppa->ppa_ctl != sps); 3947c478bd9Sstevel@tonic-gate mp = NULL; 3957c478bd9Sstevel@tonic-gate if (sps->sps_sap == PPP_IP) { 3967c478bd9Sstevel@tonic-gate ppa->ppa_ip_cache = NULL; 3977c478bd9Sstevel@tonic-gate mp = create_lsmsg(PPP_LINKSTAT_IPV4_UNBOUND); 3987c478bd9Sstevel@tonic-gate } else if (sps->sps_sap == PPP_IPV6) { 3997c478bd9Sstevel@tonic-gate ppa->ppa_ip6_cache = NULL; 4007c478bd9Sstevel@tonic-gate mp = create_lsmsg(PPP_LINKSTAT_IPV6_UNBOUND); 4017c478bd9Sstevel@tonic-gate } 4027c478bd9Sstevel@tonic-gate /* Tell the daemon the bad news. */ 4037c478bd9Sstevel@tonic-gate if (mp != NULL && ppa->ppa_ctl != NULL && 4047c478bd9Sstevel@tonic-gate (sps->sps_npmode == NPMODE_PASS || 4057c478bd9Sstevel@tonic-gate sps->sps_npmode == NPMODE_QUEUE)) { 4067c478bd9Sstevel@tonic-gate putnext(ppa->ppa_ctl->sps_rq, mp); 4077c478bd9Sstevel@tonic-gate } else { 4087c478bd9Sstevel@tonic-gate freemsg(mp); 4097c478bd9Sstevel@tonic-gate } 4107c478bd9Sstevel@tonic-gate /* 4117c478bd9Sstevel@tonic-gate * Walk through all of sibling streams attached to the 4127c478bd9Sstevel@tonic-gate * same ppa, and remove this stream from the sibling 4137c478bd9Sstevel@tonic-gate * streams list. We have exclusive access for the 4147c478bd9Sstevel@tonic-gate * entire driver here, so there's no need to hold 4157c478bd9Sstevel@tonic-gate * ppa_sib_lock. 4167c478bd9Sstevel@tonic-gate */ 4177c478bd9Sstevel@tonic-gate sib = ppa->ppa_streams; 4187c478bd9Sstevel@tonic-gate if (sib == sps) { 4197c478bd9Sstevel@tonic-gate ppa->ppa_streams = sps->sps_nextsib; 4207c478bd9Sstevel@tonic-gate } else { 4217c478bd9Sstevel@tonic-gate while (sib->sps_nextsib != NULL) { 4227c478bd9Sstevel@tonic-gate if (sib->sps_nextsib == sps) { 4237c478bd9Sstevel@tonic-gate sib->sps_nextsib = sps->sps_nextsib; 4247c478bd9Sstevel@tonic-gate break; 4257c478bd9Sstevel@tonic-gate } 4267c478bd9Sstevel@tonic-gate sib = sib->sps_nextsib; 4277c478bd9Sstevel@tonic-gate } 4287c478bd9Sstevel@tonic-gate } 4297c478bd9Sstevel@tonic-gate sps->sps_nextsib = NULL; 4307c478bd9Sstevel@tonic-gate freemsg(sps->sps_hangup); 4317c478bd9Sstevel@tonic-gate sps->sps_hangup = NULL; 4327c478bd9Sstevel@tonic-gate /* 4337c478bd9Sstevel@tonic-gate * Check if this is a promiscous stream. If the SPS_PROMISC bit 4347c478bd9Sstevel@tonic-gate * is still set, it means that the stream is closed without 4357c478bd9Sstevel@tonic-gate * ever having issued DL_DETACH_REQ or DL_PROMISCOFF_REQ. 4367c478bd9Sstevel@tonic-gate * In this case, we simply decrement the promiscous counter, 4377c478bd9Sstevel@tonic-gate * and it's safe to do it without holding ppa_sib_lock since 4387c478bd9Sstevel@tonic-gate * we're exclusive (inner and outer) at this point. 4397c478bd9Sstevel@tonic-gate */ 4407c478bd9Sstevel@tonic-gate if (IS_SPS_PROMISC(sps)) { 4417c478bd9Sstevel@tonic-gate ASSERT(ppa->ppa_promicnt > 0); 4427c478bd9Sstevel@tonic-gate ppa->ppa_promicnt--; 4437c478bd9Sstevel@tonic-gate } 4447c478bd9Sstevel@tonic-gate } 4457c478bd9Sstevel@tonic-gate /* If we're the only one left, then delete now. */ 4467c478bd9Sstevel@tonic-gate if (ppa->ppa_refcnt <= 1) 4477c478bd9Sstevel@tonic-gate sppp_free_ppa(ppa); 4487c478bd9Sstevel@tonic-gate else 4497c478bd9Sstevel@tonic-gate ppa->ppa_refcnt--; 4507c478bd9Sstevel@tonic-gate close_unattached: 4517c478bd9Sstevel@tonic-gate q->q_ptr = WR(q)->q_ptr = NULL; 4527c478bd9Sstevel@tonic-gate for (nextmn = &sps_list; *nextmn != NULL; 4537c478bd9Sstevel@tonic-gate nextmn = &(*nextmn)->sps_nextmn) { 4547c478bd9Sstevel@tonic-gate if (*nextmn == sps) { 4557c478bd9Sstevel@tonic-gate *nextmn = sps->sps_nextmn; 4567c478bd9Sstevel@tonic-gate break; 4577c478bd9Sstevel@tonic-gate } 4587c478bd9Sstevel@tonic-gate } 4597c478bd9Sstevel@tonic-gate kmem_free(sps, sizeof (spppstr_t)); 4607c478bd9Sstevel@tonic-gate return (0); 4617c478bd9Sstevel@tonic-gate } 4627c478bd9Sstevel@tonic-gate 4637c478bd9Sstevel@tonic-gate static void 4647c478bd9Sstevel@tonic-gate sppp_ioctl(struct queue *q, mblk_t *mp) 4657c478bd9Sstevel@tonic-gate { 4667c478bd9Sstevel@tonic-gate spppstr_t *sps; 4677c478bd9Sstevel@tonic-gate spppstr_t *nextsib; 4687c478bd9Sstevel@tonic-gate sppa_t *ppa; 4697c478bd9Sstevel@tonic-gate struct iocblk *iop; 4707c478bd9Sstevel@tonic-gate mblk_t *nmp; 4717c478bd9Sstevel@tonic-gate enum NPmode npmode; 4727c478bd9Sstevel@tonic-gate struct ppp_idle *pip; 4737c478bd9Sstevel@tonic-gate struct ppp_stats64 *psp; 4747c478bd9Sstevel@tonic-gate struct ppp_comp_stats *pcsp; 4757c478bd9Sstevel@tonic-gate hrtime_t hrtime; 4767c478bd9Sstevel@tonic-gate int sap; 4777c478bd9Sstevel@tonic-gate int count = 0; 4787c478bd9Sstevel@tonic-gate int error = EINVAL; 4797c478bd9Sstevel@tonic-gate 4807c478bd9Sstevel@tonic-gate sps = (spppstr_t *)q->q_ptr; 4817c478bd9Sstevel@tonic-gate ppa = sps->sps_ppa; 4827c478bd9Sstevel@tonic-gate 4837c478bd9Sstevel@tonic-gate iop = (struct iocblk *)mp->b_rptr; 4847c478bd9Sstevel@tonic-gate switch (iop->ioc_cmd) { 4857c478bd9Sstevel@tonic-gate case PPPIO_NPMODE: 4867c478bd9Sstevel@tonic-gate if (!IS_SPS_CONTROL(sps)) { 4877c478bd9Sstevel@tonic-gate break; /* return EINVAL */ 4887c478bd9Sstevel@tonic-gate } else if (iop->ioc_count != 2 * sizeof (uint32_t) || 4897c478bd9Sstevel@tonic-gate (mp->b_cont == NULL)) { 4907c478bd9Sstevel@tonic-gate error = EPROTO; 4917c478bd9Sstevel@tonic-gate break; 4927c478bd9Sstevel@tonic-gate } 4937c478bd9Sstevel@tonic-gate ASSERT(ppa != NULL); 4947c478bd9Sstevel@tonic-gate ASSERT(mp->b_cont->b_rptr != NULL); 4957c478bd9Sstevel@tonic-gate ASSERT(sps->sps_npmode == NPMODE_PASS); 4967c478bd9Sstevel@tonic-gate sap = ((uint32_t *)mp->b_cont->b_rptr)[0]; 4977c478bd9Sstevel@tonic-gate npmode = (enum NPmode)((uint32_t *)mp->b_cont->b_rptr)[1]; 4987c478bd9Sstevel@tonic-gate /* 4997c478bd9Sstevel@tonic-gate * Walk the sibling streams which belong to the same 5007c478bd9Sstevel@tonic-gate * ppa, and try to find a stream with matching sap 5017c478bd9Sstevel@tonic-gate * number. 5027c478bd9Sstevel@tonic-gate */ 5037c478bd9Sstevel@tonic-gate rw_enter(&ppa->ppa_sib_lock, RW_WRITER); 5047c478bd9Sstevel@tonic-gate for (nextsib = ppa->ppa_streams; nextsib != NULL; 5057c478bd9Sstevel@tonic-gate nextsib = nextsib->sps_nextsib) { 5067c478bd9Sstevel@tonic-gate if (nextsib->sps_sap == sap) { 5077c478bd9Sstevel@tonic-gate break; /* found it */ 5087c478bd9Sstevel@tonic-gate } 5097c478bd9Sstevel@tonic-gate } 5107c478bd9Sstevel@tonic-gate if (nextsib == NULL) { 5117c478bd9Sstevel@tonic-gate rw_exit(&ppa->ppa_sib_lock); 5127c478bd9Sstevel@tonic-gate break; /* return EINVAL */ 5137c478bd9Sstevel@tonic-gate } else { 5147c478bd9Sstevel@tonic-gate nextsib->sps_npmode = npmode; 5157c478bd9Sstevel@tonic-gate if ((nextsib->sps_npmode != NPMODE_QUEUE) && 5167c478bd9Sstevel@tonic-gate (WR(nextsib->sps_rq)->q_first != NULL)) { 5177c478bd9Sstevel@tonic-gate qenable(WR(nextsib->sps_rq)); 5187c478bd9Sstevel@tonic-gate } 5197c478bd9Sstevel@tonic-gate } 5207c478bd9Sstevel@tonic-gate rw_exit(&ppa->ppa_sib_lock); 5217c478bd9Sstevel@tonic-gate error = 0; /* return success */ 5227c478bd9Sstevel@tonic-gate break; 5237c478bd9Sstevel@tonic-gate case PPPIO_GIDLE: 5247c478bd9Sstevel@tonic-gate if (ppa == NULL) { 5257c478bd9Sstevel@tonic-gate ASSERT(!IS_SPS_CONTROL(sps)); 5267c478bd9Sstevel@tonic-gate error = ENOLINK; 5277c478bd9Sstevel@tonic-gate break; 5287c478bd9Sstevel@tonic-gate } else if (!IS_PPA_TIMESTAMP(ppa)) { 5297c478bd9Sstevel@tonic-gate break; /* return EINVAL */ 5307c478bd9Sstevel@tonic-gate } 5317c478bd9Sstevel@tonic-gate if ((nmp = allocb(sizeof (struct ppp_idle), 5327c478bd9Sstevel@tonic-gate BPRI_MED)) == NULL) { 5337c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 5347c478bd9Sstevel@tonic-gate ppa->ppa_allocbfail++; 5357c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 5367c478bd9Sstevel@tonic-gate error = ENOSR; 5377c478bd9Sstevel@tonic-gate break; 5387c478bd9Sstevel@tonic-gate } 5397c478bd9Sstevel@tonic-gate if (mp->b_cont != NULL) { 5407c478bd9Sstevel@tonic-gate freemsg(mp->b_cont); 5417c478bd9Sstevel@tonic-gate } 5427c478bd9Sstevel@tonic-gate mp->b_cont = nmp; 5437c478bd9Sstevel@tonic-gate pip = (struct ppp_idle *)nmp->b_wptr; 5447c478bd9Sstevel@tonic-gate nmp->b_wptr += sizeof (struct ppp_idle); 5457c478bd9Sstevel@tonic-gate /* 5467c478bd9Sstevel@tonic-gate * Get current timestamp and subtract the tx and rx 5477c478bd9Sstevel@tonic-gate * timestamps to get the actual idle time to be 5487c478bd9Sstevel@tonic-gate * returned. 5497c478bd9Sstevel@tonic-gate */ 5507c478bd9Sstevel@tonic-gate hrtime = gethrtime(); 5517c478bd9Sstevel@tonic-gate pip->xmit_idle = (hrtime - ppa->ppa_lasttx) / 1000000000ul; 5527c478bd9Sstevel@tonic-gate pip->recv_idle = (hrtime - ppa->ppa_lastrx) / 1000000000ul; 5537c478bd9Sstevel@tonic-gate count = msgsize(nmp); 5547c478bd9Sstevel@tonic-gate error = 0; 5557c478bd9Sstevel@tonic-gate break; /* return success (error is 0) */ 5567c478bd9Sstevel@tonic-gate case PPPIO_GTYPE: 5577c478bd9Sstevel@tonic-gate nmp = allocb(sizeof (uint32_t), BPRI_MED); 5587c478bd9Sstevel@tonic-gate if (nmp == NULL) { 5597c478bd9Sstevel@tonic-gate error = ENOSR; 5607c478bd9Sstevel@tonic-gate break; 5617c478bd9Sstevel@tonic-gate } 5627c478bd9Sstevel@tonic-gate if (mp->b_cont != NULL) { 5637c478bd9Sstevel@tonic-gate freemsg(mp->b_cont); 5647c478bd9Sstevel@tonic-gate } 5657c478bd9Sstevel@tonic-gate mp->b_cont = nmp; 5667c478bd9Sstevel@tonic-gate /* 5677c478bd9Sstevel@tonic-gate * Let the requestor know that we are the PPP 5687c478bd9Sstevel@tonic-gate * multiplexer (PPPTYP_MUX). 5697c478bd9Sstevel@tonic-gate */ 5707c478bd9Sstevel@tonic-gate *(uint32_t *)nmp->b_wptr = PPPTYP_MUX; 5717c478bd9Sstevel@tonic-gate nmp->b_wptr += sizeof (uint32_t); 5727c478bd9Sstevel@tonic-gate count = msgsize(nmp); 5737c478bd9Sstevel@tonic-gate error = 0; /* return success */ 5747c478bd9Sstevel@tonic-gate break; 5757c478bd9Sstevel@tonic-gate case PPPIO_GETSTAT64: 5767c478bd9Sstevel@tonic-gate if (ppa == NULL) { 5777c478bd9Sstevel@tonic-gate break; /* return EINVAL */ 5787c478bd9Sstevel@tonic-gate } else if ((ppa->ppa_lower_wq != NULL) && 5797c478bd9Sstevel@tonic-gate !IS_PPA_LASTMOD(ppa)) { 5807c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 5817c478bd9Sstevel@tonic-gate /* 5829f7c4232SAnil udupa * We match sps_ioc_id on the M_IOC{ACK,NAK}, 5839f7c4232SAnil udupa * so if the response hasn't come back yet, 5849f7c4232SAnil udupa * new ioctls must be queued instead. 5857c478bd9Sstevel@tonic-gate */ 5869f7c4232SAnil udupa if (IS_SPS_IOCQ(sps)) { 5879f7c4232SAnil udupa mutex_exit(&ppa->ppa_sta_lock); 5889f7c4232SAnil udupa if (!putq(q, mp)) { 5899f7c4232SAnil udupa error = EAGAIN; 5909f7c4232SAnil udupa break; 5919f7c4232SAnil udupa } 5929f7c4232SAnil udupa return; 5939f7c4232SAnil udupa } else { 5949f7c4232SAnil udupa ppa->ppa_ioctlsfwd++; 5959f7c4232SAnil udupa /* 5969f7c4232SAnil udupa * Record the ioctl CMD & ID - this will be 5979f7c4232SAnil udupa * used to check the ACK or NAK responses 5989f7c4232SAnil udupa * coming from below. 5999f7c4232SAnil udupa */ 6009f7c4232SAnil udupa sps->sps_ioc_id = iop->ioc_id; 6019f7c4232SAnil udupa sps->sps_flags |= SPS_IOCQ; 6029f7c4232SAnil udupa mutex_exit(&ppa->ppa_sta_lock); 6039f7c4232SAnil udupa } 6047c478bd9Sstevel@tonic-gate putnext(ppa->ppa_lower_wq, mp); 6057c478bd9Sstevel@tonic-gate return; /* don't ack or nak the request */ 6067c478bd9Sstevel@tonic-gate } 6077c478bd9Sstevel@tonic-gate nmp = allocb(sizeof (*psp), BPRI_MED); 6087c478bd9Sstevel@tonic-gate if (nmp == NULL) { 6097c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 6107c478bd9Sstevel@tonic-gate ppa->ppa_allocbfail++; 6117c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 6127c478bd9Sstevel@tonic-gate error = ENOSR; 6137c478bd9Sstevel@tonic-gate break; 6147c478bd9Sstevel@tonic-gate } 6157c478bd9Sstevel@tonic-gate if (mp->b_cont != NULL) { 6167c478bd9Sstevel@tonic-gate freemsg(mp->b_cont); 6177c478bd9Sstevel@tonic-gate } 6187c478bd9Sstevel@tonic-gate mp->b_cont = nmp; 6197c478bd9Sstevel@tonic-gate psp = (struct ppp_stats64 *)nmp->b_wptr; 6207c478bd9Sstevel@tonic-gate /* 6217c478bd9Sstevel@tonic-gate * Copy the contents of ppp_stats64 structure for this 6227c478bd9Sstevel@tonic-gate * ppa and return them to the caller. 6237c478bd9Sstevel@tonic-gate */ 6247c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 6257c478bd9Sstevel@tonic-gate bcopy(&ppa->ppa_stats, psp, sizeof (*psp)); 6267c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 6277c478bd9Sstevel@tonic-gate nmp->b_wptr += sizeof (*psp); 6287c478bd9Sstevel@tonic-gate count = sizeof (*psp); 6297c478bd9Sstevel@tonic-gate error = 0; /* return success */ 6307c478bd9Sstevel@tonic-gate break; 6317c478bd9Sstevel@tonic-gate case PPPIO_GETCSTAT: 6327c478bd9Sstevel@tonic-gate if (ppa == NULL) { 6337c478bd9Sstevel@tonic-gate break; /* return EINVAL */ 6347c478bd9Sstevel@tonic-gate } else if ((ppa->ppa_lower_wq != NULL) && 6357c478bd9Sstevel@tonic-gate !IS_PPA_LASTMOD(ppa)) { 6367c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 6377c478bd9Sstevel@tonic-gate /* 6389f7c4232SAnil udupa * See comments in PPPIO_GETSTAT64 case 6399f7c4232SAnil udupa * in sppp_ioctl(). 6407c478bd9Sstevel@tonic-gate */ 6419f7c4232SAnil udupa if (IS_SPS_IOCQ(sps)) { 6429f7c4232SAnil udupa mutex_exit(&ppa->ppa_sta_lock); 6439f7c4232SAnil udupa if (!putq(q, mp)) { 6449f7c4232SAnil udupa error = EAGAIN; 6459f7c4232SAnil udupa break; 6469f7c4232SAnil udupa } 6479f7c4232SAnil udupa return; 6489f7c4232SAnil udupa } else { 6499f7c4232SAnil udupa ppa->ppa_ioctlsfwd++; 6509f7c4232SAnil udupa /* 6519f7c4232SAnil udupa * Record the ioctl CMD & ID - this will be 6529f7c4232SAnil udupa * used to check the ACK or NAK responses 6539f7c4232SAnil udupa * coming from below. 6549f7c4232SAnil udupa */ 6559f7c4232SAnil udupa sps->sps_ioc_id = iop->ioc_id; 6569f7c4232SAnil udupa sps->sps_flags |= SPS_IOCQ; 6579f7c4232SAnil udupa mutex_exit(&ppa->ppa_sta_lock); 6589f7c4232SAnil udupa } 6597c478bd9Sstevel@tonic-gate putnext(ppa->ppa_lower_wq, mp); 6607c478bd9Sstevel@tonic-gate return; /* don't ack or nak the request */ 6617c478bd9Sstevel@tonic-gate } 6627c478bd9Sstevel@tonic-gate nmp = allocb(sizeof (struct ppp_comp_stats), BPRI_MED); 6637c478bd9Sstevel@tonic-gate if (nmp == NULL) { 6647c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 6657c478bd9Sstevel@tonic-gate ppa->ppa_allocbfail++; 6667c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 6677c478bd9Sstevel@tonic-gate error = ENOSR; 6687c478bd9Sstevel@tonic-gate break; 6697c478bd9Sstevel@tonic-gate } 6707c478bd9Sstevel@tonic-gate if (mp->b_cont != NULL) { 6717c478bd9Sstevel@tonic-gate freemsg(mp->b_cont); 6727c478bd9Sstevel@tonic-gate } 6737c478bd9Sstevel@tonic-gate mp->b_cont = nmp; 6747c478bd9Sstevel@tonic-gate pcsp = (struct ppp_comp_stats *)nmp->b_wptr; 6757c478bd9Sstevel@tonic-gate nmp->b_wptr += sizeof (struct ppp_comp_stats); 6767c478bd9Sstevel@tonic-gate bzero((caddr_t)pcsp, sizeof (struct ppp_comp_stats)); 6777c478bd9Sstevel@tonic-gate count = msgsize(nmp); 6787c478bd9Sstevel@tonic-gate error = 0; /* return success */ 6797c478bd9Sstevel@tonic-gate break; 6807c478bd9Sstevel@tonic-gate } 6817c478bd9Sstevel@tonic-gate 6827c478bd9Sstevel@tonic-gate if (error == 0) { 6837c478bd9Sstevel@tonic-gate /* Success; tell the user. */ 6847c478bd9Sstevel@tonic-gate miocack(q, mp, count, 0); 6857c478bd9Sstevel@tonic-gate } else { 6867c478bd9Sstevel@tonic-gate /* Failure; send error back upstream. */ 6877c478bd9Sstevel@tonic-gate miocnak(q, mp, 0, error); 6887c478bd9Sstevel@tonic-gate } 6897c478bd9Sstevel@tonic-gate } 6907c478bd9Sstevel@tonic-gate 6917c478bd9Sstevel@tonic-gate /* 6927c478bd9Sstevel@tonic-gate * sppp_uwput() 6937c478bd9Sstevel@tonic-gate * 6947c478bd9Sstevel@tonic-gate * MT-Perimeters: 6957c478bd9Sstevel@tonic-gate * shared inner, shared outer. 6967c478bd9Sstevel@tonic-gate * 6977c478bd9Sstevel@tonic-gate * Description: 6987c478bd9Sstevel@tonic-gate * Upper write-side put procedure. Messages from above arrive here. 6997c478bd9Sstevel@tonic-gate */ 700002c70ffScarlsonj void 7017c478bd9Sstevel@tonic-gate sppp_uwput(queue_t *q, mblk_t *mp) 7027c478bd9Sstevel@tonic-gate { 7037c478bd9Sstevel@tonic-gate queue_t *nextq; 7047c478bd9Sstevel@tonic-gate spppstr_t *sps; 7057c478bd9Sstevel@tonic-gate sppa_t *ppa; 7067c478bd9Sstevel@tonic-gate struct iocblk *iop; 7077c478bd9Sstevel@tonic-gate int error; 7087c478bd9Sstevel@tonic-gate 7097c478bd9Sstevel@tonic-gate ASSERT(q != NULL && q->q_ptr != NULL); 7107c478bd9Sstevel@tonic-gate ASSERT(mp != NULL && mp->b_rptr != NULL); 7117c478bd9Sstevel@tonic-gate sps = (spppstr_t *)q->q_ptr; 7127c478bd9Sstevel@tonic-gate ppa = sps->sps_ppa; 7137c478bd9Sstevel@tonic-gate 7147c478bd9Sstevel@tonic-gate switch (MTYPE(mp)) { 7157c478bd9Sstevel@tonic-gate case M_PCPROTO: 7167c478bd9Sstevel@tonic-gate case M_PROTO: 7177c478bd9Sstevel@tonic-gate if (IS_SPS_CONTROL(sps)) { 7187c478bd9Sstevel@tonic-gate ASSERT(ppa != NULL); 7197c478bd9Sstevel@tonic-gate /* 7207c478bd9Sstevel@tonic-gate * Intentionally change this to a high priority 7217c478bd9Sstevel@tonic-gate * message so it doesn't get queued up. M_PROTO is 7227c478bd9Sstevel@tonic-gate * specifically used for signalling between pppd and its 7237c478bd9Sstevel@tonic-gate * kernel-level component(s), such as ppptun, so we 7247c478bd9Sstevel@tonic-gate * make sure that it doesn't get queued up behind 7257c478bd9Sstevel@tonic-gate * data messages. 7267c478bd9Sstevel@tonic-gate */ 7277c478bd9Sstevel@tonic-gate MTYPE(mp) = M_PCPROTO; 7287c478bd9Sstevel@tonic-gate if ((ppa->ppa_lower_wq != NULL) && 7297c478bd9Sstevel@tonic-gate canputnext(ppa->ppa_lower_wq)) { 7307c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 7317c478bd9Sstevel@tonic-gate ppa->ppa_mctlsfwd++; 7327c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 7337c478bd9Sstevel@tonic-gate putnext(ppa->ppa_lower_wq, mp); 7347c478bd9Sstevel@tonic-gate } else { 7357c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 7367c478bd9Sstevel@tonic-gate ppa->ppa_mctlsfwderr++; 7377c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 7387c478bd9Sstevel@tonic-gate freemsg(mp); 7397c478bd9Sstevel@tonic-gate } 7407c478bd9Sstevel@tonic-gate } else { 741002c70ffScarlsonj (void) sppp_mproto(q, mp, sps); 742002c70ffScarlsonj return; 7437c478bd9Sstevel@tonic-gate } 7447c478bd9Sstevel@tonic-gate break; 7457c478bd9Sstevel@tonic-gate case M_DATA: 7467c478bd9Sstevel@tonic-gate if ((nextq = sppp_send(q, &mp, sps)) != NULL) 7477c478bd9Sstevel@tonic-gate putnext(nextq, mp); 7487c478bd9Sstevel@tonic-gate break; 7497c478bd9Sstevel@tonic-gate case M_IOCTL: 7507c478bd9Sstevel@tonic-gate error = EINVAL; 7517c478bd9Sstevel@tonic-gate iop = (struct iocblk *)mp->b_rptr; 7527c478bd9Sstevel@tonic-gate switch (iop->ioc_cmd) { 7537c478bd9Sstevel@tonic-gate case DLIOCRAW: 7547c478bd9Sstevel@tonic-gate case DL_IOC_HDR_INFO: 7557c478bd9Sstevel@tonic-gate case PPPIO_ATTACH: 7567c478bd9Sstevel@tonic-gate case PPPIO_DEBUG: 7577c478bd9Sstevel@tonic-gate case PPPIO_DETACH: 7587c478bd9Sstevel@tonic-gate case PPPIO_LASTMOD: 7597c478bd9Sstevel@tonic-gate case PPPIO_MRU: 7607c478bd9Sstevel@tonic-gate case PPPIO_MTU: 7617c478bd9Sstevel@tonic-gate case PPPIO_USETIMESTAMP: 7627c478bd9Sstevel@tonic-gate case PPPIO_BLOCKNP: 7637c478bd9Sstevel@tonic-gate case PPPIO_UNBLOCKNP: 7647c478bd9Sstevel@tonic-gate qwriter(q, mp, sppp_inner_ioctl, PERIM_INNER); 765002c70ffScarlsonj return; 7667c478bd9Sstevel@tonic-gate case I_LINK: 7677c478bd9Sstevel@tonic-gate case I_UNLINK: 7687c478bd9Sstevel@tonic-gate case PPPIO_NEWPPA: 7697c478bd9Sstevel@tonic-gate qwriter(q, mp, sppp_outer_ioctl, PERIM_OUTER); 770002c70ffScarlsonj return; 7717c478bd9Sstevel@tonic-gate case PPPIO_NPMODE: 7727c478bd9Sstevel@tonic-gate case PPPIO_GIDLE: 7737c478bd9Sstevel@tonic-gate case PPPIO_GTYPE: 7747c478bd9Sstevel@tonic-gate case PPPIO_GETSTAT64: 7757c478bd9Sstevel@tonic-gate case PPPIO_GETCSTAT: 7767c478bd9Sstevel@tonic-gate /* 7777c478bd9Sstevel@tonic-gate * These require additional auto variables to 7787c478bd9Sstevel@tonic-gate * handle, so (for optimization reasons) 7797c478bd9Sstevel@tonic-gate * they're moved off to a separate function. 7807c478bd9Sstevel@tonic-gate */ 7817c478bd9Sstevel@tonic-gate sppp_ioctl(q, mp); 782002c70ffScarlsonj return; 7837c478bd9Sstevel@tonic-gate case PPPIO_GETSTAT: 7847c478bd9Sstevel@tonic-gate break; /* 32 bit interface gone */ 7857c478bd9Sstevel@tonic-gate default: 7867c478bd9Sstevel@tonic-gate if (iop->ioc_cr == NULL || 787f53eecf5SJames Carlson secpolicy_ppp_config(iop->ioc_cr) != 0) { 7887c478bd9Sstevel@tonic-gate error = EPERM; 7897c478bd9Sstevel@tonic-gate break; 7907c478bd9Sstevel@tonic-gate } else if ((ppa == NULL) || 7917c478bd9Sstevel@tonic-gate (ppa->ppa_lower_wq == NULL)) { 7927c478bd9Sstevel@tonic-gate break; /* return EINVAL */ 7937c478bd9Sstevel@tonic-gate } 7947c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 7957c478bd9Sstevel@tonic-gate /* 7969f7c4232SAnil udupa * See comments in PPPIO_GETSTAT64 case 7979f7c4232SAnil udupa * in sppp_ioctl(). 7987c478bd9Sstevel@tonic-gate */ 7999f7c4232SAnil udupa if (IS_SPS_IOCQ(sps)) { 8009f7c4232SAnil udupa mutex_exit(&ppa->ppa_sta_lock); 8019f7c4232SAnil udupa if (!putq(q, mp)) { 8029f7c4232SAnil udupa error = EAGAIN; 8039f7c4232SAnil udupa break; 8049f7c4232SAnil udupa } 8059f7c4232SAnil udupa return; 8069f7c4232SAnil udupa } else { 8079f7c4232SAnil udupa ppa->ppa_ioctlsfwd++; 8089f7c4232SAnil udupa /* 8099f7c4232SAnil udupa * Record the ioctl CMD & ID - 8109f7c4232SAnil udupa * this will be used to check the 8119f7c4232SAnil udupa * ACK or NAK responses coming from below. 8129f7c4232SAnil udupa */ 8139f7c4232SAnil udupa sps->sps_ioc_id = iop->ioc_id; 8149f7c4232SAnil udupa sps->sps_flags |= SPS_IOCQ; 8159f7c4232SAnil udupa mutex_exit(&ppa->ppa_sta_lock); 8169f7c4232SAnil udupa } 8177c478bd9Sstevel@tonic-gate putnext(ppa->ppa_lower_wq, mp); 818002c70ffScarlsonj return; /* don't ack or nak the request */ 8197c478bd9Sstevel@tonic-gate } 8207c478bd9Sstevel@tonic-gate /* Failure; send error back upstream. */ 8217c478bd9Sstevel@tonic-gate miocnak(q, mp, 0, error); 8227c478bd9Sstevel@tonic-gate break; 8237c478bd9Sstevel@tonic-gate case M_FLUSH: 8247c478bd9Sstevel@tonic-gate if (*mp->b_rptr & FLUSHW) { 8257c478bd9Sstevel@tonic-gate flushq(q, FLUSHDATA); 8267c478bd9Sstevel@tonic-gate } 8277c478bd9Sstevel@tonic-gate if (*mp->b_rptr & FLUSHR) { 8287c478bd9Sstevel@tonic-gate *mp->b_rptr &= ~FLUSHW; 8297c478bd9Sstevel@tonic-gate qreply(q, mp); 8307c478bd9Sstevel@tonic-gate } else { 8317c478bd9Sstevel@tonic-gate freemsg(mp); 8327c478bd9Sstevel@tonic-gate } 8337c478bd9Sstevel@tonic-gate break; 8347c478bd9Sstevel@tonic-gate default: 8357c478bd9Sstevel@tonic-gate freemsg(mp); 8367c478bd9Sstevel@tonic-gate break; 8377c478bd9Sstevel@tonic-gate } 8387c478bd9Sstevel@tonic-gate } 8397c478bd9Sstevel@tonic-gate 8407c478bd9Sstevel@tonic-gate /* 8417c478bd9Sstevel@tonic-gate * sppp_uwsrv() 8427c478bd9Sstevel@tonic-gate * 8437c478bd9Sstevel@tonic-gate * MT-Perimeters: 8447c478bd9Sstevel@tonic-gate * exclusive inner, shared outer. 8457c478bd9Sstevel@tonic-gate * 8467c478bd9Sstevel@tonic-gate * Description: 8477c478bd9Sstevel@tonic-gate * Upper write-side service procedure. Note that this procedure does 8487c478bd9Sstevel@tonic-gate * not get called when a message is placed on our write-side queue, since 8497c478bd9Sstevel@tonic-gate * automatic queue scheduling has been turned off by noenable() when 8507c478bd9Sstevel@tonic-gate * the queue was opened. We do this on purpose, as we explicitly control 8517c478bd9Sstevel@tonic-gate * the write-side queue. Therefore, this procedure gets called when 8527c478bd9Sstevel@tonic-gate * the lower write service procedure qenable() the upper write stream queue. 8537c478bd9Sstevel@tonic-gate */ 854002c70ffScarlsonj void 8557c478bd9Sstevel@tonic-gate sppp_uwsrv(queue_t *q) 8567c478bd9Sstevel@tonic-gate { 8577c478bd9Sstevel@tonic-gate spppstr_t *sps; 8589f7c4232SAnil udupa sppa_t *ppa; 8597c478bd9Sstevel@tonic-gate mblk_t *mp; 8607c478bd9Sstevel@tonic-gate queue_t *nextq; 8619f7c4232SAnil udupa struct iocblk *iop; 8627c478bd9Sstevel@tonic-gate 8637c478bd9Sstevel@tonic-gate ASSERT(q != NULL && q->q_ptr != NULL); 8647c478bd9Sstevel@tonic-gate sps = (spppstr_t *)q->q_ptr; 8659f7c4232SAnil udupa 8667c478bd9Sstevel@tonic-gate while ((mp = getq(q)) != NULL) { 8679f7c4232SAnil udupa if (MTYPE(mp) == M_IOCTL) { 8689f7c4232SAnil udupa ppa = sps->sps_ppa; 8699f7c4232SAnil udupa if ((ppa == NULL) || (ppa->ppa_lower_wq == NULL)) { 8709f7c4232SAnil udupa miocnak(q, mp, 0, EINVAL); 8719f7c4232SAnil udupa continue; 8729f7c4232SAnil udupa } 8739f7c4232SAnil udupa 8749f7c4232SAnil udupa iop = (struct iocblk *)mp->b_rptr; 8759f7c4232SAnil udupa mutex_enter(&ppa->ppa_sta_lock); 8769f7c4232SAnil udupa /* 8779f7c4232SAnil udupa * See comments in PPPIO_GETSTAT64 case 8789f7c4232SAnil udupa * in sppp_ioctl(). 8799f7c4232SAnil udupa */ 8809f7c4232SAnil udupa if (IS_SPS_IOCQ(sps)) { 8819f7c4232SAnil udupa mutex_exit(&ppa->ppa_sta_lock); 8829f7c4232SAnil udupa if (putbq(q, mp) == 0) 8839f7c4232SAnil udupa miocnak(q, mp, 0, EAGAIN); 8849f7c4232SAnil udupa break; 8859f7c4232SAnil udupa } else { 8869f7c4232SAnil udupa ppa->ppa_ioctlsfwd++; 8879f7c4232SAnil udupa sps->sps_ioc_id = iop->ioc_id; 8889f7c4232SAnil udupa sps->sps_flags |= SPS_IOCQ; 8899f7c4232SAnil udupa mutex_exit(&ppa->ppa_sta_lock); 8909f7c4232SAnil udupa putnext(ppa->ppa_lower_wq, mp); 8919f7c4232SAnil udupa } 8929f7c4232SAnil udupa } else if ((nextq = 8939f7c4232SAnil udupa sppp_outpkt(q, &mp, msgdsize(mp), sps)) == NULL) { 8947c478bd9Sstevel@tonic-gate if (mp != NULL) { 8957c478bd9Sstevel@tonic-gate if (putbq(q, mp) == 0) 8967c478bd9Sstevel@tonic-gate freemsg(mp); 8977c478bd9Sstevel@tonic-gate break; 8987c478bd9Sstevel@tonic-gate } 8997c478bd9Sstevel@tonic-gate } else { 9007c478bd9Sstevel@tonic-gate putnext(nextq, mp); 9017c478bd9Sstevel@tonic-gate } 9027c478bd9Sstevel@tonic-gate } 9037c478bd9Sstevel@tonic-gate } 9047c478bd9Sstevel@tonic-gate 9057c478bd9Sstevel@tonic-gate void 9067c478bd9Sstevel@tonic-gate sppp_remove_ppa(spppstr_t *sps) 9077c478bd9Sstevel@tonic-gate { 9087c478bd9Sstevel@tonic-gate spppstr_t *nextsib; 9097c478bd9Sstevel@tonic-gate sppa_t *ppa = sps->sps_ppa; 9107c478bd9Sstevel@tonic-gate 9117c478bd9Sstevel@tonic-gate rw_enter(&ppa->ppa_sib_lock, RW_WRITER); 9127c478bd9Sstevel@tonic-gate if (ppa->ppa_refcnt <= 1) { 9137c478bd9Sstevel@tonic-gate rw_exit(&ppa->ppa_sib_lock); 9147c478bd9Sstevel@tonic-gate sppp_free_ppa(ppa); 9157c478bd9Sstevel@tonic-gate } else { 9167c478bd9Sstevel@tonic-gate nextsib = ppa->ppa_streams; 9177c478bd9Sstevel@tonic-gate if (nextsib == sps) { 9187c478bd9Sstevel@tonic-gate ppa->ppa_streams = sps->sps_nextsib; 9197c478bd9Sstevel@tonic-gate } else { 9207c478bd9Sstevel@tonic-gate while (nextsib->sps_nextsib != NULL) { 9217c478bd9Sstevel@tonic-gate if (nextsib->sps_nextsib == sps) { 9227c478bd9Sstevel@tonic-gate nextsib->sps_nextsib = 9237c478bd9Sstevel@tonic-gate sps->sps_nextsib; 9247c478bd9Sstevel@tonic-gate break; 9257c478bd9Sstevel@tonic-gate } 9267c478bd9Sstevel@tonic-gate nextsib = nextsib->sps_nextsib; 9277c478bd9Sstevel@tonic-gate } 9287c478bd9Sstevel@tonic-gate } 9297c478bd9Sstevel@tonic-gate ppa->ppa_refcnt--; 9307c478bd9Sstevel@tonic-gate /* 9317c478bd9Sstevel@tonic-gate * And if this stream was marked as promiscuous 9327c478bd9Sstevel@tonic-gate * (SPS_PROMISC), then we need to update the 9337c478bd9Sstevel@tonic-gate * promiscuous streams count. This should only happen 9347c478bd9Sstevel@tonic-gate * when DL_DETACH_REQ is issued prior to marking the 9357c478bd9Sstevel@tonic-gate * stream as non-promiscuous, through 9367c478bd9Sstevel@tonic-gate * DL_PROMISCOFF_REQ request. 9377c478bd9Sstevel@tonic-gate */ 9387c478bd9Sstevel@tonic-gate if (IS_SPS_PROMISC(sps)) { 9397c478bd9Sstevel@tonic-gate ASSERT(ppa->ppa_promicnt > 0); 9407c478bd9Sstevel@tonic-gate ppa->ppa_promicnt--; 9417c478bd9Sstevel@tonic-gate } 9427c478bd9Sstevel@tonic-gate rw_exit(&ppa->ppa_sib_lock); 9437c478bd9Sstevel@tonic-gate } 9447c478bd9Sstevel@tonic-gate sps->sps_nextsib = NULL; 9457c478bd9Sstevel@tonic-gate sps->sps_ppa = NULL; 9467c478bd9Sstevel@tonic-gate freemsg(sps->sps_hangup); 9477c478bd9Sstevel@tonic-gate sps->sps_hangup = NULL; 9487c478bd9Sstevel@tonic-gate } 9497c478bd9Sstevel@tonic-gate 9507c478bd9Sstevel@tonic-gate sppa_t * 9517c478bd9Sstevel@tonic-gate sppp_find_ppa(uint32_t ppa_id) 9527c478bd9Sstevel@tonic-gate { 9537c478bd9Sstevel@tonic-gate sppa_t *ppa; 9547c478bd9Sstevel@tonic-gate 9557c478bd9Sstevel@tonic-gate for (ppa = ppa_list; ppa != NULL; ppa = ppa->ppa_nextppa) { 9567c478bd9Sstevel@tonic-gate if (ppa->ppa_ppa_id == ppa_id) { 9577c478bd9Sstevel@tonic-gate break; /* found the ppa */ 9587c478bd9Sstevel@tonic-gate } 9597c478bd9Sstevel@tonic-gate } 9607c478bd9Sstevel@tonic-gate return (ppa); 9617c478bd9Sstevel@tonic-gate } 9627c478bd9Sstevel@tonic-gate 9637c478bd9Sstevel@tonic-gate /* 9647c478bd9Sstevel@tonic-gate * sppp_inner_ioctl() 9657c478bd9Sstevel@tonic-gate * 9667c478bd9Sstevel@tonic-gate * MT-Perimeters: 9677c478bd9Sstevel@tonic-gate * exclusive inner, shared outer 9687c478bd9Sstevel@tonic-gate * 9697c478bd9Sstevel@tonic-gate * Description: 9707c478bd9Sstevel@tonic-gate * Called by sppp_uwput as a result of receiving ioctls which require 9717c478bd9Sstevel@tonic-gate * an exclusive access at the inner perimeter. 9727c478bd9Sstevel@tonic-gate */ 9737c478bd9Sstevel@tonic-gate static void 9747c478bd9Sstevel@tonic-gate sppp_inner_ioctl(queue_t *q, mblk_t *mp) 9757c478bd9Sstevel@tonic-gate { 9767c478bd9Sstevel@tonic-gate spppstr_t *sps; 9777c478bd9Sstevel@tonic-gate sppa_t *ppa; 9787c478bd9Sstevel@tonic-gate struct iocblk *iop; 9797c478bd9Sstevel@tonic-gate mblk_t *nmp; 9807c478bd9Sstevel@tonic-gate int error = EINVAL; 9817c478bd9Sstevel@tonic-gate int count = 0; 9827c478bd9Sstevel@tonic-gate int dbgcmd; 9837c478bd9Sstevel@tonic-gate int mru, mtu; 9847c478bd9Sstevel@tonic-gate uint32_t ppa_id; 9857c478bd9Sstevel@tonic-gate hrtime_t hrtime; 9867c478bd9Sstevel@tonic-gate uint16_t proto; 9877c478bd9Sstevel@tonic-gate 9887c478bd9Sstevel@tonic-gate ASSERT(q != NULL && q->q_ptr != NULL); 9897c478bd9Sstevel@tonic-gate ASSERT(mp != NULL && mp->b_rptr != NULL); 9907c478bd9Sstevel@tonic-gate 9917c478bd9Sstevel@tonic-gate sps = (spppstr_t *)q->q_ptr; 9927c478bd9Sstevel@tonic-gate ppa = sps->sps_ppa; 9937c478bd9Sstevel@tonic-gate iop = (struct iocblk *)mp->b_rptr; 9947c478bd9Sstevel@tonic-gate switch (iop->ioc_cmd) { 9957c478bd9Sstevel@tonic-gate case DLIOCRAW: 9967c478bd9Sstevel@tonic-gate if (IS_SPS_CONTROL(sps)) { 9977c478bd9Sstevel@tonic-gate break; /* return EINVAL */ 9987c478bd9Sstevel@tonic-gate } 9997c478bd9Sstevel@tonic-gate sps->sps_flags |= SPS_RAWDATA; 10007c478bd9Sstevel@tonic-gate error = 0; /* return success */ 10017c478bd9Sstevel@tonic-gate break; 10027c478bd9Sstevel@tonic-gate case DL_IOC_HDR_INFO: 10037c478bd9Sstevel@tonic-gate if (IS_SPS_CONTROL(sps)) { 10047c478bd9Sstevel@tonic-gate break; /* return EINVAL */ 10057c478bd9Sstevel@tonic-gate } else if ((mp->b_cont == NULL) || 10067c478bd9Sstevel@tonic-gate *((t_uscalar_t *)mp->b_cont->b_rptr) != DL_UNITDATA_REQ || 10077c478bd9Sstevel@tonic-gate (MBLKL(mp->b_cont) < (sizeof (dl_unitdata_req_t) + 1008002c70ffScarlsonj SPPP_ADDRL))) { 10097c478bd9Sstevel@tonic-gate error = EPROTO; 10107c478bd9Sstevel@tonic-gate break; 10117c478bd9Sstevel@tonic-gate } else if (ppa == NULL) { 10127c478bd9Sstevel@tonic-gate error = ENOLINK; 10137c478bd9Sstevel@tonic-gate break; 10147c478bd9Sstevel@tonic-gate } 10157c478bd9Sstevel@tonic-gate if ((nmp = allocb(PPP_HDRLEN, BPRI_MED)) == NULL) { 10167c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 10177c478bd9Sstevel@tonic-gate ppa->ppa_allocbfail++; 10187c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 10197c478bd9Sstevel@tonic-gate error = ENOMEM; 10207c478bd9Sstevel@tonic-gate break; 10217c478bd9Sstevel@tonic-gate } 10227c478bd9Sstevel@tonic-gate *(uchar_t *)nmp->b_wptr++ = PPP_ALLSTATIONS; 10237c478bd9Sstevel@tonic-gate *(uchar_t *)nmp->b_wptr++ = PPP_UI; 10247c478bd9Sstevel@tonic-gate *(uchar_t *)nmp->b_wptr++ = sps->sps_sap >> 8; 10257c478bd9Sstevel@tonic-gate *(uchar_t *)nmp->b_wptr++ = sps->sps_sap & 0xff; 10267c478bd9Sstevel@tonic-gate ASSERT(MBLKL(nmp) == PPP_HDRLEN); 10277c478bd9Sstevel@tonic-gate 10287c478bd9Sstevel@tonic-gate linkb(mp, nmp); 10297c478bd9Sstevel@tonic-gate sps->sps_flags |= SPS_FASTPATH; 10307c478bd9Sstevel@tonic-gate error = 0; /* return success */ 10317c478bd9Sstevel@tonic-gate count = msgsize(nmp); 10327c478bd9Sstevel@tonic-gate break; 10337c478bd9Sstevel@tonic-gate case PPPIO_ATTACH: 10347c478bd9Sstevel@tonic-gate if (IS_SPS_CONTROL(sps) || IS_SPS_PIOATTACH(sps) || 10357c478bd9Sstevel@tonic-gate (sps->sps_dlstate != DL_UNATTACHED) || 10367c478bd9Sstevel@tonic-gate (iop->ioc_count != sizeof (uint32_t))) { 10377c478bd9Sstevel@tonic-gate break; /* return EINVAL */ 10387c478bd9Sstevel@tonic-gate } else if (mp->b_cont == NULL) { 10397c478bd9Sstevel@tonic-gate error = EPROTO; 10407c478bd9Sstevel@tonic-gate break; 10417c478bd9Sstevel@tonic-gate } 10427c478bd9Sstevel@tonic-gate ASSERT(mp->b_cont->b_rptr != NULL); 10437c478bd9Sstevel@tonic-gate /* If there's something here, it's detached. */ 10447c478bd9Sstevel@tonic-gate if (ppa != NULL) { 10457c478bd9Sstevel@tonic-gate sppp_remove_ppa(sps); 10467c478bd9Sstevel@tonic-gate } 10477c478bd9Sstevel@tonic-gate ppa_id = *(uint32_t *)mp->b_cont->b_rptr; 10487c478bd9Sstevel@tonic-gate ppa = sppp_find_ppa(ppa_id); 10497c478bd9Sstevel@tonic-gate /* 10507c478bd9Sstevel@tonic-gate * If we can't find it, then it's either because the requestor 10517c478bd9Sstevel@tonic-gate * has supplied a wrong ppa_id to be attached to, or because 10527c478bd9Sstevel@tonic-gate * the control stream for the specified ppa_id has been closed 10537c478bd9Sstevel@tonic-gate * before we get here. 10547c478bd9Sstevel@tonic-gate */ 10557c478bd9Sstevel@tonic-gate if (ppa == NULL) { 10567c478bd9Sstevel@tonic-gate error = ENOENT; 10577c478bd9Sstevel@tonic-gate break; 10587c478bd9Sstevel@tonic-gate } 1059f53eecf5SJames Carlson if (iop->ioc_cr == NULL || 1060f53eecf5SJames Carlson ppa->ppa_zoneid != crgetzoneid(iop->ioc_cr)) { 1061f53eecf5SJames Carlson error = EPERM; 1062f53eecf5SJames Carlson break; 1063f53eecf5SJames Carlson } 10647c478bd9Sstevel@tonic-gate /* 10657c478bd9Sstevel@tonic-gate * Preallocate the hangup message so that we're always 10667c478bd9Sstevel@tonic-gate * able to send this upstream in the event of a 10677c478bd9Sstevel@tonic-gate * catastrophic failure. 10687c478bd9Sstevel@tonic-gate */ 10697c478bd9Sstevel@tonic-gate if ((sps->sps_hangup = allocb(1, BPRI_MED)) == NULL) { 10707c478bd9Sstevel@tonic-gate error = ENOSR; 10717c478bd9Sstevel@tonic-gate break; 10727c478bd9Sstevel@tonic-gate } 10737c478bd9Sstevel@tonic-gate /* 10747c478bd9Sstevel@tonic-gate * There are two ways to attach a stream to a ppa: one is 10757c478bd9Sstevel@tonic-gate * through DLPI (DL_ATTACH_REQ) and the other is through 10767c478bd9Sstevel@tonic-gate * PPPIO_ATTACH. This is why we need to distinguish whether or 10777c478bd9Sstevel@tonic-gate * not a stream was allocated via PPPIO_ATTACH, so that we can 10787c478bd9Sstevel@tonic-gate * properly detach it when we receive PPPIO_DETACH ioctl 10797c478bd9Sstevel@tonic-gate * request. 10807c478bd9Sstevel@tonic-gate */ 10817c478bd9Sstevel@tonic-gate sps->sps_flags |= SPS_PIOATTACH; 10827c478bd9Sstevel@tonic-gate sps->sps_ppa = ppa; 10837c478bd9Sstevel@tonic-gate /* 10847c478bd9Sstevel@tonic-gate * Add this stream to the head of the list of sibling streams 10857c478bd9Sstevel@tonic-gate * which belong to the same ppa as specified. 10867c478bd9Sstevel@tonic-gate */ 10877c478bd9Sstevel@tonic-gate rw_enter(&ppa->ppa_sib_lock, RW_WRITER); 10887c478bd9Sstevel@tonic-gate ppa->ppa_refcnt++; 10897c478bd9Sstevel@tonic-gate sps->sps_nextsib = ppa->ppa_streams; 10907c478bd9Sstevel@tonic-gate ppa->ppa_streams = sps; 10917c478bd9Sstevel@tonic-gate rw_exit(&ppa->ppa_sib_lock); 10927c478bd9Sstevel@tonic-gate error = 0; /* return success */ 10937c478bd9Sstevel@tonic-gate break; 10947c478bd9Sstevel@tonic-gate case PPPIO_BLOCKNP: 10957c478bd9Sstevel@tonic-gate case PPPIO_UNBLOCKNP: 10967c478bd9Sstevel@tonic-gate if (iop->ioc_cr == NULL || 1097f53eecf5SJames Carlson secpolicy_ppp_config(iop->ioc_cr) != 0) { 10987c478bd9Sstevel@tonic-gate error = EPERM; 10997c478bd9Sstevel@tonic-gate break; 11007c478bd9Sstevel@tonic-gate } 11017c478bd9Sstevel@tonic-gate error = miocpullup(mp, sizeof (uint16_t)); 11027c478bd9Sstevel@tonic-gate if (error != 0) 11037c478bd9Sstevel@tonic-gate break; 11047c478bd9Sstevel@tonic-gate ASSERT(mp->b_cont->b_rptr != NULL); 11057c478bd9Sstevel@tonic-gate proto = *(uint16_t *)mp->b_cont->b_rptr; 11067c478bd9Sstevel@tonic-gate if (iop->ioc_cmd == PPPIO_BLOCKNP) { 11077c478bd9Sstevel@tonic-gate uint32_t npflagpos = sppp_ppp2np(proto); 11087c478bd9Sstevel@tonic-gate /* 11097c478bd9Sstevel@tonic-gate * Mark proto as blocked in ppa_npflag until the 11107c478bd9Sstevel@tonic-gate * corresponding queues for proto have been plumbed. 11117c478bd9Sstevel@tonic-gate */ 11127c478bd9Sstevel@tonic-gate if (npflagpos != 0) { 11137c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_npmutex); 11147c478bd9Sstevel@tonic-gate ppa->ppa_npflag |= (1 << npflagpos); 11157c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_npmutex); 11167c478bd9Sstevel@tonic-gate } else { 11177c478bd9Sstevel@tonic-gate error = EINVAL; 11187c478bd9Sstevel@tonic-gate } 11197c478bd9Sstevel@tonic-gate } else { 11207c478bd9Sstevel@tonic-gate /* 11217c478bd9Sstevel@tonic-gate * reset ppa_npflag and release proto 11227c478bd9Sstevel@tonic-gate * packets that were being held in control queue. 11237c478bd9Sstevel@tonic-gate */ 11247c478bd9Sstevel@tonic-gate sppp_release_pkts(ppa, proto); 11257c478bd9Sstevel@tonic-gate } 11267c478bd9Sstevel@tonic-gate break; 11277c478bd9Sstevel@tonic-gate case PPPIO_DEBUG: 11287c478bd9Sstevel@tonic-gate if (iop->ioc_cr == NULL || 1129f53eecf5SJames Carlson secpolicy_ppp_config(iop->ioc_cr) != 0) { 11307c478bd9Sstevel@tonic-gate error = EPERM; 11317c478bd9Sstevel@tonic-gate break; 11327c478bd9Sstevel@tonic-gate } else if (iop->ioc_count != sizeof (uint32_t)) { 11337c478bd9Sstevel@tonic-gate break; /* return EINVAL */ 11347c478bd9Sstevel@tonic-gate } else if (mp->b_cont == NULL) { 11357c478bd9Sstevel@tonic-gate error = EPROTO; 11367c478bd9Sstevel@tonic-gate break; 11377c478bd9Sstevel@tonic-gate } 11387c478bd9Sstevel@tonic-gate ASSERT(mp->b_cont->b_rptr != NULL); 11397c478bd9Sstevel@tonic-gate dbgcmd = *(uint32_t *)mp->b_cont->b_rptr; 11407c478bd9Sstevel@tonic-gate /* 11417c478bd9Sstevel@tonic-gate * We accept PPPDBG_LOG + PPPDBG_DRIVER value as an indication 11427c478bd9Sstevel@tonic-gate * that SPS_KDEBUG needs to be enabled for this upper stream. 11437c478bd9Sstevel@tonic-gate */ 11447c478bd9Sstevel@tonic-gate if (dbgcmd == PPPDBG_LOG + PPPDBG_DRIVER) { 11457c478bd9Sstevel@tonic-gate sps->sps_flags |= SPS_KDEBUG; 11467c478bd9Sstevel@tonic-gate error = 0; /* return success */ 11477c478bd9Sstevel@tonic-gate break; 11487c478bd9Sstevel@tonic-gate } 11497c478bd9Sstevel@tonic-gate /* 11507c478bd9Sstevel@tonic-gate * Otherwise, for any other values, we send them down only if 11517c478bd9Sstevel@tonic-gate * there is an attachment and if the attachment has something 11527c478bd9Sstevel@tonic-gate * linked underneath it. 11537c478bd9Sstevel@tonic-gate */ 11547c478bd9Sstevel@tonic-gate if ((ppa == NULL) || (ppa->ppa_lower_wq == NULL)) { 11557c478bd9Sstevel@tonic-gate error = ENOLINK; 11567c478bd9Sstevel@tonic-gate break; 11577c478bd9Sstevel@tonic-gate } 11587c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 11597c478bd9Sstevel@tonic-gate /* 11609f7c4232SAnil udupa * See comments in PPPIO_GETSTAT64 case 11619f7c4232SAnil udupa * in sppp_ioctl(). 11627c478bd9Sstevel@tonic-gate */ 11639f7c4232SAnil udupa if (IS_SPS_IOCQ(sps)) { 11649f7c4232SAnil udupa mutex_exit(&ppa->ppa_sta_lock); 11659f7c4232SAnil udupa if (!putq(q, mp)) { 11669f7c4232SAnil udupa error = EAGAIN; 11679f7c4232SAnil udupa break; 11689f7c4232SAnil udupa } 11699f7c4232SAnil udupa return; 11709f7c4232SAnil udupa } else { 11719f7c4232SAnil udupa ppa->ppa_ioctlsfwd++; 11729f7c4232SAnil udupa /* 11739f7c4232SAnil udupa * Record the ioctl CMD & ID - 11749f7c4232SAnil udupa * this will be used to check the 11759f7c4232SAnil udupa * ACK or NAK responses coming from below. 11769f7c4232SAnil udupa */ 11779f7c4232SAnil udupa sps->sps_ioc_id = iop->ioc_id; 11789f7c4232SAnil udupa sps->sps_flags |= SPS_IOCQ; 11799f7c4232SAnil udupa mutex_exit(&ppa->ppa_sta_lock); 11809f7c4232SAnil udupa } 11817c478bd9Sstevel@tonic-gate putnext(ppa->ppa_lower_wq, mp); 11827c478bd9Sstevel@tonic-gate return; /* don't ack or nak the request */ 11837c478bd9Sstevel@tonic-gate case PPPIO_DETACH: 11847c478bd9Sstevel@tonic-gate if (!IS_SPS_PIOATTACH(sps)) { 11857c478bd9Sstevel@tonic-gate break; /* return EINVAL */ 11867c478bd9Sstevel@tonic-gate } 11877c478bd9Sstevel@tonic-gate /* 11887c478bd9Sstevel@tonic-gate * The SPS_PIOATTACH flag set on the stream tells us that 11897c478bd9Sstevel@tonic-gate * the ppa field is still valid. In the event that the control 11907c478bd9Sstevel@tonic-gate * stream be closed prior to this stream's detachment, the 11917c478bd9Sstevel@tonic-gate * SPS_PIOATTACH flag would have been cleared from this stream 11927c478bd9Sstevel@tonic-gate * during close; in that case we won't get here. 11937c478bd9Sstevel@tonic-gate */ 11947c478bd9Sstevel@tonic-gate ASSERT(ppa != NULL); 11957c478bd9Sstevel@tonic-gate ASSERT(ppa->ppa_ctl != sps); 11967c478bd9Sstevel@tonic-gate ASSERT(sps->sps_dlstate == DL_UNATTACHED); 11977c478bd9Sstevel@tonic-gate 11987c478bd9Sstevel@tonic-gate /* 11997c478bd9Sstevel@tonic-gate * We don't actually detach anything until the stream is 12007c478bd9Sstevel@tonic-gate * closed or reattached. 12017c478bd9Sstevel@tonic-gate */ 12027c478bd9Sstevel@tonic-gate 12037c478bd9Sstevel@tonic-gate sps->sps_flags &= ~SPS_PIOATTACH; 12047c478bd9Sstevel@tonic-gate error = 0; /* return success */ 12057c478bd9Sstevel@tonic-gate break; 12067c478bd9Sstevel@tonic-gate case PPPIO_LASTMOD: 12077c478bd9Sstevel@tonic-gate if (!IS_SPS_CONTROL(sps)) { 12087c478bd9Sstevel@tonic-gate break; /* return EINVAL */ 12097c478bd9Sstevel@tonic-gate } 12107c478bd9Sstevel@tonic-gate ASSERT(ppa != NULL); 12117c478bd9Sstevel@tonic-gate ppa->ppa_flags |= PPA_LASTMOD; 12127c478bd9Sstevel@tonic-gate error = 0; /* return success */ 12137c478bd9Sstevel@tonic-gate break; 12147c478bd9Sstevel@tonic-gate case PPPIO_MRU: 12157c478bd9Sstevel@tonic-gate if (!IS_SPS_CONTROL(sps) || 12167c478bd9Sstevel@tonic-gate (iop->ioc_count != sizeof (uint32_t))) { 12177c478bd9Sstevel@tonic-gate break; /* return EINVAL */ 12187c478bd9Sstevel@tonic-gate } else if (mp->b_cont == NULL) { 12197c478bd9Sstevel@tonic-gate error = EPROTO; 12207c478bd9Sstevel@tonic-gate break; 12217c478bd9Sstevel@tonic-gate } 12227c478bd9Sstevel@tonic-gate ASSERT(ppa != NULL); 12237c478bd9Sstevel@tonic-gate ASSERT(mp->b_cont->b_rptr != NULL); 12247c478bd9Sstevel@tonic-gate mru = *(uint32_t *)mp->b_cont->b_rptr; 12257c478bd9Sstevel@tonic-gate if ((mru <= 0) || (mru > PPP_MAXMRU)) { 12267c478bd9Sstevel@tonic-gate error = EPROTO; 12277c478bd9Sstevel@tonic-gate break; 12287c478bd9Sstevel@tonic-gate } 12297c478bd9Sstevel@tonic-gate if (mru < PPP_MRU) { 12307c478bd9Sstevel@tonic-gate mru = PPP_MRU; 12317c478bd9Sstevel@tonic-gate } 12327c478bd9Sstevel@tonic-gate ppa->ppa_mru = (uint16_t)mru; 12337c478bd9Sstevel@tonic-gate /* 12347c478bd9Sstevel@tonic-gate * If there's something beneath this driver for the ppa, then 12357c478bd9Sstevel@tonic-gate * inform it (or them) of the MRU size. Only do this is we 12367c478bd9Sstevel@tonic-gate * are not the last PPP module on the stream. 12377c478bd9Sstevel@tonic-gate */ 12387c478bd9Sstevel@tonic-gate if (!IS_PPA_LASTMOD(ppa) && (ppa->ppa_lower_wq != NULL)) { 12397c478bd9Sstevel@tonic-gate (void) putctl4(ppa->ppa_lower_wq, M_CTL, PPPCTL_MRU, 12407c478bd9Sstevel@tonic-gate mru); 12417c478bd9Sstevel@tonic-gate } 12427c478bd9Sstevel@tonic-gate error = 0; /* return success */ 12437c478bd9Sstevel@tonic-gate break; 12447c478bd9Sstevel@tonic-gate case PPPIO_MTU: 12457c478bd9Sstevel@tonic-gate if (!IS_SPS_CONTROL(sps) || 12467c478bd9Sstevel@tonic-gate (iop->ioc_count != sizeof (uint32_t))) { 12477c478bd9Sstevel@tonic-gate break; /* return EINVAL */ 12487c478bd9Sstevel@tonic-gate } else if (mp->b_cont == NULL) { 12497c478bd9Sstevel@tonic-gate error = EPROTO; 12507c478bd9Sstevel@tonic-gate break; 12517c478bd9Sstevel@tonic-gate } 12527c478bd9Sstevel@tonic-gate ASSERT(ppa != NULL); 12537c478bd9Sstevel@tonic-gate ASSERT(mp->b_cont->b_rptr != NULL); 12547c478bd9Sstevel@tonic-gate mtu = *(uint32_t *)mp->b_cont->b_rptr; 12557c478bd9Sstevel@tonic-gate if ((mtu <= 0) || (mtu > PPP_MAXMTU)) { 12567c478bd9Sstevel@tonic-gate error = EPROTO; 12577c478bd9Sstevel@tonic-gate break; 12587c478bd9Sstevel@tonic-gate } 12597c478bd9Sstevel@tonic-gate ppa->ppa_mtu = (uint16_t)mtu; 12607c478bd9Sstevel@tonic-gate /* 12617c478bd9Sstevel@tonic-gate * If there's something beneath this driver for the ppa, then 12627c478bd9Sstevel@tonic-gate * inform it (or them) of the MTU size. Only do this if we 12637c478bd9Sstevel@tonic-gate * are not the last PPP module on the stream. 12647c478bd9Sstevel@tonic-gate */ 12657c478bd9Sstevel@tonic-gate if (!IS_PPA_LASTMOD(ppa) && (ppa->ppa_lower_wq != NULL)) { 12667c478bd9Sstevel@tonic-gate (void) putctl4(ppa->ppa_lower_wq, M_CTL, PPPCTL_MTU, 12677c478bd9Sstevel@tonic-gate mtu); 12687c478bd9Sstevel@tonic-gate } 12697c478bd9Sstevel@tonic-gate error = 0; /* return success */ 12707c478bd9Sstevel@tonic-gate break; 12717c478bd9Sstevel@tonic-gate case PPPIO_USETIMESTAMP: 12727c478bd9Sstevel@tonic-gate if (!IS_SPS_CONTROL(sps)) { 12737c478bd9Sstevel@tonic-gate break; /* return EINVAL */ 12747c478bd9Sstevel@tonic-gate } 12757c478bd9Sstevel@tonic-gate if (!IS_PPA_TIMESTAMP(ppa)) { 12767c478bd9Sstevel@tonic-gate hrtime = gethrtime(); 12777c478bd9Sstevel@tonic-gate ppa->ppa_lasttx = ppa->ppa_lastrx = hrtime; 12787c478bd9Sstevel@tonic-gate ppa->ppa_flags |= PPA_TIMESTAMP; 12797c478bd9Sstevel@tonic-gate } 12807c478bd9Sstevel@tonic-gate error = 0; 12817c478bd9Sstevel@tonic-gate break; 12827c478bd9Sstevel@tonic-gate } 12837c478bd9Sstevel@tonic-gate 12847c478bd9Sstevel@tonic-gate if (error == 0) { 12857c478bd9Sstevel@tonic-gate /* Success; tell the user */ 12867c478bd9Sstevel@tonic-gate miocack(q, mp, count, 0); 12877c478bd9Sstevel@tonic-gate } else { 12887c478bd9Sstevel@tonic-gate /* Failure; send error back upstream */ 12897c478bd9Sstevel@tonic-gate miocnak(q, mp, 0, error); 12907c478bd9Sstevel@tonic-gate } 12917c478bd9Sstevel@tonic-gate } 12927c478bd9Sstevel@tonic-gate 12937c478bd9Sstevel@tonic-gate /* 12947c478bd9Sstevel@tonic-gate * sppp_outer_ioctl() 12957c478bd9Sstevel@tonic-gate * 12967c478bd9Sstevel@tonic-gate * MT-Perimeters: 12977c478bd9Sstevel@tonic-gate * exclusive inner, exclusive outer 12987c478bd9Sstevel@tonic-gate * 12997c478bd9Sstevel@tonic-gate * Description: 13007c478bd9Sstevel@tonic-gate * Called by sppp_uwput as a result of receiving ioctls which require 13017c478bd9Sstevel@tonic-gate * an exclusive access at the outer perimeter. 13027c478bd9Sstevel@tonic-gate */ 13037c478bd9Sstevel@tonic-gate static void 13047c478bd9Sstevel@tonic-gate sppp_outer_ioctl(queue_t *q, mblk_t *mp) 13057c478bd9Sstevel@tonic-gate { 1306f53eecf5SJames Carlson spppstr_t *sps = q->q_ptr; 13077c478bd9Sstevel@tonic-gate spppstr_t *nextsib; 13087c478bd9Sstevel@tonic-gate queue_t *lwq; 13097c478bd9Sstevel@tonic-gate sppa_t *ppa; 13107c478bd9Sstevel@tonic-gate struct iocblk *iop; 13117c478bd9Sstevel@tonic-gate int error = EINVAL; 13127c478bd9Sstevel@tonic-gate int count = 0; 13137c478bd9Sstevel@tonic-gate uint32_t ppa_id; 13147c478bd9Sstevel@tonic-gate mblk_t *nmp; 1315f53eecf5SJames Carlson zoneid_t zoneid; 13167c478bd9Sstevel@tonic-gate 13177c478bd9Sstevel@tonic-gate sps = (spppstr_t *)q->q_ptr; 13187c478bd9Sstevel@tonic-gate ppa = sps->sps_ppa; 13197c478bd9Sstevel@tonic-gate iop = (struct iocblk *)mp->b_rptr; 13207c478bd9Sstevel@tonic-gate switch (iop->ioc_cmd) { 13217c478bd9Sstevel@tonic-gate case I_LINK: 13227c478bd9Sstevel@tonic-gate if (!IS_SPS_CONTROL(sps)) { 13237c478bd9Sstevel@tonic-gate break; /* return EINVAL */ 13247c478bd9Sstevel@tonic-gate } else if (ppa->ppa_lower_wq != NULL) { 13257c478bd9Sstevel@tonic-gate error = EEXIST; 13267c478bd9Sstevel@tonic-gate break; 13277c478bd9Sstevel@tonic-gate } 13287c478bd9Sstevel@tonic-gate ASSERT(ppa->ppa_ctl != NULL); 13297c478bd9Sstevel@tonic-gate ASSERT(sps->sps_npmode == NPMODE_PASS); 13307c478bd9Sstevel@tonic-gate ASSERT(mp->b_cont != NULL && mp->b_cont->b_rptr != NULL); 13317c478bd9Sstevel@tonic-gate 13327c478bd9Sstevel@tonic-gate lwq = ((struct linkblk *)mp->b_cont->b_rptr)->l_qbot; 13337c478bd9Sstevel@tonic-gate ASSERT(lwq != NULL); 13347c478bd9Sstevel@tonic-gate 13357c478bd9Sstevel@tonic-gate ppa->ppa_lower_wq = lwq; 13367c478bd9Sstevel@tonic-gate lwq->q_ptr = RD(lwq)->q_ptr = (caddr_t)ppa; 13377c478bd9Sstevel@tonic-gate /* 13387c478bd9Sstevel@tonic-gate * Unblock upper network streams which now feed this lower 13397c478bd9Sstevel@tonic-gate * stream. We don't need to hold ppa_sib_lock here, since we 13407c478bd9Sstevel@tonic-gate * are writer at the outer perimeter. 13417c478bd9Sstevel@tonic-gate */ 13427c478bd9Sstevel@tonic-gate if (WR(sps->sps_rq)->q_first != NULL) 13437c478bd9Sstevel@tonic-gate qenable(WR(sps->sps_rq)); 13447c478bd9Sstevel@tonic-gate for (nextsib = ppa->ppa_streams; nextsib != NULL; 13457c478bd9Sstevel@tonic-gate nextsib = nextsib->sps_nextsib) { 13467c478bd9Sstevel@tonic-gate nextsib->sps_npmode = NPMODE_PASS; 13477c478bd9Sstevel@tonic-gate if (WR(nextsib->sps_rq)->q_first != NULL) { 13487c478bd9Sstevel@tonic-gate qenable(WR(nextsib->sps_rq)); 13497c478bd9Sstevel@tonic-gate } 13507c478bd9Sstevel@tonic-gate } 1351f53eecf5SJames Carlson 1352f53eecf5SJames Carlson /* 1353f53eecf5SJames Carlson * Also unblock (run once) our lower read-side queue. This is 1354f53eecf5SJames Carlson * where packets received while doing the I_LINK may be 1355f53eecf5SJames Carlson * languishing; see sppp_lrsrv. 1356f53eecf5SJames Carlson */ 1357f53eecf5SJames Carlson qenable(RD(lwq)); 1358f53eecf5SJames Carlson 13597c478bd9Sstevel@tonic-gate /* 13607c478bd9Sstevel@tonic-gate * Send useful information down to the modules which are now 13617c478bd9Sstevel@tonic-gate * linked below this driver (for this particular ppa). Only 13627c478bd9Sstevel@tonic-gate * do this if we are not the last PPP module on the stream. 13637c478bd9Sstevel@tonic-gate */ 13647c478bd9Sstevel@tonic-gate if (!IS_PPA_LASTMOD(ppa)) { 13657c478bd9Sstevel@tonic-gate (void) putctl8(lwq, M_CTL, PPPCTL_UNIT, 13667c478bd9Sstevel@tonic-gate ppa->ppa_ppa_id); 13677c478bd9Sstevel@tonic-gate (void) putctl4(lwq, M_CTL, PPPCTL_MRU, ppa->ppa_mru); 13687c478bd9Sstevel@tonic-gate (void) putctl4(lwq, M_CTL, PPPCTL_MTU, ppa->ppa_mtu); 13697c478bd9Sstevel@tonic-gate } 13707c478bd9Sstevel@tonic-gate 13717c478bd9Sstevel@tonic-gate if (IS_SPS_KDEBUG(sps)) { 13727c478bd9Sstevel@tonic-gate SPDEBUG(PPP_DRV_NAME 13737c478bd9Sstevel@tonic-gate "/%d: I_LINK lwq=0x%p sps=0x%p flags=0x%b ppa=0x%p " 13747c478bd9Sstevel@tonic-gate "flags=0x%b\n", sps->sps_mn_id, 13757c478bd9Sstevel@tonic-gate (void *)ppa->ppa_lower_wq, (void *)sps, 13767c478bd9Sstevel@tonic-gate sps->sps_flags, SPS_FLAGS_STR, 13777c478bd9Sstevel@tonic-gate (void *)ppa, ppa->ppa_flags, 13787c478bd9Sstevel@tonic-gate PPA_FLAGS_STR); 13797c478bd9Sstevel@tonic-gate } 13807c478bd9Sstevel@tonic-gate error = 0; /* return success */ 13817c478bd9Sstevel@tonic-gate break; 13827c478bd9Sstevel@tonic-gate case I_UNLINK: 13837c478bd9Sstevel@tonic-gate ASSERT(IS_SPS_CONTROL(sps)); 13847c478bd9Sstevel@tonic-gate ASSERT(ppa != NULL); 13857c478bd9Sstevel@tonic-gate lwq = ppa->ppa_lower_wq; 13867c478bd9Sstevel@tonic-gate ASSERT(mp->b_cont != NULL && mp->b_cont->b_rptr != NULL); 13877c478bd9Sstevel@tonic-gate ASSERT(lwq == ((struct linkblk *)mp->b_cont->b_rptr)->l_qbot); 13887c478bd9Sstevel@tonic-gate 13897c478bd9Sstevel@tonic-gate if (IS_SPS_KDEBUG(sps)) { 13907c478bd9Sstevel@tonic-gate SPDEBUG(PPP_DRV_NAME 13917c478bd9Sstevel@tonic-gate "/%d: I_UNLINK lwq=0x%p sps=0x%p flags=0x%b " 13927c478bd9Sstevel@tonic-gate "ppa=0x%p flags=0x%b\n", sps->sps_mn_id, 13937c478bd9Sstevel@tonic-gate (void *)lwq, (void *)sps, sps->sps_flags, 13947c478bd9Sstevel@tonic-gate SPS_FLAGS_STR, (void *)ppa, ppa->ppa_flags, 13957c478bd9Sstevel@tonic-gate PPA_FLAGS_STR); 13967c478bd9Sstevel@tonic-gate } 13977c478bd9Sstevel@tonic-gate /* 13987c478bd9Sstevel@tonic-gate * While accessing the outer perimeter exclusively, we 13997c478bd9Sstevel@tonic-gate * disassociate our ppa's lower_wq from the lower stream linked 14007c478bd9Sstevel@tonic-gate * beneath us, and we also disassociate our control stream from 14017c478bd9Sstevel@tonic-gate * the q_ptr of the lower stream. 14027c478bd9Sstevel@tonic-gate */ 14037c478bd9Sstevel@tonic-gate lwq->q_ptr = RD(lwq)->q_ptr = NULL; 14047c478bd9Sstevel@tonic-gate ppa->ppa_lower_wq = NULL; 14057c478bd9Sstevel@tonic-gate /* 14067c478bd9Sstevel@tonic-gate * Unblock streams which now feed back up the control stream, 14077c478bd9Sstevel@tonic-gate * and acknowledge the request. We don't need to hold 14087c478bd9Sstevel@tonic-gate * ppa_sib_lock here, since we are writer at the outer 14097c478bd9Sstevel@tonic-gate * perimeter. 14107c478bd9Sstevel@tonic-gate */ 14117c478bd9Sstevel@tonic-gate if (WR(sps->sps_rq)->q_first != NULL) 14127c478bd9Sstevel@tonic-gate qenable(WR(sps->sps_rq)); 14137c478bd9Sstevel@tonic-gate for (nextsib = ppa->ppa_streams; nextsib != NULL; 14147c478bd9Sstevel@tonic-gate nextsib = nextsib->sps_nextsib) { 14157c478bd9Sstevel@tonic-gate if (WR(nextsib->sps_rq)->q_first != NULL) { 14167c478bd9Sstevel@tonic-gate qenable(WR(nextsib->sps_rq)); 14177c478bd9Sstevel@tonic-gate } 14187c478bd9Sstevel@tonic-gate } 14197c478bd9Sstevel@tonic-gate error = 0; /* return success */ 14207c478bd9Sstevel@tonic-gate break; 14217c478bd9Sstevel@tonic-gate case PPPIO_NEWPPA: 14227c478bd9Sstevel@tonic-gate /* 14237c478bd9Sstevel@tonic-gate * Do sanity check to ensure that we don't accept PPPIO_NEWPPA 14247c478bd9Sstevel@tonic-gate * on a stream which DLPI is used (since certain DLPI messages 14257c478bd9Sstevel@tonic-gate * will cause state transition reflected in sps_dlstate, 14267c478bd9Sstevel@tonic-gate * changing it from its default DL_UNATTACHED value). In other 14277c478bd9Sstevel@tonic-gate * words, we won't allow a network/snoop stream to become 14287c478bd9Sstevel@tonic-gate * a control stream. 14297c478bd9Sstevel@tonic-gate */ 14307c478bd9Sstevel@tonic-gate if (iop->ioc_cr == NULL || 1431f53eecf5SJames Carlson secpolicy_ppp_config(iop->ioc_cr) != 0) { 14327c478bd9Sstevel@tonic-gate error = EPERM; 14337c478bd9Sstevel@tonic-gate break; 14347c478bd9Sstevel@tonic-gate } else if (IS_SPS_CONTROL(sps) || IS_SPS_PIOATTACH(sps) || 14357c478bd9Sstevel@tonic-gate (ppa != NULL) || (sps->sps_dlstate != DL_UNATTACHED)) { 14367c478bd9Sstevel@tonic-gate break; /* return EINVAL */ 14377c478bd9Sstevel@tonic-gate } 14387c478bd9Sstevel@tonic-gate /* Get requested unit number (if any) */ 14397c478bd9Sstevel@tonic-gate if (iop->ioc_count == sizeof (uint32_t) && mp->b_cont != NULL) 14407c478bd9Sstevel@tonic-gate ppa_id = *(uint32_t *)mp->b_cont->b_rptr; 14417c478bd9Sstevel@tonic-gate else 14427c478bd9Sstevel@tonic-gate ppa_id = 0; 14437c478bd9Sstevel@tonic-gate /* Get mblk to use for response message */ 14447c478bd9Sstevel@tonic-gate nmp = allocb(sizeof (uint32_t), BPRI_MED); 14457c478bd9Sstevel@tonic-gate if (nmp == NULL) { 14467c478bd9Sstevel@tonic-gate error = ENOSR; 14477c478bd9Sstevel@tonic-gate break; 14487c478bd9Sstevel@tonic-gate } 14497c478bd9Sstevel@tonic-gate if (mp->b_cont != NULL) { 14507c478bd9Sstevel@tonic-gate freemsg(mp->b_cont); 14517c478bd9Sstevel@tonic-gate } 14527c478bd9Sstevel@tonic-gate mp->b_cont = nmp; /* chain our response mblk */ 14537c478bd9Sstevel@tonic-gate /* 14547c478bd9Sstevel@tonic-gate * Walk the global ppa list and determine the lowest 14557c478bd9Sstevel@tonic-gate * available ppa_id number to be used. 14567c478bd9Sstevel@tonic-gate */ 14577c478bd9Sstevel@tonic-gate if (ppa_id == (uint32_t)-1) 14587c478bd9Sstevel@tonic-gate ppa_id = 0; 1459f53eecf5SJames Carlson zoneid = crgetzoneid(iop->ioc_cr); 14607c478bd9Sstevel@tonic-gate for (ppa = ppa_list; ppa != NULL; ppa = ppa->ppa_nextppa) { 14617c478bd9Sstevel@tonic-gate if (ppa_id == (uint32_t)-2) { 1462f53eecf5SJames Carlson if (ppa->ppa_ctl == NULL && 1463f53eecf5SJames Carlson ppa->ppa_zoneid == zoneid) 14647c478bd9Sstevel@tonic-gate break; 14657c478bd9Sstevel@tonic-gate } else { 14667c478bd9Sstevel@tonic-gate if (ppa_id < ppa->ppa_ppa_id) 14677c478bd9Sstevel@tonic-gate break; 14687c478bd9Sstevel@tonic-gate if (ppa_id == ppa->ppa_ppa_id) 14697c478bd9Sstevel@tonic-gate ++ppa_id; 14707c478bd9Sstevel@tonic-gate } 14717c478bd9Sstevel@tonic-gate } 14727c478bd9Sstevel@tonic-gate if (ppa_id == (uint32_t)-2) { 14737c478bd9Sstevel@tonic-gate if (ppa == NULL) { 14747c478bd9Sstevel@tonic-gate error = ENXIO; 14757c478bd9Sstevel@tonic-gate break; 14767c478bd9Sstevel@tonic-gate } 14777c478bd9Sstevel@tonic-gate /* Clear timestamp and lastmod flags */ 14787c478bd9Sstevel@tonic-gate ppa->ppa_flags = 0; 14797c478bd9Sstevel@tonic-gate } else { 1480f53eecf5SJames Carlson ppa = sppp_create_ppa(ppa_id, zoneid); 14817c478bd9Sstevel@tonic-gate if (ppa == NULL) { 14827c478bd9Sstevel@tonic-gate error = ENOMEM; 14837c478bd9Sstevel@tonic-gate break; 14847c478bd9Sstevel@tonic-gate } 14857c478bd9Sstevel@tonic-gate } 14867c478bd9Sstevel@tonic-gate 14877c478bd9Sstevel@tonic-gate sps->sps_ppa = ppa; /* chain the ppa structure */ 14887c478bd9Sstevel@tonic-gate sps->sps_npmode = NPMODE_PASS; /* network packets may travel */ 14897c478bd9Sstevel@tonic-gate sps->sps_flags |= SPS_CONTROL; /* this is the control stream */ 14907c478bd9Sstevel@tonic-gate 14917c478bd9Sstevel@tonic-gate ppa->ppa_refcnt++; /* new PPA reference */ 14927c478bd9Sstevel@tonic-gate ppa->ppa_ctl = sps; /* back ptr to upper stream */ 14937c478bd9Sstevel@tonic-gate /* 14947c478bd9Sstevel@tonic-gate * Return the newly created ppa_id to the requestor and 14957c478bd9Sstevel@tonic-gate * acnowledge the request. 14967c478bd9Sstevel@tonic-gate */ 14977c478bd9Sstevel@tonic-gate *(uint32_t *)nmp->b_wptr = ppa->ppa_ppa_id; 14987c478bd9Sstevel@tonic-gate nmp->b_wptr += sizeof (uint32_t); 14997c478bd9Sstevel@tonic-gate 15007c478bd9Sstevel@tonic-gate if (IS_SPS_KDEBUG(sps)) { 15017c478bd9Sstevel@tonic-gate SPDEBUG(PPP_DRV_NAME 15027c478bd9Sstevel@tonic-gate "/%d: PPPIO_NEWPPA ppa_id=%d sps=0x%p flags=0x%b " 15037c478bd9Sstevel@tonic-gate "ppa=0x%p flags=0x%b\n", sps->sps_mn_id, ppa_id, 15047c478bd9Sstevel@tonic-gate (void *)sps, sps->sps_flags, SPS_FLAGS_STR, 15057c478bd9Sstevel@tonic-gate (void *)ppa, ppa->ppa_flags, 15067c478bd9Sstevel@tonic-gate PPA_FLAGS_STR); 15077c478bd9Sstevel@tonic-gate } 15087c478bd9Sstevel@tonic-gate count = msgsize(nmp); 15097c478bd9Sstevel@tonic-gate error = 0; 15107c478bd9Sstevel@tonic-gate break; 15117c478bd9Sstevel@tonic-gate } 15127c478bd9Sstevel@tonic-gate 15137c478bd9Sstevel@tonic-gate if (error == 0) { 15147c478bd9Sstevel@tonic-gate /* Success; tell the user. */ 15157c478bd9Sstevel@tonic-gate miocack(q, mp, count, 0); 15167c478bd9Sstevel@tonic-gate } else { 15177c478bd9Sstevel@tonic-gate /* Failure; send error back upstream. */ 15187c478bd9Sstevel@tonic-gate miocnak(q, mp, 0, error); 15197c478bd9Sstevel@tonic-gate } 15207c478bd9Sstevel@tonic-gate } 15217c478bd9Sstevel@tonic-gate 15227c478bd9Sstevel@tonic-gate /* 15237c478bd9Sstevel@tonic-gate * sppp_send() 15247c478bd9Sstevel@tonic-gate * 15257c478bd9Sstevel@tonic-gate * MT-Perimeters: 15267c478bd9Sstevel@tonic-gate * shared inner, shared outer. 15277c478bd9Sstevel@tonic-gate * 15287c478bd9Sstevel@tonic-gate * Description: 15297c478bd9Sstevel@tonic-gate * Called by sppp_uwput to handle M_DATA message type. Returns 15307c478bd9Sstevel@tonic-gate * queue_t for putnext, or NULL to mean that the packet was 15317c478bd9Sstevel@tonic-gate * handled internally. 15327c478bd9Sstevel@tonic-gate */ 15337c478bd9Sstevel@tonic-gate static queue_t * 15347c478bd9Sstevel@tonic-gate sppp_send(queue_t *q, mblk_t **mpp, spppstr_t *sps) 15357c478bd9Sstevel@tonic-gate { 15367c478bd9Sstevel@tonic-gate mblk_t *mp; 15377c478bd9Sstevel@tonic-gate sppa_t *ppa; 15387c478bd9Sstevel@tonic-gate int is_promisc; 15397c478bd9Sstevel@tonic-gate int msize; 15407c478bd9Sstevel@tonic-gate int error = 0; 15417c478bd9Sstevel@tonic-gate queue_t *nextq; 15427c478bd9Sstevel@tonic-gate 15437c478bd9Sstevel@tonic-gate ASSERT(mpp != NULL); 15447c478bd9Sstevel@tonic-gate mp = *mpp; 15457c478bd9Sstevel@tonic-gate ASSERT(q != NULL && q->q_ptr != NULL); 15467c478bd9Sstevel@tonic-gate ASSERT(mp != NULL && mp->b_rptr != NULL); 15477c478bd9Sstevel@tonic-gate ASSERT(sps != NULL); 15487c478bd9Sstevel@tonic-gate ASSERT(q->q_ptr == sps); 15497c478bd9Sstevel@tonic-gate /* 15507c478bd9Sstevel@tonic-gate * We only let M_DATA through if the sender is either the control 15517c478bd9Sstevel@tonic-gate * stream (for PPP control packets) or one of the network streams 15527c478bd9Sstevel@tonic-gate * (for IP packets) in IP fastpath mode. If this stream is not attached 15537c478bd9Sstevel@tonic-gate * to any ppas, then discard data coming down through this stream. 15547c478bd9Sstevel@tonic-gate */ 15557c478bd9Sstevel@tonic-gate ppa = sps->sps_ppa; 15567c478bd9Sstevel@tonic-gate if (ppa == NULL) { 15577c478bd9Sstevel@tonic-gate ASSERT(!IS_SPS_CONTROL(sps)); 15587c478bd9Sstevel@tonic-gate error = ENOLINK; 15597c478bd9Sstevel@tonic-gate } else if (!IS_SPS_CONTROL(sps) && !IS_SPS_FASTPATH(sps)) { 15607c478bd9Sstevel@tonic-gate error = EPROTO; 15617c478bd9Sstevel@tonic-gate } 15627c478bd9Sstevel@tonic-gate if (error != 0) { 15637c478bd9Sstevel@tonic-gate merror(q, mp, error); 15647c478bd9Sstevel@tonic-gate return (NULL); 15657c478bd9Sstevel@tonic-gate } 15667c478bd9Sstevel@tonic-gate msize = msgdsize(mp); 15677c478bd9Sstevel@tonic-gate if (msize > (ppa->ppa_mtu + PPP_HDRLEN)) { 15687c478bd9Sstevel@tonic-gate /* Log, and send it anyway */ 15697c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 15707c478bd9Sstevel@tonic-gate ppa->ppa_otoolongs++; 15717c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 15727c478bd9Sstevel@tonic-gate } else if (msize < PPP_HDRLEN) { 15737c478bd9Sstevel@tonic-gate /* 15747c478bd9Sstevel@tonic-gate * Log, and send it anyway. We log it because we get things 15757c478bd9Sstevel@tonic-gate * in M_DATA form here, which tells us that the sender is 15767c478bd9Sstevel@tonic-gate * either IP in fastpath transmission mode, or pppd. In both 15777c478bd9Sstevel@tonic-gate * cases, they are currently expected to send the 4-bytes 15787c478bd9Sstevel@tonic-gate * PPP header in front of any possible payloads. 15797c478bd9Sstevel@tonic-gate */ 15807c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 15817c478bd9Sstevel@tonic-gate ppa->ppa_orunts++; 15827c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 15837c478bd9Sstevel@tonic-gate } 15847c478bd9Sstevel@tonic-gate 15857c478bd9Sstevel@tonic-gate if (IS_SPS_KDEBUG(sps)) { 15867c478bd9Sstevel@tonic-gate SPDEBUG(PPP_DRV_NAME 15877c478bd9Sstevel@tonic-gate "/%d: M_DATA send (%d bytes) sps=0x%p flags=0x%b " 15887c478bd9Sstevel@tonic-gate "ppa=0x%p flags=0x%b\n", sps->sps_mn_id, msize, 15897c478bd9Sstevel@tonic-gate (void *)sps, sps->sps_flags, SPS_FLAGS_STR, 15907c478bd9Sstevel@tonic-gate (void *)ppa, ppa->ppa_flags, PPA_FLAGS_STR); 15917c478bd9Sstevel@tonic-gate } 15927c478bd9Sstevel@tonic-gate /* 15937c478bd9Sstevel@tonic-gate * Should there be any promiscuous stream(s), send the data up 15947c478bd9Sstevel@tonic-gate * for each promiscuous stream that we recognize. Make sure that 15957c478bd9Sstevel@tonic-gate * for fastpath, we skip the PPP header in the M_DATA mblk. We skip 15967c478bd9Sstevel@tonic-gate * the control stream as we obviously never allow the control stream 15977c478bd9Sstevel@tonic-gate * to become promiscous and bind to PPP_ALLSAP. 15987c478bd9Sstevel@tonic-gate */ 15997c478bd9Sstevel@tonic-gate rw_enter(&ppa->ppa_sib_lock, RW_READER); 16007c478bd9Sstevel@tonic-gate is_promisc = sps->sps_ppa->ppa_promicnt; 16017c478bd9Sstevel@tonic-gate if (is_promisc) { 16027c478bd9Sstevel@tonic-gate ASSERT(ppa->ppa_streams != NULL); 16037c478bd9Sstevel@tonic-gate sppp_dlprsendup(ppa->ppa_streams, mp, sps->sps_sap, B_TRUE); 16047c478bd9Sstevel@tonic-gate } 16057c478bd9Sstevel@tonic-gate rw_exit(&ppa->ppa_sib_lock); 16067c478bd9Sstevel@tonic-gate /* 16077c478bd9Sstevel@tonic-gate * Only time-stamp the packet with hrtime if the upper stream 16087c478bd9Sstevel@tonic-gate * is configured to do so. PPP control (negotiation) messages 16097c478bd9Sstevel@tonic-gate * are never considered link activity; only data is activity. 16107c478bd9Sstevel@tonic-gate */ 16117c478bd9Sstevel@tonic-gate if (!IS_SPS_CONTROL(sps) && IS_PPA_TIMESTAMP(ppa)) { 16127c478bd9Sstevel@tonic-gate ppa->ppa_lasttx = gethrtime(); 16137c478bd9Sstevel@tonic-gate } 16147c478bd9Sstevel@tonic-gate /* 16157c478bd9Sstevel@tonic-gate * If there's already a message in the write-side service queue, 16167c478bd9Sstevel@tonic-gate * then queue this message there as well, otherwise, try to send 16177c478bd9Sstevel@tonic-gate * it down to the module immediately below us. 16187c478bd9Sstevel@tonic-gate */ 16197c478bd9Sstevel@tonic-gate if (q->q_first != NULL || 16207c478bd9Sstevel@tonic-gate (nextq = sppp_outpkt(q, mpp, msize, sps)) == NULL) { 16217c478bd9Sstevel@tonic-gate mp = *mpp; 16227c478bd9Sstevel@tonic-gate if (mp != NULL && putq(q, mp) == 0) { 16237c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 16247c478bd9Sstevel@tonic-gate ppa->ppa_oqdropped++; 16257c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 16267c478bd9Sstevel@tonic-gate freemsg(mp); 16277c478bd9Sstevel@tonic-gate } 16287c478bd9Sstevel@tonic-gate return (NULL); 16297c478bd9Sstevel@tonic-gate } 16307c478bd9Sstevel@tonic-gate return (nextq); 16317c478bd9Sstevel@tonic-gate } 16327c478bd9Sstevel@tonic-gate 16337c478bd9Sstevel@tonic-gate /* 16347c478bd9Sstevel@tonic-gate * sppp_outpkt() 16357c478bd9Sstevel@tonic-gate * 16367c478bd9Sstevel@tonic-gate * MT-Perimeters: 16377c478bd9Sstevel@tonic-gate * shared inner, shared outer (if called from sppp_wput, sppp_dlunitdatareq). 16387c478bd9Sstevel@tonic-gate * exclusive inner, shared outer (if called from sppp_wsrv). 16397c478bd9Sstevel@tonic-gate * 16407c478bd9Sstevel@tonic-gate * Description: 16417c478bd9Sstevel@tonic-gate * Called from 1) sppp_uwput when processing a M_DATA fastpath message, 16427c478bd9Sstevel@tonic-gate * or 2) sppp_uwsrv when processing the upper write-side service queue. 16437c478bd9Sstevel@tonic-gate * For both cases, it prepares to send the data to the module below 16447c478bd9Sstevel@tonic-gate * this driver if there is a lower stream linked underneath. If none, then 16457c478bd9Sstevel@tonic-gate * the data will be sent upstream via the control channel to pppd. 16467c478bd9Sstevel@tonic-gate * 16477c478bd9Sstevel@tonic-gate * Returns: 16487c478bd9Sstevel@tonic-gate * Non-NULL queue_t if message should be sent now, otherwise 16497c478bd9Sstevel@tonic-gate * if *mpp == NULL, then message was freed, otherwise put *mpp 16507c478bd9Sstevel@tonic-gate * (back) on the queue. (Does not do putq/putbq, since it's 16517c478bd9Sstevel@tonic-gate * called both from srv and put procedures.) 16527c478bd9Sstevel@tonic-gate */ 16537c478bd9Sstevel@tonic-gate static queue_t * 16547c478bd9Sstevel@tonic-gate sppp_outpkt(queue_t *q, mblk_t **mpp, int msize, spppstr_t *sps) 16557c478bd9Sstevel@tonic-gate { 16567c478bd9Sstevel@tonic-gate mblk_t *mp; 16577c478bd9Sstevel@tonic-gate sppa_t *ppa; 16587c478bd9Sstevel@tonic-gate enum NPmode npmode; 16597c478bd9Sstevel@tonic-gate mblk_t *mpnew; 16607c478bd9Sstevel@tonic-gate 16617c478bd9Sstevel@tonic-gate ASSERT(mpp != NULL); 16627c478bd9Sstevel@tonic-gate mp = *mpp; 16637c478bd9Sstevel@tonic-gate ASSERT(q != NULL && q->q_ptr != NULL); 16647c478bd9Sstevel@tonic-gate ASSERT(mp != NULL && mp->b_rptr != NULL); 16657c478bd9Sstevel@tonic-gate ASSERT(sps != NULL); 16667c478bd9Sstevel@tonic-gate 16677c478bd9Sstevel@tonic-gate ppa = sps->sps_ppa; 16687c478bd9Sstevel@tonic-gate npmode = sps->sps_npmode; 16697c478bd9Sstevel@tonic-gate 16707c478bd9Sstevel@tonic-gate if (npmode == NPMODE_QUEUE) { 16717c478bd9Sstevel@tonic-gate ASSERT(!IS_SPS_CONTROL(sps)); 16727c478bd9Sstevel@tonic-gate return (NULL); /* queue it for later */ 16737c478bd9Sstevel@tonic-gate } else if (ppa == NULL || ppa->ppa_ctl == NULL || 16747c478bd9Sstevel@tonic-gate npmode == NPMODE_DROP || npmode == NPMODE_ERROR) { 16757c478bd9Sstevel@tonic-gate /* 16767c478bd9Sstevel@tonic-gate * This can not be the control stream, as it must always have 16777c478bd9Sstevel@tonic-gate * a valid ppa, and its npmode must always be NPMODE_PASS. 16787c478bd9Sstevel@tonic-gate */ 16797c478bd9Sstevel@tonic-gate ASSERT(!IS_SPS_CONTROL(sps)); 16807c478bd9Sstevel@tonic-gate if (npmode == NPMODE_DROP) { 16817c478bd9Sstevel@tonic-gate freemsg(mp); 16827c478bd9Sstevel@tonic-gate } else { 16837c478bd9Sstevel@tonic-gate /* 16847c478bd9Sstevel@tonic-gate * If we no longer have the control stream, or if the 16857c478bd9Sstevel@tonic-gate * mode is set to NPMODE_ERROR, then we need to tell IP 16867c478bd9Sstevel@tonic-gate * that the interface need to be marked as down. In 16877c478bd9Sstevel@tonic-gate * other words, we tell IP to be quiescent. 16887c478bd9Sstevel@tonic-gate */ 16897c478bd9Sstevel@tonic-gate merror(q, mp, EPROTO); 16907c478bd9Sstevel@tonic-gate } 16917c478bd9Sstevel@tonic-gate *mpp = NULL; 16927c478bd9Sstevel@tonic-gate return (NULL); /* don't queue it */ 16937c478bd9Sstevel@tonic-gate } 16947c478bd9Sstevel@tonic-gate /* 16957c478bd9Sstevel@tonic-gate * Do we have a driver stream linked underneath ? If not, we need to 16967c478bd9Sstevel@tonic-gate * notify pppd that the link needs to be brought up and configure 16977c478bd9Sstevel@tonic-gate * this upper stream to drop subsequent outgoing packets. This is 16987c478bd9Sstevel@tonic-gate * for demand-dialing, in which case pppd has done the IP plumbing 16997c478bd9Sstevel@tonic-gate * but hasn't linked the driver stream underneath us. Therefore, when 17007c478bd9Sstevel@tonic-gate * a packet is sent down the IP interface, a notification message 17017c478bd9Sstevel@tonic-gate * will be sent up the control stream to pppd in order for it to 17027c478bd9Sstevel@tonic-gate * establish the physical link. The driver stream is then expected 17037c478bd9Sstevel@tonic-gate * to be linked underneath after physical link establishment is done. 17047c478bd9Sstevel@tonic-gate */ 17057c478bd9Sstevel@tonic-gate if (ppa->ppa_lower_wq == NULL) { 17067c478bd9Sstevel@tonic-gate ASSERT(ppa->ppa_ctl != NULL); 17077c478bd9Sstevel@tonic-gate ASSERT(ppa->ppa_ctl->sps_rq != NULL); 17087c478bd9Sstevel@tonic-gate 17097c478bd9Sstevel@tonic-gate *mpp = NULL; 17107c478bd9Sstevel@tonic-gate mpnew = create_lsmsg(PPP_LINKSTAT_NEEDUP); 17117c478bd9Sstevel@tonic-gate if (mpnew == NULL) { 17127c478bd9Sstevel@tonic-gate freemsg(mp); 17137c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 17147c478bd9Sstevel@tonic-gate ppa->ppa_allocbfail++; 17157c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 17167c478bd9Sstevel@tonic-gate return (NULL); /* don't queue it */ 17177c478bd9Sstevel@tonic-gate } 17187c478bd9Sstevel@tonic-gate /* Include the data in the message for logging. */ 17197c478bd9Sstevel@tonic-gate mpnew->b_cont = mp; 17207c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 17217c478bd9Sstevel@tonic-gate ppa->ppa_lsneedup++; 17227c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 17237c478bd9Sstevel@tonic-gate /* 17247c478bd9Sstevel@tonic-gate * We need to set the mode to NPMODE_DROP, but should only 17257c478bd9Sstevel@tonic-gate * do so when this stream is not the control stream. 17267c478bd9Sstevel@tonic-gate */ 17277c478bd9Sstevel@tonic-gate if (!IS_SPS_CONTROL(sps)) { 17287c478bd9Sstevel@tonic-gate sps->sps_npmode = NPMODE_DROP; 17297c478bd9Sstevel@tonic-gate } 17307c478bd9Sstevel@tonic-gate putnext(ppa->ppa_ctl->sps_rq, mpnew); 17317c478bd9Sstevel@tonic-gate return (NULL); /* don't queue it */ 17327c478bd9Sstevel@tonic-gate } 17337c478bd9Sstevel@tonic-gate /* 17347c478bd9Sstevel@tonic-gate * If so, then try to send it down. The lower queue is only ever 17357c478bd9Sstevel@tonic-gate * detached while holding an exclusive lock on the whole driver, 17367c478bd9Sstevel@tonic-gate * so we can be confident that the lower queue is still there. 17377c478bd9Sstevel@tonic-gate */ 17387c478bd9Sstevel@tonic-gate if (bcanputnext(ppa->ppa_lower_wq, mp->b_band)) { 17397c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 17407c478bd9Sstevel@tonic-gate ppa->ppa_stats.p.ppp_opackets++; 17417c478bd9Sstevel@tonic-gate if (IS_SPS_CONTROL(sps)) { 17427c478bd9Sstevel@tonic-gate ppa->ppa_opkt_ctl++; 17437c478bd9Sstevel@tonic-gate } 17447c478bd9Sstevel@tonic-gate ppa->ppa_stats.p.ppp_obytes += msize; 17457c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 17467c478bd9Sstevel@tonic-gate return (ppa->ppa_lower_wq); /* don't queue it */ 17477c478bd9Sstevel@tonic-gate } 17487c478bd9Sstevel@tonic-gate return (NULL); /* queue it for later */ 17497c478bd9Sstevel@tonic-gate } 17507c478bd9Sstevel@tonic-gate 17517c478bd9Sstevel@tonic-gate /* 17527c478bd9Sstevel@tonic-gate * sppp_lwsrv() 17537c478bd9Sstevel@tonic-gate * 17547c478bd9Sstevel@tonic-gate * MT-Perimeters: 17557c478bd9Sstevel@tonic-gate * exclusive inner, shared outer. 17567c478bd9Sstevel@tonic-gate * 17577c478bd9Sstevel@tonic-gate * Description: 17587c478bd9Sstevel@tonic-gate * Lower write-side service procedure. No messages are ever placed on 17597c478bd9Sstevel@tonic-gate * the write queue here, this just back-enables all upper write side 17607c478bd9Sstevel@tonic-gate * service procedures. 17617c478bd9Sstevel@tonic-gate */ 1762002c70ffScarlsonj void 17637c478bd9Sstevel@tonic-gate sppp_lwsrv(queue_t *q) 17647c478bd9Sstevel@tonic-gate { 17657c478bd9Sstevel@tonic-gate sppa_t *ppa; 17667c478bd9Sstevel@tonic-gate spppstr_t *nextsib; 17677c478bd9Sstevel@tonic-gate 17687c478bd9Sstevel@tonic-gate ASSERT(q != NULL && q->q_ptr != NULL); 17697c478bd9Sstevel@tonic-gate ppa = (sppa_t *)q->q_ptr; 17707c478bd9Sstevel@tonic-gate ASSERT(ppa != NULL); 17717c478bd9Sstevel@tonic-gate 17727c478bd9Sstevel@tonic-gate rw_enter(&ppa->ppa_sib_lock, RW_READER); 17737c478bd9Sstevel@tonic-gate if ((nextsib = ppa->ppa_ctl) != NULL && 17747c478bd9Sstevel@tonic-gate WR(nextsib->sps_rq)->q_first != NULL) 17757c478bd9Sstevel@tonic-gate qenable(WR(nextsib->sps_rq)); 17767c478bd9Sstevel@tonic-gate for (nextsib = ppa->ppa_streams; nextsib != NULL; 17777c478bd9Sstevel@tonic-gate nextsib = nextsib->sps_nextsib) { 17787c478bd9Sstevel@tonic-gate if (WR(nextsib->sps_rq)->q_first != NULL) { 17797c478bd9Sstevel@tonic-gate qenable(WR(nextsib->sps_rq)); 17807c478bd9Sstevel@tonic-gate } 17817c478bd9Sstevel@tonic-gate } 17827c478bd9Sstevel@tonic-gate rw_exit(&ppa->ppa_sib_lock); 17837c478bd9Sstevel@tonic-gate } 17847c478bd9Sstevel@tonic-gate 17857c478bd9Sstevel@tonic-gate /* 17867c478bd9Sstevel@tonic-gate * sppp_lrput() 17877c478bd9Sstevel@tonic-gate * 17887c478bd9Sstevel@tonic-gate * MT-Perimeters: 17897c478bd9Sstevel@tonic-gate * shared inner, shared outer. 17907c478bd9Sstevel@tonic-gate * 17917c478bd9Sstevel@tonic-gate * Description: 17927c478bd9Sstevel@tonic-gate * Lower read-side put procedure. Messages from below get here. 17937c478bd9Sstevel@tonic-gate * Data messages are handled separately to limit stack usage 17947c478bd9Sstevel@tonic-gate * going into IP. 1795002c70ffScarlsonj * 1796002c70ffScarlsonj * Note that during I_UNLINK processing, it's possible for a downstream 1797002c70ffScarlsonj * message to enable upstream data (due to pass_wput() removing the 1798002c70ffScarlsonj * SQ_BLOCKED flag), and thus we must protect against a NULL sppa pointer. 1799002c70ffScarlsonj * In this case, the only thing above us is passthru, and we might as well 1800002c70ffScarlsonj * discard. 18017c478bd9Sstevel@tonic-gate */ 1802002c70ffScarlsonj void 18037c478bd9Sstevel@tonic-gate sppp_lrput(queue_t *q, mblk_t *mp) 18047c478bd9Sstevel@tonic-gate { 18057c478bd9Sstevel@tonic-gate sppa_t *ppa; 18067c478bd9Sstevel@tonic-gate spppstr_t *sps; 18077c478bd9Sstevel@tonic-gate 1808002c70ffScarlsonj if ((ppa = q->q_ptr) == NULL) { 1809002c70ffScarlsonj freemsg(mp); 1810002c70ffScarlsonj return; 1811002c70ffScarlsonj } 1812002c70ffScarlsonj 18137c478bd9Sstevel@tonic-gate sps = ppa->ppa_ctl; 18147c478bd9Sstevel@tonic-gate 18157c478bd9Sstevel@tonic-gate if (MTYPE(mp) != M_DATA) { 18167c478bd9Sstevel@tonic-gate sppp_recv_nondata(q, mp, sps); 18177c478bd9Sstevel@tonic-gate } else if (sps == NULL) { 18187c478bd9Sstevel@tonic-gate freemsg(mp); 18197c478bd9Sstevel@tonic-gate } else if ((q = sppp_recv(q, &mp, sps)) != NULL) { 18207c478bd9Sstevel@tonic-gate putnext(q, mp); 18217c478bd9Sstevel@tonic-gate } 18227c478bd9Sstevel@tonic-gate } 18237c478bd9Sstevel@tonic-gate 1824f53eecf5SJames Carlson /* 1825f53eecf5SJames Carlson * sppp_lrsrv() 1826f53eecf5SJames Carlson * 1827f53eecf5SJames Carlson * MT-Perimeters: 1828f53eecf5SJames Carlson * exclusive inner, shared outer. 1829f53eecf5SJames Carlson * 1830f53eecf5SJames Carlson * Description: 1831f53eecf5SJames Carlson * Lower read-side service procedure. This is run once after the I_LINK 1832f53eecf5SJames Carlson * occurs in order to clean up any packets that came in while we were 1833f53eecf5SJames Carlson * transferring in the lower stream. Otherwise, it's not used. 1834f53eecf5SJames Carlson */ 1835f53eecf5SJames Carlson void 1836f53eecf5SJames Carlson sppp_lrsrv(queue_t *q) 1837f53eecf5SJames Carlson { 1838f53eecf5SJames Carlson mblk_t *mp; 1839f53eecf5SJames Carlson 1840f53eecf5SJames Carlson while ((mp = getq(q)) != NULL) 1841f53eecf5SJames Carlson sppp_lrput(q, mp); 1842f53eecf5SJames Carlson } 1843f53eecf5SJames Carlson 18447c478bd9Sstevel@tonic-gate /* 18457c478bd9Sstevel@tonic-gate * sppp_recv_nondata() 18467c478bd9Sstevel@tonic-gate * 18477c478bd9Sstevel@tonic-gate * MT-Perimeters: 18487c478bd9Sstevel@tonic-gate * shared inner, shared outer. 18497c478bd9Sstevel@tonic-gate * 18507c478bd9Sstevel@tonic-gate * Description: 18517c478bd9Sstevel@tonic-gate * All received non-data messages come through here. 18527c478bd9Sstevel@tonic-gate */ 18537c478bd9Sstevel@tonic-gate static void 18547c478bd9Sstevel@tonic-gate sppp_recv_nondata(queue_t *q, mblk_t *mp, spppstr_t *ctlsps) 18557c478bd9Sstevel@tonic-gate { 18567c478bd9Sstevel@tonic-gate sppa_t *ppa; 18577c478bd9Sstevel@tonic-gate spppstr_t *destsps; 18587c478bd9Sstevel@tonic-gate struct iocblk *iop; 18597c478bd9Sstevel@tonic-gate 18607c478bd9Sstevel@tonic-gate ppa = (sppa_t *)q->q_ptr; 18617c478bd9Sstevel@tonic-gate ctlsps = ppa->ppa_ctl; 18627c478bd9Sstevel@tonic-gate 18637c478bd9Sstevel@tonic-gate switch (MTYPE(mp)) { 18647c478bd9Sstevel@tonic-gate case M_CTL: 18657c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 18667c478bd9Sstevel@tonic-gate if (*mp->b_rptr == PPPCTL_IERROR) { 18677c478bd9Sstevel@tonic-gate ppa->ppa_stats.p.ppp_ierrors++; 18687c478bd9Sstevel@tonic-gate ppa->ppa_ierr_low++; 18697c478bd9Sstevel@tonic-gate ppa->ppa_mctlsknown++; 18707c478bd9Sstevel@tonic-gate } else if (*mp->b_rptr == PPPCTL_OERROR) { 18717c478bd9Sstevel@tonic-gate ppa->ppa_stats.p.ppp_oerrors++; 18727c478bd9Sstevel@tonic-gate ppa->ppa_oerr_low++; 18737c478bd9Sstevel@tonic-gate ppa->ppa_mctlsknown++; 18747c478bd9Sstevel@tonic-gate } else { 18757c478bd9Sstevel@tonic-gate ppa->ppa_mctlsunknown++; 18767c478bd9Sstevel@tonic-gate } 18777c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 18787c478bd9Sstevel@tonic-gate freemsg(mp); 18797c478bd9Sstevel@tonic-gate break; 18807c478bd9Sstevel@tonic-gate case M_IOCTL: 18817c478bd9Sstevel@tonic-gate miocnak(q, mp, 0, EINVAL); 18827c478bd9Sstevel@tonic-gate break; 18837c478bd9Sstevel@tonic-gate case M_IOCACK: 18847c478bd9Sstevel@tonic-gate case M_IOCNAK: 18857c478bd9Sstevel@tonic-gate iop = (struct iocblk *)mp->b_rptr; 18867c478bd9Sstevel@tonic-gate ASSERT(iop != NULL); 18877c478bd9Sstevel@tonic-gate /* 18887c478bd9Sstevel@tonic-gate * Attempt to match up the response with the stream that the 18897c478bd9Sstevel@tonic-gate * request came from. If ioc_id doesn't match the one that we 18907c478bd9Sstevel@tonic-gate * recorded, then discard this message. 18917c478bd9Sstevel@tonic-gate */ 18927c478bd9Sstevel@tonic-gate rw_enter(&ppa->ppa_sib_lock, RW_READER); 18937c478bd9Sstevel@tonic-gate if ((destsps = ctlsps) == NULL || 18947c478bd9Sstevel@tonic-gate destsps->sps_ioc_id != iop->ioc_id) { 18957c478bd9Sstevel@tonic-gate destsps = ppa->ppa_streams; 18967c478bd9Sstevel@tonic-gate while (destsps != NULL) { 18977c478bd9Sstevel@tonic-gate if (destsps->sps_ioc_id == iop->ioc_id) { 18987c478bd9Sstevel@tonic-gate break; /* found the upper stream */ 18997c478bd9Sstevel@tonic-gate } 19007c478bd9Sstevel@tonic-gate destsps = destsps->sps_nextsib; 19017c478bd9Sstevel@tonic-gate } 19027c478bd9Sstevel@tonic-gate } 19037c478bd9Sstevel@tonic-gate rw_exit(&ppa->ppa_sib_lock); 19047c478bd9Sstevel@tonic-gate if (destsps == NULL) { 19057c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 19067c478bd9Sstevel@tonic-gate ppa->ppa_ioctlsfwderr++; 19077c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 19087c478bd9Sstevel@tonic-gate freemsg(mp); 19097c478bd9Sstevel@tonic-gate break; 19107c478bd9Sstevel@tonic-gate } 19117c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 19127c478bd9Sstevel@tonic-gate ppa->ppa_ioctlsfwdok++; 19139f7c4232SAnil udupa 19149f7c4232SAnil udupa /* 19159f7c4232SAnil udupa * Clear SPS_IOCQ and enable the lower write side queue, 19169f7c4232SAnil udupa * this would allow the upper stream service routine 19179f7c4232SAnil udupa * to start processing the queue for pending messages. 19189f7c4232SAnil udupa * sppp_lwsrv -> sppp_uwsrv. 19199f7c4232SAnil udupa */ 19209f7c4232SAnil udupa destsps->sps_flags &= ~SPS_IOCQ; 19217c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 19229f7c4232SAnil udupa qenable(WR(destsps->sps_rq)); 19239f7c4232SAnil udupa 19247c478bd9Sstevel@tonic-gate putnext(destsps->sps_rq, mp); 19257c478bd9Sstevel@tonic-gate break; 19267c478bd9Sstevel@tonic-gate case M_HANGUP: 19277c478bd9Sstevel@tonic-gate /* 19287c478bd9Sstevel@tonic-gate * Free the original mblk_t. We don't really want to send 19297c478bd9Sstevel@tonic-gate * a M_HANGUP message upstream, so we need to translate this 19307c478bd9Sstevel@tonic-gate * message into something else. 19317c478bd9Sstevel@tonic-gate */ 19327c478bd9Sstevel@tonic-gate freemsg(mp); 19337c478bd9Sstevel@tonic-gate if (ctlsps == NULL) 19347c478bd9Sstevel@tonic-gate break; 19357c478bd9Sstevel@tonic-gate mp = create_lsmsg(PPP_LINKSTAT_HANGUP); 19367c478bd9Sstevel@tonic-gate if (mp == NULL) { 19377c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 19387c478bd9Sstevel@tonic-gate ppa->ppa_allocbfail++; 19397c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 19407c478bd9Sstevel@tonic-gate break; 19417c478bd9Sstevel@tonic-gate } 19427c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 19437c478bd9Sstevel@tonic-gate ppa->ppa_lsdown++; 19447c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 19457c478bd9Sstevel@tonic-gate putnext(ctlsps->sps_rq, mp); 19467c478bd9Sstevel@tonic-gate break; 19477c478bd9Sstevel@tonic-gate case M_FLUSH: 19487c478bd9Sstevel@tonic-gate if (*mp->b_rptr & FLUSHR) { 19497c478bd9Sstevel@tonic-gate flushq(q, FLUSHDATA); 19507c478bd9Sstevel@tonic-gate } 19517c478bd9Sstevel@tonic-gate if (*mp->b_rptr & FLUSHW) { 19527c478bd9Sstevel@tonic-gate *mp->b_rptr &= ~FLUSHR; 19537c478bd9Sstevel@tonic-gate qreply(q, mp); 19547c478bd9Sstevel@tonic-gate } else { 19557c478bd9Sstevel@tonic-gate freemsg(mp); 19567c478bd9Sstevel@tonic-gate } 19577c478bd9Sstevel@tonic-gate break; 19587c478bd9Sstevel@tonic-gate default: 19597c478bd9Sstevel@tonic-gate if (ctlsps != NULL && 19607c478bd9Sstevel@tonic-gate (queclass(mp) == QPCTL) || canputnext(ctlsps->sps_rq)) { 19617c478bd9Sstevel@tonic-gate putnext(ctlsps->sps_rq, mp); 19627c478bd9Sstevel@tonic-gate } else { 19637c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 19647c478bd9Sstevel@tonic-gate ppa->ppa_iqdropped++; 19657c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 19667c478bd9Sstevel@tonic-gate freemsg(mp); 19677c478bd9Sstevel@tonic-gate } 19687c478bd9Sstevel@tonic-gate break; 19697c478bd9Sstevel@tonic-gate } 19707c478bd9Sstevel@tonic-gate } 19717c478bd9Sstevel@tonic-gate 19727c478bd9Sstevel@tonic-gate /* 19737c478bd9Sstevel@tonic-gate * sppp_recv() 19747c478bd9Sstevel@tonic-gate * 19757c478bd9Sstevel@tonic-gate * MT-Perimeters: 19767c478bd9Sstevel@tonic-gate * shared inner, shared outer. 19777c478bd9Sstevel@tonic-gate * 19787c478bd9Sstevel@tonic-gate * Description: 19797c478bd9Sstevel@tonic-gate * Receive function called by sppp_lrput. Finds appropriate 19807c478bd9Sstevel@tonic-gate * receive stream and does accounting. 19817c478bd9Sstevel@tonic-gate */ 19827c478bd9Sstevel@tonic-gate static queue_t * 19837c478bd9Sstevel@tonic-gate sppp_recv(queue_t *q, mblk_t **mpp, spppstr_t *ctlsps) 19847c478bd9Sstevel@tonic-gate { 19857c478bd9Sstevel@tonic-gate mblk_t *mp; 19867c478bd9Sstevel@tonic-gate int len; 19877c478bd9Sstevel@tonic-gate sppa_t *ppa; 19887c478bd9Sstevel@tonic-gate spppstr_t *destsps; 19897c478bd9Sstevel@tonic-gate mblk_t *zmp; 19907c478bd9Sstevel@tonic-gate uint32_t npflagpos; 19917c478bd9Sstevel@tonic-gate 19927c478bd9Sstevel@tonic-gate ASSERT(mpp != NULL); 19937c478bd9Sstevel@tonic-gate mp = *mpp; 19947c478bd9Sstevel@tonic-gate ASSERT(q != NULL && q->q_ptr != NULL); 19957c478bd9Sstevel@tonic-gate ASSERT(mp != NULL && mp->b_rptr != NULL); 19967c478bd9Sstevel@tonic-gate ASSERT(ctlsps != NULL); 19977c478bd9Sstevel@tonic-gate ASSERT(IS_SPS_CONTROL(ctlsps)); 19987c478bd9Sstevel@tonic-gate ppa = ctlsps->sps_ppa; 19997c478bd9Sstevel@tonic-gate ASSERT(ppa != NULL && ppa->ppa_ctl != NULL); 20007c478bd9Sstevel@tonic-gate 20017c478bd9Sstevel@tonic-gate len = msgdsize(mp); 20027c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 20037c478bd9Sstevel@tonic-gate ppa->ppa_stats.p.ppp_ibytes += len; 20047c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 20057c478bd9Sstevel@tonic-gate /* 20067c478bd9Sstevel@tonic-gate * If the entire data size of the mblk is less than the length of the 20077c478bd9Sstevel@tonic-gate * PPP header, then free it. We can't do much with such message anyway, 20087c478bd9Sstevel@tonic-gate * since we can't really determine what the PPP protocol type is. 20097c478bd9Sstevel@tonic-gate */ 20107c478bd9Sstevel@tonic-gate if (len < PPP_HDRLEN) { 20117c478bd9Sstevel@tonic-gate /* Log, and free it */ 20127c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 20137c478bd9Sstevel@tonic-gate ppa->ppa_irunts++; 20147c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 20157c478bd9Sstevel@tonic-gate freemsg(mp); 20167c478bd9Sstevel@tonic-gate return (NULL); 20177c478bd9Sstevel@tonic-gate } else if (len > (ppa->ppa_mru + PPP_HDRLEN)) { 20187c478bd9Sstevel@tonic-gate /* Log, and accept it anyway */ 20197c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 20207c478bd9Sstevel@tonic-gate ppa->ppa_itoolongs++; 20217c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 20227c478bd9Sstevel@tonic-gate } 20237c478bd9Sstevel@tonic-gate /* 20247c478bd9Sstevel@tonic-gate * We need at least be able to read the PPP protocol from the header, 20257c478bd9Sstevel@tonic-gate * so if the first message block is too small, then we concatenate the 20267c478bd9Sstevel@tonic-gate * rest of the following blocks into one message. 20277c478bd9Sstevel@tonic-gate */ 20287c478bd9Sstevel@tonic-gate if (MBLKL(mp) < PPP_HDRLEN) { 20297c478bd9Sstevel@tonic-gate zmp = msgpullup(mp, PPP_HDRLEN); 20307c478bd9Sstevel@tonic-gate freemsg(mp); 20317c478bd9Sstevel@tonic-gate mp = zmp; 20327c478bd9Sstevel@tonic-gate if (mp == NULL) { 20337c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 20347c478bd9Sstevel@tonic-gate ppa->ppa_allocbfail++; 20357c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 20367c478bd9Sstevel@tonic-gate return (NULL); 20377c478bd9Sstevel@tonic-gate } 20387c478bd9Sstevel@tonic-gate *mpp = mp; 20397c478bd9Sstevel@tonic-gate } 20407c478bd9Sstevel@tonic-gate /* 20417c478bd9Sstevel@tonic-gate * Hold this packet in the control-queue until 20427c478bd9Sstevel@tonic-gate * the matching network-layer upper stream for the PPP protocol (sap) 20437c478bd9Sstevel@tonic-gate * has not been plumbed and configured 20447c478bd9Sstevel@tonic-gate */ 20457c478bd9Sstevel@tonic-gate npflagpos = sppp_ppp2np(PPP_PROTOCOL(mp->b_rptr)); 20467c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_npmutex); 20477c478bd9Sstevel@tonic-gate if (npflagpos != 0 && (ppa->ppa_npflag & (1 << npflagpos))) { 20487c478bd9Sstevel@tonic-gate /* 20497c478bd9Sstevel@tonic-gate * proto is currently blocked; Hold up to 4 packets 20507c478bd9Sstevel@tonic-gate * in the kernel. 20517c478bd9Sstevel@tonic-gate */ 20527c478bd9Sstevel@tonic-gate if (ppa->ppa_holdpkts[npflagpos] > 3 || 20537c478bd9Sstevel@tonic-gate putq(ctlsps->sps_rq, mp) == 0) 20547c478bd9Sstevel@tonic-gate freemsg(mp); 20557c478bd9Sstevel@tonic-gate else 20567c478bd9Sstevel@tonic-gate ppa->ppa_holdpkts[npflagpos]++; 20577c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_npmutex); 20587c478bd9Sstevel@tonic-gate return (NULL); 20597c478bd9Sstevel@tonic-gate } 20607c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_npmutex); 20617c478bd9Sstevel@tonic-gate /* 20627c478bd9Sstevel@tonic-gate * Try to find a matching network-layer upper stream for the specified 20637c478bd9Sstevel@tonic-gate * PPP protocol (sap), and if none is found, send this frame up the 20647c478bd9Sstevel@tonic-gate * control stream. 20657c478bd9Sstevel@tonic-gate */ 20667c478bd9Sstevel@tonic-gate destsps = sppp_inpkt(q, mp, ctlsps); 20677c478bd9Sstevel@tonic-gate if (destsps == NULL) { 20687c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 20697c478bd9Sstevel@tonic-gate ppa->ppa_ipkt_ctl++; 20707c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 20717c478bd9Sstevel@tonic-gate if (canputnext(ctlsps->sps_rq)) { 20727c478bd9Sstevel@tonic-gate if (IS_SPS_KDEBUG(ctlsps)) { 20737c478bd9Sstevel@tonic-gate SPDEBUG(PPP_DRV_NAME 20747c478bd9Sstevel@tonic-gate "/%d: M_DATA recv (%d bytes) sps=0x%p " 20757c478bd9Sstevel@tonic-gate "flags=0x%b ppa=0x%p flags=0x%b\n", 20767c478bd9Sstevel@tonic-gate ctlsps->sps_mn_id, len, (void *)ctlsps, 20777c478bd9Sstevel@tonic-gate ctlsps->sps_flags, SPS_FLAGS_STR, 20787c478bd9Sstevel@tonic-gate (void *)ppa, ppa->ppa_flags, 20797c478bd9Sstevel@tonic-gate PPA_FLAGS_STR); 20807c478bd9Sstevel@tonic-gate } 20817c478bd9Sstevel@tonic-gate return (ctlsps->sps_rq); 20827c478bd9Sstevel@tonic-gate } else { 20837c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 20847c478bd9Sstevel@tonic-gate ppa->ppa_iqdropped++; 20857c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 20867c478bd9Sstevel@tonic-gate freemsg(mp); 20877c478bd9Sstevel@tonic-gate return (NULL); 20887c478bd9Sstevel@tonic-gate } 20897c478bd9Sstevel@tonic-gate } 20907c478bd9Sstevel@tonic-gate if (canputnext(destsps->sps_rq)) { 20917c478bd9Sstevel@tonic-gate if (IS_SPS_KDEBUG(destsps)) { 20927c478bd9Sstevel@tonic-gate SPDEBUG(PPP_DRV_NAME 20937c478bd9Sstevel@tonic-gate "/%d: M_DATA recv (%d bytes) sps=0x%p flags=0x%b " 20947c478bd9Sstevel@tonic-gate "ppa=0x%p flags=0x%b\n", destsps->sps_mn_id, len, 20957c478bd9Sstevel@tonic-gate (void *)destsps, destsps->sps_flags, 20967c478bd9Sstevel@tonic-gate SPS_FLAGS_STR, (void *)ppa, ppa->ppa_flags, 20977c478bd9Sstevel@tonic-gate PPA_FLAGS_STR); 20987c478bd9Sstevel@tonic-gate } 20997c478bd9Sstevel@tonic-gate /* 21007c478bd9Sstevel@tonic-gate * If fastpath is enabled on the network-layer stream, then 21017c478bd9Sstevel@tonic-gate * make sure we skip over the PPP header, otherwise, we wrap 21027c478bd9Sstevel@tonic-gate * the message in a DLPI message. 21037c478bd9Sstevel@tonic-gate */ 21047c478bd9Sstevel@tonic-gate if (IS_SPS_FASTPATH(destsps)) { 21057c478bd9Sstevel@tonic-gate mp->b_rptr += PPP_HDRLEN; 21067c478bd9Sstevel@tonic-gate return (destsps->sps_rq); 21077c478bd9Sstevel@tonic-gate } else { 21087c478bd9Sstevel@tonic-gate spppstr_t *uqs = (spppstr_t *)destsps->sps_rq->q_ptr; 21097c478bd9Sstevel@tonic-gate ASSERT(uqs != NULL); 21107c478bd9Sstevel@tonic-gate mp->b_rptr += PPP_HDRLEN; 21117c478bd9Sstevel@tonic-gate mp = sppp_dladdud(uqs, mp, uqs->sps_sap, B_FALSE); 21127c478bd9Sstevel@tonic-gate if (mp != NULL) { 21137c478bd9Sstevel@tonic-gate *mpp = mp; 21147c478bd9Sstevel@tonic-gate return (destsps->sps_rq); 21157c478bd9Sstevel@tonic-gate } else { 21167c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 21177c478bd9Sstevel@tonic-gate ppa->ppa_allocbfail++; 21187c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 21197c478bd9Sstevel@tonic-gate /* mp already freed by sppp_dladdud */ 21207c478bd9Sstevel@tonic-gate return (NULL); 21217c478bd9Sstevel@tonic-gate } 21227c478bd9Sstevel@tonic-gate } 21237c478bd9Sstevel@tonic-gate } else { 21247c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 21257c478bd9Sstevel@tonic-gate ppa->ppa_iqdropped++; 21267c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 21277c478bd9Sstevel@tonic-gate freemsg(mp); 21287c478bd9Sstevel@tonic-gate return (NULL); 21297c478bd9Sstevel@tonic-gate } 21307c478bd9Sstevel@tonic-gate } 21317c478bd9Sstevel@tonic-gate 21327c478bd9Sstevel@tonic-gate /* 21337c478bd9Sstevel@tonic-gate * sppp_inpkt() 21347c478bd9Sstevel@tonic-gate * 21357c478bd9Sstevel@tonic-gate * MT-Perimeters: 21367c478bd9Sstevel@tonic-gate * shared inner, shared outer. 21377c478bd9Sstevel@tonic-gate * 21387c478bd9Sstevel@tonic-gate * Description: 21397c478bd9Sstevel@tonic-gate * Find the destination upper stream for the received packet, called 21407c478bd9Sstevel@tonic-gate * from sppp_recv. 21417c478bd9Sstevel@tonic-gate * 21427c478bd9Sstevel@tonic-gate * Returns: 21437c478bd9Sstevel@tonic-gate * ptr to destination upper network stream, or NULL for control stream. 21447c478bd9Sstevel@tonic-gate */ 21457c478bd9Sstevel@tonic-gate /* ARGSUSED */ 21467c478bd9Sstevel@tonic-gate static spppstr_t * 21477c478bd9Sstevel@tonic-gate sppp_inpkt(queue_t *q, mblk_t *mp, spppstr_t *ctlsps) 21487c478bd9Sstevel@tonic-gate { 21497c478bd9Sstevel@tonic-gate spppstr_t *destsps = NULL; 21507c478bd9Sstevel@tonic-gate sppa_t *ppa; 21517c478bd9Sstevel@tonic-gate uint16_t proto; 21527c478bd9Sstevel@tonic-gate int is_promisc; 21537c478bd9Sstevel@tonic-gate 21547c478bd9Sstevel@tonic-gate ASSERT(q != NULL && q->q_ptr != NULL); 21557c478bd9Sstevel@tonic-gate ASSERT(mp != NULL && mp->b_rptr != NULL); 21567c478bd9Sstevel@tonic-gate ASSERT(IS_SPS_CONTROL(ctlsps)); 21577c478bd9Sstevel@tonic-gate ppa = ctlsps->sps_ppa; 21587c478bd9Sstevel@tonic-gate ASSERT(ppa != NULL); 21597c478bd9Sstevel@tonic-gate /* 21607c478bd9Sstevel@tonic-gate * From RFC 1661 (Section 2): 21617c478bd9Sstevel@tonic-gate * 21627c478bd9Sstevel@tonic-gate * The Protocol field is one or two octets, and its value identifies 21637c478bd9Sstevel@tonic-gate * the datagram encapsulated in the Information field of the packet. 21647c478bd9Sstevel@tonic-gate * The field is transmitted and received most significant octet first. 21657c478bd9Sstevel@tonic-gate * 21667c478bd9Sstevel@tonic-gate * The structure of this field is consistent with the ISO 3309 21677c478bd9Sstevel@tonic-gate * extension mechanism for address fields. All Protocols MUST be odd; 21687c478bd9Sstevel@tonic-gate * the least significant bit of the least significant octet MUST equal 21697c478bd9Sstevel@tonic-gate * "1". Also, all Protocols MUST be assigned such that the least 21707c478bd9Sstevel@tonic-gate * significant bit of the most significant octet equals "0". Frames 21717c478bd9Sstevel@tonic-gate * received which don't comply with these rules MUST be treated as 21727c478bd9Sstevel@tonic-gate * having an unrecognized Protocol. 21737c478bd9Sstevel@tonic-gate * 21747c478bd9Sstevel@tonic-gate * Protocol field values in the "0***" to "3***" range identify the 21757c478bd9Sstevel@tonic-gate * network-layer protocol of specific packets, and values in the 21767c478bd9Sstevel@tonic-gate * "8***" to "b***" range identify packets belonging to the associated 21777c478bd9Sstevel@tonic-gate * Network Control Protocols (NCPs), if any. 21787c478bd9Sstevel@tonic-gate * 21797c478bd9Sstevel@tonic-gate * Protocol field values in the "4***" to "7***" range are used for 21807c478bd9Sstevel@tonic-gate * protocols with low volume traffic which have no associated NCP. 21817c478bd9Sstevel@tonic-gate * Protocol field values in the "c***" to "f***" range identify packets 21827c478bd9Sstevel@tonic-gate * as link-layer Control Protocols (such as LCP). 21837c478bd9Sstevel@tonic-gate */ 21847c478bd9Sstevel@tonic-gate proto = PPP_PROTOCOL(mp->b_rptr); 21857c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 21867c478bd9Sstevel@tonic-gate ppa->ppa_stats.p.ppp_ipackets++; 21877c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 21887c478bd9Sstevel@tonic-gate /* 21897c478bd9Sstevel@tonic-gate * We check if this is not a network-layer protocol, and if so, 21907c478bd9Sstevel@tonic-gate * then send this packet up the control stream. 21917c478bd9Sstevel@tonic-gate */ 21927c478bd9Sstevel@tonic-gate if (proto > 0x7fff) { 21937c478bd9Sstevel@tonic-gate goto inpkt_done; /* send it up the control stream */ 21947c478bd9Sstevel@tonic-gate } 21957c478bd9Sstevel@tonic-gate /* 21967c478bd9Sstevel@tonic-gate * Try to grab the destination upper stream from the network-layer 21977c478bd9Sstevel@tonic-gate * stream cache for this ppa for PPP_IP (0x0021) or PPP_IPV6 (0x0057) 21987c478bd9Sstevel@tonic-gate * protocol types. Otherwise, if the type is not known to the cache, 21997c478bd9Sstevel@tonic-gate * or if its sap can't be matched with any of the upper streams, then 22007c478bd9Sstevel@tonic-gate * send this packet up the control stream so that it can be rejected. 22017c478bd9Sstevel@tonic-gate */ 22027c478bd9Sstevel@tonic-gate if (proto == PPP_IP) { 22037c478bd9Sstevel@tonic-gate destsps = ppa->ppa_ip_cache; 22047c478bd9Sstevel@tonic-gate } else if (proto == PPP_IPV6) { 22057c478bd9Sstevel@tonic-gate destsps = ppa->ppa_ip6_cache; 22067c478bd9Sstevel@tonic-gate } 22077c478bd9Sstevel@tonic-gate /* 22087c478bd9Sstevel@tonic-gate * Toss this one away up the control stream if there's no matching sap; 22097c478bd9Sstevel@tonic-gate * this way the protocol can be rejected (destsps is NULL). 22107c478bd9Sstevel@tonic-gate */ 22117c478bd9Sstevel@tonic-gate 22127c478bd9Sstevel@tonic-gate inpkt_done: 22137c478bd9Sstevel@tonic-gate /* 22147c478bd9Sstevel@tonic-gate * Only time-stamp the packet with hrtime if the upper stream 22157c478bd9Sstevel@tonic-gate * is configured to do so. PPP control (negotiation) messages 22167c478bd9Sstevel@tonic-gate * are never considered link activity; only data is activity. 22177c478bd9Sstevel@tonic-gate */ 22187c478bd9Sstevel@tonic-gate if (destsps != NULL && IS_PPA_TIMESTAMP(ppa)) { 22197c478bd9Sstevel@tonic-gate ppa->ppa_lastrx = gethrtime(); 22207c478bd9Sstevel@tonic-gate } 22217c478bd9Sstevel@tonic-gate /* 22227c478bd9Sstevel@tonic-gate * Should there be any promiscuous stream(s), send the data up for 22237c478bd9Sstevel@tonic-gate * each promiscuous stream that we recognize. We skip the control 22247c478bd9Sstevel@tonic-gate * stream as we obviously never allow the control stream to become 22257c478bd9Sstevel@tonic-gate * promiscous and bind to PPP_ALLSAP. 22267c478bd9Sstevel@tonic-gate */ 22277c478bd9Sstevel@tonic-gate rw_enter(&ppa->ppa_sib_lock, RW_READER); 22287c478bd9Sstevel@tonic-gate is_promisc = ppa->ppa_promicnt; 22297c478bd9Sstevel@tonic-gate if (is_promisc) { 22307c478bd9Sstevel@tonic-gate ASSERT(ppa->ppa_streams != NULL); 22317c478bd9Sstevel@tonic-gate sppp_dlprsendup(ppa->ppa_streams, mp, proto, B_TRUE); 22327c478bd9Sstevel@tonic-gate } 22337c478bd9Sstevel@tonic-gate rw_exit(&ppa->ppa_sib_lock); 22347c478bd9Sstevel@tonic-gate return (destsps); 22357c478bd9Sstevel@tonic-gate } 22367c478bd9Sstevel@tonic-gate 22377c478bd9Sstevel@tonic-gate /* 22387c478bd9Sstevel@tonic-gate * sppp_kstat_update() 22397c478bd9Sstevel@tonic-gate * 22407c478bd9Sstevel@tonic-gate * Description: 22417c478bd9Sstevel@tonic-gate * Update per-ppa kstat interface statistics. 22427c478bd9Sstevel@tonic-gate */ 22437c478bd9Sstevel@tonic-gate static int 22447c478bd9Sstevel@tonic-gate sppp_kstat_update(kstat_t *ksp, int rw) 22457c478bd9Sstevel@tonic-gate { 22467c478bd9Sstevel@tonic-gate register sppa_t *ppa; 22477c478bd9Sstevel@tonic-gate register sppp_kstats_t *pppkp; 22487c478bd9Sstevel@tonic-gate register struct pppstat64 *sp; 22497c478bd9Sstevel@tonic-gate 22507c478bd9Sstevel@tonic-gate if (rw == KSTAT_WRITE) { 22517c478bd9Sstevel@tonic-gate return (EACCES); 22527c478bd9Sstevel@tonic-gate } 22537c478bd9Sstevel@tonic-gate 22547c478bd9Sstevel@tonic-gate ppa = (sppa_t *)ksp->ks_private; 22557c478bd9Sstevel@tonic-gate ASSERT(ppa != NULL); 22567c478bd9Sstevel@tonic-gate 22577c478bd9Sstevel@tonic-gate pppkp = (sppp_kstats_t *)ksp->ks_data; 22587c478bd9Sstevel@tonic-gate sp = &ppa->ppa_stats.p; 22597c478bd9Sstevel@tonic-gate 22607c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 22617c478bd9Sstevel@tonic-gate pppkp->allocbfail.value.ui32 = ppa->ppa_allocbfail; 22627c478bd9Sstevel@tonic-gate pppkp->mctlsfwd.value.ui32 = ppa->ppa_mctlsfwd; 22637c478bd9Sstevel@tonic-gate pppkp->mctlsfwderr.value.ui32 = ppa->ppa_mctlsfwderr; 22647c478bd9Sstevel@tonic-gate pppkp->rbytes.value.ui32 = sp->ppp_ibytes; 22657c478bd9Sstevel@tonic-gate pppkp->rbytes64.value.ui64 = sp->ppp_ibytes; 22667c478bd9Sstevel@tonic-gate pppkp->ierrors.value.ui32 = sp->ppp_ierrors; 22677c478bd9Sstevel@tonic-gate pppkp->ierrors_lower.value.ui32 = ppa->ppa_ierr_low; 22687c478bd9Sstevel@tonic-gate pppkp->ioctlsfwd.value.ui32 = ppa->ppa_ioctlsfwd; 22697c478bd9Sstevel@tonic-gate pppkp->ioctlsfwdok.value.ui32 = ppa->ppa_ioctlsfwdok; 22707c478bd9Sstevel@tonic-gate pppkp->ioctlsfwderr.value.ui32 = ppa->ppa_ioctlsfwderr; 22717c478bd9Sstevel@tonic-gate pppkp->ipackets.value.ui32 = sp->ppp_ipackets; 22727c478bd9Sstevel@tonic-gate pppkp->ipackets64.value.ui64 = sp->ppp_ipackets; 22737c478bd9Sstevel@tonic-gate pppkp->ipackets_ctl.value.ui32 = ppa->ppa_ipkt_ctl; 22747c478bd9Sstevel@tonic-gate pppkp->iqdropped.value.ui32 = ppa->ppa_iqdropped; 22757c478bd9Sstevel@tonic-gate pppkp->irunts.value.ui32 = ppa->ppa_irunts; 22767c478bd9Sstevel@tonic-gate pppkp->itoolongs.value.ui32 = ppa->ppa_itoolongs; 22777c478bd9Sstevel@tonic-gate pppkp->lsneedup.value.ui32 = ppa->ppa_lsneedup; 22787c478bd9Sstevel@tonic-gate pppkp->lsdown.value.ui32 = ppa->ppa_lsdown; 22797c478bd9Sstevel@tonic-gate pppkp->mctlsknown.value.ui32 = ppa->ppa_mctlsknown; 22807c478bd9Sstevel@tonic-gate pppkp->mctlsunknown.value.ui32 = ppa->ppa_mctlsunknown; 22817c478bd9Sstevel@tonic-gate pppkp->obytes.value.ui32 = sp->ppp_obytes; 22827c478bd9Sstevel@tonic-gate pppkp->obytes64.value.ui64 = sp->ppp_obytes; 22837c478bd9Sstevel@tonic-gate pppkp->oerrors.value.ui32 = sp->ppp_oerrors; 22847c478bd9Sstevel@tonic-gate pppkp->oerrors_lower.value.ui32 = ppa->ppa_oerr_low; 22857c478bd9Sstevel@tonic-gate pppkp->opackets.value.ui32 = sp->ppp_opackets; 22867c478bd9Sstevel@tonic-gate pppkp->opackets64.value.ui64 = sp->ppp_opackets; 22877c478bd9Sstevel@tonic-gate pppkp->opackets_ctl.value.ui32 = ppa->ppa_opkt_ctl; 22887c478bd9Sstevel@tonic-gate pppkp->oqdropped.value.ui32 = ppa->ppa_oqdropped; 22897c478bd9Sstevel@tonic-gate pppkp->otoolongs.value.ui32 = ppa->ppa_otoolongs; 22907c478bd9Sstevel@tonic-gate pppkp->orunts.value.ui32 = ppa->ppa_orunts; 22917c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 22927c478bd9Sstevel@tonic-gate 22937c478bd9Sstevel@tonic-gate return (0); 22947c478bd9Sstevel@tonic-gate } 22957c478bd9Sstevel@tonic-gate 22967c478bd9Sstevel@tonic-gate /* 22977c478bd9Sstevel@tonic-gate * Turn off proto in ppa_npflag to indicate that 22987c478bd9Sstevel@tonic-gate * the corresponding network protocol has been plumbed. 22997c478bd9Sstevel@tonic-gate * Release proto packets that were being held in the control 23007c478bd9Sstevel@tonic-gate * queue in anticipation of this event. 23017c478bd9Sstevel@tonic-gate */ 23027c478bd9Sstevel@tonic-gate static void 23037c478bd9Sstevel@tonic-gate sppp_release_pkts(sppa_t *ppa, uint16_t proto) 23047c478bd9Sstevel@tonic-gate { 23057c478bd9Sstevel@tonic-gate uint32_t npflagpos = sppp_ppp2np(proto); 23067c478bd9Sstevel@tonic-gate int count; 23077c478bd9Sstevel@tonic-gate mblk_t *mp; 23087c478bd9Sstevel@tonic-gate uint16_t mp_proto; 23097c478bd9Sstevel@tonic-gate queue_t *q; 23107c478bd9Sstevel@tonic-gate spppstr_t *destsps; 23117c478bd9Sstevel@tonic-gate 23127c478bd9Sstevel@tonic-gate ASSERT(ppa != NULL); 23137c478bd9Sstevel@tonic-gate 23147c478bd9Sstevel@tonic-gate if (npflagpos == 0 || (ppa->ppa_npflag & (1 << npflagpos)) == 0) 23157c478bd9Sstevel@tonic-gate return; 23167c478bd9Sstevel@tonic-gate 23177c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_npmutex); 23187c478bd9Sstevel@tonic-gate ppa->ppa_npflag &= ~(1 << npflagpos); 23197c478bd9Sstevel@tonic-gate count = ppa->ppa_holdpkts[npflagpos]; 23207c478bd9Sstevel@tonic-gate ppa->ppa_holdpkts[npflagpos] = 0; 23217c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_npmutex); 23227c478bd9Sstevel@tonic-gate 23237c478bd9Sstevel@tonic-gate q = ppa->ppa_ctl->sps_rq; 23247c478bd9Sstevel@tonic-gate 23257c478bd9Sstevel@tonic-gate while (count > 0) { 23267c478bd9Sstevel@tonic-gate mp = getq(q); 23277c478bd9Sstevel@tonic-gate ASSERT(mp != NULL); 23287c478bd9Sstevel@tonic-gate 23297c478bd9Sstevel@tonic-gate mp_proto = PPP_PROTOCOL(mp->b_rptr); 23307c478bd9Sstevel@tonic-gate if (mp_proto != proto) { 23317c478bd9Sstevel@tonic-gate (void) putq(q, mp); 23327c478bd9Sstevel@tonic-gate continue; 23337c478bd9Sstevel@tonic-gate } 23347c478bd9Sstevel@tonic-gate count--; 23357c478bd9Sstevel@tonic-gate destsps = NULL; 23367c478bd9Sstevel@tonic-gate if (mp_proto == PPP_IP) { 23377c478bd9Sstevel@tonic-gate destsps = ppa->ppa_ip_cache; 23387c478bd9Sstevel@tonic-gate } else if (mp_proto == PPP_IPV6) { 23397c478bd9Sstevel@tonic-gate destsps = ppa->ppa_ip6_cache; 23407c478bd9Sstevel@tonic-gate } 23417c478bd9Sstevel@tonic-gate ASSERT(destsps != NULL); 23427c478bd9Sstevel@tonic-gate 23437c478bd9Sstevel@tonic-gate if (IS_SPS_FASTPATH(destsps)) { 23447c478bd9Sstevel@tonic-gate mp->b_rptr += PPP_HDRLEN; 23457c478bd9Sstevel@tonic-gate } else { 23467c478bd9Sstevel@tonic-gate spppstr_t *uqs = (spppstr_t *)destsps->sps_rq->q_ptr; 23477c478bd9Sstevel@tonic-gate ASSERT(uqs != NULL); 23487c478bd9Sstevel@tonic-gate mp->b_rptr += PPP_HDRLEN; 23497c478bd9Sstevel@tonic-gate mp = sppp_dladdud(uqs, mp, uqs->sps_sap, B_FALSE); 23507c478bd9Sstevel@tonic-gate if (mp == NULL) { 23517c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 23527c478bd9Sstevel@tonic-gate ppa->ppa_allocbfail++; 23537c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 23547c478bd9Sstevel@tonic-gate /* mp already freed by sppp_dladdud */ 23557c478bd9Sstevel@tonic-gate continue; 23567c478bd9Sstevel@tonic-gate } 23577c478bd9Sstevel@tonic-gate } 23587c478bd9Sstevel@tonic-gate 23597c478bd9Sstevel@tonic-gate if (canputnext(destsps->sps_rq)) { 23607c478bd9Sstevel@tonic-gate putnext(destsps->sps_rq, mp); 23617c478bd9Sstevel@tonic-gate } else { 23627c478bd9Sstevel@tonic-gate mutex_enter(&ppa->ppa_sta_lock); 23637c478bd9Sstevel@tonic-gate ppa->ppa_iqdropped++; 23647c478bd9Sstevel@tonic-gate mutex_exit(&ppa->ppa_sta_lock); 23657c478bd9Sstevel@tonic-gate freemsg(mp); 23667c478bd9Sstevel@tonic-gate continue; 23677c478bd9Sstevel@tonic-gate } 23687c478bd9Sstevel@tonic-gate } 23697c478bd9Sstevel@tonic-gate } 2370