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