xref: /titanic_51/usr/src/cmd/ndmpd/tlm/tlm_init.c (revision ed22c7109fc5dd9e1b7a5d0333bdc7ad2718e2ab)
1 /*
2  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
3  */
4 
5 /*
6  * BSD 3 Clause License
7  *
8  * Copyright (c) 2007, The Storage Networking Industry Association.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 	- Redistributions of source code must retain the above copyright
14  *	  notice, this list of conditions and the following disclaimer.
15  *
16  * 	- Redistributions in binary form must reproduce the above copyright
17  *	  notice, this list of conditions and the following disclaimer in
18  *	  the documentation and/or other materials provided with the
19  *	  distribution.
20  *
21  *	- Neither the name of The Storage Networking Industry Association (SNIA)
22  *	  nor the names of its contributors may be used to endorse or promote
23  *	  products derived from this software without specific prior written
24  *	  permission.
25  *
26  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
27  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
30  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36  * POSSIBILITY OF SUCH DAMAGE.
37  */
38 #include <sys/errno.h>
39 #include <sys/types.h>
40 #include <stdlib.h>
41 #include <unistd.h>
42 #include <ctype.h>
43 #include <sys/byteorder.h>
44 #include <sys/scsi/impl/uscsi.h>
45 #include <sys/scsi/scsi.h>
46 #include <tlm.h>
47 #include <pthread.h>
48 #include "tlm_proto.h"
49 
50 /*
51  * generic routine to read a SCSI page
52  */
53 int
54 read_scsi_page(scsi_link_t *slink, union scsi_cdb *cdb,
55     int command_size, caddr_t data, int size)
56 {
57 	struct uscsi_cmd uscsi_cmd;
58 	char *dname;
59 	int dev;
60 
61 	if (slink == 0 || slink->sl_sa == 0)
62 		return (EINVAL);
63 
64 	(void) memset(&uscsi_cmd, 0, sizeof (uscsi_cmd));
65 
66 	/* Lun is in the 5th bit */
67 	cdb->scc_lun = slink->sl_lun;
68 	uscsi_cmd.uscsi_flags |= USCSI_READ | USCSI_ISOLATE;
69 	uscsi_cmd.uscsi_bufaddr = data;
70 	uscsi_cmd.uscsi_buflen = size;
71 	uscsi_cmd.uscsi_timeout = 1000;
72 	uscsi_cmd.uscsi_cdb = (char *)cdb;
73 
74 	if (cdb->scc_cmd == SCMD_READ_ELEMENT_STATUS) {
75 		uscsi_cmd.uscsi_flags |= USCSI_RQENABLE;
76 		uscsi_cmd.uscsi_rqbuf = data;
77 		uscsi_cmd.uscsi_rqlen = size;
78 	}
79 	uscsi_cmd.uscsi_cdblen = command_size;
80 
81 	dname = sasd_slink_name(slink);
82 	dev = open(dname, O_RDWR | O_NDELAY);
83 	if (dev == -1) {
84 		NDMP_LOG(LOG_DEBUG, "Open failed for %s err=%d",
85 		    dname, errno);
86 		return (errno);
87 	}
88 	if (tlm_ioctl(dev, USCSICMD, &uscsi_cmd) < 0) {
89 		NDMP_LOG(LOG_DEBUG, "SCSI cmd %d failed for %s err=%d",
90 		    cdb->scc_cmd, dname, errno);
91 		(void) close(dev);
92 		return (errno);
93 	}
94 	(void) close(dev);
95 	return (uscsi_cmd.uscsi_status);
96 }
97 
98 /*
99  * Read the Inquiry Page.
100  */
101 static int
102 read_inquiry_page(scsi_link_t *slink, struct scsi_inquiry *inq)
103 {
104 	union scsi_cdb cdb;
105 
106 	(void) memset(&cdb, 0, sizeof (union scsi_cdb));
107 	cdb.scc_cmd = SCMD_INQUIRY;
108 	cdb.g0_count0 = sizeof (struct scsi_inquiry);
109 
110 	return (read_scsi_page(slink, &cdb, CDB_GROUP0,
111 	    (caddr_t)inq, sizeof (*inq)) ? -1 : 0);
112 }
113 
114 /*
115  * Read the Product Data Page.
116  */
117 static int
118 read_data_page(scsi_link_t *slink, int pcode, char *snum, int size)
119 {
120 	char cmd[CDB_GROUP0];
121 
122 	(void) memset(cmd, 0, sizeof (cmd));
123 
124 	cmd[0] = SCMD_INQUIRY;
125 	cmd[1] = pcode ? 0x01 : 0x00;
126 	cmd[2] = pcode;
127 	cmd[4] = size;
128 
129 	/* LINTED improper alignment */
130 	return (read_scsi_page(slink, (union scsi_cdb *)&cmd, CDB_GROUP0,
131 	    (caddr_t)snum, size) == -1 ? -1 : 0);
132 }
133 
134 
135 /*
136  * Read the Serial Number Page.
137  */
138 static int
139 read_serial_num_page(scsi_link_t *slink, char *snum, int size)
140 {
141 	scsi_serial_t serial;
142 	int rv;
143 
144 	(void) memset(&serial, 0, sizeof (scsi_serial_t));
145 	rv = read_data_page(slink, SCSI_SERIAL_PAGE, (caddr_t)&serial,
146 	    sizeof (scsi_serial_t));
147 	(void) strlcpy(snum, serial.sr_num, size);
148 
149 	return (rv == -1 ? -1 : 0);
150 }
151 
152 
153 /*
154  * Read the Device Name Page.
155  */
156 static int
157 read_dev_name_page(scsi_link_t *slink, device_ident_header_t *devp, int len)
158 {
159 	(void) memset(devp, 0, len);
160 
161 	if (read_data_page(slink, SCSI_DEVICE_IDENT_PAGE, (caddr_t)devp,
162 	    len) == -1)
163 		return (-1);
164 
165 	if (devp->di_page_code != SCSI_DEVICE_IDENT_PAGE)
166 		return (-1);
167 
168 	return (0);
169 }
170 
171 /*
172  * Formatted print of WWN
173  */
174 static void
175 snprintf_wwn(char *buf, int size, uint8_t *wwn)
176 {
177 	if (wwn == NULL || buf == NULL)
178 		return;
179 
180 	(void) snprintf(buf, size, "0x%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X",
181 	    wwn[0], wwn[1], wwn[2], wwn[3], wwn[4], wwn[5], wwn[6], wwn[7]);
182 }
183 
184 
185 /*
186  * Extract and print the world wide name (WWN)
187  */
188 int
189 read_device_wwn(scsi_link_t *slink, char *wwnp, int wsize)
190 {
191 	device_ident_header_t *header;
192 	name_ident_t *ident;
193 	uint16_t page_len = sizeof (device_ident_header_t);
194 	uint16_t act_len;
195 	int accessed;
196 	uint8_t *designator_data;
197 
198 	(void) memset(wwnp, 0, wsize);
199 resize:
200 	header = malloc(page_len);
201 	if (header == NULL)
202 		return (-1);
203 
204 	if (read_dev_name_page(slink, header, page_len) == -1) {
205 		free(header);
206 		return (-1);
207 	}
208 
209 	act_len = BE_16(header->di_page_length);
210 	if (act_len > page_len) {
211 		free(header);
212 		page_len = act_len;
213 		goto resize;
214 	}
215 
216 	ident = (name_ident_t *)&header[1];
217 	accessed = sizeof (device_ident_header_t);
218 
219 	while (accessed < act_len) {
220 
221 		accessed += sizeof (name_ident_t);
222 		accessed += ident->ni_ident_length;
223 		designator_data = (uint8_t *)&ident[1];
224 		/*
225 		 * Looking for code set 1 (Binary) ident type NAA 64 bit
226 		 * address that is associated with the node (0).
227 		 */
228 		if ((ident->ni_code_set == 1) &&
229 		    (ident->ni_ident_type == 3)) {
230 			snprintf_wwn(wwnp, wsize, designator_data);
231 			/*
232 			 * If assc is zero (Node) this is the one we want.
233 			 * If we find that we're done.
234 			 */
235 			if (ident->ni_asso == 0)
236 				break;
237 		}
238 		/*
239 		 * If we find a EUI-64 we can use that also.
240 		 */
241 		if ((ident->ni_code_set == 2) &&
242 		    (ident->ni_ident_type == 1) &&
243 		    (ident->ni_asso == 0) &&
244 		    (isprint(wwnp[0] == 0))) { /* Don't overwrite */
245 			/*
246 			 * This isn't our first choice but we'll print it
247 			 * in case there is nothing else to use.
248 			 */
249 			(void) snprintf(wwnp, wsize, "%.*s",
250 			    ident->ni_ident_length, designator_data);
251 		}
252 		ident =
253 		    (name_ident_t *)&designator_data[ident->ni_ident_length];
254 	}
255 	free(header);
256 	/*
257 	 * See if we found something.
258 	 * Memset above would leave wwnp not printable.
259 	 */
260 	if (isprint(wwnp[0]))
261 		return (0);
262 	return (-1);
263 }
264 
265 /*
266  * Add the tape library call back function (used while scanning the bus)
267  */
268 static int
269 add_lib(scsi_link_t *slink, struct scsi_inquiry *sd, void *arg)
270 {
271 	int l;
272 	int *nlp; /* pointer to library counter */
273 	sasd_drive_t *ssd;
274 
275 	if (!slink || !sd) {
276 		NDMP_LOG(LOG_DEBUG, "Invalid argument %x %x %x",
277 		    slink, sd, arg);
278 		return (-TLM_INVALID);
279 	}
280 
281 	if (sd->inq_dtype == DTYPE_CHANGER) {
282 		/* This is a robot, which means this is also a library */
283 		nlp = (int *)arg;
284 		(*nlp)++;
285 		l = tlm_insert_new_library(slink);
286 		tlm_enable_barcode(l);
287 
288 		NDMP_LOG(LOG_DEBUG, "lib %d sid %d lun %d",
289 		    l, slink->sl_sid, slink->sl_lun);
290 
291 		if ((ssd = sasd_slink_drive(slink)) != NULL) {
292 			(void) strlcpy(ssd->sd_vendor, sd->inq_vid,
293 			    sizeof (ssd->sd_vendor));
294 			(void) strlcpy(ssd->sd_id, sd->inq_pid,
295 			    sizeof (ssd->sd_id));
296 			(void) strlcpy(ssd->sd_rev, sd->inq_revision,
297 			    sizeof (ssd->sd_rev));
298 			(void) read_serial_num_page(slink, ssd->sd_serial,
299 			    sizeof (ssd->sd_serial));
300 			(void) read_device_wwn(slink, ssd->sd_wwn,
301 			    sizeof (ssd->sd_wwn));
302 		}
303 	}
304 
305 	return (TLM_NO_ERRORS);
306 }
307 
308 /*
309  * Create some virutal slots
310  */
311 static int
312 make_virtual_slot(int l, tlm_drive_t *dp)
313 {
314 	int s;
315 	tlm_slot_t *sp;
316 
317 	if (l <= 0 || !dp) {
318 		NDMP_LOG(LOG_DEBUG, "Invalid argument %d, %x", l, dp);
319 		return (-TLM_INVALID);
320 	}
321 
322 	if ((s = tlm_insert_new_slot(l)) <= 0)
323 		return (-TLM_NO_MEMORY);
324 
325 	if (!(sp = tlm_slot(l, s))) {
326 		NDMP_LOG(LOG_DEBUG, "Internal error: slot not found %d", s);
327 		return (-TLM_ERROR_INTERNAL);
328 	}
329 	/*
330 	 * For virtual slots element number is 0 and they are always full.
331 	 */
332 	sp->ts_element = 0;
333 	sp->ts_status_full = TRUE;
334 	return (TLM_NO_ERRORS);
335 }
336 
337 /*
338  * Make the tape drive not part of a tape library (stand alone)
339  */
340 static int
341 make_stand_alone_drive(scsi_link_t *slink, int l)
342 {
343 	int d;
344 	tlm_drive_t *dp;
345 
346 	if (!slink || l <= 0) {
347 		NDMP_LOG(LOG_DEBUG, "Invalid argument %x %d", slink, l);
348 		return (-TLM_INVALID);
349 	}
350 
351 	d = tlm_insert_new_drive(l);
352 	if (!(dp = tlm_drive(l, d))) {
353 		NDMP_LOG(LOG_DEBUG, "Internal error: drive not found %d", d);
354 		return (-TLM_ERROR_INTERNAL);
355 	}
356 
357 	/* For stand-alone drives, the element number is the drive number. */
358 	dp->td_element = d;
359 	dp->td_slink = slink;
360 	dp->td_scsi_id = slink->sl_sid;
361 	dp->td_lun = slink->sl_lun;
362 	dp->td_exists = TRUE;
363 
364 	/*
365 	 * Note: There is no way to remove library elements.  We cannot clean
366 	 * up if make_virtual_slot() fails.
367 	 */
368 	(void) make_virtual_slot(l, dp);
369 	return (d);
370 }
371 
372 /*
373  * Find the LIBRARY structure that has control of this DRIVE.
374  */
375 static int
376 new_drive(scsi_link_t *slink, int *lib)
377 {
378 	int d;
379 	tlm_drive_t *dp;
380 	tlm_library_t *lp;
381 
382 	/* Walk through all libraries. */
383 	for (*lib = 1; *lib <= tlm_library_count(); (*lib)++) {
384 		if (!(lp = tlm_library(*lib)))
385 			continue;
386 		/* Walk through drives that are already found. */
387 		for (d = 1; d <= lp->tl_drive_count; d++) {
388 			if (!(dp = tlm_drive(*lib, d)))
389 				continue;
390 			if (dp->td_scsi_id == slink->sl_sid &&
391 			    dp->td_lun == slink->sl_lun)
392 				return (d);
393 		}
394 	}
395 
396 	/* Not part of any library, this is a newly found tape drive. */
397 	return (0);
398 }
399 
400 
401 /*
402  * Add the tape library call back function (used while scanning the bus)
403  */
404 static int
405 add_drv(scsi_link_t *slink, struct scsi_inquiry *sd, void *arg)
406 {
407 	int l, d;
408 	int *vlp; /* pointer to virtual library number */
409 	sasd_drive_t *ssd;
410 	tlm_library_t *library;
411 	tlm_drive_t *drive;
412 
413 	if (!slink || !sd) {
414 		NDMP_LOG(LOG_DEBUG, "Invalid argument %x %x %x",
415 		    slink, sd, arg);
416 		return (-TLM_INVALID);
417 	}
418 
419 	if (sd->inq_dtype == DTYPE_SEQUENTIAL) {
420 		vlp = (int *)arg;
421 		d = new_drive(slink, &l);
422 		if (d == 0) {
423 			/* This tape drive was not found inside any robot. */
424 			if (*vlp == 0) {
425 				/*
426 				 * First, create a virtual library if it's not
427 				 * done yet.
428 				 */
429 				*vlp = tlm_insert_new_library(slink);
430 				if ((library = tlm_library(*vlp)) != NULL)
431 					library->tl_capability_robot = FALSE;
432 			}
433 			if ((d = make_stand_alone_drive(slink, *vlp)) < 0) {
434 				/* sorry, we can not clean up the vlib now * */
435 				return (-TLM_INVALID);
436 			}
437 			l = *vlp;
438 			NDMP_LOG(LOG_DEBUG, "vlib(%d, %d) sid %d lun %d",
439 			    l, d, slink->sl_sid, slink->sl_lun);
440 		} else
441 			NDMP_LOG(LOG_DEBUG, "(%d, %d) sid %d lun %d",
442 			    l, d, slink->sl_sid, slink->sl_lun);
443 
444 		if ((drive = tlm_drive(l, d)) != NULL) {
445 			drive->td_exists = TRUE;
446 			drive->td_slink = slink;
447 		}
448 		if ((ssd = sasd_slink_drive(slink)) != NULL) {
449 			(void) strlcpy(ssd->sd_vendor,
450 			    sd->inq_vid, sizeof (ssd->sd_vendor));
451 			(void) strlcpy(ssd->sd_id, sd->inq_pid,
452 			    sizeof (ssd->sd_id));
453 			(void) strlcpy(ssd->sd_rev, sd->inq_revision,
454 			    sizeof (ssd->sd_rev));
455 			(void) read_serial_num_page(slink, ssd->sd_serial,
456 			    sizeof (ssd->sd_serial));
457 			(void) read_device_wwn(slink, ssd->sd_wwn,
458 			    sizeof (ssd->sd_wwn));
459 		}
460 	}
461 
462 	return (TLM_NO_ERRORS);
463 }
464 
465 /*
466  * Scan the specified bus and call the handler function.
467  */
468 static int
469 scan_bus(scsi_adapter_t *sa, int(*hndlr)(), void *args)
470 {
471 	int nerr;
472 	scsi_link_t *slink;
473 	struct scsi_inquiry scsi_data;
474 
475 	nerr = 0;
476 	slink = sa->sa_link_head.sl_next;
477 	for (; slink != &sa->sa_link_head; slink = slink->sl_next) {
478 		(void) memset(&scsi_data, 0, sizeof (struct scsi_inquiry));
479 		if (read_inquiry_page(slink, &scsi_data) == -1)
480 			nerr++;
481 		else
482 			if ((*hndlr)(slink, &scsi_data, args) != TLM_NO_ERRORS)
483 				nerr++;
484 	}
485 
486 	return (nerr);
487 }
488 
489 /*
490  * Marks the library/slots inaccessible if there are not enough drives
491  * available on the library
492  */
493 static void
494 inaccbl_drv_warn(int start, int max)
495 {
496 	char *dname;
497 	int l, d;
498 	tlm_library_t *lp;
499 
500 	for (l = start; l < max; l++) {
501 		if (!(lp = tlm_library(l)))
502 			continue;
503 		if (lp->tl_drive_count <= 0)
504 			continue;
505 
506 		NDMP_LOG(LOG_DEBUG,
507 		    "Warning: The following drives are not accessible:");
508 		for (d = 1; d <= lp->tl_drive_count; d++)
509 			if (!(dname = tlm_get_tape_name(l, d))) {
510 				NDMP_LOG(LOG_DEBUG,
511 				    "Error getting drive(%d, %d)", l, d);
512 			} else
513 				NDMP_LOG(LOG_DEBUG, "%s", dname);
514 
515 		/*
516 		 * Note: Make the slots inaccessible to prevent running
517 		 * discovery on these libraries.  The better idea is
518 		 * removing these libraries, but we don't have that
519 		 * feature available now.
520 		 */
521 		lp->tl_slot_count = 0;
522 	}
523 }
524 
525 /*
526  * Initialize the tape library data structure, asks the libraries what
527  * equipments they have.
528  */
529 int
530 tlm_init(void)
531 {
532 	static int nlibs; /* number of found libraries */
533 	int i, nsa;
534 	int l, vlibs, d;
535 	int rv;
536 	scsi_adapter_t *sa;
537 	tlm_library_t *lp;
538 	tlm_drive_t *dp;
539 
540 	/* Search through all SCSI adapters, look for tape robots. */
541 	nlibs = 0;
542 
543 	/*
544 	 * We probe both changers and tape drives here
545 	 * but later on this needs to be removed as the
546 	 * probe will happen somewhere else.
547 	 */
548 	if (probe_scsi() < 0)
549 		return (-1);
550 
551 	nsa = scsi_get_adapter_count();
552 	for (i = 0; i < nsa; i++)
553 		if ((sa = scsi_get_adapter(i)))
554 			(void) scan_bus(sa, add_lib, (void *)&nlibs);
555 
556 	NDMP_LOG(LOG_DEBUG, "nlibs %d", nlibs);
557 
558 	/* Search through all SCSI adapters, look for tape drives. */
559 	vlibs = 0;
560 	for (i = 0; i < nsa; i++)
561 		if ((sa = scsi_get_adapter(i)))
562 			(void) scan_bus(sa, add_drv, (void *)&vlibs);
563 
564 	NDMP_LOG(LOG_DEBUG, "vlibs %d", vlibs);
565 
566 	if (nlibs > 0 && vlibs > 0)
567 		inaccbl_drv_warn(nlibs + 1, vlibs + nlibs + 1);
568 
569 	for (l = 1; l <= tlm_library_count(); l++) {
570 		if (!(lp = tlm_library(l))) {
571 			NDMP_LOG(LOG_DEBUG, "can't find lib %d", l);
572 			continue;
573 		}
574 
575 		/*
576 		 * Make sure all libraries have tape drives.
577 		 */
578 		if (lp->tl_drive_count == 0)
579 			continue;
580 
581 		/*
582 		 * Make sure all tape drives exist. A drive that is not
583 		 * linked into the SCSI chain will be seen by the library
584 		 * but we cannot talk to it.
585 		 */
586 		for (d = 1; d <= lp->tl_drive_count; d++) {
587 			dp = tlm_drive(l, d);
588 			if (dp && !dp->td_exists) {
589 				NDMP_LOG(LOG_DEBUG, "Ghost drive found %d.%d",
590 				    l, d);
591 				lp->tl_ghost_drives = TRUE;
592 				continue;
593 			}
594 		}
595 	}
596 
597 	if (nlibs > 0)
598 		rv = (vlibs > 0) ? 0 : nlibs;
599 	else
600 		rv = vlibs;
601 
602 	return (rv);
603 }
604