s390/zcrypt: Support up to 256 crypto adapters. (af4a7227) · Commits · 戴 / test

arch/s390/include/asm/ap.h

+3 −3

Original line number	Diff line number	Diff line
		@@ -20,9 +20,9 @@
		*/
		typedef unsigned int ap_qid_t;

		#define AP_MKQID(_card, _queue) (((_card) & 63) << 8 \| ((_queue) & 255))
		#define AP_QID_CARD(_qid) (((_qid) >> 8) & 63)
		#define AP_QID_QUEUE(_qid) ((_qid) & 255)
		#define AP_MKQID(_card, _queue) (((_card) & 0xff) << 8 \| ((_queue) & 0xff))
		#define AP_QID_CARD(_qid) (((_qid) >> 8) & 0xff)
		#define AP_QID_QUEUE(_qid) ((_qid) & 0xff)

		/**
		* struct ap_queue_status - Holds the AP queue status.

arch/s390/include/uapi/asm/zcrypt.h

+78 −46

Original line number	Diff line number	Diff line
		@@ -203,9 +203,9 @@ struct ep11_urb {
		} __attribute__((packed));

		/**
		* struct zcrypt_device_status
		* struct zcrypt_device_status_ext
		* @hwtype: raw hardware type
		* @qid: 6 bit device index, 8 bit domain
		* @qid: 8 bit device index, 8 bit domain
		* @functions: AP device function bit field 'abcdef'
		* a, b, c = reserved
		* d = CCA coprocessor
		@@ -214,28 +214,23 @@ struct ep11_urb {
		* @online online status
		* @reserved reserved
		*/
		struct zcrypt_device_status {
		struct zcrypt_device_status_ext {
		unsigned int hwtype:8;
		unsigned int qid:14;
		unsigned int qid:16;
		unsigned int online:1;
		unsigned int functions:6;
		unsigned int reserved:3;
		unsigned int reserved:1;
		};

		#define MAX_ZDEV_CARDIDS 64
		#define MAX_ZDEV_DOMAINS 256
		#define MAX_ZDEV_CARDIDS_EXT 256
		#define MAX_ZDEV_DOMAINS_EXT 256

		/**
		* Maximum number of zcrypt devices
		*/
		#define MAX_ZDEV_ENTRIES (MAX_ZDEV_CARDIDS * MAX_ZDEV_DOMAINS)
		/* Maximum number of zcrypt devices */
		#define MAX_ZDEV_ENTRIES_EXT (MAX_ZDEV_CARDIDS_EXT * MAX_ZDEV_DOMAINS_EXT)

		/**
		* zcrypt_device_matrix
		* Device matrix of all zcrypt devices
		*/
		struct zcrypt_device_matrix {
		struct zcrypt_device_status device[MAX_ZDEV_ENTRIES];
		/* Device matrix of all zcrypt devices */
		struct zcrypt_device_matrix_ext {
		struct zcrypt_device_status_ext device[MAX_ZDEV_ENTRIES_EXT];
		};

		#define AUTOSELECT ((unsigned int)0xFFFFFFFF)
		@@ -270,39 +265,35 @@ struct zcrypt_device_matrix {
		* ZSENDEP11CPRB
		* Send an arbitrary EP11 CPRB to an EP11 coprocessor crypto card.
		*
		* Z90STAT_STATUS_MASK
		* Return an 64 element array of unsigned chars for the status of
		* all devices.
		* ZCRYPT_DEVICE_STATUS
		* The given struct zcrypt_device_matrix_ext is updated with
		* status information for each currently known apqn.
		*
		* ZCRYPT_STATUS_MASK
		* Return an MAX_ZDEV_CARDIDS_EXT element array of unsigned chars for the
		* status of all devices.
		* 0x01: PCICA
		* 0x02: PCICC
		* 0x03: PCIXCC_MCL2
		* 0x04: PCIXCC_MCL3
		* 0x05: CEX2C
		* 0x06: CEX2A
		* 0x0d: device is disabled via the proc filesystem
		*
		* Z90STAT_QDEPTH_MASK
		* Return an 64 element array of unsigned chars for the queue
		* depth of all devices.
		*
		* Z90STAT_PERDEV_REQCNT
		* Return an 64 element array of unsigned integers for the number
		* of successfully completed requests per device since the device
		* was detected and made available.
		* 0x07: CEX3C
		* 0x08: CEX3A
		* 0x0a: CEX4
		* 0x0b: CEX5
		* 0x0c: CEX6
		* 0x0d: device is disabled
		*
		* Z90STAT_REQUESTQ_COUNT
		* Return an integer count of the number of entries waiting to be
		* sent to a device.
		* ZCRYPT_QDEPTH_MASK
		* Return an MAX_ZDEV_CARDIDS_EXT element array of unsigned chars for the
		* queue depth of all devices.
		*
		* Z90STAT_PENDINGQ_COUNT
		* Return an integer count of the number of entries sent to all
		* devices awaiting the reply.
		* ZCRYPT_PERDEV_REQCNT
		* Return an MAX_ZDEV_CARDIDS_EXT element array of unsigned integers for
		* the number of successfully completed requests per device since the
		* device was detected and made available.
		*
		* Z90STAT_TOTALOPEN_COUNT
		* Return an integer count of the number of open file handles.
		*
		* Z90STAT_DOMAIN_INDEX
		* Return the integer value of the Cryptographic Domain.
		*/

		/**
		@@ -312,15 +303,56 @@ struct zcrypt_device_matrix {
		#define ICARSACRT _IOC(_IOC_READ\|_IOC_WRITE, ZCRYPT_IOCTL_MAGIC, 0x06, 0)
		#define ZSECSENDCPRB _IOC(_IOC_READ\|_IOC_WRITE, ZCRYPT_IOCTL_MAGIC, 0x81, 0)
		#define ZSENDEP11CPRB _IOC(_IOC_READ\|_IOC_WRITE, ZCRYPT_IOCTL_MAGIC, 0x04, 0)

		#define ZCRYPT_DEVICE_STATUS _IOC(_IOC_READ\|_IOC_WRITE, ZCRYPT_IOCTL_MAGIC, 0x5f, 0)
		#define ZCRYPT_STATUS_MASK _IOR(ZCRYPT_IOCTL_MAGIC, 0x58, char[MAX_ZDEV_CARDIDS_EXT])
		#define ZCRYPT_QDEPTH_MASK _IOR(ZCRYPT_IOCTL_MAGIC, 0x59, char[MAX_ZDEV_CARDIDS_EXT])
		#define ZCRYPT_PERDEV_REQCNT _IOR(ZCRYPT_IOCTL_MAGIC, 0x5a, int[MAX_ZDEV_CARDIDS_EXT])

		/*
		* Only deprecated defines, structs and ioctls below this line.
		*/

		/* Deprecated: use MAX_ZDEV_CARDIDS_EXT */
		#define MAX_ZDEV_CARDIDS 64
		/* Deprecated: use MAX_ZDEV_DOMAINS_EXT */
		#define MAX_ZDEV_DOMAINS 256

		/* Deprecated: use MAX_ZDEV_ENTRIES_EXT */
		#define MAX_ZDEV_ENTRIES (MAX_ZDEV_CARDIDS * MAX_ZDEV_DOMAINS)

		/* Deprecated: use struct zcrypt_device_status_ext */
		struct zcrypt_device_status {
		unsigned int hwtype:8;
		unsigned int qid:14;
		unsigned int online:1;
		unsigned int functions:6;
		unsigned int reserved:3;
		};

		/* Deprecated: use struct zcrypt_device_matrix_ext */
		struct zcrypt_device_matrix {
		struct zcrypt_device_status device[MAX_ZDEV_ENTRIES];
		};

		/* Deprecated: use ZCRYPT_DEVICE_STATUS */
		#define ZDEVICESTATUS _IOC(_IOC_READ\|_IOC_WRITE, ZCRYPT_IOCTL_MAGIC, 0x4f, 0)
		/* Deprecated: use ZCRYPT_STATUS_MASK */
		#define Z90STAT_STATUS_MASK _IOR(ZCRYPT_IOCTL_MAGIC, 0x48, char[64])
		/* Deprecated: use ZCRYPT_QDEPTH_MASK */
		#define Z90STAT_QDEPTH_MASK _IOR(ZCRYPT_IOCTL_MAGIC, 0x49, char[64])
		/* Deprecated: use ZCRYPT_PERDEV_REQCNT */
		#define Z90STAT_PERDEV_REQCNT _IOR(ZCRYPT_IOCTL_MAGIC, 0x4a, int[64])

		/* Status ioctl calls */
		/* Deprecated: use sysfs to query these values */
		#define Z90STAT_REQUESTQ_COUNT _IOR(ZCRYPT_IOCTL_MAGIC, 0x44, int)
		#define Z90STAT_PENDINGQ_COUNT _IOR(ZCRYPT_IOCTL_MAGIC, 0x45, int)
		#define Z90STAT_TOTALOPEN_COUNT _IOR(ZCRYPT_IOCTL_MAGIC, 0x46, int)
		#define Z90STAT_DOMAIN_INDEX _IOR(ZCRYPT_IOCTL_MAGIC, 0x47, int)
		#define Z90STAT_STATUS_MASK _IOR(ZCRYPT_IOCTL_MAGIC, 0x48, char[64])
		#define Z90STAT_QDEPTH_MASK _IOR(ZCRYPT_IOCTL_MAGIC, 0x49, char[64])
		#define Z90STAT_PERDEV_REQCNT _IOR(ZCRYPT_IOCTL_MAGIC, 0x4a, int[64])

		/*
		* The ioctl number ranges 0x40 - 0x42 and 0x4b - 0x4e had been used in the
		* past, don't assign new ioctls for these.
		*/

		#endif /* __ASM_S390_ZCRYPT_H */

drivers/s390/crypto/ap_bus.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -17,7 +17,7 @@
		#include <linux/types.h>
		#include <asm/ap.h>

		#define AP_DEVICES 64 /* Number of AP devices. */
		#define AP_DEVICES 256 /* Number of AP devices. */
		#define AP_DOMAINS 256 /* Number of AP domains. */
		#define AP_RESET_TIMEOUT (HZ0.7) / Time in ticks for reset timeouts. */
		#define AP_CONFIG_TIME 30 /* Time in seconds between AP bus rescans. */

drivers/s390/crypto/pkey_api.c

+21 −20

Original line number	Diff line number	Diff line
		@@ -889,7 +889,7 @@ int pkey_findcard(const struct pkey_seckey *seckey,
		u16 pcardnr, u16 pdomain, int verify)
		{
		struct secaeskeytoken t = (struct secaeskeytoken ) seckey;
		struct zcrypt_device_matrix *device_matrix;
		struct zcrypt_device_status_ext *device_status;
		u16 card, dom;
		u64 mkvp[2];
		int i, rc, oi = -1;
		@@ -899,18 +899,19 @@ int pkey_findcard(const struct pkey_seckey *seckey,
		return -EINVAL;

		/* fetch status of all crypto cards */
		device_matrix = kmalloc(sizeof(struct zcrypt_device_matrix),
		device_status = kmalloc(MAX_ZDEV_ENTRIES_EXT
		* sizeof(struct zcrypt_device_status_ext),
		GFP_KERNEL);
		if (!device_matrix)
		if (!device_status)
		return -ENOMEM;
		zcrypt_device_status_mask(device_matrix);
		zcrypt_device_status_mask_ext(device_status);

		/* walk through all crypto cards */
		for (i = 0; i < MAX_ZDEV_ENTRIES; i++) {
		card = AP_QID_CARD(device_matrix->device[i].qid);
		dom = AP_QID_QUEUE(device_matrix->device[i].qid);
		if (device_matrix->device[i].online &&
		device_matrix->device[i].functions & 0x04) {
		for (i = 0; i < MAX_ZDEV_ENTRIES_EXT; i++) {
		card = AP_QID_CARD(device_status[i].qid);
		dom = AP_QID_QUEUE(device_status[i].qid);
		if (device_status[i].online &&
		device_status[i].functions & 0x04) {
		/* an enabled CCA Coprocessor card */
		/* try cached mkvp */
		if (mkvp_cache_fetch(card, dom, mkvp) == 0 &&
		@@ -930,14 +931,14 @@ int pkey_findcard(const struct pkey_seckey *seckey,
		mkvp_cache_scrub(card, dom);
		}
		}
		if (i >= MAX_ZDEV_ENTRIES) {
		if (i >= MAX_ZDEV_ENTRIES_EXT) {
		/* nothing found, so this time without cache */
		for (i = 0; i < MAX_ZDEV_ENTRIES; i++) {
		if (!(device_matrix->device[i].online &&
		device_matrix->device[i].functions & 0x04))
		for (i = 0; i < MAX_ZDEV_ENTRIES_EXT; i++) {
		if (!(device_status[i].online &&
		device_status[i].functions & 0x04))
		continue;
		card = AP_QID_CARD(device_matrix->device[i].qid);
		dom = AP_QID_QUEUE(device_matrix->device[i].qid);
		card = AP_QID_CARD(device_status[i].qid);
		dom = AP_QID_QUEUE(device_status[i].qid);
		/* fresh fetch mkvp from adapter */
		if (fetch_mkvp(card, dom, mkvp) == 0) {
		mkvp_cache_update(card, dom, mkvp);
		@@ -947,13 +948,13 @@ int pkey_findcard(const struct pkey_seckey *seckey,
		oi = i;
		}
		}
		if (i >= MAX_ZDEV_ENTRIES && oi >= 0) {
		if (i >= MAX_ZDEV_ENTRIES_EXT && oi >= 0) {
		/* old mkvp matched, use this card then */
		card = AP_QID_CARD(device_matrix->device[oi].qid);
		dom = AP_QID_QUEUE(device_matrix->device[oi].qid);
		card = AP_QID_CARD(device_status[oi].qid);
		dom = AP_QID_QUEUE(device_status[oi].qid);
		}
		}
		if (i < MAX_ZDEV_ENTRIES \|\| oi >= 0) {
		if (i < MAX_ZDEV_ENTRIES_EXT \|\| oi >= 0) {
		if (pcardnr)
		*pcardnr = card;
		if (pdomain)
		@@ -962,7 +963,7 @@ int pkey_findcard(const struct pkey_seckey *seckey,
		} else
		rc = -ENODEV;

		kfree(device_matrix);
		kfree(device_status);
		return rc;
		}
		EXPORT_SYMBOL(pkey_findcard);

drivers/s390/crypto/zcrypt_api.c

+133 −49

Original line number	Diff line number	Diff line
		@@ -605,19 +605,24 @@ out:
		return rc;
		}

		void zcrypt_device_status_mask(struct zcrypt_device_matrix *matrix)
		static void zcrypt_device_status_mask(struct zcrypt_device_status *devstatus)
		{
		struct zcrypt_card *zc;
		struct zcrypt_queue *zq;
		struct zcrypt_device_status *stat;
		int card, queue;

		memset(devstatus, 0, MAX_ZDEV_ENTRIES
		* sizeof(struct zcrypt_device_status));

		memset(matrix, 0, sizeof(*matrix));
		spin_lock(&zcrypt_list_lock);
		for_each_zcrypt_card(zc) {
		for_each_zcrypt_queue(zq, zc) {
		stat = matrix->device;
		stat += AP_QID_CARD(zq->queue->qid) * MAX_ZDEV_DOMAINS;
		stat += AP_QID_QUEUE(zq->queue->qid);
		card = AP_QID_CARD(zq->queue->qid);
		if (card >= MAX_ZDEV_CARDIDS)
		continue;
		queue = AP_QID_QUEUE(zq->queue->qid);
		stat = &devstatus[card * AP_DOMAINS + queue];
		stat->hwtype = zc->card->ap_dev.device_type;
		stat->functions = zc->card->functions >> 26;
		stat->qid = zq->queue->qid;
		@@ -626,40 +631,70 @@ void zcrypt_device_status_mask(struct zcrypt_device_matrix *matrix)
		}
		spin_unlock(&zcrypt_list_lock);
		}
		EXPORT_SYMBOL(zcrypt_device_status_mask);

		static void zcrypt_status_mask(char status[AP_DEVICES])
		void zcrypt_device_status_mask_ext(struct zcrypt_device_status_ext *devstatus)
		{
		struct zcrypt_card *zc;
		struct zcrypt_queue *zq;
		struct zcrypt_device_status_ext *stat;
		int card, queue;

		memset(devstatus, 0, MAX_ZDEV_ENTRIES_EXT
		* sizeof(struct zcrypt_device_status_ext));

		memset(status, 0, sizeof(char) * AP_DEVICES);
		spin_lock(&zcrypt_list_lock);
		for_each_zcrypt_card(zc) {
		for_each_zcrypt_queue(zq, zc) {
		if (AP_QID_QUEUE(zq->queue->qid) != ap_domain_index)
		card = AP_QID_CARD(zq->queue->qid);
		queue = AP_QID_QUEUE(zq->queue->qid);
		stat = &devstatus[card * AP_DOMAINS + queue];
		stat->hwtype = zc->card->ap_dev.device_type;
		stat->functions = zc->card->functions >> 26;
		stat->qid = zq->queue->qid;
		stat->online = zq->online ? 0x01 : 0x00;
		}
		}
		spin_unlock(&zcrypt_list_lock);
		}
		EXPORT_SYMBOL(zcrypt_device_status_mask_ext);

		static void zcrypt_status_mask(char status[], size_t max_adapters)
		{
		struct zcrypt_card *zc;
		struct zcrypt_queue *zq;
		int card;

		memset(status, 0, max_adapters);
		spin_lock(&zcrypt_list_lock);
		for_each_zcrypt_card(zc) {
		for_each_zcrypt_queue(zq, zc) {
		card = AP_QID_CARD(zq->queue->qid);
		if (AP_QID_QUEUE(zq->queue->qid) != ap_domain_index
		\|\| card >= max_adapters)
		continue;
		status[AP_QID_CARD(zq->queue->qid)] =
		zc->online ? zc->user_space_type : 0x0d;
		status[card] = zc->online ? zc->user_space_type : 0x0d;
		}
		}
		spin_unlock(&zcrypt_list_lock);
		}

		static void zcrypt_qdepth_mask(char qdepth[AP_DEVICES])
		static void zcrypt_qdepth_mask(char qdepth[], size_t max_adapters)
		{
		struct zcrypt_card *zc;
		struct zcrypt_queue *zq;
		int card;

		memset(qdepth, 0, sizeof(char) * AP_DEVICES);
		memset(qdepth, 0, max_adapters);
		spin_lock(&zcrypt_list_lock);
		local_bh_disable();
		for_each_zcrypt_card(zc) {
		for_each_zcrypt_queue(zq, zc) {
		if (AP_QID_QUEUE(zq->queue->qid) != ap_domain_index)
		card = AP_QID_CARD(zq->queue->qid);
		if (AP_QID_QUEUE(zq->queue->qid) != ap_domain_index
		\|\| card >= max_adapters)
		continue;
		spin_lock(&zq->queue->lock);
		qdepth[AP_QID_CARD(zq->queue->qid)] =
		qdepth[card] =
		zq->queue->pendingq_count +
		zq->queue->requestq_count;
		spin_unlock(&zq->queue->lock);
		@@ -669,21 +704,23 @@ static void zcrypt_qdepth_mask(char qdepth[AP_DEVICES])
		spin_unlock(&zcrypt_list_lock);
		}

		static void zcrypt_perdev_reqcnt(int reqcnt[AP_DEVICES])
		static void zcrypt_perdev_reqcnt(int reqcnt[], size_t max_adapters)
		{
		struct zcrypt_card *zc;
		struct zcrypt_queue *zq;
		int card;

		memset(reqcnt, 0, sizeof(int) * AP_DEVICES);
		memset(reqcnt, 0, sizeof(int) * max_adapters);
		spin_lock(&zcrypt_list_lock);
		local_bh_disable();
		for_each_zcrypt_card(zc) {
		for_each_zcrypt_queue(zq, zc) {
		if (AP_QID_QUEUE(zq->queue->qid) != ap_domain_index)
		card = AP_QID_CARD(zq->queue->qid);
		if (AP_QID_QUEUE(zq->queue->qid) != ap_domain_index
		\|\| card >= max_adapters)
		continue;
		spin_lock(&zq->queue->lock);
		reqcnt[AP_QID_CARD(zq->queue->qid)] =
		zq->queue->total_request_count;
		reqcnt[card] = zq->queue->total_request_count;
		spin_unlock(&zq->queue->lock);
		}
		}
		@@ -740,7 +777,7 @@ static int zcrypt_requestq_count(void)
		static long zcrypt_unlocked_ioctl(struct file *filp, unsigned int cmd,
		unsigned long arg)
		{
		int rc;
		int rc = 0;

		switch (cmd) {
		case ICARSAMODEXPO: {
		@@ -819,48 +856,48 @@ static long zcrypt_unlocked_ioctl(struct file *filp, unsigned int cmd,
		return -EFAULT;
		return rc;
		}
		case ZDEVICESTATUS: {
		struct zcrypt_device_matrix *device_status;
		case ZCRYPT_DEVICE_STATUS: {
		struct zcrypt_device_status_ext *device_status;
		size_t total_size = MAX_ZDEV_ENTRIES_EXT
		* sizeof(struct zcrypt_device_status_ext);

		device_status = kzalloc(sizeof(struct zcrypt_device_matrix),
		GFP_KERNEL);
		device_status = kzalloc(total_size, GFP_KERNEL);
		if (!device_status)
		return -ENOMEM;

		zcrypt_device_status_mask(device_status);

		zcrypt_device_status_mask_ext(device_status);
		if (copy_to_user((char __user *) arg, device_status,
		sizeof(struct zcrypt_device_matrix))) {
		kfree(device_status);
		return -EFAULT;
		}

		total_size))
		rc = -EFAULT;
		kfree(device_status);
		return 0;
		return rc;
		}
		case Z90STAT_STATUS_MASK: {
		case ZCRYPT_STATUS_MASK: {
		char status[AP_DEVICES];
		zcrypt_status_mask(status);
		if (copy_to_user((char __user *) arg, status,
		sizeof(char) * AP_DEVICES))

		zcrypt_status_mask(status, AP_DEVICES);
		if (copy_to_user((char __user *) arg, status, sizeof(status)))
		return -EFAULT;
		return 0;
		}
		case Z90STAT_QDEPTH_MASK: {
		case ZCRYPT_QDEPTH_MASK: {
		char qdepth[AP_DEVICES];
		zcrypt_qdepth_mask(qdepth);
		if (copy_to_user((char __user *) arg, qdepth,
		sizeof(char) * AP_DEVICES))

		zcrypt_qdepth_mask(qdepth, AP_DEVICES);
		if (copy_to_user((char __user *) arg, qdepth, sizeof(qdepth)))
		return -EFAULT;
		return 0;
		}
		case Z90STAT_PERDEV_REQCNT: {
		int reqcnt[AP_DEVICES];
		zcrypt_perdev_reqcnt(reqcnt);
		if (copy_to_user((int __user *) arg, reqcnt,
		sizeof(int) * AP_DEVICES))
		return -EFAULT;
		return 0;
		case ZCRYPT_PERDEV_REQCNT: {
		int *reqcnt;

		reqcnt = kcalloc(AP_DEVICES, sizeof(int), GFP_KERNEL);
		if (!reqcnt)
		return -ENOMEM;
		zcrypt_perdev_reqcnt(reqcnt, AP_DEVICES);
		if (copy_to_user((int __user *) arg, reqcnt, sizeof(reqcnt)))
		rc = -EFAULT;
		kfree(reqcnt);
		return rc;
		}
		case Z90STAT_REQUESTQ_COUNT:
		return put_user(zcrypt_requestq_count(), (int __user *) arg);
		@@ -871,8 +908,55 @@ static long zcrypt_unlocked_ioctl(struct file *filp, unsigned int cmd,
		(int __user *) arg);
		case Z90STAT_DOMAIN_INDEX:
		return put_user(ap_domain_index, (int __user *) arg);
		/*
		* Deprecated ioctls
		*/
		case ZDEVICESTATUS: {
		/* the old ioctl supports only 64 adapters */
		struct zcrypt_device_status *device_status;
		size_t total_size = MAX_ZDEV_ENTRIES
		* sizeof(struct zcrypt_device_status);

		device_status = kzalloc(total_size, GFP_KERNEL);
		if (!device_status)
		return -ENOMEM;
		zcrypt_device_status_mask(device_status);
		if (copy_to_user((char __user *) arg, device_status,
		total_size))
		rc = -EFAULT;
		kfree(device_status);
		return rc;
		}
		case Z90STAT_STATUS_MASK: {
		/* the old ioctl supports only 64 adapters */
		char status[MAX_ZDEV_CARDIDS];

		zcrypt_status_mask(status, MAX_ZDEV_CARDIDS);
		if (copy_to_user((char __user *) arg, status, sizeof(status)))
		return -EFAULT;
		return 0;
		}
		case Z90STAT_QDEPTH_MASK: {
		/* the old ioctl supports only 64 adapters */
		char qdepth[MAX_ZDEV_CARDIDS];

		zcrypt_qdepth_mask(qdepth, MAX_ZDEV_CARDIDS);
		if (copy_to_user((char __user *) arg, qdepth, sizeof(qdepth)))
		return -EFAULT;
		return 0;
		}
		case Z90STAT_PERDEV_REQCNT: {
		/* the old ioctl supports only 64 adapters */
		int reqcnt[MAX_ZDEV_CARDIDS];

		zcrypt_perdev_reqcnt(reqcnt, MAX_ZDEV_CARDIDS);
		if (copy_to_user((int __user *) arg, reqcnt, sizeof(reqcnt)))
		return -EFAULT;
		return 0;
		}
		/* unknown ioctl number */
		default:
		ZCRYPT_DBF(DBF_DEBUG, "unknown ioctl 0x%08x\n", cmd);
		return -ENOIOCTLCMD;
		}
		}

Admin message