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 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26
27
28 #include <TgtFCHBAPort.h>
29 #include <Exceptions.h>
30 #include <Trace.h>
31 #include <sun_fc.h>
32 #include <iostream>
33 #include <iomanip>
34 #include <sys/types.h>
35 #include <sys/mkdev.h>
36 #include <sys/stat.h>
37 #include <fcntl.h>
38 #include <unistd.h>
39 #include <stropts.h>
40 #include <dirent.h>
41 #include <sys/fibre-channel/fc.h>
42 #include <sys/fctio.h>
43 #include <sys/fibre-channel/impl/fc_error.h>
44 #include <sys/fibre-channel/fc_appif.h>
45 #include <sys/scsi/generic/commands.h>
46 #include <sys/scsi/impl/commands.h>
47 #include <sys/scsi/impl/sense.h>
48 #include <sys/scsi/generic/inquiry.h>
49 #include <sys/scsi/generic/status.h>
50 #include <errno.h>
51 #include <cstdlib>
52
53
54 using namespace std;
55
56 const int TgtFCHBAPort::MAX_FCTIO_MSG_LEN = 256;
57 const string TgtFCHBAPort::FCT_DRIVER_PATH = "/devices/pseudo/fct@0:admin";
58
59 /*
60 * Interpret the error code in the fctio_t structure
61 *
62 * message must be at least MAX_FCTIO_MSG_LEN in length.
63 */
64 void
transportError(uint32_t fctio_errno,char * message)65 TgtFCHBAPort::transportError(uint32_t fctio_errno, char *message) {
66 Trace log("transportError");
67 string fcioErrorString;
68 if (message == NULL) {
69 log.internalError("NULL routine argument");
70 return;
71 }
72 switch (fctio_errno) {
73 case (uint32_t)FC_FAILURE:
74 fcioErrorString = "general failure";
75 break;
76 case (uint32_t)FC_FAILURE_SILENT:
77 fcioErrorString = "general failure but fail silently";
78 break;
79 case FC_SUCCESS:
80 fcioErrorString = "successful completion";
81 break;
82 case FC_CAP_ERROR:
83 fcioErrorString = "FCA capability error";
84 break;
85 case FC_CAP_FOUND:
86 fcioErrorString = "FCA capability unsettable";
87 break;
88 case FC_CAP_SETTABLE:
89 fcioErrorString = "FCA capability settable";
90 break;
91 case FC_UNBOUND:
92 fcioErrorString = "unbound stuff";
93 break;
94 case FC_NOMEM:
95 fcioErrorString = "allocation error";
96 break;
97 case FC_BADPACKET:
98 fcioErrorString = "invalid packet specified/supplied";
99 break;
100 case FC_OFFLINE:
101 fcioErrorString = "I/O resource unavailable";
102 break;
103 case FC_OLDPORT:
104 fcioErrorString = "operation on non-loop port";
105 break;
106 case FC_NO_MAP:
107 fcioErrorString = "requested map unavailable";
108 break;
109 case FC_TRANSPORT_ERROR:
110 fcioErrorString = "unable to transport I/O";
111 break;
112 case FC_ELS_FREJECT:
113 fcioErrorString = "ELS rejected by a Fabric";
114 break;
115 case FC_ELS_PREJECT:
116 fcioErrorString = "ELS rejected by an N_port";
117 break;
118 case FC_ELS_BAD:
119 fcioErrorString = "ELS rejected by FCA/fctl";
120 break;
121 case FC_ELS_MALFORMED:
122 fcioErrorString = "poorly formed ELS request";
123 break;
124 case FC_TOOMANY:
125 fcioErrorString = "resource request too large";
126 break;
127 case FC_UB_BADTOKEN:
128 fcioErrorString = "invalid unsolicited buffer token";
129 break;
130 case FC_UB_ERROR:
131 fcioErrorString = "invalid unsol buf request";
132 break;
133 case FC_UB_BUSY:
134 fcioErrorString = "buffer already in use";
135 break;
136 case FC_BADULP:
137 fcioErrorString = "Unknown ulp";
138 break;
139 case FC_BADTYPE:
140 fcioErrorString = "ULP not registered to handle this FC4 type";
141 break;
142 case FC_UNCLAIMED:
143 fcioErrorString = "request or data not claimed";
144 break;
145 case FC_ULP_SAMEMODULE:
146 fcioErrorString = "module already in use";
147 break;
148 case FC_ULP_SAMETYPE:
149 fcioErrorString = "FC4 module already in use";
150 break;
151 case FC_ABORTED:
152 fcioErrorString = "request aborted";
153 break;
154 case FC_ABORT_FAILED:
155 fcioErrorString = "abort request failed";
156 break;
157 case FC_BADEXCHANGE:
158 fcioErrorString = "exchange doesn�t exist";
159 break;
160 case FC_BADWWN:
161 fcioErrorString = "WWN not recognized";
162 break;
163 case FC_BADDEV:
164 fcioErrorString = "device unrecognized";
165 break;
166 case FC_BADCMD:
167 fcioErrorString = "invalid command issued";
168 break;
169 case FC_BADOBJECT:
170 fcioErrorString = "invalid object requested";
171 break;
172 case FC_BADPORT:
173 fcioErrorString = "invalid port specified";
174 break;
175 case FC_NOTTHISPORT:
176 fcioErrorString = "resource not at this port";
177 break;
178 case FC_PREJECT:
179 fcioErrorString = "reject at remote N_Port";
180 break;
181 case FC_FREJECT:
182 fcioErrorString = "reject at remote Fabric";
183 break;
184 case FC_PBUSY:
185 fcioErrorString = "remote N_Port busy";
186 break;
187 case FC_FBUSY:
188 fcioErrorString = "remote Fabric busy";
189 break;
190 case FC_ALREADY:
191 fcioErrorString = "already logged in";
192 break;
193 case FC_LOGINREQ:
194 fcioErrorString = "login required";
195 break;
196 case FC_RESETFAIL:
197 fcioErrorString = "reset failed";
198 break;
199 case FC_INVALID_REQUEST:
200 fcioErrorString = "request is invalid";
201 break;
202 case FC_OUTOFBOUNDS:
203 fcioErrorString = "port number is out of bounds";
204 break;
205 case FC_TRAN_BUSY:
206 fcioErrorString = "command transport busy";
207 break;
208 case FC_STATEC_BUSY:
209 fcioErrorString = "port driver currently busy";
210 break;
211 case FC_DEVICE_BUSY:
212 fcioErrorString = "transport working on this device";
213 break;
214 case FC_DEVICE_NOT_TGT:
215 fcioErrorString = "device is not a SCSI target";
216 break;
217 default:
218 snprintf(message, MAX_FCTIO_MSG_LEN, "Unknown error code 0x%x",
219 fctio_errno);
220 return;
221 }
222 snprintf(message, MAX_FCTIO_MSG_LEN, "%s", fcioErrorString.c_str());
223 }
224
TgtFCHBAPort(string thePath)225 TgtFCHBAPort::TgtFCHBAPort(string thePath) : HBAPort() {
226 Trace log("TgtFCHBAPort::TgtFCHBAPort");
227 log.debug("Initializing HBA port %s", path.c_str());
228 path = thePath;
229
230 // This routine is not index based, so we can discard stateChange
231 uint64_t tmp;
232 HBA_PORTATTRIBUTES attrs = getPortAttributes(tmp);
233 memcpy(&tmp, &attrs.PortWWN, 8);
234 portWWN = ntohll(tmp);
235 memcpy(&tmp, &attrs.NodeWWN, 8);
236 nodeWWN = ntohll(tmp);
237
238 // For reference, here's how to dump WWN's through C++ streams.
239 // cout << "\tPort WWN: " << hex << setfill('0') << setw(16) << portWWN
240 // << endl;
241 // cout << "\tNode WWN: " << hex << setfill('0') << setw(16) << nodeWWN
242 // << endl;
243 }
244
getPortAttributes(uint64_t & stateChange)245 HBA_PORTATTRIBUTES TgtFCHBAPort::getPortAttributes(uint64_t &stateChange) {
246 Trace log("TgtFCHBAPort::getPortAttributes");
247
248 HBA_PORTATTRIBUTES attributes;
249 fctio_t fctio;
250 fc_tgt_hba_port_attributes_t attrs;
251
252 memset(&fctio, 0, sizeof (fctio));
253 memset(&attributes, 0, sizeof (attributes));
254
255 uint64_t portwwn = 0;
256 try {
257 string::size_type offset = path.find_last_of(".");
258 if (offset >= 0) {
259 string portwwnString = path.substr(offset+1);
260 portwwn = strtoull(portwwnString.c_str(), NULL, 16);
261 }
262 } catch (...) {
263 throw BadArgumentException();
264 }
265
266 uint64_t en_wwn = htonll(portwwn);
267
268 fctio.fctio_cmd = FCTIO_GET_ADAPTER_PORT_ATTRIBUTES;
269 fctio.fctio_ilen = 8;
270 fctio.fctio_ibuf = (uint64_t)(uintptr_t)&en_wwn;
271 fctio.fctio_xfer = FCTIO_XFER_READ;
272 fctio.fctio_olen = (uint32_t)(sizeof (attrs));
273 fctio.fctio_obuf = (uint64_t)(uintptr_t)&attrs;
274
275 fct_ioctl(FCTIO_CMD, &fctio);
276
277 stateChange = attrs.lastChange;
278
279 attributes.PortFcId = attrs.PortFcId;
280 attributes.PortType = attrs.PortType;
281 attributes.PortState = attrs.PortState;
282 attributes.PortSupportedClassofService = attrs.PortSupportedClassofService;
283 attributes.PortSupportedSpeed = attrs.PortSupportedSpeed;
284 attributes.PortSpeed = attrs.PortSpeed;
285 attributes.PortMaxFrameSize = attrs.PortMaxFrameSize;
286 attributes.NumberofDiscoveredPorts = attrs.NumberofDiscoveredPorts;
287 memcpy(&attributes.NodeWWN, &attrs.NodeWWN, 8);
288 memcpy(&attributes.PortWWN, &attrs.PortWWN, 8);
289 memcpy(&attributes.FabricName, &attrs.FabricName, 8);
290 memcpy(&attributes.PortSupportedFc4Types, &attrs.PortSupportedFc4Types, 32);
291 memcpy(&attributes.PortActiveFc4Types, &attrs.PortActiveFc4Types, 32);
292 memcpy(&attributes.PortSymbolicName, &attrs.PortSymbolicName, 256);
293
294 strncpy((char *)attributes.OSDeviceName, "Not Applicable", 15);
295 return (attributes);
296 }
297
getDiscoveredAttributes(HBA_UINT32 discoveredport,uint64_t & stateChange)298 HBA_PORTATTRIBUTES TgtFCHBAPort::getDiscoveredAttributes(
299 HBA_UINT32 discoveredport, uint64_t &stateChange) {
300 Trace log("TgtFCHBAPort::getDiscoverdAttributes(i)");
301
302 HBA_PORTATTRIBUTES attributes;
303 fctio_t fctio;
304 fc_tgt_hba_port_attributes_t attrs;
305
306 memset(&fctio, 0, sizeof (fctio));
307 memset(&attributes, 0, sizeof (attributes));
308
309 uint64_t portwwn = 0;
310 try {
311 string::size_type offset = path.find_last_of(".");
312 if (offset >= 0) {
313 string portwwnString = path.substr(offset+1);
314 portwwn = strtoull(portwwnString.c_str(), NULL, 16);
315 }
316 } catch (...) {
317 throw BadArgumentException();
318 }
319
320 uint64_t en_wwn = htonll(portwwn);
321
322 fctio.fctio_cmd = FCTIO_GET_DISCOVERED_PORT_ATTRIBUTES;
323 fctio.fctio_ilen = 8;
324 fctio.fctio_ibuf = (uint64_t)(uintptr_t)&en_wwn;
325 fctio.fctio_xfer = FCTIO_XFER_READ;
326 fctio.fctio_olen = (uint32_t)(sizeof (attrs));
327 fctio.fctio_obuf = (uint64_t)(uintptr_t)&attrs;
328 fctio.fctio_alen = (uint32_t)(sizeof (discoveredport));
329 fctio.fctio_abuf = (uint64_t)(uintptr_t)&discoveredport;
330
331 fct_ioctl(FCTIO_CMD, &fctio);
332
333 stateChange = attrs.lastChange;
334
335 attributes.PortFcId = attrs.PortFcId;
336 attributes.PortType = attrs.PortType;
337 attributes.PortState = attrs.PortState;
338 attributes.PortSupportedClassofService = attrs.PortSupportedClassofService;
339 attributes.PortSupportedSpeed = attrs.PortSupportedSpeed;
340 attributes.PortSpeed = attrs.PortSpeed;
341 attributes.PortMaxFrameSize = attrs.PortMaxFrameSize;
342 attributes.NumberofDiscoveredPorts = attrs.NumberofDiscoveredPorts;
343 memcpy(&attributes.NodeWWN, &attrs.NodeWWN, 8);
344 memcpy(&attributes.PortWWN, &attrs.PortWWN, 8);
345 memcpy(&attributes.FabricName, &attrs.FabricName, 8);
346 memcpy(&attributes.PortSupportedFc4Types, &attrs.PortSupportedFc4Types, 32);
347 memcpy(&attributes.PortActiveFc4Types, &attrs.PortActiveFc4Types, 32);
348 memcpy(&attributes.PortSymbolicName, &attrs.PortSymbolicName, 256);
349
350
351 return (attributes);
352 }
353
getDiscoveredAttributes(uint64_t wwn,uint64_t & stateChange)354 HBA_PORTATTRIBUTES TgtFCHBAPort::getDiscoveredAttributes(
355 uint64_t wwn, uint64_t &stateChange) {
356 Trace log("TgtFCHBAPort::getDiscoverdAttributes(p)");
357
358 HBA_PORTATTRIBUTES attributes;
359 fctio_t fctio;
360 fc_tgt_hba_port_attributes_t attrs;
361
362 memset(&fctio, 0, sizeof (fctio));
363 memset(&attributes, 0, sizeof (attributes));
364
365 uint64_t en_wwn = htonll(wwn);
366
367 fctio.fctio_cmd = FCTIO_GET_PORT_ATTRIBUTES;
368 fctio.fctio_olen = (uint32_t)(sizeof (attrs));
369 fctio.fctio_xfer = FCTIO_XFER_READ;
370 fctio.fctio_obuf = (uint64_t)(uintptr_t)&attrs;
371 fctio.fctio_ilen = (uint32_t)(sizeof (wwn));
372 fctio.fctio_ibuf = (uint64_t)(uintptr_t)&en_wwn;
373
374 fct_ioctl(FCTIO_CMD, &fctio);
375
376 stateChange = attrs.lastChange;
377
378 attributes.PortFcId = attrs.PortFcId;
379 attributes.PortType = attrs.PortType;
380 attributes.PortState = attrs.PortState;
381 attributes.PortSupportedClassofService = attrs.PortSupportedClassofService;
382 attributes.PortSupportedSpeed = attrs.PortSupportedSpeed;
383 attributes.PortSpeed = attrs.PortSpeed;
384 attributes.PortMaxFrameSize = attrs.PortMaxFrameSize;
385 attributes.NumberofDiscoveredPorts = attrs.NumberofDiscoveredPorts;
386 memcpy(&attributes.NodeWWN, &attrs.NodeWWN, 8);
387 memcpy(&attributes.PortWWN, &attrs.PortWWN, 8);
388 memcpy(&attributes.FabricName, &attrs.FabricName, 8);
389 memcpy(&attributes.PortSupportedFc4Types, &attrs.PortSupportedFc4Types, 32);
390 memcpy(&attributes.PortActiveFc4Types, &attrs.PortActiveFc4Types, 32);
391 memcpy(&attributes.PortSymbolicName, &attrs.PortSymbolicName, 256);
392
393
394 return (attributes);
395 }
396
sendRLS(uint64_t destWWN,void * pRspBuffer,HBA_UINT32 * pRspBufferSize)397 void TgtFCHBAPort::sendRLS(uint64_t destWWN,
398 void *pRspBuffer,
399 HBA_UINT32 *pRspBufferSize) {
400 Trace log("FCHBAPort::sendRLS");
401
402 fctio_t fctio;
403 // fc_hba_adapter_port_stats_t fc_port_stat;
404 uint64_t en_portWWN;
405 uint64_t DestPortID;
406
407 // Validate the arguments
408 if (pRspBuffer == NULL ||
409 pRspBufferSize == NULL) {
410 log.userError("NULL hba");
411 throw BadArgumentException();
412 }
413
414 // check to see if we are sending RLS to the HBA
415 HBA_PORTATTRIBUTES attrs;
416 uint64_t tmp;
417 portWWN = getPortWWN();
418 en_portWWN = htonll(portWWN);
419
420 /* The destWWN is either the adapter port or a discovered port. */
421 memset(&fctio, 0, sizeof (fctio));
422 fctio.fctio_cmd = FCTIO_GET_LINK_STATUS;
423 fctio.fctio_ibuf = (uint64_t)(uintptr_t)&en_portWWN;
424 fctio.fctio_ilen = (uint32_t)(sizeof (en_portWWN));
425 if (portWWN != destWWN) {
426 attrs = getDiscoveredAttributes(destWWN, tmp);
427 DestPortID = (uint64_t)attrs.PortFcId;
428 fctio.fctio_abuf = (uint64_t)(uintptr_t)&DestPortID;
429 fctio.fctio_alen = (uint32_t)(sizeof (DestPortID));
430 }
431 fctio.fctio_xfer = FCTIO_XFER_READ;
432 fctio.fctio_flags = 0;
433 fctio.fctio_obuf = (uint64_t)(uintptr_t)new uchar_t[*pRspBufferSize];
434 fctio.fctio_olen = *pRspBufferSize;
435
436 if (fctio.fctio_obuf == 0) {
437 log.noMemory();
438 throw InternalError();
439 }
440
441 fct_ioctl(FCTIO_CMD, &fctio);
442 memcpy(pRspBuffer, (uchar_t *)(uintptr_t)fctio.fctio_obuf,
443 *pRspBufferSize);
444 if (fctio.fctio_obuf != 0) {
445 delete((uchar_t *)(uintptr_t)fctio.fctio_obuf);
446 }
447 }
448
449 /**
450 * @memo Validate that the port is still present in the system
451 * @exception UnavailableException if the port is not present
452 * @version 1.7
453 *
454 * @doc If the port is still present on the system, the routine
455 * will return normally. If the port is not present
456 * an exception will be thrown.
457 */
validatePresent()458 void TgtFCHBAPort::validatePresent() {
459 Trace log("TgtFCHBAPort::validatePresent");
460 // We already got the adapter list through the ioctl
461 // so calling it again to validate it is too expensive.
462 }
463
fct_ioctl(int cmd,fctio_t * fctio)464 void TgtFCHBAPort::fct_ioctl(int cmd, fctio_t *fctio) {
465 Trace log("TgtFCHBAPort::fct_ioctl");
466 char fcioErrorString[MAX_FCTIO_MSG_LEN] = "";
467 int fd = HBA::_open(FCT_DRIVER_PATH, O_NDELAY | O_RDONLY);
468 try {
469 HBA::_ioctl(fd, cmd, (uchar_t *)fctio);
470 close(fd);
471 if (fctio->fctio_errno) {
472 throw IOError("IOCTL transport failure");
473 }
474 } catch (...) {
475 close(fd);
476 transportError(fctio->fctio_errno, fcioErrorString);
477 log.genericIOError("ioctl (0x%x) failed. Transport: \"%s\"", cmd,
478 fcioErrorString);
479 switch (fctio->fctio_errno) {
480 case FC_BADWWN:
481 throw IllegalWWNException();
482 case FC_BADPORT:
483 throw IllegalWWNException();
484 case FC_OUTOFBOUNDS:
485 throw IllegalIndexException();
486 case FC_PBUSY:
487 case FC_FBUSY:
488 case FC_TRAN_BUSY:
489 case FC_STATEC_BUSY:
490 case FC_DEVICE_BUSY:
491 throw BusyException();
492 case FC_SUCCESS:
493 default:
494 throw;
495 }
496 }
497 }
498