Attachment #226787 for bug #254437

View | Details | Raw Unified | Return to bug 254437
Collapse All | Expand All




	 *     configuration generation.  We need these ioctls
	 *     to also pass in/out a generation number.
	 */
	sx_slock(&enc->enc_cache_lock);
	switch (cmd) {
	case ENCIOC_GETNELM:
		sx_slock(&enc->enc_cache_lock);
		error = copyout(&cache->nelms, addr, sizeof (cache->nelms));
		break;
		
	case ENCIOC_GETELMMAP:
		sx_slock(&enc->enc_cache_lock);
		for (uelm = addr, i = 0; i != cache->nelms; i++) {
			encioc_element_t kelm;
			kelm.elm_idx = i;

		break;

	case ENCIOC_GETENCSTAT:
		sx_slock(&enc->enc_cache_lock);
		cam_periph_lock(periph);
		error = enc->enc_vec.get_enc_status(enc, 1);
		if (error) {

		tmp = cache->enc_status;
		cam_periph_unlock(periph);
		error = copyout(&tmp, addr, sizeof(tmp));
		// XXX Why this next line?
		cache->enc_status = tmp;
		break;

	case ENCIOC_SETENCSTAT:
		error = copyin(addr, &tmp, sizeof(tmp));
		if (error)
			return (error);
		cam_periph_lock(periph);
		error = enc->enc_vec.set_enc_status(enc, tmp, 1);
		cam_periph_unlock(periph);
		return (error);	/* Return early so as not to double-unlock */

	case ENCIOC_GETSTRING:
	case ENCIOC_SETSTRING:
	case ENCIOC_GETENCNAME:
	case ENCIOC_GETENCID:
		sx_slock(&enc->enc_cache_lock);
		if (enc->enc_vec.handle_string == NULL) {
			error = EINVAL;
			break;

		break;

	case ENCIOC_GETELMSTAT:
		sx_slock(&enc->enc_cache_lock);
		error = copyin(addr, &elms, sizeof(elms));
		if (error)
			break;

		break;

	case ENCIOC_GETELMDESC:
		sx_slock(&enc->enc_cache_lock);
		error = copyin(addr, &elmd, sizeof(elmd));
		if (error)
			break;

		break;

	case ENCIOC_GETELMDEVNAMES:
		sx_slock(&enc->enc_cache_lock);
		if (enc->enc_vec.get_elm_devnames == NULL) {
			error = EINVAL;
			break;

		break;

	case ENCIOC_SETELMSTAT:
		sx_slock(&enc->enc_cache_lock);
		error = copyin(addr, &elms, sizeof(elms));
		if (error)
			break;

			error = EINVAL;
			break;
		}
		sx_sunlock(&enc->enc_cache_lock);
		cam_periph_lock(periph);
		error = enc->enc_vec.set_elm_status(enc, &elms, 1);
		cam_periph_unlock(periph);

		return (error);	/* Return early so as not to double-unlock */

	case ENCIOC_INIT:
		sx_slock(&enc->enc_cache_lock);
		cam_periph_lock(periph);
		error = enc->enc_vec.init_enc(enc);
		cam_periph_unlock(periph);

		cam_periph_lock(periph);
		error = cam_periph_ioctl(periph, cmd, arg_addr, enc_error);
		cam_periph_unlock(periph);
		return (error);
	}
	sx_sunlock(&enc->enc_cache_lock);
	return (error);

	} else
		xfer_len = 0;

	// Why unlock enc->periph here?  I think it's responsible for missed
	// wakeups.
	cam_periph_unlock(enc->periph);
	cur_state->done(enc, cur_state, ccb, &buf, error, xfer_len);
	cam_periph_lock(enc->periph);

Return to bug 254437

Lines 435-447 enc_ioctl(struct cdev *dev, u_long cmd, caddr_t arg_addr, int flag, Link Here

(-)b/sys/cam/scsi/scsi_enc.c (-6 / +17 lines)
435	* configuration generation. We need these ioctls	435	* configuration generation. We need these ioctls
436	* to also pass in/out a generation number.	436	* to also pass in/out a generation number.
437	*/	437	*/
438	sx_slock(&enc->enc_cache_lock);
439	switch (cmd) {	438	switch (cmd) {
440	case ENCIOC_GETNELM:	439	case ENCIOC_GETNELM:
		440	sx_slock(&enc->enc_cache_lock);
441	error = copyout(&cache->nelms, addr, sizeof (cache->nelms));	441	error = copyout(&cache->nelms, addr, sizeof (cache->nelms));
442	break;	442	break;
443		443
444	case ENCIOC_GETELMMAP:	444	case ENCIOC_GETELMMAP:
		445	sx_slock(&enc->enc_cache_lock);
445	for (uelm = addr, i = 0; i != cache->nelms; i++) {	446	for (uelm = addr, i = 0; i != cache->nelms; i++) {
446	encioc_element_t kelm;	447	encioc_element_t kelm;
447	kelm.elm_idx = i;	448	kelm.elm_idx = i;
Lines 454-459 enc_ioctl(struct cdev *dev, u_long cmd, caddr_t arg_addr, int flag, Link Here
454	break;	455	break;
455		456
456	case ENCIOC_GETENCSTAT:	457	case ENCIOC_GETENCSTAT:
		458	sx_slock(&enc->enc_cache_lock);
457	cam_periph_lock(periph);	459	cam_periph_lock(periph);
458	error = enc->enc_vec.get_enc_status(enc, 1);	460	error = enc->enc_vec.get_enc_status(enc, 1);
459	if (error) {	461	if (error) {
Lines 463-484 enc_ioctl(struct cdev *dev, u_long cmd, caddr_t arg_addr, int flag, Link Here
463	tmp = cache->enc_status;	465	tmp = cache->enc_status;
464	cam_periph_unlock(periph);	466	cam_periph_unlock(periph);
465	error = copyout(&tmp, addr, sizeof(tmp));	467	error = copyout(&tmp, addr, sizeof(tmp));
		468	// XXX Why this next line?
466	cache->enc_status = tmp;	469	cache->enc_status = tmp;
467	break;	470	break;
468		471
469	case ENCIOC_SETENCSTAT:	472	case ENCIOC_SETENCSTAT:
470	error = copyin(addr, &tmp, sizeof(tmp));	473	error = copyin(addr, &tmp, sizeof(tmp));
471	if (error)	474	if (error)
472	break;	475	return (error);
473	cam_periph_lock(periph);	476	cam_periph_lock(periph);
474	error = enc->enc_vec.set_enc_status(enc, tmp, 1);	477	error = enc->enc_vec.set_enc_status(enc, tmp, 1);
475	cam_periph_unlock(periph);	478	cam_periph_unlock(periph);
476	break;	479	return (error); /* Return early so as not to double-unlock */
477		480
478	case ENCIOC_GETSTRING:	481	case ENCIOC_GETSTRING:
479	case ENCIOC_SETSTRING:	482	case ENCIOC_SETSTRING:
480	case ENCIOC_GETENCNAME:	483	case ENCIOC_GETENCNAME:
481	case ENCIOC_GETENCID:	484	case ENCIOC_GETENCID:
		485	sx_slock(&enc->enc_cache_lock);
482	if (enc->enc_vec.handle_string == NULL) {	486	if (enc->enc_vec.handle_string == NULL) {
483	error = EINVAL;	487	error = EINVAL;
484	break;	488	break;
Lines 496-501 enc_ioctl(struct cdev *dev, u_long cmd, caddr_t arg_addr, int flag, Link Here
496	break;	500	break;
497		501
498	case ENCIOC_GETELMSTAT:	502	case ENCIOC_GETELMSTAT:
		503	sx_slock(&enc->enc_cache_lock);
499	error = copyin(addr, &elms, sizeof(elms));	504	error = copyin(addr, &elms, sizeof(elms));
500	if (error)	505	if (error)
501	break;	506	break;
Lines 512-517 enc_ioctl(struct cdev *dev, u_long cmd, caddr_t arg_addr, int flag, Link Here
512	break;	517	break;
513		518
514	case ENCIOC_GETELMDESC:	519	case ENCIOC_GETELMDESC:
		520	sx_slock(&enc->enc_cache_lock);
515	error = copyin(addr, &elmd, sizeof(elmd));	521	error = copyin(addr, &elmd, sizeof(elmd));
516	if (error)	522	if (error)
517	break;	523	break;
Lines 529-534 enc_ioctl(struct cdev *dev, u_long cmd, caddr_t arg_addr, int flag, Link Here
529	break;	535	break;
530		536
531	case ENCIOC_GETELMDEVNAMES:	537	case ENCIOC_GETELMDEVNAMES:
		538	sx_slock(&enc->enc_cache_lock);
532	if (enc->enc_vec.get_elm_devnames == NULL) {	539	if (enc->enc_vec.get_elm_devnames == NULL) {
533	error = EINVAL;	540	error = EINVAL;
534	break;	541	break;
Lines 549-554 enc_ioctl(struct cdev *dev, u_long cmd, caddr_t arg_addr, int flag, Link Here
549	break;	556	break;
550		557
551	case ENCIOC_SETELMSTAT:	558	case ENCIOC_SETELMSTAT:
		559	sx_slock(&enc->enc_cache_lock);
552	error = copyin(addr, &elms, sizeof(elms));	560	error = copyin(addr, &elms, sizeof(elms));
553	if (error)	561	if (error)
554	break;	562	break;
Lines 557-570 enc_ioctl(struct cdev *dev, u_long cmd, caddr_t arg_addr, int flag, Link Here
557	error = EINVAL;	565	error = EINVAL;
558	break;	566	break;
559	}	567	}
		568	sx_sunlock(&enc->enc_cache_lock);
560	cam_periph_lock(periph);	569	cam_periph_lock(periph);
561	error = enc->enc_vec.set_elm_status(enc, &elms, 1);	570	error = enc->enc_vec.set_elm_status(enc, &elms, 1);
562	cam_periph_unlock(periph);	571	cam_periph_unlock(periph);
563		572
564	break;	573	return (error); /* Return early so as not to double-unlock */
565		574
566	case ENCIOC_INIT:	575	case ENCIOC_INIT:
567		576	sx_slock(&enc->enc_cache_lock);
568	cam_periph_lock(periph);	577	cam_periph_lock(periph);
569	error = enc->enc_vec.init_enc(enc);	578	error = enc->enc_vec.init_enc(enc);
570	cam_periph_unlock(periph);	579	cam_periph_unlock(periph);
Lines 574-580 enc_ioctl(struct cdev *dev, u_long cmd, caddr_t arg_addr, int flag, Link Here
574	cam_periph_lock(periph);	583	cam_periph_lock(periph);
575	error = cam_periph_ioctl(periph, cmd, arg_addr, enc_error);	584	error = cam_periph_ioctl(periph, cmd, arg_addr, enc_error);
576	cam_periph_unlock(periph);	585	cam_periph_unlock(periph);
577	break;	586	return (error);
578	}	587	}
579	sx_sunlock(&enc->enc_cache_lock);	588	sx_sunlock(&enc->enc_cache_lock);
580	return (error);	589	return (error);
Lines 802-807 enc_fsm_step(enc_softc_t *enc) Link Here
802	} else	811	} else
803	xfer_len = 0;	812	xfer_len = 0;
804		813
		814	// Why unlock enc->periph here? I think it's responsible for missed
		815	// wakeups.
805	cam_periph_unlock(enc->periph);	816	cam_periph_unlock(enc->periph);
806	cur_state->done(enc, cur_state, ccb, &buf, error, xfer_len);	817	cur_state->done(enc, cur_state, ccb, &buf, error, xfer_len);
807	cam_periph_lock(enc->periph);	818	cam_periph_lock(enc->periph);