Commit 91ffc519 authored by Harald Freudenberger's avatar Harald Freudenberger Committed by Vasily Gorbik
Browse files

s390/zcrypt: introduce msg tracking in zcrypt functions 



Introduce a new internal struct zcrypt_track with an retry counter
field and a last return code field. Fill and update these fields at
certain points during processing of an request/reply. This tracking
info is then used to
- avoid trying to resend the message forever. Now each message is
  tried to be send TRACK_AGAIN_MAX (currently 10) times and then the
  ioctl returns to userspace with errno EAGAIN.
- avoid trying to resend the message on the very same card/domain. If
  possible (more than one APQN with same quality) don't use the very
  same qid as the previous attempt when again scheduling the request.
  This is done by adding penalty weight values when the dispatching
  takes place. There is a penalty TRACK_AGAIN_CARD_WEIGHT_PENALTY for
  using the same card as previously and another penalty define
  TRACK_AGAIN_QUEUE_WEIGHT_PENALTY to be considered when the same qid
  as the previous sent attempt is calculated. Both values make it
  harder to choose the very same card/domain but not impossible. For
  example when only one APQN is available a resend can only address the
  very same APQN.

There are some more ideas for the future to extend the use of this
tracking information. For example the last response code at NQAP and
DQAP could be stored there, giving the possibility to extended tracing
and debugging about requests failing to get processed properly.

Signed-off-by: default avatarHarald Freudenberger <freude@linux.ibm.com>
Signed-off-by: default avatarVasily Gorbik <gor@linux.ibm.com>
parent 4ec95ed3

drivers/s390/crypto/zcrypt_api.c

+173 −80
Original line number Diff line number Diff line
@@ -602,13 +602,13 @@ static inline bool zcrypt_card_compare(struct zcrypt_card *zc, 
				       unsigned int pref_weight)

{

	if (!pref_zc)

		return false;

		return true;

	weight += atomic_read(&zc->load);

	pref_weight += atomic_read(&pref_zc->load);

	if (weight == pref_weight)

		return atomic64_read(&zc->card->total_request_count) >

		return atomic64_read(&zc->card->total_request_count) <

			atomic64_read(&pref_zc->card->total_request_count);

	return weight > pref_weight;

	return weight < pref_weight;

}



