1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2000 Matthew Jacob
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions, and the following disclaimer,
12 * without modification, immediately at the beginning of the file.
13 * 2. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
20 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 #include <sys/cdefs.h>
30 #include <sys/param.h>
31
32 #include <sys/conf.h>
33 #include <sys/errno.h>
34 #include <sys/fcntl.h>
35 #include <sys/kernel.h>
36 #include <sys/kthread.h>
37 #include <sys/lock.h>
38 #include <sys/malloc.h>
39 #include <sys/mutex.h>
40 #include <sys/proc.h>
41 #include <sys/queue.h>
42 #include <sys/sbuf.h>
43 #include <sys/sx.h>
44 #include <sys/sysent.h>
45 #include <sys/systm.h>
46 #include <sys/sysctl.h>
47 #include <sys/types.h>
48
49 #include <machine/stdarg.h>
50
51 #include <cam/cam.h>
52 #include <cam/cam_ccb.h>
53 #include <cam/cam_debug.h>
54 #include <cam/cam_periph.h>
55 #include <cam/cam_xpt_periph.h>
56
57 #include <cam/scsi/scsi_all.h>
58 #include <cam/scsi/scsi_message.h>
59 #include <cam/scsi/scsi_enc.h>
60 #include <cam/scsi/scsi_enc_internal.h>
61
62 #include "opt_ses.h"
63
64 MALLOC_DEFINE(M_SCSIENC, "SCSI ENC", "SCSI ENC buffers");
65
66 /* Enclosure type independent driver */
67
68 static d_open_t enc_open;
69 static d_close_t enc_close;
70 static d_ioctl_t enc_ioctl;
71 static periph_init_t enc_init;
72 static periph_ctor_t enc_ctor;
73 static periph_oninv_t enc_oninvalidate;
74 static periph_dtor_t enc_dtor;
75
76 static void enc_async(void *, uint32_t, struct cam_path *, void *);
77 static enctyp enc_type(struct ccb_getdev *);
78
79 SYSCTL_NODE(_kern_cam, OID_AUTO, enc, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
80 "CAM Enclosure Services driver");
81
82 #if defined(DEBUG) || defined(ENC_DEBUG)
83 int enc_verbose = 1;
84 #else
85 int enc_verbose = 0;
86 #endif
87 SYSCTL_INT(_kern_cam_enc, OID_AUTO, verbose, CTLFLAG_RWTUN,
88 &enc_verbose, 0, "Enable verbose logging");
89
90 const char *elm_type_names[] = ELM_TYPE_NAMES;
91 CTASSERT(nitems(elm_type_names) - 1 == ELMTYP_LAST);
92
93 static struct periph_driver encdriver = {
94 enc_init, "ses",
95 TAILQ_HEAD_INITIALIZER(encdriver.units), /* generation */ 0
96 };
97
98 PERIPHDRIVER_DECLARE(enc, encdriver);
99
100 static struct cdevsw enc_cdevsw = {
101 .d_version = D_VERSION,
102 .d_open = enc_open,
103 .d_close = enc_close,
104 .d_ioctl = enc_ioctl,
105 .d_name = "ses",
106 .d_flags = D_TRACKCLOSE,
107 };
108
109 static void
enc_init(void)110 enc_init(void)
111 {
112 cam_status status;
113
114 /*
115 * Install a global async callback. This callback will
116 * receive async callbacks like "new device found".
117 */
118 status = xpt_register_async(AC_FOUND_DEVICE, enc_async, NULL, NULL);
119
120 if (status != CAM_REQ_CMP) {
121 printf("enc: Failed to attach master async callback "
122 "due to status 0x%x!\n", status);
123 }
124 }
125
126 static void
enc_devgonecb(void * arg)127 enc_devgonecb(void *arg)
128 {
129 struct cam_periph *periph;
130 struct enc_softc *enc;
131 struct mtx *mtx;
132 int i;
133
134 periph = (struct cam_periph *)arg;
135 mtx = cam_periph_mtx(periph);
136 mtx_lock(mtx);
137 enc = (struct enc_softc *)periph->softc;
138
139 /*
140 * When we get this callback, we will get no more close calls from
141 * devfs. So if we have any dangling opens, we need to release the
142 * reference held for that particular context.
143 */
144 for (i = 0; i < enc->open_count; i++)
145 cam_periph_release_locked(periph);
146
147 enc->open_count = 0;
148
149 /*
150 * Release the reference held for the device node, it is gone now.
151 */
152 cam_periph_release_locked(periph);
153
154 /*
155 * We reference the lock directly here, instead of using
156 * cam_periph_unlock(). The reason is that the final call to
157 * cam_periph_release_locked() above could result in the periph
158 * getting freed. If that is the case, dereferencing the periph
159 * with a cam_periph_unlock() call would cause a page fault.
160 */
161 mtx_unlock(mtx);
162 }
163
164 static void
enc_oninvalidate(struct cam_periph * periph)165 enc_oninvalidate(struct cam_periph *periph)
166 {
167 struct enc_softc *enc;
168
169 enc = periph->softc;
170
171 enc->enc_flags |= ENC_FLAG_INVALID;
172
173 /* If the sub-driver has an invalidate routine, call it */
174 if (enc->enc_vec.softc_invalidate != NULL)
175 enc->enc_vec.softc_invalidate(enc);
176
177 /*
178 * Unregister any async callbacks.
179 */
180 xpt_register_async(0, enc_async, periph, periph->path);
181
182 /*
183 * Shutdown our daemon.
184 */
185 enc->enc_flags |= ENC_FLAG_SHUTDOWN;
186 if (enc->enc_daemon != NULL) {
187 /* Signal the ses daemon to terminate. */
188 wakeup(enc->enc_daemon);
189 }
190 callout_drain(&enc->status_updater);
191
192 destroy_dev_sched_cb(enc->enc_dev, enc_devgonecb, periph);
193 }
194
195 static void
enc_dtor(struct cam_periph * periph)196 enc_dtor(struct cam_periph *periph)
197 {
198 struct enc_softc *enc;
199
200 enc = periph->softc;
201
202 /* If the sub-driver has a cleanup routine, call it */
203 if (enc->enc_vec.softc_cleanup != NULL)
204 enc->enc_vec.softc_cleanup(enc);
205
206 cam_periph_release_boot(periph);
207
208 ENC_FREE(enc);
209 }
210
211 static void
enc_async(void * callback_arg,uint32_t code,struct cam_path * path,void * arg)212 enc_async(void *callback_arg, uint32_t code, struct cam_path *path, void *arg)
213 {
214 struct cam_periph *periph;
215
216 periph = (struct cam_periph *)callback_arg;
217
218 switch(code) {
219 case AC_FOUND_DEVICE:
220 {
221 struct ccb_getdev *cgd;
222 cam_status status;
223 path_id_t path_id;
224
225 cgd = (struct ccb_getdev *)arg;
226 if (arg == NULL) {
227 break;
228 }
229
230 if (enc_type(cgd) == ENC_NONE) {
231 /*
232 * Schedule announcement of the ENC bindings for
233 * this device if it is managed by a SEP.
234 */
235 path_id = xpt_path_path_id(path);
236 xpt_lock_buses();
237 TAILQ_FOREACH(periph, &encdriver.units, unit_links) {
238 struct enc_softc *softc;
239
240 softc = (struct enc_softc *)periph->softc;
241
242 /* Check this SEP is ready. */
243 if (softc == NULL || (softc->enc_flags &
244 ENC_FLAG_INITIALIZED) == 0 ||
245 softc->enc_vec.device_found == NULL)
246 continue;
247
248 /* Check this SEP may manage this device. */
249 if (xpt_path_path_id(periph->path) != path_id &&
250 (softc->enc_type != ENC_SEMB_SES ||
251 cgd->protocol != PROTO_ATA))
252 continue;
253
254 softc->enc_vec.device_found(softc);
255 }
256 xpt_unlock_buses();
257 return;
258 }
259
260 status = cam_periph_alloc(enc_ctor, enc_oninvalidate,
261 enc_dtor, NULL, "ses", CAM_PERIPH_BIO,
262 path, enc_async, AC_FOUND_DEVICE, cgd);
263
264 if (status != CAM_REQ_CMP && status != CAM_REQ_INPROG) {
265 printf("enc_async: Unable to probe new device due to "
266 "status 0x%x\n", status);
267 }
268 break;
269 }
270 default:
271 cam_periph_async(periph, code, path, arg);
272 break;
273 }
274 }
275
276 static int
enc_open(struct cdev * dev,int flags,int fmt,struct thread * td)277 enc_open(struct cdev *dev, int flags, int fmt, struct thread *td)
278 {
279 struct cam_periph *periph;
280 struct enc_softc *softc;
281 int error = 0;
282
283 periph = (struct cam_periph *)dev->si_drv1;
284 if (cam_periph_acquire(periph) != 0)
285 return (ENXIO);
286
287 cam_periph_lock(periph);
288
289 softc = (struct enc_softc *)periph->softc;
290
291 if ((softc->enc_flags & ENC_FLAG_INITIALIZED) == 0) {
292 error = ENXIO;
293 goto out;
294 }
295 if (softc->enc_flags & ENC_FLAG_INVALID) {
296 error = ENXIO;
297 goto out;
298 }
299 out:
300 if (error != 0)
301 cam_periph_release_locked(periph);
302 else
303 softc->open_count++;
304
305 cam_periph_unlock(periph);
306
307 return (error);
308 }
309
310 static int
enc_close(struct cdev * dev,int flag,int fmt,struct thread * td)311 enc_close(struct cdev *dev, int flag, int fmt, struct thread *td)
312 {
313 struct cam_periph *periph;
314 struct enc_softc *enc;
315 struct mtx *mtx;
316
317 periph = (struct cam_periph *)dev->si_drv1;
318 mtx = cam_periph_mtx(periph);
319 mtx_lock(mtx);
320
321 enc = periph->softc;
322 enc->open_count--;
323
324 cam_periph_release_locked(periph);
325
326 /*
327 * We reference the lock directly here, instead of using
328 * cam_periph_unlock(). The reason is that the call to
329 * cam_periph_release_locked() above could result in the periph
330 * getting freed. If that is the case, dereferencing the periph
331 * with a cam_periph_unlock() call would cause a page fault.
332 *
333 * cam_periph_release() avoids this problem using the same method,
334 * but we're manually acquiring and dropping the lock here to
335 * protect the open count and avoid another lock acquisition and
336 * release.
337 */
338 mtx_unlock(mtx);
339
340 return (0);
341 }
342
343 int
enc_error(union ccb * ccb,uint32_t cflags,uint32_t sflags)344 enc_error(union ccb *ccb, uint32_t cflags, uint32_t sflags)
345 {
346
347 return (cam_periph_error(ccb, cflags, sflags));
348 }
349
350 static int
enc_ioctl(struct cdev * dev,u_long cmd,caddr_t arg_addr,int flag,struct thread * td)351 enc_ioctl(struct cdev *dev, u_long cmd, caddr_t arg_addr, int flag,
352 struct thread *td)
353 {
354 struct cam_periph *periph;
355 enc_softc_t *enc;
356 enc_cache_t *cache;
357 void *addr;
358 int error, i;
359
360 #ifdef COMPAT_FREEBSD32
361 if (SV_PROC_FLAG(td->td_proc, SV_ILP32))
362 return (ENOTTY);
363 #endif
364
365 if (arg_addr)
366 addr = *((caddr_t *) arg_addr);
367 else
368 addr = NULL;
369
370 periph = (struct cam_periph *)dev->si_drv1;
371 CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("entering encioctl\n"));
372
373 cam_periph_lock(periph);
374 enc = (struct enc_softc *)periph->softc;
375 cache = &enc->enc_cache;
376
377 /*
378 * Now check to see whether we're initialized or not.
379 * This actually should never fail as we're not supposed
380 * to get past enc_open w/o successfully initializing
381 * things.
382 */
383 if ((enc->enc_flags & ENC_FLAG_INITIALIZED) == 0) {
384 cam_periph_unlock(periph);
385 return (ENXIO);
386 }
387 cam_periph_unlock(periph);
388
389 error = 0;
390
391 CAM_DEBUG(periph->path, CAM_DEBUG_TRACE,
392 ("trying to do ioctl %#lx\n", cmd));
393
394 /*
395 * If this command can change the device's state,
396 * we must have the device open for writing.
397 *
398 * For commands that get information about the
399 * device- we don't need to lock the peripheral
400 * if we aren't running a command. The periph
401 * also can't go away while a user process has
402 * it open.
403 */
404 switch (cmd) {
405 case ENCIOC_GETNELM:
406 case ENCIOC_GETELMMAP:
407 case ENCIOC_GETENCSTAT:
408 case ENCIOC_GETELMSTAT:
409 case ENCIOC_GETELMDESC:
410 case ENCIOC_GETELMDEVNAMES:
411 case ENCIOC_GETENCNAME:
412 case ENCIOC_GETENCID:
413 break;
414 default:
415 if ((flag & FWRITE) == 0) {
416 return (EBADF);
417 }
418 }
419
420 /*
421 * XXX The values read here are only valid for the current
422 * configuration generation. We need these ioctls
423 * to also pass in/out a generation number.
424 */
425 sx_slock(&enc->enc_cache_lock);
426 switch (cmd) {
427 case ENCIOC_GETNELM:
428 error = copyout(&cache->nelms, addr, sizeof (cache->nelms));
429 break;
430
431 case ENCIOC_GETELMMAP: {
432 encioc_element_t *uelm;
433
434 for (uelm = addr, i = 0; i != cache->nelms; i++) {
435 encioc_element_t kelm;
436 kelm.elm_idx = i;
437 kelm.elm_subenc_id = cache->elm_map[i].subenclosure;
438 kelm.elm_type = cache->elm_map[i].elm_type;
439 error = copyout(&kelm, &uelm[i], sizeof(kelm));
440 if (error)
441 break;
442 }
443 break;
444 }
445 case ENCIOC_GETENCSTAT: {
446 error = copyout(&cache->enc_status, addr,
447 sizeof(cache->enc_status));
448 break;
449 }
450 case ENCIOC_SETENCSTAT: {
451 encioc_enc_status_t tmp;
452
453 error = copyin(addr, &tmp, sizeof(tmp));
454 if (error)
455 break;
456 cam_periph_lock(periph);
457 error = enc->enc_vec.set_enc_status(enc, tmp, 1);
458 cam_periph_unlock(periph);
459 break;
460 }
461 case ENCIOC_GETSTRING:
462 case ENCIOC_SETSTRING:
463 case ENCIOC_GETENCNAME:
464 case ENCIOC_GETENCID: {
465 encioc_string_t sstr;
466
467 if (enc->enc_vec.handle_string == NULL) {
468 error = EINVAL;
469 break;
470 }
471 error = copyin(addr, &sstr, sizeof(sstr));
472 if (error)
473 break;
474 cam_periph_lock(periph);
475 error = enc->enc_vec.handle_string(enc, &sstr, cmd);
476 cam_periph_unlock(periph);
477 if (error == 0 || error == ENOMEM)
478 (void)copyout(&sstr.bufsiz,
479 &((encioc_string_t *)addr)->bufsiz,
480 sizeof(sstr.bufsiz));
481 break;
482 }
483 case ENCIOC_GETELMSTAT: {
484 encioc_elm_status_t elms;
485
486 error = copyin(addr, &elms, sizeof(elms));
487 if (error)
488 break;
489 if (elms.elm_idx >= cache->nelms) {
490 error = EINVAL;
491 break;
492 }
493 cam_periph_lock(periph);
494 error = enc->enc_vec.get_elm_status(enc, &elms, 1);
495 cam_periph_unlock(periph);
496 if (error)
497 break;
498 error = copyout(&elms, addr, sizeof(elms));
499 break;
500 }
501 case ENCIOC_GETELMDESC: {
502 encioc_elm_desc_t elmd;
503
504 error = copyin(addr, &elmd, sizeof(elmd));
505 if (error)
506 break;
507 if (elmd.elm_idx >= cache->nelms) {
508 error = EINVAL;
509 break;
510 }
511 if (enc->enc_vec.get_elm_desc != NULL) {
512 error = enc->enc_vec.get_elm_desc(enc, &elmd);
513 if (error)
514 break;
515 } else
516 elmd.elm_desc_len = 0;
517 error = copyout(&elmd, addr, sizeof(elmd));
518 break;
519 }
520 case ENCIOC_GETELMDEVNAMES: {
521 encioc_elm_devnames_t elmdn;
522
523 if (enc->enc_vec.get_elm_devnames == NULL) {
524 error = EINVAL;
525 break;
526 }
527 error = copyin(addr, &elmdn, sizeof(elmdn));
528 if (error)
529 break;
530 if (elmdn.elm_idx >= cache->nelms) {
531 error = EINVAL;
532 break;
533 }
534 cam_periph_lock(periph);
535 error = (*enc->enc_vec.get_elm_devnames)(enc, &elmdn);
536 cam_periph_unlock(periph);
537 if (error)
538 break;
539 error = copyout(&elmdn, addr, sizeof(elmdn));
540 break;
541 }
542 case ENCIOC_SETELMSTAT: {
543 encioc_elm_status_t elms;
544
545 error = copyin(addr, &elms, sizeof(elms));
546 if (error)
547 break;
548
549 if (elms.elm_idx >= cache->nelms) {
550 error = EINVAL;
551 break;
552 }
553 cam_periph_lock(periph);
554 error = enc->enc_vec.set_elm_status(enc, &elms, 1);
555 cam_periph_unlock(periph);
556
557 break;
558 }
559 case ENCIOC_INIT:
560
561 cam_periph_lock(periph);
562 error = enc->enc_vec.init_enc(enc);
563 cam_periph_unlock(periph);
564 break;
565
566 default:
567 cam_periph_lock(periph);
568 error = cam_periph_ioctl(periph, cmd, arg_addr, enc_error);
569 cam_periph_unlock(periph);
570 break;
571 }
572 sx_sunlock(&enc->enc_cache_lock);
573 return (error);
574 }
575
576 int
enc_runcmd(struct enc_softc * enc,char * cdb,int cdbl,char * dptr,int * dlenp)577 enc_runcmd(struct enc_softc *enc, char *cdb, int cdbl, char *dptr, int *dlenp)
578 {
579 int error, dlen, tdlen;
580 ccb_flags ddf;
581 union ccb *ccb;
582
583 CAM_DEBUG(enc->periph->path, CAM_DEBUG_TRACE,
584 ("entering enc_runcmd\n"));
585 if (dptr) {
586 if ((dlen = *dlenp) < 0) {
587 dlen = -dlen;
588 ddf = CAM_DIR_OUT;
589 } else {
590 ddf = CAM_DIR_IN;
591 }
592 } else {
593 dlen = 0;
594 ddf = CAM_DIR_NONE;
595 }
596
597 if (cdbl > IOCDBLEN) {
598 cdbl = IOCDBLEN;
599 }
600
601 ccb = cam_periph_getccb(enc->periph, CAM_PRIORITY_NORMAL);
602 if (enc->enc_type == ENC_SEMB_SES || enc->enc_type == ENC_SEMB_SAFT) {
603 tdlen = min(dlen, 1020);
604 tdlen = (tdlen + 3) & ~3;
605 cam_fill_ataio(&ccb->ataio, 0, NULL, ddf, 0, dptr, tdlen,
606 30 * 1000);
607 if (cdb[0] == RECEIVE_DIAGNOSTIC)
608 ata_28bit_cmd(&ccb->ataio,
609 ATA_SEP_ATTN, cdb[2], 0x02, tdlen / 4);
610 else if (cdb[0] == SEND_DIAGNOSTIC)
611 ata_28bit_cmd(&ccb->ataio,
612 ATA_SEP_ATTN, dlen > 0 ? dptr[0] : 0,
613 0x82, tdlen / 4);
614 else if (cdb[0] == READ_BUFFER)
615 ata_28bit_cmd(&ccb->ataio,
616 ATA_SEP_ATTN, cdb[2], 0x00, tdlen / 4);
617 else
618 ata_28bit_cmd(&ccb->ataio,
619 ATA_SEP_ATTN, dlen > 0 ? dptr[0] : 0,
620 0x80, tdlen / 4);
621 } else {
622 tdlen = dlen;
623 cam_fill_csio(&ccb->csio, 0, NULL, ddf, MSG_SIMPLE_Q_TAG,
624 dptr, dlen, sizeof (struct scsi_sense_data), cdbl,
625 60 * 1000);
626 bcopy(cdb, ccb->csio.cdb_io.cdb_bytes, cdbl);
627 }
628
629 error = cam_periph_runccb(ccb, enc_error, ENC_CFLAGS, ENC_FLAGS, NULL);
630 if (error) {
631 if (dptr) {
632 *dlenp = dlen;
633 }
634 } else {
635 if (dptr) {
636 if (ccb->ccb_h.func_code == XPT_ATA_IO)
637 *dlenp = ccb->ataio.resid;
638 else
639 *dlenp = ccb->csio.resid;
640 *dlenp += tdlen - dlen;
641 }
642 }
643 xpt_release_ccb(ccb);
644 CAM_DEBUG(enc->periph->path, CAM_DEBUG_SUBTRACE,
645 ("exiting enc_runcmd: *dlenp = %d\n", *dlenp));
646 return (error);
647 }
648
649 void
enc_log(struct enc_softc * enc,const char * fmt,...)650 enc_log(struct enc_softc *enc, const char *fmt, ...)
651 {
652 va_list ap;
653
654 printf("%s%d: ", enc->periph->periph_name, enc->periph->unit_number);
655 va_start(ap, fmt);
656 vprintf(fmt, ap);
657 va_end(ap);
658 }
659
660 /*
661 * The code after this point runs on many platforms,
662 * so forgive the slightly awkward and nonconforming
663 * appearance.
664 */
665
666 /*
667 * Is this a device that supports enclosure services?
668 *
669 * It's a pretty simple ruleset- if it is device type
670 * 0x0D (13), it's an ENCLOSURE device.
671 */
672
673 #define SAFTE_START 44
674 #define SAFTE_END 50
675 #define SAFTE_LEN SAFTE_END-SAFTE_START
676
677 static enctyp
enc_type(struct ccb_getdev * cgd)678 enc_type(struct ccb_getdev *cgd)
679 {
680 int buflen;
681 unsigned char *iqd;
682
683 if (cgd->protocol == PROTO_SEMB) {
684 iqd = (unsigned char *)&cgd->ident_data;
685 if (STRNCMP(iqd + 43, "S-E-S", 5) == 0)
686 return (ENC_SEMB_SES);
687 else if (STRNCMP(iqd + 43, "SAF-TE", 6) == 0)
688 return (ENC_SEMB_SAFT);
689 return (ENC_NONE);
690
691 } else if (cgd->protocol != PROTO_SCSI)
692 return (ENC_NONE);
693
694 iqd = (unsigned char *)&cgd->inq_data;
695 buflen = min(sizeof(cgd->inq_data),
696 SID_ADDITIONAL_LENGTH(&cgd->inq_data));
697
698 if ((iqd[0] & 0x1f) == T_ENCLOSURE)
699 return (ENC_SES);
700
701 #ifdef SES_ENABLE_PASSTHROUGH
702 if ((iqd[6] & 0x40) && (iqd[2] & 0x7) >= 2) {
703 /*
704 * PassThrough Device.
705 */
706 return (ENC_SES_PASSTHROUGH);
707 }
708 #endif
709
710 /*
711 * The comparison is short for a reason-
712 * some vendors were chopping it short.
713 */
714
715 if (buflen < SAFTE_END - 2) {
716 return (ENC_NONE);
717 }
718
719 if (STRNCMP((char *)&iqd[SAFTE_START], "SAF-TE", SAFTE_LEN - 2) == 0) {
720 return (ENC_SAFT);
721 }
722 return (ENC_NONE);
723 }
724
725 /*================== Enclosure Monitoring/Processing Daemon ==================*/
726 /**
727 * \brief Queue an update request for a given action, if needed.
728 *
729 * \param enc SES softc to queue the request for.
730 * \param action Action requested.
731 */
732 void
enc_update_request(enc_softc_t * enc,uint32_t action)733 enc_update_request(enc_softc_t *enc, uint32_t action)
734 {
735 if ((enc->pending_actions & (0x1 << action)) == 0) {
736 enc->pending_actions |= (0x1 << action);
737 ENC_DLOG(enc, "%s: queing requested action %d\n",
738 __func__, action);
739 if (enc->current_action == ENC_UPDATE_NONE)
740 wakeup(enc->enc_daemon);
741 } else {
742 ENC_DLOG(enc, "%s: ignoring requested action %d - "
743 "Already queued\n", __func__, action);
744 }
745 }
746
747 /**
748 * \brief Invoke the handler of the highest priority pending
749 * state in the SES state machine.
750 *
751 * \param enc The SES instance invoking the state machine.
752 */
753 static void
enc_fsm_step(enc_softc_t * enc)754 enc_fsm_step(enc_softc_t *enc)
755 {
756 union ccb *ccb;
757 uint8_t *buf;
758 struct enc_fsm_state *cur_state;
759 int error;
760 uint32_t xfer_len;
761
762 ENC_DLOG(enc, "%s enter %p\n", __func__, enc);
763
764 enc->current_action = ffs(enc->pending_actions) - 1;
765 enc->pending_actions &= ~(0x1 << enc->current_action);
766
767 cur_state = &enc->enc_fsm_states[enc->current_action];
768
769 buf = NULL;
770 if (cur_state->buf_size != 0) {
771 cam_periph_unlock(enc->periph);
772 buf = malloc(cur_state->buf_size, M_SCSIENC, M_WAITOK|M_ZERO);
773 cam_periph_lock(enc->periph);
774 }
775
776 error = 0;
777 ccb = NULL;
778 if (cur_state->fill != NULL) {
779 ccb = cam_periph_getccb(enc->periph, CAM_PRIORITY_NORMAL);
780
781 error = cur_state->fill(enc, cur_state, ccb, buf);
782 if (error != 0)
783 goto done;
784
785 error = cam_periph_runccb(ccb, cur_state->error,
786 ENC_CFLAGS,
787 ENC_FLAGS|SF_QUIET_IR, NULL);
788 }
789
790 if (ccb != NULL) {
791 if (ccb->ccb_h.func_code == XPT_ATA_IO)
792 xfer_len = ccb->ataio.dxfer_len - ccb->ataio.resid;
793 else
794 xfer_len = ccb->csio.dxfer_len - ccb->csio.resid;
795 } else
796 xfer_len = 0;
797
798 cam_periph_unlock(enc->periph);
799 cur_state->done(enc, cur_state, ccb, &buf, error, xfer_len);
800 cam_periph_lock(enc->periph);
801
802 done:
803 ENC_DLOG(enc, "%s exit - result %d\n", __func__, error);
804 ENC_FREE_AND_NULL(buf);
805 if (ccb != NULL)
806 xpt_release_ccb(ccb);
807 }
808
809 /**
810 * \invariant Called with cam_periph mutex held.
811 */
812 static void
enc_status_updater(void * arg)813 enc_status_updater(void *arg)
814 {
815 enc_softc_t *enc;
816
817 enc = arg;
818 if (enc->enc_vec.poll_status != NULL)
819 enc->enc_vec.poll_status(enc);
820 }
821
822 static void
enc_daemon(void * arg)823 enc_daemon(void *arg)
824 {
825 enc_softc_t *enc;
826
827 enc = arg;
828
829 cam_periph_lock(enc->periph);
830 while ((enc->enc_flags & ENC_FLAG_SHUTDOWN) == 0) {
831 if (enc->pending_actions == 0) {
832 /*
833 * Reset callout and msleep, or
834 * issue timed task completion
835 * status command.
836 */
837 enc->current_action = ENC_UPDATE_NONE;
838
839 /*
840 * We've been through our state machine at least
841 * once. Allow the transition to userland.
842 */
843 cam_periph_release_boot(enc->periph);
844
845 callout_reset_sbt(&enc->status_updater, 60 * SBT_1S, 0,
846 enc_status_updater, enc, C_PREL(1));
847
848 cam_periph_sleep(enc->periph, enc->enc_daemon,
849 PUSER, "idle", 0);
850 } else {
851 enc_fsm_step(enc);
852 }
853 }
854 enc->enc_daemon = NULL;
855 cam_periph_unlock(enc->periph);
856 cam_periph_release(enc->periph);
857 kproc_exit(0);
858 }
859
860 static int
enc_kproc_init(enc_softc_t * enc)861 enc_kproc_init(enc_softc_t *enc)
862 {
863 int result;
864
865 callout_init_mtx(&enc->status_updater, cam_periph_mtx(enc->periph), 0);
866
867 if (cam_periph_acquire(enc->periph) != 0)
868 return (ENXIO);
869
870 result = kproc_create(enc_daemon, enc, &enc->enc_daemon, /*flags*/0,
871 /*stackpgs*/0, "enc_daemon%d",
872 enc->periph->unit_number);
873 if (result == 0) {
874 /* Do an initial load of all page data. */
875 cam_periph_lock(enc->periph);
876 enc->enc_vec.poll_status(enc);
877 cam_periph_unlock(enc->periph);
878 } else
879 cam_periph_release(enc->periph);
880 return (result);
881 }
882
883 static cam_status
enc_ctor(struct cam_periph * periph,void * arg)884 enc_ctor(struct cam_periph *periph, void *arg)
885 {
886 cam_status status = CAM_REQ_CMP_ERR;
887 int err;
888 enc_softc_t *enc;
889 struct ccb_getdev *cgd;
890 char *tname;
891 struct make_dev_args args;
892 struct sbuf sb;
893
894 cgd = (struct ccb_getdev *)arg;
895 if (cgd == NULL) {
896 printf("enc_ctor: no getdev CCB, can't register device\n");
897 goto out;
898 }
899
900 enc = ENC_MALLOCZ(sizeof(*enc));
901 if (enc == NULL) {
902 printf("enc_ctor: Unable to probe new device. "
903 "Unable to allocate enc\n");
904 goto out;
905 }
906 enc->periph = periph;
907 enc->current_action = ENC_UPDATE_INVALID;
908
909 enc->enc_type = enc_type(cgd);
910 sx_init(&enc->enc_cache_lock, "enccache");
911
912 switch (enc->enc_type) {
913 case ENC_SES:
914 case ENC_SES_PASSTHROUGH:
915 case ENC_SEMB_SES:
916 err = ses_softc_init(enc);
917 break;
918 case ENC_SAFT:
919 case ENC_SEMB_SAFT:
920 err = safte_softc_init(enc);
921 break;
922 case ENC_NONE:
923 default:
924 ENC_FREE(enc);
925 return (CAM_REQ_CMP_ERR);
926 }
927
928 if (err) {
929 xpt_print(periph->path, "error %d initializing\n", err);
930 goto out;
931 }
932
933 /*
934 * Hold off userland until we have made at least one pass
935 * through our state machine so that physical path data is
936 * present.
937 */
938 if (enc->enc_vec.poll_status != NULL)
939 cam_periph_hold_boot(periph);
940
941 /*
942 * The softc field is set only once the enc is fully initialized
943 * so that we can rely on this field to detect partially
944 * initialized periph objects in the AC_FOUND_DEVICE handler.
945 */
946 periph->softc = enc;
947
948 cam_periph_unlock(periph);
949 if (enc->enc_vec.poll_status != NULL) {
950 err = enc_kproc_init(enc);
951 if (err) {
952 xpt_print(periph->path,
953 "error %d starting enc_daemon\n", err);
954 goto out;
955 }
956 }
957
958 /*
959 * Acquire a reference to the periph before we create the devfs
960 * instance for it. We'll release this reference once the devfs
961 * instance has been freed.
962 */
963 if (cam_periph_acquire(periph) != 0) {
964 xpt_print(periph->path, "%s: lost periph during "
965 "registration!\n", __func__);
966 cam_periph_lock(periph);
967
968 return (CAM_REQ_CMP_ERR);
969 }
970
971 make_dev_args_init(&args);
972 args.mda_devsw = &enc_cdevsw;
973 args.mda_unit = periph->unit_number;
974 args.mda_uid = UID_ROOT;
975 args.mda_gid = GID_OPERATOR;
976 args.mda_mode = 0600;
977 args.mda_si_drv1 = periph;
978 err = make_dev_s(&args, &enc->enc_dev, "%s%d", periph->periph_name,
979 periph->unit_number);
980 cam_periph_lock(periph);
981 if (err != 0) {
982 cam_periph_release_locked(periph);
983 return (CAM_REQ_CMP_ERR);
984 }
985
986 enc->enc_flags |= ENC_FLAG_INITIALIZED;
987
988 /*
989 * Add an async callback so that we get notified if this
990 * device goes away.
991 */
992 xpt_register_async(AC_LOST_DEVICE, enc_async, periph, periph->path);
993
994 switch (enc->enc_type) {
995 default:
996 case ENC_NONE:
997 tname = "No ENC device";
998 break;
999 case ENC_SES:
1000 tname = "SES Device";
1001 break;
1002 case ENC_SES_PASSTHROUGH:
1003 tname = "SES Passthrough Device";
1004 break;
1005 case ENC_SAFT:
1006 tname = "SAF-TE Device";
1007 break;
1008 case ENC_SEMB_SES:
1009 tname = "SEMB SES Device";
1010 break;
1011 case ENC_SEMB_SAFT:
1012 tname = "SEMB SAF-TE Device";
1013 break;
1014 }
1015
1016 sbuf_new(&sb, enc->announce_buf, ENC_ANNOUNCE_SZ, SBUF_FIXEDLEN);
1017 xpt_announce_periph_sbuf(periph, &sb, tname);
1018 sbuf_finish(&sb);
1019 sbuf_putbuf(&sb);
1020
1021 status = CAM_REQ_CMP;
1022
1023 out:
1024 if (status != CAM_REQ_CMP)
1025 enc_dtor(periph);
1026 return (status);
1027 }
1028