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