static inline bool zcrypt_queue_compare(struct zcrypt_queue *zq,
@@ -617,26 +617,27 @@ static inline bool zcrypt_queue_compare(struct zcrypt_queue *zq, 
					unsigned int pref_weight)

{

	if (!pref_zq)

		return false;

		return true;

	weight += atomic_read(&zq->load);

	pref_weight += atomic_read(&pref_zq->load);

	if (weight == pref_weight)

		return zq->queue->total_request_count >

		return zq->queue->total_request_count <

			pref_zq->queue->total_request_count;

	return weight > pref_weight;

	return weight < pref_weight;

}



/*

 * zcrypt ioctls.

 */

static long zcrypt_rsa_modexpo(struct ap_perms *perms,

			       struct zcrypt_track *tr,

			       struct ica_rsa_modexpo *mex)

{

	struct zcrypt_card *zc, *pref_zc;

	struct zcrypt_queue *zq, *pref_zq;

	unsigned int weight = 0, pref_weight = 0;

	unsigned int wgt = 0, pref_wgt = 0;

	unsigned int func_code;

	int qid = 0, rc = -ENODEV;

	int cpen, qpen, qid = 0, rc = -ENODEV;

	struct module *mod;



	trace_s390_zcrypt_req(mex, TP_ICARSAMODEXPO);
@@ -673,8 +674,12 @@ static long zcrypt_rsa_modexpo(struct ap_perms *perms, 
		if (!zcrypt_check_card(perms, zc->card->id))

			continue;

		/* get weight index of the card device	*/

		weight = zc->speed_rating[func_code];

		if (zcrypt_card_compare(zc, pref_zc, weight, pref_weight))

		wgt = zc->speed_rating[func_code];

		/* penalty if this msg was previously sent via this card */

		cpen = (tr && tr->again_counter && tr->last_qid &&

			AP_QID_CARD(tr->last_qid) == zc->card->id) ?

			TRACK_AGAIN_CARD_WEIGHT_PENALTY : 0;

		if (!zcrypt_card_compare(zc, pref_zc, wgt + cpen, pref_wgt))

			continue;

		for_each_zcrypt_queue(zq, zc) {

			/* check if device is online and eligible */
@@ -684,15 +689,19 @@ static long zcrypt_rsa_modexpo(struct ap_perms *perms, 
			if (!zcrypt_check_queue(perms,

						AP_QID_QUEUE(zq->queue->qid)))

				continue;

			if (zcrypt_queue_compare(zq, pref_zq,

						 weight, pref_weight))

			/* penalty if the msg was previously sent at this qid */

			qpen = (tr && tr->again_counter && tr->last_qid &&

				tr->last_qid == zq->queue->qid) ?

				TRACK_AGAIN_QUEUE_WEIGHT_PENALTY : 0;

			if (!zcrypt_queue_compare(zq, pref_zq,

						  wgt + cpen + qpen, pref_wgt))

				continue;

			pref_zc = zc;

			pref_zq = zq;

			pref_weight = weight;

			pref_wgt = wgt + cpen + qpen;

		}

	}

	pref_zq = zcrypt_pick_queue(pref_zc, pref_zq, &mod, weight);

	pref_zq = zcrypt_pick_queue(pref_zc, pref_zq, &mod, wgt);

	spin_unlock(&zcrypt_list_lock);



	if (!pref_zq) {
@@ -704,23 +713,28 @@ static long zcrypt_rsa_modexpo(struct ap_perms *perms, 
	rc = pref_zq->ops->rsa_modexpo(pref_zq, mex);



	spin_lock(&zcrypt_list_lock);

	zcrypt_drop_queue(pref_zc, pref_zq, mod, weight);

	zcrypt_drop_queue(pref_zc, pref_zq, mod, wgt);

	spin_unlock(&zcrypt_list_lock);



out:

	if (tr) {

		tr->last_rc = rc;

		tr->last_qid = qid;

	}

	trace_s390_zcrypt_rep(mex, func_code, rc,

			      AP_QID_CARD(qid), AP_QID_QUEUE(qid));

	return rc;

}



static long zcrypt_rsa_crt(struct ap_perms *perms,

			   struct zcrypt_track *tr,

			   struct ica_rsa_modexpo_crt *crt)

{

	struct zcrypt_card *zc, *pref_zc;

	struct zcrypt_queue *zq, *pref_zq;

	unsigned int weight = 0, pref_weight = 0;

	unsigned int wgt = 0, pref_wgt = 0;

	unsigned int func_code;

	int qid = 0, rc = -ENODEV;

	int cpen, qpen, qid = 0, rc = -ENODEV;

	struct module *mod;



	trace_s390_zcrypt_req(crt, TP_ICARSACRT);
@@ -757,8 +771,12 @@ static long zcrypt_rsa_crt(struct ap_perms *perms, 
		if (!zcrypt_check_card(perms, zc->card->id))

			continue;

		/* get weight index of the card device	*/

		weight = zc->speed_rating[func_code];

		if (zcrypt_card_compare(zc, pref_zc, weight, pref_weight))

		wgt = zc->speed_rating[func_code];

		/* penalty if this msg was previously sent via this card */

		cpen = (tr && tr->again_counter && tr->last_qid &&

			AP_QID_CARD(tr->last_qid) == zc->card->id) ?

			TRACK_AGAIN_CARD_WEIGHT_PENALTY : 0;

		if (!zcrypt_card_compare(zc, pref_zc, wgt + cpen, pref_wgt))

			continue;

		for_each_zcrypt_queue(zq, zc) {

			/* check if device is online and eligible */
@@ -768,15 +786,19 @@ static long zcrypt_rsa_crt(struct ap_perms *perms, 
			if (!zcrypt_check_queue(perms,

						AP_QID_QUEUE(zq->queue->qid)))

				continue;

			if (zcrypt_queue_compare(zq, pref_zq,

						 weight, pref_weight))

			/* penalty if the msg was previously sent at this qid */

			qpen = (tr && tr->again_counter && tr->last_qid &&

				tr->last_qid == zq->queue->qid) ?

				TRACK_AGAIN_QUEUE_WEIGHT_PENALTY : 0;

			if (!zcrypt_queue_compare(zq, pref_zq,

						  wgt + cpen + qpen, pref_wgt))

				continue;

			pref_zc = zc;

			pref_zq = zq;

			pref_weight = weight;

			pref_wgt = wgt + cpen + qpen;

		}

	}

	pref_zq = zcrypt_pick_queue(pref_zc, pref_zq, &mod, weight);

	pref_zq = zcrypt_pick_queue(pref_zc, pref_zq, &mod, wgt);

	spin_unlock(&zcrypt_list_lock);



	if (!pref_zq) {
@@ -788,25 +810,30 @@ static long zcrypt_rsa_crt(struct ap_perms *perms, 
	rc = pref_zq->ops->rsa_modexpo_crt(pref_zq, crt);



	spin_lock(&zcrypt_list_lock);

	zcrypt_drop_queue(pref_zc, pref_zq, mod, weight);

	zcrypt_drop_queue(pref_zc, pref_zq, mod, wgt);

	spin_unlock(&zcrypt_list_lock);



out:

	if (tr) {

		tr->last_rc = rc;

		tr->last_qid = qid;

	}

	trace_s390_zcrypt_rep(crt, func_code, rc,

			      AP_QID_CARD(qid), AP_QID_QUEUE(qid));

	return rc;

}



static long _zcrypt_send_cprb(bool userspace, struct ap_perms *perms,

			      struct zcrypt_track *tr,

			      struct ica_xcRB *xcRB)

{

	struct zcrypt_card *zc, *pref_zc;

	struct zcrypt_queue *zq, *pref_zq;

	struct ap_message ap_msg;

	unsigned int weight = 0, pref_weight = 0;

	unsigned int wgt = 0, pref_wgt = 0;

	unsigned int func_code;

	unsigned short *domain, tdom;

	int qid = 0, rc = -ENODEV;

	int cpen, qpen, qid = 0, rc = -ENODEV;

	struct module *mod;



	trace_s390_zcrypt_req(xcRB, TB_ZSECSENDCPRB);
@@ -843,8 +870,12 @@ static long _zcrypt_send_cprb(bool userspace, struct ap_perms *perms, 
		if (!zcrypt_check_card(perms, zc->card->id))

			continue;

		/* get weight index of the card device	*/

		weight = speed_idx_cca(func_code) * zc->speed_rating[SECKEY];

		if (zcrypt_card_compare(zc, pref_zc, weight, pref_weight))

		wgt = speed_idx_cca(func_code) * zc->speed_rating[SECKEY];

		/* penalty if this msg was previously sent via this card */

		cpen = (tr && tr->again_counter && tr->last_qid &&

			AP_QID_CARD(tr->last_qid) == zc->card->id) ?

			TRACK_AGAIN_CARD_WEIGHT_PENALTY : 0;

		if (!zcrypt_card_compare(zc, pref_zc, wgt + cpen, pref_wgt))

			continue;

		for_each_zcrypt_queue(zq, zc) {

			/* check if device is online and eligible */
@@ -857,15 +888,19 @@ static long _zcrypt_send_cprb(bool userspace, struct ap_perms *perms, 
			if (!zcrypt_check_queue(perms,

						AP_QID_QUEUE(zq->queue->qid)))

				continue;

			if (zcrypt_queue_compare(zq, pref_zq,

						 weight, pref_weight))

			/* penalty if the msg was previously sent at this qid */

			qpen = (tr && tr->again_counter && tr->last_qid &&

				tr->last_qid == zq->queue->qid) ?

				TRACK_AGAIN_QUEUE_WEIGHT_PENALTY : 0;

			if (!zcrypt_queue_compare(zq, pref_zq,

						  wgt + cpen + qpen, pref_wgt))

				continue;

			pref_zc = zc;

			pref_zq = zq;

			pref_weight = weight;

			pref_wgt = wgt + cpen + qpen;

		}

	}

	pref_zq = zcrypt_pick_queue(pref_zc, pref_zq, &mod, weight);

	pref_zq = zcrypt_pick_queue(pref_zc, pref_zq, &mod, wgt);

	spin_unlock(&zcrypt_list_lock);



	if (!pref_zq) {
@@ -881,11 +916,15 @@ static long _zcrypt_send_cprb(bool userspace, struct ap_perms *perms, 
	rc = pref_zq->ops->send_cprb(userspace, pref_zq, xcRB, &ap_msg);



	spin_lock(&zcrypt_list_lock);

	zcrypt_drop_queue(pref_zc, pref_zq, mod, weight);

	zcrypt_drop_queue(pref_zc, pref_zq, mod, wgt);

	spin_unlock(&zcrypt_list_lock);



out:

	ap_release_message(&ap_msg);

	if (tr) {

		tr->last_rc = rc;

		tr->last_qid = qid;

	}

	trace_s390_zcrypt_rep(xcRB, func_code, rc,

			      AP_QID_CARD(qid), AP_QID_QUEUE(qid));

	return rc;
@@ -893,7 +932,7 @@ out: 


long zcrypt_send_cprb(struct ica_xcRB *xcRB)

{

	return _zcrypt_send_cprb(false, &ap_perms, xcRB);

	return _zcrypt_send_cprb(false, &ap_perms, NULL, xcRB);

}

EXPORT_SYMBOL(zcrypt_send_cprb);
@@ -925,16 +964,17 @@ static bool is_desired_ep11_queue(unsigned int dev_qid, 
}



static long _zcrypt_send_ep11_cprb(bool userspace, struct ap_perms *perms,

				   struct zcrypt_track *tr,

				   struct ep11_urb *xcrb)

{

	struct zcrypt_card *zc, *pref_zc;

	struct zcrypt_queue *zq, *pref_zq;

	struct ep11_target_dev *targets;

	unsigned short target_num;

	unsigned int weight = 0, pref_weight = 0;

	unsigned int wgt = 0, pref_wgt = 0;

	unsigned int func_code;

	struct ap_message ap_msg;

	int qid = 0, rc = -ENODEV;

	int cpen, qpen, qid = 0, rc = -ENODEV;

	struct module *mod;



	trace_s390_zcrypt_req(xcrb, TP_ZSENDEP11CPRB);
@@ -983,8 +1023,12 @@ static long _zcrypt_send_ep11_cprb(bool userspace, struct ap_perms *perms, 
		if (!zcrypt_check_card(perms, zc->card->id))

			continue;

		/* get weight index of the card device	*/

		weight = speed_idx_ep11(func_code) * zc->speed_rating[SECKEY];

		if (zcrypt_card_compare(zc, pref_zc, weight, pref_weight))

		wgt = speed_idx_ep11(func_code) * zc->speed_rating[SECKEY];

		/* penalty if this msg was previously sent via this card */

		cpen = (tr && tr->again_counter && tr->last_qid &&

			AP_QID_CARD(tr->last_qid) == zc->card->id) ?

			TRACK_AGAIN_CARD_WEIGHT_PENALTY : 0;

		if (!zcrypt_card_compare(zc, pref_zc, wgt + cpen, pref_wgt))

			continue;

		for_each_zcrypt_queue(zq, zc) {

			/* check if device is online and eligible */
@@ -998,15 +1042,19 @@ static long _zcrypt_send_ep11_cprb(bool userspace, struct ap_perms *perms, 
			if (!zcrypt_check_queue(perms,

						AP_QID_QUEUE(zq->queue->qid)))

				continue;

			if (zcrypt_queue_compare(zq, pref_zq,

						 weight, pref_weight))

			/* penalty if the msg was previously sent at this qid */

			qpen = (tr && tr->again_counter && tr->last_qid &&

				tr->last_qid == zq->queue->qid) ?

				TRACK_AGAIN_QUEUE_WEIGHT_PENALTY : 0;

			if (!zcrypt_queue_compare(zq, pref_zq,

						  wgt + cpen + qpen, pref_wgt))

				continue;

			pref_zc = zc;

			pref_zq = zq;

			pref_weight = weight;

			pref_wgt = wgt + cpen + qpen;

		}

	}

	pref_zq = zcrypt_pick_queue(pref_zc, pref_zq, &mod, weight);

	pref_zq = zcrypt_pick_queue(pref_zc, pref_zq, &mod, wgt);

	spin_unlock(&zcrypt_list_lock);



	if (!pref_zq) {
@@ -1018,13 +1066,17 @@ static long _zcrypt_send_ep11_cprb(bool userspace, struct ap_perms *perms, 
	rc = pref_zq->ops->send_ep11_cprb(userspace, pref_zq, xcrb, &ap_msg);



	spin_lock(&zcrypt_list_lock);

	zcrypt_drop_queue(pref_zc, pref_zq, mod, weight);

	zcrypt_drop_queue(pref_zc, pref_zq, mod, wgt);

	spin_unlock(&zcrypt_list_lock);



out_free:

	kfree(targets);

out:

	ap_release_message(&ap_msg);

	if (tr) {

		tr->last_rc = rc;

		tr->last_qid = qid;

	}

	trace_s390_zcrypt_rep(xcrb, func_code, rc,

			      AP_QID_CARD(qid), AP_QID_QUEUE(qid));

	return rc;
@@ -1032,7 +1084,7 @@ out: 


long zcrypt_send_ep11_cprb(struct ep11_urb *xcrb)

{

	return _zcrypt_send_ep11_cprb(false, &ap_perms, xcrb);

	return _zcrypt_send_ep11_cprb(false, &ap_perms, NULL, xcrb);

}

EXPORT_SYMBOL(zcrypt_send_ep11_cprb);
@@ -1040,7 +1092,7 @@ static long zcrypt_rng(char *buffer) 
{

	struct zcrypt_card *zc, *pref_zc;

	struct zcrypt_queue *zq, *pref_zq;

	unsigned int weight = 0, pref_weight = 0;

	unsigned int wgt = 0, pref_wgt = 0;

	unsigned int func_code;

	struct ap_message ap_msg;

	unsigned int domain;
@@ -1062,22 +1114,21 @@ static long zcrypt_rng(char *buffer) 
		if (!zc->online || !(zc->card->functions & 0x10000000))

			continue;

		/* get weight index of the card device	*/

		weight = zc->speed_rating[func_code];

		if (zcrypt_card_compare(zc, pref_zc, weight, pref_weight))

		wgt = zc->speed_rating[func_code];

		if (!zcrypt_card_compare(zc, pref_zc, wgt, pref_wgt))

			continue;

		for_each_zcrypt_queue(zq, zc) {

			/* check if device is online and eligible */

			if (!zq->online || !zq->ops->rng)

				continue;

			if (zcrypt_queue_compare(zq, pref_zq,

						 weight, pref_weight))

			if (!zcrypt_queue_compare(zq, pref_zq, wgt, pref_wgt))

				continue;

			pref_zc = zc;

			pref_zq = zq;

			pref_weight = weight;

			pref_wgt = wgt;

		}

	}

	pref_zq = zcrypt_pick_queue(pref_zc, pref_zq, &mod, weight);

	pref_zq = zcrypt_pick_queue(pref_zc, pref_zq, &mod, wgt);

	spin_unlock(&zcrypt_list_lock);



	if (!pref_zq) {
@@ -1089,7 +1140,7 @@ static long zcrypt_rng(char *buffer) 
	rc = pref_zq->ops->rng(pref_zq, buffer, &ap_msg);



	spin_lock(&zcrypt_list_lock);

	zcrypt_drop_queue(pref_zc, pref_zq, mod, weight);

	zcrypt_drop_queue(pref_zc, pref_zq, mod, wgt);

	spin_unlock(&zcrypt_list_lock);



out:
@@ -1301,19 +1352,25 @@ static int zcrypt_requestq_count(void) 
static int icarsamodexpo_ioctl(struct ap_perms *perms, unsigned long arg)

{

	int rc;

	struct zcrypt_track tr;

	struct ica_rsa_modexpo mex;

	struct ica_rsa_modexpo __user *umex = (void __user *) arg;



	memset(&tr, 0, sizeof(tr));

	if (copy_from_user(&mex, umex, sizeof(mex)))

		return -EFAULT;

	do {

		rc = zcrypt_rsa_modexpo(perms, &mex);

	} while (rc == -EAGAIN);

		rc = zcrypt_rsa_modexpo(perms, &tr, &mex);

		if (rc == -EAGAIN)

			tr.again_counter++;

	} while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX);

	/* on failure: retry once again after a requested rescan */

	if ((rc == -ENODEV) && (zcrypt_process_rescan()))

		do {

			rc = zcrypt_rsa_modexpo(perms, &mex);

		} while (rc == -EAGAIN);

			rc = zcrypt_rsa_modexpo(perms, &tr, &mex);

			if (rc == -EAGAIN)

				tr.again_counter++;

		} while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX);

	if (rc) {

		ZCRYPT_DBF(DBF_DEBUG, "ioctl ICARSAMODEXPO rc=%d\n", rc);

		return rc;
@@ -1324,19 +1381,25 @@ static int icarsamodexpo_ioctl(struct ap_perms *perms, unsigned long arg) 
static int icarsacrt_ioctl(struct ap_perms *perms, unsigned long arg)

{

	int rc;

	struct zcrypt_track tr;

	struct ica_rsa_modexpo_crt crt;

	struct ica_rsa_modexpo_crt __user *ucrt = (void __user *) arg;



	memset(&tr, 0, sizeof(tr));

	if (copy_from_user(&crt, ucrt, sizeof(crt)))

		return -EFAULT;

	do {

		rc = zcrypt_rsa_crt(perms, &crt);

	} while (rc == -EAGAIN);

		rc = zcrypt_rsa_crt(perms, &tr, &crt);

		if (rc == -EAGAIN)

			tr.again_counter++;

	} while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX);

	/* on failure: retry once again after a requested rescan */

	if ((rc == -ENODEV) && (zcrypt_process_rescan()))

		do {

			rc = zcrypt_rsa_crt(perms, &crt);

		} while (rc == -EAGAIN);

			rc = zcrypt_rsa_crt(perms, &tr, &crt);

			if (rc == -EAGAIN)

				tr.again_counter++;

		} while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX);

	if (rc) {

		ZCRYPT_DBF(DBF_DEBUG, "ioctl ICARSACRT rc=%d\n", rc);

		return rc;
@@ -1348,18 +1411,24 @@ static int zsecsendcprb_ioctl(struct ap_perms *perms, unsigned long arg) 
{

	int rc;

	struct ica_xcRB xcRB;

	struct zcrypt_track tr;

	struct ica_xcRB __user *uxcRB = (void __user *) arg;



	memset(&tr, 0, sizeof(tr));

	if (copy_from_user(&xcRB, uxcRB, sizeof(xcRB)))

		return -EFAULT;

	do {

		rc = _zcrypt_send_cprb(true, perms, &xcRB);

	} while (rc == -EAGAIN);

		rc = _zcrypt_send_cprb(true, perms, &tr, &xcRB);

		if (rc == -EAGAIN)

			tr.again_counter++;

	} while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX);

	/* on failure: retry once again after a requested rescan */

	if ((rc == -ENODEV) && (zcrypt_process_rescan()))

		do {

			rc = _zcrypt_send_cprb(true, perms, &xcRB);

		} while (rc == -EAGAIN);

			rc = _zcrypt_send_cprb(true, perms, &tr, &xcRB);

			if (rc == -EAGAIN)

				tr.again_counter++;

		} while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX);

	if (rc)

		ZCRYPT_DBF(DBF_DEBUG, "ioctl ZSENDCPRB rc=%d status=0x%x\n",

			   rc, xcRB.status);
@@ -1372,18 +1441,24 @@ static int zsendep11cprb_ioctl(struct ap_perms *perms, unsigned long arg) 
{

	int rc;

	struct ep11_urb xcrb;

	struct zcrypt_track tr;

	struct ep11_urb __user *uxcrb = (void __user *)arg;



	memset(&tr, 0, sizeof(tr));

	if (copy_from_user(&xcrb, uxcrb, sizeof(xcrb)))

		return -EFAULT;

	do {

		rc = _zcrypt_send_ep11_cprb(true, perms, &xcrb);

	} while (rc == -EAGAIN);

		rc = _zcrypt_send_ep11_cprb(true, perms, &tr, &xcrb);

		if (rc == -EAGAIN)

			tr.again_counter++;

	} while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX);

	/* on failure: retry once again after a requested rescan */

	if ((rc == -ENODEV) && (zcrypt_process_rescan()))

		do {

			rc = _zcrypt_send_ep11_cprb(true, perms, &xcrb);

		} while (rc == -EAGAIN);

			rc = _zcrypt_send_ep11_cprb(true, perms, &tr, &xcrb);

			if (rc == -EAGAIN)

				tr.again_counter++;

		} while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX);

	if (rc)

		ZCRYPT_DBF(DBF_DEBUG, "ioctl ZSENDEP11CPRB rc=%d\n", rc);

	if (copy_to_user(uxcrb, &xcrb, sizeof(xcrb)))
@@ -1535,8 +1610,10 @@ static long trans_modexpo32(struct ap_perms *perms, struct file *filp, 
	struct compat_ica_rsa_modexpo __user *umex32 = compat_ptr(arg);

	struct compat_ica_rsa_modexpo mex32;

	struct ica_rsa_modexpo mex64;

	struct zcrypt_track tr;

	long rc;



	memset(&tr, 0, sizeof(tr));

	if (copy_from_user(&mex32, umex32, sizeof(mex32)))

		return -EFAULT;

	mex64.inputdata = compat_ptr(mex32.inputdata);
@@ -1546,13 +1623,17 @@ static long trans_modexpo32(struct ap_perms *perms, struct file *filp, 
	mex64.b_key = compat_ptr(mex32.b_key);

	mex64.n_modulus = compat_ptr(mex32.n_modulus);

	do {

		rc = zcrypt_rsa_modexpo(perms, &mex64);

	} while (rc == -EAGAIN);

		rc = zcrypt_rsa_modexpo(perms, &tr, &mex64);

		if (rc == -EAGAIN)

			tr.again_counter++;

	} while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX);

	/* on failure: retry once again after a requested rescan */

	if ((rc == -ENODEV) && (zcrypt_process_rescan()))

		do {

			rc = zcrypt_rsa_modexpo(perms, &mex64);

		} while (rc == -EAGAIN);

			rc = zcrypt_rsa_modexpo(perms, &tr, &mex64);

			if (rc == -EAGAIN)

				tr.again_counter++;

		} while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX);

	if (rc)

		return rc;

	return put_user(mex64.outputdatalength,
@@ -1577,8 +1658,10 @@ static long trans_modexpo_crt32(struct ap_perms *perms, struct file *filp, 
	struct compat_ica_rsa_modexpo_crt __user *ucrt32 = compat_ptr(arg);

	struct compat_ica_rsa_modexpo_crt crt32;

	struct ica_rsa_modexpo_crt crt64;

	struct zcrypt_track tr;

	long rc;



	memset(&tr, 0, sizeof(tr));

	if (copy_from_user(&crt32, ucrt32, sizeof(crt32)))

		return -EFAULT;

	crt64.inputdata = compat_ptr(crt32.inputdata);
@@ -1591,13 +1674,17 @@ static long trans_modexpo_crt32(struct ap_perms *perms, struct file *filp, 
	crt64.nq_prime = compat_ptr(crt32.nq_prime);

	crt64.u_mult_inv = compat_ptr(crt32.u_mult_inv);

	do {

		rc = zcrypt_rsa_crt(perms, &crt64);

	} while (rc == -EAGAIN);

		rc = zcrypt_rsa_crt(perms, &tr, &crt64);

		if (rc == -EAGAIN)

			tr.again_counter++;

	} while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX);

	/* on failure: retry once again after a requested rescan */

	if ((rc == -ENODEV) && (zcrypt_process_rescan()))

		do {

			rc = zcrypt_rsa_crt(perms, &crt64);

		} while (rc == -EAGAIN);

			rc = zcrypt_rsa_crt(perms, &tr, &crt64);

			if (rc == -EAGAIN)

				tr.again_counter++;

		} while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX);

	if (rc)

		return rc;

	return put_user(crt64.outputdatalength,
@@ -1629,9 +1716,11 @@ static long trans_xcRB32(struct ap_perms *perms, struct file *filp, 
{

	struct compat_ica_xcRB __user *uxcRB32 = compat_ptr(arg);

	struct compat_ica_xcRB xcRB32;

	struct zcrypt_track tr;

	struct ica_xcRB xcRB64;

	long rc;



	memset(&tr, 0, sizeof(tr));

	if (copy_from_user(&xcRB32, uxcRB32, sizeof(xcRB32)))

		return -EFAULT;

	xcRB64.agent_ID = xcRB32.agent_ID;
@@ -1655,13 +1744,17 @@ static long trans_xcRB32(struct ap_perms *perms, struct file *filp, 
	xcRB64.priority_window = xcRB32.priority_window;

	xcRB64.status = xcRB32.status;

	do {

		rc = _zcrypt_send_cprb(true, perms, &xcRB64);

	} while (rc == -EAGAIN);

		rc = _zcrypt_send_cprb(true, perms, &tr, &xcRB64);

		if (rc == -EAGAIN)

			tr.again_counter++;

	} while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX);

	/* on failure: retry once again after a requested rescan */

	if ((rc == -ENODEV) && (zcrypt_process_rescan()))

		do {

			rc = _zcrypt_send_cprb(true, perms, &xcRB64);

		} while (rc == -EAGAIN);

			rc = _zcrypt_send_cprb(true, perms, &tr, &xcRB64);

			if (rc == -EAGAIN)

				tr.again_counter++;

		} while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX);

	xcRB32.reply_control_blk_length = xcRB64.reply_control_blk_length;

	xcRB32.reply_data_length = xcRB64.reply_data_length;

	xcRB32.status = xcRB64.status;

drivers/s390/crypto/zcrypt_api.h

+13 −1
Original line number Diff line number Diff line
@@ -55,6 +55,18 @@ enum crypto_ops { 


struct zcrypt_queue;



/* struct to hold tracking information for a userspace request/response */

struct zcrypt_track {

	int again_counter;		/* retry attempts counter */

	int last_qid;			/* last qid used */

	int last_rc;			/* last return code */

};



/* defines related to message tracking */

#define TRACK_AGAIN_MAX 10

#define TRACK_AGAIN_CARD_WEIGHT_PENALTY  1000

#define TRACK_AGAIN_QUEUE_WEIGHT_PENALTY 10000



struct zcrypt_ops {

	long (*rsa_modexpo)(struct zcrypt_queue *, struct ica_rsa_modexpo *);

	long (*rsa_modexpo_crt)(struct zcrypt_queue *,
@@ -82,7 +94,7 @@ struct zcrypt_card { 
	int min_mod_size;		/* Min number of bits. */

	int max_mod_size;		/* Max number of bits. */

	int max_exp_bit_length;

	int speed_rating[NUM_OPS];	/* Speed idx of crypto ops. */

	const int *speed_rating;	/* Speed idx of crypto ops. */

	atomic_t load;			/* Utilization of the crypto device */



	int request_count;		/* # current requests. */

drivers/s390/crypto/zcrypt_cex2a.c

+2 −4
Original line number Diff line number Diff line
@@ -94,8 +94,7 @@ static int zcrypt_cex2a_card_probe(struct ap_device *ap_dev) 
	if (ac->ap_dev.device_type == AP_DEVICE_TYPE_CEX2A) {

		zc->min_mod_size = CEX2A_MIN_MOD_SIZE;

		zc->max_mod_size = CEX2A_MAX_MOD_SIZE;

		memcpy(zc->speed_rating, CEX2A_SPEED_IDX,

		       sizeof(CEX2A_SPEED_IDX));

		zc->speed_rating = CEX2A_SPEED_IDX;

		zc->max_exp_bit_length = CEX2A_MAX_MOD_SIZE;

		zc->type_string = "CEX2A";

		zc->user_space_type = ZCRYPT_CEX2A;
@@ -108,8 +107,7 @@ static int zcrypt_cex2a_card_probe(struct ap_device *ap_dev) 
			zc->max_mod_size = CEX3A_MAX_MOD_SIZE;

			zc->max_exp_bit_length = CEX3A_MAX_MOD_SIZE;

		}

		memcpy(zc->speed_rating, CEX3A_SPEED_IDX,

		       sizeof(CEX3A_SPEED_IDX));

		zc->speed_rating = CEX3A_SPEED_IDX;

		zc->type_string = "CEX3A";

		zc->user_space_type = ZCRYPT_CEX3A;

	} else {

drivers/s390/crypto/zcrypt_cex2c.c

+2 −4
Original line number Diff line number Diff line
@@ -266,8 +266,7 @@ static int zcrypt_cex2c_card_probe(struct ap_device *ap_dev) 
	case AP_DEVICE_TYPE_CEX2C:

		zc->user_space_type = ZCRYPT_CEX2C;

		zc->type_string = "CEX2C";

		memcpy(zc->speed_rating, CEX2C_SPEED_IDX,

		       sizeof(CEX2C_SPEED_IDX));

		zc->speed_rating = CEX2C_SPEED_IDX;

		zc->min_mod_size = CEX2C_MIN_MOD_SIZE;

		zc->max_mod_size = CEX2C_MAX_MOD_SIZE;

		zc->max_exp_bit_length = CEX2C_MAX_MOD_SIZE;
@@ -275,8 +274,7 @@ static int zcrypt_cex2c_card_probe(struct ap_device *ap_dev) 
	case AP_DEVICE_TYPE_CEX3C:

		zc->user_space_type = ZCRYPT_CEX3C;

		zc->type_string = "CEX3C";

		memcpy(zc->speed_rating, CEX3C_SPEED_IDX,

		       sizeof(CEX3C_SPEED_IDX));

		zc->speed_rating = CEX3C_SPEED_IDX;

		zc->min_mod_size = CEX3C_MIN_MOD_SIZE;

		zc->max_mod_size = CEX3C_MAX_MOD_SIZE;

		zc->max_exp_bit_length = CEX3C_MAX_MOD_SIZE;

drivers/s390/crypto/zcrypt_cex4.c

+23 −35

File changed.

Preview size limit exceeded, changes collapsed.

CRA Git | Maintained and supported by SUSTech CRA and CCSE