xref: /freebsd/lib/libcam/camlib.c (revision b1b73fc4c9924c4ca2f94b76155a0895373a0b5c)
1  /*
2   * Copyright (c) 1997, 1998, 1999, 2002 Kenneth D. Merry.
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   * 2. The name of the author may not be used to endorse or promote products
11   *    derived from this software without specific prior written permission.
12   *
13   * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
14   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16   * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
17   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19   * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
21   * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22   * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
23   * SUCH DAMAGE.
24   */
25  
26  #include <sys/cdefs.h>
27  __FBSDID("$FreeBSD$");
28  
29  #include <sys/types.h>
30  #include <sys/param.h>
31  #include <stdio.h>
32  #include <stdlib.h>
33  #include <stdint.h>
34  #include <string.h>
35  #include <fcntl.h>
36  #include <unistd.h>
37  #include <errno.h>
38  #include <ctype.h>
39  
40  #include <cam/cam.h>
41  #include <cam/scsi/scsi_all.h>
42  #include <cam/cam_ccb.h>
43  #include <cam/scsi/scsi_pass.h>
44  #include "camlib.h"
45  
46  
47  static const char *nonrewind_devs[] = {
48  	"sa"
49  };
50  
51  char cam_errbuf[CAM_ERRBUF_SIZE];
52  
53  static struct cam_device *cam_real_open_device(const char *path, int flags,
54  					       struct cam_device *device,
55  					       const char *given_path,
56  					       const char *given_dev_name,
57  					       int given_unit_number);
58  static struct cam_device *cam_lookup_pass(const char *dev_name, int unit,
59  					  int flags, const char *given_path,
60  					  struct cam_device *device);
61  
62  /*
63   * Send a ccb to a passthrough device.
64   */
65  int
66  cam_send_ccb(struct cam_device *device, union ccb *ccb)
67  {
68  	return(ioctl(device->fd, CAMIOCOMMAND, ccb));
69  }
70  
71  /*
72   * Malloc a CCB, zero out the header and set its path, target and lun ids.
73   */
74  union ccb *
75  cam_getccb(struct cam_device *dev)
76  {
77  	union ccb *ccb;
78  
79  	ccb = (union ccb *)malloc(sizeof(union ccb));
80  	if (ccb != NULL) {
81  		bzero(&ccb->ccb_h, sizeof(struct ccb_hdr));
82  		ccb->ccb_h.path_id = dev->path_id;
83  		ccb->ccb_h.target_id = dev->target_id;
84  		ccb->ccb_h.target_lun = dev->target_lun;
85  	}
86  
87  	return(ccb);
88  }
89  
90  /*
91   * Free a CCB.
92   */
93  void
94  cam_freeccb(union ccb *ccb)
95  {
96  	free(ccb);
97  }
98  
99  /*
100   * Take a device name or path passed in by the user, and attempt to figure
101   * out the device name and unit number.  Some possible device name formats are:
102   * /dev/foo0
103   * foo0
104   * nfoo0
105   *
106   * Some peripheral drivers create separate device nodes with 'n' prefix for
107   * non-rewind operations.  Currently only sa(4) tape driver has this feature.
108   * We extract pure peripheral name as device name for this special case.
109   *
110   * Input parameters:  device name/path, length of devname string
111   * Output:            device name, unit number
112   * Return values:     returns 0 for success, -1 for failure
113   */
114  int
115  cam_get_device(const char *path, char *dev_name, int devnamelen, int *unit)
116  {
117  	char *func_name = "cam_get_device";
118  	char *tmpstr, *tmpstr2;
119  	char *newpath;
120  	int unit_offset;
121  	int i;
122  
123  
124  	if (path == NULL) {
125  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
126  			 "%s: device pathname was NULL", func_name);
127  		return(-1);
128  	}
129  
130  	/*
131  	 * We can be rather destructive to the path string.  Make a copy of
132  	 * it so we don't hose the user's string.
133  	 */
134  	newpath = (char *)strdup(path);
135  	tmpstr = newpath;
136  
137  	/*
138  	 * Check to see whether we have an absolute pathname.
139  	 */
140  	if (*tmpstr == '/') {
141  		tmpstr2 = tmpstr;
142  		tmpstr = strrchr(tmpstr2, '/');
143  		if ((tmpstr != NULL) && (*tmpstr != '\0'))
144  			tmpstr++;
145  	}
146  
147  	if (*tmpstr == '\0') {
148  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
149  			 "%s: no text after slash", func_name);
150  		free(newpath);
151  		return(-1);
152  	}
153  
154  	/*
155  	 * Check to see whether the user has given us a nonrewound tape
156  	 * device.
157  	 */
158  	if (*tmpstr == 'n' || *tmpstr == 'e') {
159  		for (i = 0; i < sizeof(nonrewind_devs)/sizeof(char *); i++) {
160  			int len = strlen(nonrewind_devs[i]);
161  			if (strncmp(tmpstr + 1, nonrewind_devs[i], len) == 0) {
162  				if (isdigit(tmpstr[len + 1])) {
163  					tmpstr++;
164  					break;
165  				}
166  			}
167  		}
168  	}
169  
170  	/*
171  	 * We should now have just a device name and unit number.
172  	 * That means that there must be at least 2 characters.
173  	 * If we only have 1, we don't have a valid device name.
174  	 */
175  	if (strlen(tmpstr) < 2) {
176  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
177  			 "%s: must have both device name and unit number",
178  			 func_name);
179  		free(newpath);
180  		return(-1);
181  	}
182  
183  	/*
184  	 * If the first character of the string is a digit, then the user
185  	 * has probably given us all numbers.  Point out the error.
186  	 */
187  	if (isdigit(*tmpstr)) {
188  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
189  			 "%s: device name cannot begin with a number",
190  			 func_name);
191  		free(newpath);
192  		return(-1);
193  	}
194  
195  	/*
196  	 * At this point, if the last character of the string isn't a
197  	 * number, we know the user either didn't give us a device number,
198  	 * or he gave us a device name/number format we don't recognize.
199  	 */
200  	if (!isdigit(tmpstr[strlen(tmpstr) - 1])) {
201  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
202  			 "%s: unable to find device unit number", func_name);
203  		free(newpath);
204  		return(-1);
205  	}
206  
207  	/*
208  	 * Attempt to figure out where the device name ends and the unit
209  	 * number begins.  As long as unit_offset is at least 1 less than
210  	 * the length of the string, we can still potentially have a device
211  	 * name at the front of the string.  When we get to something that
212  	 * isn't a digit, we've hit the device name.  Because of the check
213  	 * above, we know that this cannot happen when unit_offset == 1.
214  	 * Therefore it is okay to decrement unit_offset -- it won't cause
215  	 * us to go past the end of the character array.
216  	 */
217  	for (unit_offset = 1;
218  	    (unit_offset < (strlen(tmpstr)))
219  	    && (isdigit(tmpstr[strlen(tmpstr) - unit_offset])); unit_offset++);
220  
221  	unit_offset--;
222  
223  	/*
224  	 * Grab the unit number.
225  	 */
226  	*unit = atoi(&tmpstr[strlen(tmpstr) - unit_offset]);
227  
228  	/*
229  	 * Put a null in place of the first number of the unit number so
230  	 * that all we have left is the device name.
231  	 */
232  	tmpstr[strlen(tmpstr) - unit_offset] = '\0';
233  
234  	strlcpy(dev_name, tmpstr, devnamelen);
235  
236  	/* Clean up allocated memory */
237  	free(newpath);
238  
239  	return(0);
240  
241  }
242  
243  /*
244   * Backwards compatible wrapper for the real open routine.  This translates
245   * a pathname into a device name and unit number for use with the real open
246   * routine.
247   */
248  struct cam_device *
249  cam_open_device(const char *path, int flags)
250  {
251  	int unit;
252  	char dev_name[DEV_IDLEN + 1];
253  
254  	/*
255  	 * cam_get_device() has already put an error message in cam_errbuf,
256  	 * so we don't need to.
257  	 */
258  	if (cam_get_device(path, dev_name, sizeof(dev_name), &unit) == -1)
259  		return(NULL);
260  
261  	return(cam_lookup_pass(dev_name, unit, flags, path, NULL));
262  }
263  
264  /*
265   * Open the passthrough device for a given bus, target and lun, if the
266   * passthrough device exists.
267   */
268  struct cam_device *
269  cam_open_btl(path_id_t path_id, target_id_t target_id, lun_id_t target_lun,
270  	     int flags, struct cam_device *device)
271  {
272  	union ccb ccb;
273  	struct periph_match_pattern *match_pat;
274  	char *func_name = "cam_open_btl";
275  	int fd, bufsize;
276  
277  	if ((fd = open(XPT_DEVICE, O_RDWR)) < 0) {
278  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
279  			 "%s: couldn't open %s\n%s: %s", func_name, XPT_DEVICE,
280  			 func_name, strerror(errno));
281  		return(NULL);
282  	}
283  
284  	bzero(&ccb, sizeof(union ccb));
285  	ccb.ccb_h.func_code = XPT_DEV_MATCH;
286  	ccb.ccb_h.path_id = CAM_XPT_PATH_ID;
287  	ccb.ccb_h.target_id = CAM_TARGET_WILDCARD;
288  	ccb.ccb_h.target_lun = CAM_LUN_WILDCARD;
289  
290  	/* Setup the result buffer */
291  	bufsize = sizeof(struct dev_match_result);
292  	ccb.cdm.match_buf_len = bufsize;
293  	ccb.cdm.matches = (struct dev_match_result *)malloc(bufsize);
294  	if (ccb.cdm.matches == NULL) {
295  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
296  			 "%s: couldn't malloc match buffer", func_name);
297  		close(fd);
298  		return(NULL);
299  	}
300  	ccb.cdm.num_matches = 0;
301  
302  	/* Setup the pattern buffer */
303  	ccb.cdm.num_patterns = 1;
304  	ccb.cdm.pattern_buf_len = sizeof(struct dev_match_pattern);
305  	ccb.cdm.patterns = (struct dev_match_pattern *)malloc(
306  		sizeof(struct dev_match_pattern));
307  	if (ccb.cdm.patterns == NULL) {
308  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
309  			 "%s: couldn't malloc pattern buffer", func_name);
310  		free(ccb.cdm.matches);
311  		close(fd);
312  		return(NULL);
313  	}
314  	ccb.cdm.patterns[0].type = DEV_MATCH_PERIPH;
315  	match_pat = &ccb.cdm.patterns[0].pattern.periph_pattern;
316  
317  	/*
318  	 * We're looking for the passthrough device associated with this
319  	 * particular bus/target/lun.
320  	 */
321  	sprintf(match_pat->periph_name, "pass");
322  	match_pat->path_id = path_id;
323  	match_pat->target_id = target_id;
324  	match_pat->target_lun = target_lun;
325  	/* Now set the flags to indicate what we're looking for. */
326  	match_pat->flags = PERIPH_MATCH_PATH | PERIPH_MATCH_TARGET |
327  			   PERIPH_MATCH_LUN | PERIPH_MATCH_NAME;
328  
329  	if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
330  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
331  			 "%s: CAMIOCOMMAND ioctl failed\n"
332  			 "%s: %s", func_name, func_name, strerror(errno));
333  		goto btl_bailout;
334  	}
335  
336  	/*
337  	 * Check for an outright error.
338  	 */
339  	if ((ccb.ccb_h.status != CAM_REQ_CMP)
340  	 || ((ccb.cdm.status != CAM_DEV_MATCH_LAST)
341  	   && (ccb.cdm.status != CAM_DEV_MATCH_MORE))) {
342  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
343  			 "%s: CAM error %#x, CDM error %d "
344  			 "returned from XPT_DEV_MATCH ccb", func_name,
345  			 ccb.ccb_h.status, ccb.cdm.status);
346  		goto btl_bailout;
347  	}
348  
349  	if (ccb.cdm.status == CAM_DEV_MATCH_MORE) {
350  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
351  			 "%s: CDM reported more than one"
352  			 " passthrough device at %d:%d:%jx!!\n",
353  			 func_name, path_id, target_id, (uintmax_t)target_lun);
354  		goto btl_bailout;
355  	}
356  
357  	if (ccb.cdm.num_matches == 0) {
358  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
359  			 "%s: no passthrough device found at"
360  			 " %d:%d:%jx", func_name, path_id, target_id,
361  			 (uintmax_t)target_lun);
362  		goto btl_bailout;
363  	}
364  
365  	switch(ccb.cdm.matches[0].type) {
366  	case DEV_MATCH_PERIPH: {
367  		int pass_unit;
368  		char dev_path[256];
369  		struct periph_match_result *periph_result;
370  
371  		periph_result = &ccb.cdm.matches[0].result.periph_result;
372  		pass_unit = periph_result->unit_number;
373  		free(ccb.cdm.matches);
374  		free(ccb.cdm.patterns);
375  		close(fd);
376  		sprintf(dev_path, "/dev/pass%d", pass_unit);
377  		return(cam_real_open_device(dev_path, flags, device, NULL,
378  					    NULL, 0));
379  		break; /* NOTREACHED */
380  	}
381  	default:
382  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
383  			 "%s: asked for a peripheral match, but"
384  			 " got a bus or device match", func_name);
385  		goto btl_bailout;
386  		break; /* NOTREACHED */
387  	}
388  
389  btl_bailout:
390  	free(ccb.cdm.matches);
391  	free(ccb.cdm.patterns);
392  	close(fd);
393  	return(NULL);
394  }
395  
396  struct cam_device *
397  cam_open_spec_device(const char *dev_name, int unit, int flags,
398  		     struct cam_device *device)
399  {
400  	return(cam_lookup_pass(dev_name, unit, flags, NULL, device));
401  }
402  
403  struct cam_device *
404  cam_open_pass(const char *path, int flags, struct cam_device *device)
405  {
406  	return(cam_real_open_device(path, flags, device, path, NULL, 0));
407  }
408  
409  static struct cam_device *
410  cam_lookup_pass(const char *dev_name, int unit, int flags,
411  		const char *given_path, struct cam_device *device)
412  {
413  	int fd;
414  	union ccb ccb;
415  	char dev_path[256];
416  	char *func_name = "cam_lookup_pass";
417  
418  	/*
419  	 * The flags argument above only applies to the actual passthrough
420  	 * device open, not our open of the given device to find the
421  	 * passthrough device.
422  	 */
423  	if ((fd = open(XPT_DEVICE, O_RDWR)) < 0) {
424  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
425  			 "%s: couldn't open %s\n%s: %s", func_name, XPT_DEVICE,
426  			 func_name, strerror(errno));
427  		return(NULL);
428  	}
429  
430  	/* This isn't strictly necessary for the GETPASSTHRU ioctl. */
431  	ccb.ccb_h.func_code = XPT_GDEVLIST;
432  
433  	/* These two are necessary for the GETPASSTHRU ioctl to work. */
434  	strlcpy(ccb.cgdl.periph_name, dev_name, sizeof(ccb.cgdl.periph_name));
435  	ccb.cgdl.unit_number = unit;
436  
437  	/*
438  	 * Attempt to get the passthrough device.  This ioctl will fail if
439  	 * the device name is null, if the device doesn't exist, or if the
440  	 * passthrough driver isn't in the kernel.
441  	 */
442  	if (ioctl(fd, CAMGETPASSTHRU, &ccb) == -1) {
443  		char tmpstr[256];
444  
445  		/*
446  		 * If we get ENOENT from the transport layer version of
447  		 * the CAMGETPASSTHRU ioctl, it means one of two things:
448  		 * either the device name/unit number passed in doesn't
449  		 * exist, or the passthrough driver isn't in the kernel.
450  		 */
451  		if (errno == ENOENT) {
452  			snprintf(tmpstr, sizeof(tmpstr),
453  				 "\n%s: either the pass driver isn't in "
454  				 "your kernel\n%s: or %s%d doesn't exist",
455  				 func_name, func_name, dev_name, unit);
456  		}
457  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
458  			 "%s: CAMGETPASSTHRU ioctl failed\n"
459  			 "%s: %s%s", func_name, func_name, strerror(errno),
460  			 (errno == ENOENT) ? tmpstr : "");
461  
462  		close(fd);
463  		return(NULL);
464  	}
465  
466  	close(fd);
467  
468  	/*
469  	 * If the ioctl returned the right status, but we got an error back
470  	 * in the ccb, that means that the kernel found the device the user
471  	 * passed in, but was unable to find the passthrough device for
472  	 * the device the user gave us.
473  	 */
474  	if (ccb.cgdl.status == CAM_GDEVLIST_ERROR) {
475  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
476  			 "%s: device %s%d does not exist!",
477  			 func_name, dev_name, unit);
478  		return(NULL);
479  	}
480  
481  	sprintf(dev_path, "/dev/%s%d", ccb.cgdl.periph_name,
482  		ccb.cgdl.unit_number);
483  
484  	return(cam_real_open_device(dev_path, flags, device, NULL,
485  				    dev_name, unit));
486  }
487  
488  /*
489   * Open a given device.  The path argument isn't strictly necessary, but it
490   * is copied into the cam_device structure as a convenience to the user.
491   */
492  static struct cam_device *
493  cam_real_open_device(const char *path, int flags, struct cam_device *device,
494  		     const char *given_path, const char *given_dev_name,
495  		     int given_unit_number)
496  {
497  	char *func_name = "cam_real_open_device";
498  	union ccb ccb;
499  	int fd = -1, malloced_device = 0;
500  
501  	/*
502  	 * See if the user wants us to malloc a device for him.
503  	 */
504  	if (device == NULL) {
505  		if ((device = (struct cam_device *)malloc(
506  		     sizeof(struct cam_device))) == NULL) {
507  			snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
508  				 "%s: device structure malloc"
509  				 " failed\n%s: %s", func_name, func_name,
510  				 strerror(errno));
511  			return(NULL);
512  		}
513  		device->fd = -1;
514  		malloced_device = 1;
515  	}
516  
517  	/*
518  	 * If the user passed in a path, save it for him.
519  	 */
520  	if (given_path != NULL)
521  		strlcpy(device->device_path, given_path,
522  			sizeof(device->device_path));
523  	else
524  		device->device_path[0] = '\0';
525  
526  	/*
527  	 * If the user passed in a device name and unit number pair, save
528  	 * those as well.
529  	 */
530  	if (given_dev_name != NULL)
531  		strlcpy(device->given_dev_name, given_dev_name,
532  			sizeof(device->given_dev_name));
533  	else
534  		device->given_dev_name[0] = '\0';
535  	device->given_unit_number = given_unit_number;
536  
537  	if ((fd = open(path, flags)) < 0) {
538  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
539  			 "%s: couldn't open passthrough device %s\n"
540  			 "%s: %s", func_name, path, func_name,
541  			 strerror(errno));
542  		goto crod_bailout;
543  	}
544  
545  	device->fd = fd;
546  
547  	bzero(&ccb, sizeof(union ccb));
548  
549  	/*
550  	 * Unlike the transport layer version of the GETPASSTHRU ioctl,
551  	 * we don't have to set any fields.
552  	 */
553  	ccb.ccb_h.func_code = XPT_GDEVLIST;
554  
555  	/*
556  	 * We're only doing this to get some information on the device in
557  	 * question.  Otherwise, we'd have to pass in yet another
558  	 * parameter: the passthrough driver unit number.
559  	 */
560  	if (ioctl(fd, CAMGETPASSTHRU, &ccb) == -1) {
561  		/*
562  		 * At this point we know the passthrough device must exist
563  		 * because we just opened it above.  The only way this
564  		 * ioctl can fail is if the ccb size is wrong.
565  		 */
566  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
567  			 "%s: CAMGETPASSTHRU ioctl failed\n"
568  			 "%s: %s", func_name, func_name, strerror(errno));
569  		goto crod_bailout;
570  	}
571  
572  	/*
573  	 * If the ioctl returned the right status, but we got an error back
574  	 * in the ccb, that means that the kernel found the device the user
575  	 * passed in, but was unable to find the passthrough device for
576  	 * the device the user gave us.
577  	 */
578  	if (ccb.cgdl.status == CAM_GDEVLIST_ERROR) {
579  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
580  			 "%s: passthrough device does not exist!", func_name);
581  		goto crod_bailout;
582  	}
583  
584  	device->dev_unit_num = ccb.cgdl.unit_number;
585  	strlcpy(device->device_name, ccb.cgdl.periph_name,
586  		sizeof(device->device_name));
587  	device->path_id = ccb.ccb_h.path_id;
588  	device->target_id = ccb.ccb_h.target_id;
589  	device->target_lun = ccb.ccb_h.target_lun;
590  
591  	ccb.ccb_h.func_code = XPT_PATH_INQ;
592  	if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
593  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
594  			 "%s: Path Inquiry CCB failed\n"
595  			 "%s: %s", func_name, func_name, strerror(errno));
596  		goto crod_bailout;
597  	}
598  	strlcpy(device->sim_name, ccb.cpi.dev_name, sizeof(device->sim_name));
599  	device->sim_unit_number = ccb.cpi.unit_number;
600  	device->bus_id = ccb.cpi.bus_id;
601  
602  	/*
603  	 * It doesn't really matter what is in the payload for a getdev
604  	 * CCB, the kernel doesn't look at it.
605  	 */
606  	ccb.ccb_h.func_code = XPT_GDEV_TYPE;
607  	if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
608  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
609  			 "%s: Get Device Type CCB failed\n"
610  			 "%s: %s", func_name, func_name, strerror(errno));
611  		goto crod_bailout;
612  	}
613  	device->pd_type = SID_TYPE(&ccb.cgd.inq_data);
614  	bcopy(&ccb.cgd.inq_data, &device->inq_data,
615  	      sizeof(struct scsi_inquiry_data));
616  	device->serial_num_len = ccb.cgd.serial_num_len;
617  	bcopy(&ccb.cgd.serial_num, &device->serial_num, device->serial_num_len);
618  
619  	/*
620  	 * Zero the payload, the kernel does look at the flags.
621  	 */
622  	CCB_CLEAR_ALL_EXCEPT_HDR(&ccb.cts);
623  
624  	/*
625  	 * Get transfer settings for this device.
626  	 */
627  	ccb.ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
628  
629  	ccb.cts.type = CTS_TYPE_CURRENT_SETTINGS;
630  
631  	if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
632  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
633  			 "%s: Get Transfer Settings CCB failed\n"
634  			 "%s: %s", func_name, func_name, strerror(errno));
635  		goto crod_bailout;
636  	}
637  	if (ccb.cts.transport == XPORT_SPI) {
638  		struct ccb_trans_settings_spi *spi =
639  		    &ccb.cts.xport_specific.spi;
640  		device->sync_period = spi->sync_period;
641  		device->sync_offset = spi->sync_offset;
642  		device->bus_width = spi->bus_width;
643  	} else {
644  		device->sync_period = 0;
645  		device->sync_offset = 0;
646  		device->bus_width = 0;
647  	}
648  
649  	return(device);
650  
651  crod_bailout:
652  
653  	if (fd >= 0)
654  		close(fd);
655  
656  	if (malloced_device)
657  		free(device);
658  
659  	return(NULL);
660  }
661  
662  void
663  cam_close_device(struct cam_device *dev)
664  {
665  	if (dev == NULL)
666  		return;
667  
668  	cam_close_spec_device(dev);
669  
670  	free(dev);
671  }
672  
673  void
674  cam_close_spec_device(struct cam_device *dev)
675  {
676  	if (dev == NULL)
677  		return;
678  
679  	if (dev->fd >= 0) {
680  		close(dev->fd);
681  		dev->fd = -1;
682  	}
683  }
684  
685  char *
686  cam_path_string(struct cam_device *dev, char *str, int len)
687  {
688  	if (dev == NULL) {
689  		snprintf(str, len, "No path");
690  		return(str);
691  	}
692  
693  	snprintf(str, len, "(%s%d:%s%d:%d:%d:%jx): ",
694  		 (dev->device_name[0] != '\0') ? dev->device_name : "pass",
695  		 dev->dev_unit_num,
696  		 (dev->sim_name[0] != '\0') ? dev->sim_name : "unknown",
697  		 dev->sim_unit_number,
698  		 dev->bus_id,
699  		 dev->target_id,
700  		 (uintmax_t)dev->target_lun);
701  
702  	return(str);
703  }
704  
705  /*
706   * Malloc/duplicate a CAM device structure.
707   */
708  struct cam_device *
709  cam_device_dup(struct cam_device *device)
710  {
711  	char *func_name = "cam_device_dup";
712  	struct cam_device *newdev;
713  
714  	if (device == NULL) {
715  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
716  			 "%s: device is NULL", func_name);
717  		return(NULL);
718  	}
719  
720  	newdev = malloc(sizeof(struct cam_device));
721  	if (newdev == NULL) {
722  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
723  			"%s: couldn't malloc CAM device structure", func_name);
724  		return(NULL);
725  	}
726  
727  	bcopy(device, newdev, sizeof(struct cam_device));
728  
729  	return(newdev);
730  }
731  
732  /*
733   * Copy a CAM device structure.
734   */
735  void
736  cam_device_copy(struct cam_device *src, struct cam_device *dst)
737  {
738  	char *func_name = "cam_device_copy";
739  
740  	if (src == NULL) {
741  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
742  			 "%s: source device struct was NULL", func_name);
743  		return;
744  	}
745  
746  	if (dst == NULL) {
747  		snprintf(cam_errbuf, CAM_ERRBUF_SIZE,
748  			 "%s: destination device struct was NULL", func_name);
749  		return;
750  	}
751  
752  	bcopy(src, dst, sizeof(struct cam_device));
753  
754  }
755