hermon_srq.c revision 9e39c5ba00a55fa05777cc94b148296af305e135
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Hermon Shared Receive Queue Processing Routines
*
* Implements all the routines necessary for allocating, freeing, querying,
* modifying and posting shared receive queues.
*/
/*
* hermon_srq_alloc()
* Context: Can be called only from user or kernel context.
*/
int
{
/*
* options-->wq_location used to be for location, now explicitly
* LOCATION_NORMAL
*/
/*
* Extract the necessary info from the hermon_srq_info_t structure
*/
/*
* Determine whether SRQ is being allocated for userland access or
* whether it is being allocated for kernel access. If the SRQ is
* being allocated for userland access, then lookup the UAR doorbell
* page number for the current process. Note: If this is not found
* (e.g. if the process has not previously open()'d the Hermon driver),
* then an error is returned.
*/
if (srq_is_umap) {
if (status != DDI_SUCCESS) {
goto srqalloc_fail3;
}
} else {
}
/* Increase PD refcnt */
/* Allocate an SRQ context entry */
if (status != DDI_SUCCESS) {
goto srqalloc_fail1;
}
/* Allocate the SRQ Handle entry */
if (status != DDI_SUCCESS) {
goto srqalloc_fail2;
}
/* Calculate the SRQ number */
/* just use the index, implicit in Hermon */
/*
* If this will be a user-mappable SRQ, then allocate an entry for
* the "userland resources database". This will later be added to
* the database (after all further SRQ operations are successful).
* If we fail here, we must undo the reference counts and the
* previous resource allocation.
*/
if (srq_is_umap) {
goto srqalloc_fail3;
}
}
/*
* Allocate the doorbell record. Hermon just needs one for the
* SRQ, and use uarpg (above) as the uar index
*/
if (status != DDI_SUCCESS) {
goto srqalloc_fail4;
}
/*
* Calculate the appropriate size for the SRQ.
* Note: All Hermon SRQs must be a power-of-2 in size. Also
* they may not be any smaller than HERMON_SRQ_MIN_SIZE. This step
* is to round the requested size up to the next highest power-of-2
*/
}
/*
* Next we verify that the rounded-up size is valid (i.e. consistent
* then obviously we have a lot of cleanup to do before returning.
*/
goto srqalloc_fail4a;
}
/*
* Next we verify that the requested number of SGL is valid (i.e.
* limits). If not, then obviously the same cleanup needs to be done.
*/
goto srqalloc_fail4a;
}
/*
* Determine the SRQ's WQE sizes. This depends on the requested
* number of SGLs. Note: This also has the side-effect of
* calculating the real number of SGLs (for the calculated WQE size)
*/
&srq->srq_wq_sgl);
/*
* Allocate the memory for SRQ work queues. Note: The location from
* which we will allocate these work queues is always
* QUEUE_LOCATION_NORMAL. Since Hermon work queues are not
* allowed to cross a 32-bit (4GB) boundary, the alignment of the work
* queue memory is very important. We used to allocate work queues
* (the combined receive and send queues) so that they would be aligned
* on their combined size. That alignment guaranteed that they would
* never cross the 4GB boundary (Hermon work queues are on the order of
* MBs at maximum). Now we are able to relax this alignment constraint
* by ensuring that the IB address assigned to the queue memory (as a
* result of the hermon_mr_register() call) is offset from zero.
* Previously, we had wanted to use the ddi_dma_mem_alloc() routine to
* guarantee the alignment, but when attempting to use IOMMU bypass
* mode we found that we were not allowed to specify any alignment that
* was more restrictive than the system page size. So we avoided this
* constraint by passing two alignment values, one for the memory
* allocation itself and the other for the DMA handle (for later bind).
* This used to cause more memory than necessary to be allocated (in
* order to guarantee the more restrictive alignment contraint). But
* be guaranteeing the zero-based IB virtual address for the queue, we
* are able to conserve this memory.
*
* Note: If SRQ is not user-mappable, then it may come from either
* kernel system memory or from HCA-attached local DDR memory.
*
* Note2: We align this queue on a pagesize boundary. This is required
* to make sure that all the resulting IB addresses will start at 0, for
* a zero-based queue. By making sure we are aligned on at least a
* page, any offset we use into our queue will be the same as when we
* perform hermon_srq_modify() operations later.
*/
if (srq_is_umap) {
} else {
}
if (status != DDI_SUCCESS) {
goto srqalloc_fail4a;
}
/*
* Register the memory for the SRQ work queues. The memory for the SRQ
* must be registered in the Hermon cMPT tables. This gives us the LKey
* to specify in the SRQ context later. Note: If the work queue is to
* be allocated from DDR memory, then only a "bypass" mapping is
* appropriate. And if the SRQ memory is user-mappable, then we force
* DDI_DMA_CONSISTENT mapping. Also, in order to meet the alignment
* restriction, we pass the "mro_bind_override_addr" flag in the call
* to hermon_mr_register(). This guarantees that the resulting IB vaddr
* will be zero-based (modulo the offset into the first page). If we
* fail here, we still have the bunch of resource and reference count
* cleanup to do.
*/
&mr_op, HERMON_SRQ_CMPT);
if (status != DDI_SUCCESS) {
goto srqalloc_fail5;
}
/*
* Calculate the offset between the kernel virtual address space
* and the IB virtual address space. This will be used when
* posting work requests to properly initialize each WQE.
*/
/*
* Fill in all the return arguments (if necessary). This includes
* real queue size and real SGLs.
*/
if (real_sizes != NULL) {
}
/*
* Fill in the SRQC entry. This is the final step before passing
* ownership of the SRQC entry to the Hermon hardware. We use all of
* the information collected/calculated above to fill in the
* requisite portions of the SRQC. Note: If this SRQ is going to be
* used for userland access, then we need to set the UAR page number
* appropriately (otherwise it's a "don't care")
*/
/* 16-byte chunks */
/*
* all others - specifically, xrcd, cqn_xrc, lwm, wqe_cnt, and wqe_cntr
* are zero thanks to the bzero of the structure
*/
/*
* Write the SRQC entry to hardware. Lastly, we pass ownership of
* the entry to the hardware (using the Hermon SW2HW_SRQ firmware
* command). Note: In general, this operation shouldn't fail. But
* if it does, we have to undo everything we've done above before
* returning error.
*/
if (status != HERMON_CMD_SUCCESS) {
status);
if (status == HERMON_CMD_INVALID_STATUS) {
}
status = ibc_get_ci_failure(0);
goto srqalloc_fail8;
}
/*
* Fill in the rest of the Hermon SRQ handle. We can update
* the following fields for use in further operations on the SRQ.
*/
srq->srq_refcnt = 0;
/*
* Put SRQ handle in Hermon SRQNum-to-SRQhdl list. Then fill in the
* "srqhdl" and return success
*/
/*
* If this is a user-mappable SRQ, then we need to insert the
* previously allocated entry into the "userland resources database".
* This will allow for later lookup during devmap() (i.e. mmap())
* calls.
*/
if (srq->srq_is_umap) {
} else { /* initialize work queue for kernel SRQs */
for (i = 0; i < last; i++) {
}
}
return (status);
/*
* The following is cleanup for all possible failure cases in this routine
*/
HERMON_SLEEPFLAG_FOR_CONTEXT()) != DDI_SUCCESS) {
}
if (srq_is_umap) {
}
return (status);
}
/*
* hermon_srq_free()
* Context: Can be called only from user or kernel context.
*/
/* ARGSUSED */
int
{
int status;
/*
* Pull all the necessary information from the Hermon Shared Receive
* Queue handle. This is necessary here because the resource for the
* SRQ handle is going to be freed up as part of this operation.
*/
/*
* If there are work queues still associated with the SRQ, then return
* an error. Otherwise, we will be holding the SRQ lock.
*/
if (srq->srq_refcnt != 0) {
return (IBT_SRQ_IN_USE);
}
/*
* If this was a user-mappable SRQ, then we need to remove its entry
* from the "userland resources database". If it is also currently
* mmap()'d out to a user process, then we need to call
* devmap_devmem_remap() to remap the SRQ memory to an invalid mapping.
* We also need to invalidate the SRQ tracking information for the
* user mapping.
*/
if (srq->srq_is_umap) {
if (status != DDI_SUCCESS) {
return (ibc_get_ci_failure(0));
}
if (status != DDI_SUCCESS) {
"devmap_devmem_remap()");
return (ibc_get_ci_failure(0));
}
}
}
/*
* Put NULL into the Hermon SRQNum-to-SRQHdl list. This will allow any
* in-progress events to detect that the SRQ corresponding to this
* number has been freed.
*/
/*
* Reclaim SRQC entry from hardware (using the Hermon HW2SW_SRQ
* firmware command). If the ownership transfer fails for any reason,
* then it is an indication that something (either in HW or SW) has
* gone seriously wrong.
*/
if (status != HERMON_CMD_SUCCESS) {
status);
if (status == HERMON_CMD_INVALID_STATUS) {
}
return (ibc_get_ci_failure(0));
}
/*
* Deregister the memory for the Shared Receive Queue. If this fails
* for any reason, then it is an indication that something (either
* in HW or SW) has gone seriously wrong. So we print a warning
* message and return.
*/
if (status != DDI_SUCCESS) {
return (IBT_FAILURE);
}
/* Free the memory for the SRQ */
/* Free the dbr */
/* Free the Hermon SRQ Handle */
/* Free the SRQC entry resource */
/* Decrement the reference count on the protection domain (PD) */
/* Set the srqhdl pointer to NULL and return success */
return (DDI_SUCCESS);
}
/*
* hermon_srq_modify()
* Context: Can be called only from user or kernel context.
*/
int
{
int status;
return (IBT_NOT_SUPPORTED);
/*
* If size requested is larger than device capability, return
* Insufficient Resources
*/
if (size > max_srq_size) {
return (IBT_HCA_WR_EXCEEDED);
}
/*
* Calculate the appropriate size for the SRQ.
* Note: All Hermon SRQs must be a power-of-2 in size. Also
* they may not be any smaller than HERMON_SRQ_MIN_SIZE. This step
* is to round the requested size up to the next highest power-of-2
*/
}
/*
* Next we verify that the rounded-up size is valid (i.e. consistent
*/
goto srqmodify_fail;
}
/*
* Allocate the memory for newly resized Shared Receive Queue.
*
* Note: If SRQ is not user-mappable, then it may come from either
* kernel system memory or from HCA-attached local DDR memory.
*
* Note2: We align this queue on a pagesize boundary. This is required
* to make sure that all the resulting IB addresses will start at 0,
* for a zero-based queue. By making sure we are aligned on at least a
* page, any offset we use into our queue will be the same as it was
* when we allocated it at hermon_srq_alloc() time.
*/
if (srq->srq_is_umap) {
} else {
}
if (status != DDI_SUCCESS) {
goto srqmodify_fail;
}
/*
* Allocate the memory for the new WRE list. This will be used later
* when we resize the wridlist based on the new SRQ size.
*/
goto srqmodify_fail;
}
/*
* Fill in the "bind" struct. This struct provides the majority
* of the information that will be used to distinguish between an
* "addr" binding (as is the case here) and a "buf" binding (see
* below). The "bind" struct is later passed to hermon_mr_mem_bind()
* which does most of the "heavy lifting" for the Hermon memory
* registration routines.
*/
&mtt_pgsize_bits, 0); /* no relaxed ordering */
if (status != DDI_SUCCESS) {
sizeof (uint64_t));
goto srqmodify_fail;
}
/*
* Calculate the offset between the kernel virtual address space
* and the IB virtual address space. This will be used when
* posting work requests to properly initialize each WQE.
*
* Note: bind addr is zero-based (from alloc) so we calculate the
* correct new offset here.
*/
srq_pgoffs = (uint_t)
/*
* Fill in the MPT entry. This is the final step before passing
* ownership of the MPT entry to the Hermon hardware. We use all of
* the information collected/calculated above to fill in the
* requisite portions of the MPT.
*/
/*
* for hermon we build up a new srqc and pass that (partially filled
* to resize SRQ instead of modifying the (d)mpt directly
*/
/*
* Now we grab the SRQ lock. Since we will be updating the actual
* the lock.
*
* We do a HERMON_NOSLEEP here (and below), though, because we are
* holding the "srq_lock" and if we got raised to interrupt level
* by priority inversion, we would not want to block in this routine
* waiting for success.
*/
/*
* Copy old entries to new buffer
*/
/* Sync entire "new" SRQ for use by hardware (if necessary) */
/*
* Setup MPT information for use in the MODIFY_MPT command
*/
/*
* now, setup the srqc information needed for resize - limit the
* values, but use the same structure as the srqc
*/
/*
* RESIZE_SRQ
*
* If this fails for any reason, then it is an indication that
* something (either in HW or SW) has gone seriously wrong. So we
* print a warning message and return.
*/
if (status != HERMON_CMD_SUCCESS) {
status);
if (status == HERMON_CMD_INVALID_STATUS) {
}
sizeof (uint64_t));
return (ibc_get_ci_failure(0));
}
/*
* Update the Hermon Shared Receive Queue handle with all the new
* information. At the same time, save away all the necessary
* information for freeing up the old resources
*/
sizeof (hermon_bind_info_t));
/* Now set the new info */
/* Update MR mtt pagesize */
/*
* Initialize new wridlist, if needed.
*
* If a wridlist already is setup on an SRQ (the QP associated with an
* SRQ has moved "from_reset") then we must update this wridlist based
* on the new SRQ size. We allocate the new size of Work Request ID
* Entries, copy over the old entries to the new list, and
* re-initialize the srq wridlist in non-umap case
*/
/* Setup new sizes in wre */
/*
* If "old" SRQ was a user-mappable SRQ that is currently mmap()'d out
* to a user process, then we need to call devmap_devmem_remap() to
* invalidate the mapping to the SRQ memory. We also need to
* invalidate the SRQ tracking information for the user mapping.
*
* Note: On failure, the remap really shouldn't ever happen. So, if it
* does, it is an indication that something has gone seriously wrong.
* So we print a warning message and return error (knowing, of course,
* that the "old" SRQ memory will be leaked)
*/
if (status != DDI_SUCCESS) {
"devmap_devmem_remap()");
/* We can, however, free the memory for old wre */
return (ibc_get_ci_failure(0));
}
}
/*
* Drop the SRQ lock now. The only thing left to do is to free up
* the old resources.
*/
/*
* Unbind the MTT entries.
*/
if (status != DDI_SUCCESS) {
status = ibc_get_ci_failure(0);
goto srqmodify_fail;
}
/* Free the memory for old wre */
/* Free the memory for the old SRQ */
/*
* Fill in the return arguments (if necessary). This includes the
* real new completion queue size.
*/
}
return (DDI_SUCCESS);
return (status);
}
/*
* hermon_srq_refcnt_inc()
* Context: Can be called from interrupt or base context.
*/
void
{
srq->srq_refcnt++;
}
/*
* hermon_srq_refcnt_dec()
* Context: Can be called from interrupt or base context.
*/
void
{
srq->srq_refcnt--;
}
/*
* hermon_srqhdl_from_srqnum()
* Context: Can be called from interrupt or base context.
*
* This routine is important because changing the unconstrained
* portion of the SRQ number is critical to the detection of a
* potential race condition in the SRQ handler code (i.e. the case
* where a SRQ is freed and alloc'd again before an event for the
* "old" SRQ can be handled).
*
* While this is not a perfect solution (not sure that one exists)
* it does help to mitigate the chance that this race condition will
* cause us to deliver a "stale" event to the new SRQ owner. Note:
* this solution does not scale well because the number of constrained
* bits increases (and, hence, the number of unconstrained bits
* decreases) as the number of supported SRQ grows. For small and
* intermediate values, it should hopefully provide sufficient
* protection.
*/
{
/* Calculate the SRQ table index from the srqnum */
}
/*
* hermon_srq_sgl_to_logwqesz()
* Context: Can be called from interrupt or base context.
*/
static void
{
switch (wq_type) {
case HERMON_QP_WQ_TYPE_RECVQ:
/*
* Use requested maximum SGL to calculate max descriptor size
* (while guaranteeing that the descriptor size is a
* power-of-2 cachelines).
*/
}
/* Make sure descriptor is at least the minimum size */
/* Calculate actual number of SGL (given WQE size) */
break;
default:
break;
}
/* Fill in the return values */
}