1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* 28 * sppptun_mod.c - modload support for PPP multiplexing tunnel driver. 29 */ 30 31 #include <sys/types.h> 32 #include <sys/param.h> 33 #include <sys/stat.h> 34 #include <sys/systm.h> 35 #include <sys/socket.h> 36 #include <sys/stream.h> 37 #include <sys/stropts.h> 38 #include <sys/time.h> 39 #include <sys/conf.h> 40 #include <sys/kstat.h> 41 #include <sys/sunddi.h> 42 #include <net/sppptun.h> 43 #include <netinet/in.h> 44 45 #include "sppptun_mod.h" 46 47 /* 48 * Descriptions for flags values in cb_flags field: 49 * 50 * D_MTQPAIR: 51 * An inner perimeter that spans the queue pair. 52 * D_MTOUTPERIM: 53 * An outer perimeter that spans over all queues in the module. 54 * D_MTOCEXCL: 55 * Open & close procedures are entered exclusively at outer perimeter. 56 * D_MTPUTSHARED: 57 * Entry to put procedures are done with SHARED (reader) acess 58 * and not EXCLUSIVE (writer) access. 59 * 60 * Therefore: 61 * 62 * 1. Open and close procedures are entered with EXCLUSIVE (writer) 63 * access at the inner perimeter, and with EXCLUSIVE (writer) access at 64 * the outer perimeter. 65 * 66 * 2. Put procedures are entered with SHARED (reader) access at the inner 67 * perimeter, and with SHARED (reader) access at the outer perimeter. 68 * 69 * 3. Service procedures are entered with EXCLUSIVE (writer) access at 70 * the inner perimeter, and with SHARED (reader) access at the 71 * outer perimeter. 72 * 73 * Do not attempt to modify these flags unless the entire corresponding 74 * driver code is changed to accomodate the newly represented MT-STREAMS 75 * flags. Doing so without making proper modifications to the driver code 76 * will severely impact the intended driver behavior, and thus may affect 77 * the system's stability and performance. 78 */ 79 80 static int tun_attach(dev_info_t *, ddi_attach_cmd_t); 81 static int tun_detach(dev_info_t *, ddi_detach_cmd_t); 82 static int tun_info(dev_info_t *, ddi_info_cmd_t, void *, void **); 83 84 static dev_info_t *tun_dev_info; 85 86 DDI_DEFINE_STREAM_OPS(sppptun_ops, \ 87 nulldev, nulldev, \ 88 tun_attach, tun_detach, nodev, tun_info, \ 89 D_NEW | D_MP | D_MTQPAIR | D_MTOUTPERIM | D_MTOCEXCL | D_MTPUTSHARED, \ 90 &sppptun_tab, ddi_quiesce_not_supported); 91 92 /* 93 * This is the loadable module wrapper. 94 */ 95 #include <sys/modctl.h> 96 97 /* 98 * Module linkage information for the kernel. 99 */ 100 static struct fmodsw sppptun_fmodsw = { 101 PPP_TUN_NAME, 102 &sppptun_tab, 103 D_NEW | D_MP | D_MTQPAIR | D_MTOUTPERIM | D_MTOCEXCL | D_MTPUTSHARED 104 }; 105 106 static struct modldrv modldrv = { 107 &mod_driverops, 108 (char *)sppptun_driver_description, 109 &sppptun_ops 110 }; 111 112 static struct modlstrmod modlstrmod = { 113 &mod_strmodops, 114 (char *)sppptun_module_description, 115 &sppptun_fmodsw 116 }; 117 118 static struct modlinkage modlinkage = { 119 MODREV_1, 120 (void *)&modlstrmod, 121 (void *)&modldrv, 122 NULL 123 }; 124 125 int 126 _init(void) 127 { 128 int retv; 129 130 sppptun_init(); 131 if ((retv = mod_install(&modlinkage)) == 0) 132 sppptun_tcl_init(); 133 return (retv); 134 } 135 136 int 137 _fini(void) 138 { 139 int retv; 140 141 if ((retv = sppptun_tcl_fintest()) != 0) 142 return (retv); 143 retv = mod_remove(&modlinkage); 144 if (retv != 0) 145 return (retv); 146 sppptun_tcl_fini(); 147 return (0); 148 } 149 150 int 151 _info(struct modinfo *modinfop) 152 { 153 return (mod_info(&modlinkage, modinfop)); 154 } 155 156 /* 157 * tun_attach() 158 * 159 * Description: 160 * Attach a PPP tunnel driver to the system. 161 */ 162 static int 163 tun_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 164 { 165 if (cmd != DDI_ATTACH) 166 return (DDI_FAILURE); 167 if (ddi_create_minor_node(dip, PPP_TUN_NAME, S_IFCHR, 0, DDI_PSEUDO, 168 CLONE_DEV) == DDI_FAILURE) { 169 ddi_remove_minor_node(dip, NULL); 170 return (DDI_FAILURE); 171 } 172 tun_dev_info = dip; 173 return (DDI_SUCCESS); 174 } 175 176 /* 177 * tun_detach() 178 * 179 * Description: 180 * Detach an interface to the system. 181 */ 182 static int 183 tun_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 184 { 185 if (cmd != DDI_DETACH) 186 return (DDI_FAILURE); 187 tun_dev_info = NULL; 188 ddi_remove_minor_node(dip, NULL); 189 return (DDI_SUCCESS); 190 } 191 192 /* 193 * tun_info() 194 * 195 * Description: 196 * Translate "dev_t" to a pointer to the associated "dev_info_t". 197 */ 198 /* ARGSUSED */ 199 static int 200 tun_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, 201 void **result) 202 { 203 int rc; 204 205 switch (infocmd) { 206 case DDI_INFO_DEVT2DEVINFO: 207 if (tun_dev_info == NULL) { 208 rc = DDI_FAILURE; 209 } else { 210 *result = (void *)tun_dev_info; 211 rc = DDI_SUCCESS; 212 } 213 break; 214 case DDI_INFO_DEVT2INSTANCE: 215 *result = NULL; 216 rc = DDI_SUCCESS; 217 break; 218 default: 219 rc = DDI_FAILURE; 220 break; 221 } 222 return (rc); 223 } 224