module/crypto: fix some typos & clean up comments

 * of the poller. It is mainly a performance knob as it effectively determines how

 * much work the poller has to do.  However even that can vary between crypto drivers

 * as the AESNI_MB driver for example does all the crypto work on dequeue whereas the

 * QAT drvier just dequeues what has been completed already.

 * QAT driver just dequeues what has been completed already.

 */

#define MAX_DEQUEUE_BURST_SIZE	64

/* When enqueueing, we need to supply the crypto driver with an array of pointers to

 * operation structs. As each of these can be max 512B, we can adjust the CRYPTO_MAX_IO

 * value in conjunction with the the other defines to make sure we're not using crazy amounts

 * value in conjunction with the other defines to make sure we're not using crazy amounts

 * of memory. All of these numbers can and probably should be adjusted based on the

 * workload. By default we'll use the worst case (smallest) block size for the

 * minimum number of array entries. As an example, a CRYPTO_MAX_IO size of 64K with 512B

/* The number of MBUFS we need must be a power of two and to support other small IOs

 * in addition to the limits mentioned above, we go to the next power of two. It is

 * big number because it is one mempool for source and desitnation mbufs. It may

 * big number because it is one mempool for source and destination mbufs. It may

 * need to be bigger to support multiple crypto drivers at once.

 */

#define NUM_MBUFS		32768

static int vbdev_crypto_claim(struct spdk_bdev *bdev);

static void vbdev_crypto_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io);

/* list of crypto_bdev names and their base bdevs via configuration file.

 * Used so we can parse the conf once at init and use this list in examine().

 */

/* List of crypto_bdev names and their base bdevs via configuration file. */

struct bdev_names {

	char			*vbdev_name;	/* name of the vbdev to create */

	char			*bdev_name;	/* base bdev name */

	struct spdk_bdev_io *orig_io;			/* the original IO */

	struct spdk_bdev_io *read_io;			/* the read IO we issued */

	/* Used for the single contigous buffer that serves as the crypto destination target for writes */

	/* Used for the single contiguous buffer that serves as the crypto destination target for writes */

	uint64_t cry_num_blocks;			/* num of blocks for the contiguous buffer */

	uint64_t cry_offset_blocks;			/* block offset on media */

	struct iovec cry_iov;				/* iov representing contig write buffer */

#endif

	};

	/* Pre-setup all pottential qpairs now and assign them in the channel

	/* Pre-setup all potential qpairs now and assign them in the channel

	 * callback. If we were to create them there, we'd have to stop the

	 * entire device affecting all other threads that might be using it

	 * even on other queue pairs.

	if (bdev_io->type == SPDK_BDEV_IO_TYPE_READ) {

		/* Complete the original IO and then free the one that we created

		 * as a result of issuing an IO via submit_reqeust.

		 * as a result of issuing an IO via submit_request.

		 */

		if (bdev_io->internal.status != SPDK_BDEV_IO_STATUS_FAILED) {

			spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_SUCCESS);

	 * of crypto operations is straightforward. We build both the op, the mbuf and the

	 * dst_mbuf in our local arrays by looping through the length of the bdev IO and

	 * picking off LBA sized blocks of memory from the IOVs as we walk through them. Each

	 * LBA sized chunck of memory will correspond 1:1 to a crypto operation and a single

	 * LBA sized chunk of memory will correspond 1:1 to a crypto operation and a single

	 * mbuf per crypto operation.

	 */

	total_remaining = total_length;

	struct vbdev_crypto *crypto_bdev = (struct vbdev_crypto *)ctx;

	/* The IO channel code will allocate a channel for us which consists of

	 * the SPDK cahnnel structure plus the size of our crypto_io_channel struct

	 * the SPDK channel structure plus the size of our crypto_io_channel struct

	 * that we passed in when we registered our IO device. It will then call

	 * our channel create callback to populate any elements that we need to

	 * update.

	pthread_mutex_unlock(&g_device_qp_lock);

	assert(crypto_ch->device_qp);

	/* We use this queue to track outstanding IO in our lyaer. */

	/* We use this queue to track outstanding IO in our layer. */

	TAILQ_INIT(&crypto_ch->pending_cry_ios);

	return 0;

	return rc;

}

/* Called at driver init time, parses config file to preapre for examine calls,

/* Called at driver init time, parses config file to prepare for examine calls,

 * also fully initializes the crypto drivers.

 */

static int

	g_bdev_io->type = SPDK_BDEV_IO_TYPE_WRITE;

	g_enqueue_mock = g_dequeue_mock = ut_rte_crypto_op_bulk_alloc = 1;

	/* test failure of spdk_mempool_get_bulk(), will result in success becuase it

	/* test failure of spdk_mempool_get_bulk(), will result in success because it

	 * will get queued.

	 */

	g_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS;

{

	/* TODO: There are a few different ways to do this given that

	 * the code uses spdk_for_each_channel() to implement reset

	 * handling. SUbmitting w/o UT for this function for now and

	 * handling. Submitting w/o UT for this function for now and

	 * will follow up with something shortly.

	 */

}