1 /*- 2 * Copyright (c) 2003 Silicon Graphics International Corp. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions, and the following disclaimer, 10 * without modification. 11 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 12 * substantially similar to the "NO WARRANTY" disclaimer below 13 * ("Disclaimer") and any redistribution must be conditioned upon 14 * including a substantially similar Disclaimer requirement for further 15 * binary redistribution. 16 * 17 * NO WARRANTY 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 26 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 27 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 28 * POSSIBILITY OF SUCH DAMAGES. 29 * 30 * $Id: //depot/users/kenm/FreeBSD-test2/sys/cam/ctl/ctl_frontend.c#4 $ 31 */ 32 /* 33 * CAM Target Layer front end interface code 34 * 35 * Author: Ken Merry <ken@FreeBSD.org> 36 */ 37 38 #include <sys/cdefs.h> 39 __FBSDID("$FreeBSD$"); 40 41 #include <sys/param.h> 42 #include <sys/systm.h> 43 #include <sys/kernel.h> 44 #include <sys/types.h> 45 #include <sys/malloc.h> 46 #include <sys/lock.h> 47 #include <sys/mutex.h> 48 #include <sys/condvar.h> 49 #include <sys/endian.h> 50 #include <sys/queue.h> 51 52 #include <cam/scsi/scsi_all.h> 53 #include <cam/scsi/scsi_da.h> 54 #include <cam/ctl/ctl_io.h> 55 #include <cam/ctl/ctl.h> 56 #include <cam/ctl/ctl_frontend.h> 57 #include <cam/ctl/ctl_frontend_internal.h> 58 #include <cam/ctl/ctl_backend.h> 59 /* XXX KDM move defines from ctl_ioctl.h to somewhere else */ 60 #include <cam/ctl/ctl_ioctl.h> 61 #include <cam/ctl/ctl_ha.h> 62 #include <cam/ctl/ctl_private.h> 63 #include <cam/ctl/ctl_debug.h> 64 65 extern struct ctl_softc *control_softc; 66 67 int 68 ctl_frontend_register(struct ctl_frontend *fe, int master_shelf) 69 { 70 struct ctl_io_pool *pool; 71 int port_num; 72 int retval; 73 74 retval = 0; 75 76 KASSERT(control_softc != NULL, ("CTL is not initialized")); 77 78 mtx_lock(&control_softc->ctl_lock); 79 port_num = ctl_ffz(&control_softc->ctl_port_mask, CTL_MAX_PORTS); 80 if ((port_num == -1) 81 || (ctl_set_mask(&control_softc->ctl_port_mask, port_num) == -1)) { 82 fe->targ_port = -1; 83 mtx_unlock(&control_softc->ctl_lock); 84 return (1); 85 } 86 control_softc->num_frontends++; 87 88 mtx_unlock(&control_softc->ctl_lock); 89 /* 90 * We add 20 to whatever the caller requests, so he doesn't get 91 * burned by queueing things back to the pending sense queue. In 92 * theory, there should probably only be one outstanding item, at 93 * most, on the pending sense queue for a LUN. We'll clear the 94 * pending sense queue on the next command, whether or not it is 95 * a REQUEST SENSE. 96 */ 97 retval = ctl_pool_create(control_softc, 98 (fe->port_type != CTL_PORT_IOCTL) ? 99 CTL_POOL_FETD : CTL_POOL_IOCTL, 100 fe->num_requested_ctl_io + 20, &pool); 101 if (retval != 0) { 102 fe->targ_port = -1; 103 mtx_lock(&control_softc->ctl_lock); 104 ctl_clear_mask(&control_softc->ctl_port_mask, port_num); 105 mtx_unlock(&control_softc->ctl_lock); 106 return (retval); 107 } 108 109 mtx_lock(&control_softc->ctl_lock); 110 111 /* For now assume master shelf */ 112 //fe->targ_port = port_num; 113 fe->targ_port = port_num + (master_shelf!=0 ? 0 : CTL_MAX_PORTS); 114 fe->max_initiators = CTL_MAX_INIT_PER_PORT; 115 STAILQ_INSERT_TAIL(&control_softc->fe_list, fe, links); 116 ctl_pool_acquire(pool); 117 control_softc->ctl_ports[port_num] = fe; 118 119 mtx_unlock(&control_softc->ctl_lock); 120 121 fe->ctl_pool_ref = pool; 122 123 return (retval); 124 } 125 126 int 127 ctl_frontend_deregister(struct ctl_frontend *fe) 128 { 129 struct ctl_io_pool *pool; 130 int port_num; 131 int retval; 132 133 retval = 0; 134 135 pool = (struct ctl_io_pool *)fe->ctl_pool_ref; 136 137 if (fe->targ_port == -1) { 138 retval = 1; 139 goto bailout; 140 } 141 142 mtx_lock(&control_softc->ctl_lock); 143 144 ctl_pool_invalidate(pool); 145 ctl_pool_release(pool); 146 147 STAILQ_REMOVE(&control_softc->fe_list, fe, ctl_frontend, links); 148 control_softc->num_frontends--; 149 port_num = (fe->targ_port < CTL_MAX_PORTS) ? fe->targ_port : 150 fe->targ_port - CTL_MAX_PORTS; 151 ctl_clear_mask(&control_softc->ctl_port_mask, port_num); 152 control_softc->ctl_ports[port_num] = NULL; 153 mtx_unlock(&control_softc->ctl_lock); 154 bailout: 155 return (retval); 156 } 157 158 void 159 ctl_frontend_set_wwns(struct ctl_frontend *fe, int wwnn_valid, uint64_t wwnn, 160 int wwpn_valid, uint64_t wwpn) 161 { 162 if (wwnn_valid) 163 fe->wwnn = wwnn; 164 165 if (wwpn_valid) 166 fe->wwpn = wwpn; 167 } 168 169 void 170 ctl_frontend_online(struct ctl_frontend *fe) 171 { 172 fe->port_online(fe->onoff_arg); 173 /* XXX KDM need a lock here? */ 174 fe->status |= CTL_PORT_STATUS_ONLINE; 175 } 176 177 void 178 ctl_frontend_offline(struct ctl_frontend *fe) 179 { 180 fe->port_offline(fe->onoff_arg); 181 /* XXX KDM need a lock here? */ 182 fe->status &= ~CTL_PORT_STATUS_ONLINE; 183 } 184 185 /* 186 * vim: ts=8 187 */ 188