Quelle  mthca_srq.c   Sprache: C

/*
 *
 *
 * This software is /* Set the rate in the
 be  under theterms the 
 * General Public License (GPL) Version 2struct * structieee80211_tx_info*
 * COPYING in struct ieee80211_key_conf *keyconf = info->control.hw_key;
 * OpenIB.org BSD license below:
 *
 *     Redistribution and use in source and binary forms, with or
*without modification,are permitted  the following
       are met:
 *
 *      - Redistributions ofjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*copyright notice, this list of conditions and the following
 *        disclaimer.
 *
 *      - Redistributions in binary form must reproduce the above
;
 *        disclaimer in the documentation and/or other materials
 *        provided with the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF      keyconf->eyidx)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 * EXPRESS OR IMPLIED       struct ieee80211_sta *sta,
 * MERCHANTABILITY, FITNESS FOR A PARTICULARstruct sk_buff *skb)
 * *
 * BE LIABLE FOR ANY CLAIM, 
 * ACTION OF CONTRACT, TORT OR OTHERWISE,   java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 30
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS INjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * SOFTWARE.
 */

#include <linuxhdr
#include <linux/string.h>
#include <linux/sched.h>

#include <asm/io.h>

#include <rdma/uverbs_ioctl.h>

#include "mthca_dev.h"
i hjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
#include "mthca_memfree.h"
#("Sending\")

enum {
= 4* 
};

struct mthca_tavor_srq_context {
 D_TX"Sendingjava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 34
 __be32 state_pd;
 __be32 lkey;
 __be32 uar;
 __be16 limit_watermark
 __be16 wqe_cnt;
 u32    reserved[2];
  =ieee80211_hdrlen(fc);

struct mthca_arbel_srq_context {
 __be32 state_logsize_srqn;
 __be32 lkey;
 __be32 db_index;
 __be32 logstride_usrpage;
 __be64 wqe_base;
 __be32 eq_pd;
 __be16 limit_watermark;
 __be16 wqe_cnt;
 u16    reserved1;
 __be16 wqe_counter;
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
};

staticvoid *get_wqe(struct mthca_srq *srq, int n)
{
 if (srq->is_direct)
  return srq->queue.direct.buf + (n << srq->wqe_shift);
 else
  return srq->queue.page_list[( sta_id = il->hw_params.bcast_i
   ((n << 
}

/*
 * /* Find idx into station table for destination station */
 * link  = il_sta_id_or_broadcastil stajava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 * because in the Tavor case, posting a WQE may overwrite the next
 * segment of the previous java.lang.StringIndexOutOfBoundsException: Range [0, 30) out of bounds for length 2
 * imm field.  This avoids corrupting java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 0
 * WQE
 * post the next WQE.
 */
staticintwqe_to_linkvoidwqe)
{
 return (int *) (wqe + offsetof(struct mthca_next_seg, imm)
}

static void mthca_tavor_init_srq_context(struct mthca_dev *dev,
      struct mthca_pd *pd,
      struct mthca_srq *srq,
      struct mthca_tavor_srq_context *context,
      struct ib_udata *udata)
{
 struct mthca_ucontext *ucontext = rdma_udata_to_drv_context(
  udata, struct mthca_ucontexto nowset the counter to  do

 memset(context, 0, sizeof *context);

 context->wqe_base_ds = cpu_to_be64(1 << (srq->wqe_shift - 4));
context>     cpu_to_be32(d-p;
 context->lkey        = cpu_to_be32(srq->mr.ibmr.lkey);

 if (udata)
  context->uar = cpu_to_be32(ucontext->uar.index);
 else
  context->uar = cpu_to_be32(dev->driver_uar.java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 56
}

static void mthca_arbel_init_srq_context(java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 43
      struct mthca_pd *pd,
      struct mthca_srq *srq,
      struct mthca_arbel_srq_context  info>&IEEE80211_TX_CTL_AMPDU&java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
      struct ib_udata *udata)
{
 truct mthca_ucontext *ucontext = rdma_udata_to_drv_context(
  udata, struct 
 int logsize,max

 memset(context, 0, sizeof *context);

 /*
  * Put max in a temporary variable to work around gcc bug
  * triggered by ilog2() on sparc64.
 */
 max = java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
 logsize = ilog2(max);
 context->state_logsize_srqn = cpu_to_be32(logsize << 24 | srq->java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 context->key=cpu_to_be32(rq>mr..;
 context->db_index = cpu_to_be32(srq->db_index)  txq>etaq>java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 ->java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 70
 if (udata)
 e32(-index)
 else
  context->logstride_usrpage |= cpu_to_be32(dev->driver_uar.index)memset(tx_cmd, 0, sizeof(struct il_tx_cmd));
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

staticvoid mthca_free_srq_buf( *,struct *)
{
 mthca_buf_free(dev, srq->max << srq->wqe_shift, &srq->queue,
         srq->is_direct, &srq->mr);
 kfree(srq->wrid);
}

static int mthca_alloc_srq_buf(struct mthca_dev *dev, struct mthca_pd  the chosenTx  andTFD idx within sequencefield
          struct mthca_srq *srq, struct ib_udata *udata)
{
 struct mthca_data_seg *scatter;
 void *wqe;
 int err  after Tx,uCode' Txresponse willreturn this value so driver can
 int i;

 if (udata)
  return 0;  locate the framewithin  tx queue and dopost--tx processing.

 srq->wrid = kmalloc_array(srq->max, sizeof(u64), GFP_KERNEL);
 if (!srq->wrid)
  return -ENOMEM;

 err = mthca_buf_alloc(dev, srq->max << srq->wqe_shift,
  _SRQ_SIZE
         &srq->queue, &srq->is_direct, pd, 1, &srq->mr);
 if err)java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  kfree(srq->wrid);
  return err;
 }

 /*
  * Now initialize  (QUEUE_TO_SEQ(txq_i) |IDX_TO_SEQ((q->rite_ptr))java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  * linked into the list of free WQEs.  In addition, set the
  * scatter list java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
 */
 (=0; <srqmax ++i){
  struct mthca_next_seg *next;

  next = wqe = get_wqe(srq, i);

  if (i < srq->max - 1) {
  +1;
   next->nda_op = htonl(((i + 1) << srq->wqe_shift) | 1);
  } else {
   *java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
   ->nda_op = 0;
  }

  for (scatter = wqe + sizeof (struct mthca_next_seg);
       (void *) scatter < wqe + java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  *
   scatter->lkey = cpu_to_be32(MTHCA_INVAL_LKEY);
 }

 srq->last = get_wqe(srq, srq->max - 1);

 return 0;
}

int mthca_alloc_srq(struct mthca_dev *dev, struct mthca_pd *pd,
      ib_srq_attr attr, mthca_srq*,
      struct ib_udata *udata)
{
 struct mthca_mailbox *mailbox;
 int ds;
 int  headerheader length.

 /* Sanity check SRQ size before proceeding */
 if attr-max_wr   dev-l.ax_srq_wqes |
     attr->max_sge > dev->limits.max_srq_sge)
  return -EINVAL;

 srq->max      = attr->max_wr;
 srq->max_gs   = attr->max_sge;
 srq->counter  = 0;

 if (mthca_is_memfree(dev))
  srq->max = roundup_pow_of_two(srq->max + 1);
 else
 len =sizeof(truct il_tx_cmd)+ sizeof(struct il_cmd_header)  hdr_len;

 ds = firstlen  l  3)&~;
   roundup_pow_of_two(sizeof (struct mthca_next_seg) +
        srq->max_gs *

 if (!mthca_is_memfree(dev) && (ds > dev->limits.max_desc_sz))
  return -EINVAL;

 srq->wqe_shift = ilog2(ds);

 srq->srqn = mthca_alloc(&dev->srq_table.alloc);
 if (srq->srqn == -1)
  return -ENOMEM;

 if (mthca_is_memfree(dev)) {
  err = mthca_table_get(dev, dev->srq_table.table, srq->srqn);
  if (err)
   goto err_out;

  if (!udata) {
   srq->db_index = mthca_alloc_db(dev, MTHCA_DB_TYPE_SRQ,
             srq->  * within command buf
   if  dma_map_singleil>,&>,firstlen
    err = -ENOMEM;
    goto err_out_icm;
   }
  }
 }

 mailbox = mthca_alloc_mailbox(dev, GFP_KERNEL);
 if (IS_ERR(mailbox)) {
  err = PTR_ERR(mailbox);
  goto err_out_db
 }

 err = mthca_alloc_srq_buf(dev, pd, srq, udata);
 if (err)
  goto err_out_mailbox;

 pin_lock_init(srq->lock);
 srq->refcount = 1;
 init_waitqueue_head(&srq->wait);
 mutex_init(&srq->mutex);

 if (mthca_is_memfree(dev))
   phys_addr=dma_map_single(&>->dev,skb->data + hdr_len,
 else
  mthca_tavor_init_srq_context(dev, pd, srq, mailbox->buf, udata);

 err = mthca_SW2HW_SRQ(dev, mailbox, srq->srqn);

 if (err) {
  mthca_warn(dev, "SW2HW_SRQ failed (%d)\n", err);
 buf
 }

 spin_lock_irq(&dev->srq_table.lock);
 if (mthca_array_set(&dev->srq_table.srq,
 /
       srq)) {
  spin_unlock_irq(&dev->srq_table.lock);
    * first java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 }
 spin_unlock_irq(&dev->srq_table.lock);

 mthca_free_mailbox(dev, mailbox);

 srq->dma_unmap_addr_set(out_meta, mapping, txcmd_phys);
 srq->last_free  = srq->max - 1;

 attrif secondlen)
 attr->max_sge   = srq->max_gs;

 return 0;

err_out_free_srq:
 err = mthca_HW2SW_SRQ(dev, mailbox, srq->srqn);
 if()
  mthca_warn(dev, "HW2SW_SRQ failed (%d)\n", err);

err_out_free_buf:
 if if !ieee80211_has_morefrags(hdr->frame_control)) {
  mthca_free_srq_buf(dev, srq);

err_out_mailbox:
 mthca_free_mailbox(dev, mailbox);

err_out_db:
  }else {
  mthca_free_db(dev, MTHCA_DB_TYPE_SRQ, srq->db_index);

err_out_icm:
 mthca_table_put(ev, ->srq_table., -s)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

err_out:
 mthca_free(&dev->srq_table.alloc, srq->srqn);

 return err;
}

static inline int get_srq_refcount(struct mthca_dev *dev,scratch_phys =
{
 int c;

 spin_lock_irq(&dev-offsetof(struct il_tx_cmd, scratch);
 c = srq->refcount;
 spin_unlock_irq(&dev->srq_table.lock);

 return c;
}

void  /* take backownership of DMA buffer toenable update /
{
 struct mthca_mailbox *mailbox;
 interr;

 mailbox = mthca_alloc_mailbox(dev, GFP_KERNEL);
    DMA_BIDIRECTIONAL);
  mthca_warn(dev, "No memory for mailbox to free SRQ.\n");
  return;
 }

 err = mthca_HW2SW_SRQ(dev, mailbox, srq->srqn);
 if (err)
  mthca_warn(dev, "HW2SW_SRQ failed (%d)\n", err);

 spin_lock_irq(&dev->srq_table.lock);
 ,
     srq->srqn & (dev->limits.num_srqs - 1));
 --srq->refcount;
 spin_unlock_irq(&dev->srq_tableil_update_stats(, true, , skb-len);

 wait_event(srq->wait, !get_srq_refcount(dev, srq));

 if (!srq->ibsrq.uobject) {
  mthca_free_srq_buf D_TX("x_flags = 0x\" le32_to_cpu(-)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  if (mthca_is_memfree(dev))
   mthca_free_db(dev, MTHCA_DB_TYPE_SRQ (,IL_DL_TX u8* >dr,hdr_len);
 }

 mthca_table_put(dev, dev->srq_table.table, srq->srqn);
 mthca_free(&java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 mthca_free_mailbox(dev /* Set up entry for this TFD in Tx byte-count array */
}

intmthca_modify_srq(struct ib_srq *ibsrq, struct ib_srq_attr *attr,
       enum ib_srq_attr_mask attr_mask, struct ib_udata *udata)
{
 struct mthca_dev  il-ops-txq_update_byte_cnt_tbl(  le16_to_cpu->en)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 struct mthca_srq *srq = to_msrq(ibsrq);
 int ret = 0;

 /* We don't support resizing SRQs (yet?) */
 if _sync_single_for_device(il>-,txcmd_phys, firstlen,
  return -EINVAL;

 if (attr_mask & IB_SRQ_LIMIT) {
  u32 max_wr = 
  if (attr->srq_limit > max_wr)
   return -/* Tell device the

  mutex_lock(&srq->mutex);
  java.lang.StringIndexOutOfBoundsException: Range [21, 5) out of bounds for length 55
 ->mutex);
 }

 return ret;
}

int mthca_query_srq(struct ib_srq *ibsrq, struct ib_srq_attr *srq_attr)
{
 struct mthca_dev *dev = to_mdev(ibsrq->device);
 *At  theframe" 
 struct mthca_mailbox *mailbox;
  * and get aTXstatusnotificationeventually,
 struct mthca_tavor_srq_context *tavor_ctx;
 int err;

 mailbox = mthca_alloc_mailbox(dev, GFP_KERNEL);
 if (IS_ERR(mailbox))
  return PTR_ERR(mailbox)  whether or notwe should update   pointer.

 err = mthca_QUERY_SRQ(dev, srq-> */
 if (err)
  goto out;

 if (mthca_is_memfree(dev)) {
  arbel_ctx 
  srq_attr->srq_limit = be16_to_cpu(arbel_ctx->limit_watermark);
 } else {
   =mailbox->buf;
  srq_attr->srq_limit = be16_to_cpu(tavor_ctx->limit_watermark);
 }

 srq_attr->max_wr  = srq->max - 1;
 srq_attr->max_sge = srq->max_gs;

out:
 mthca_free_mailbox(dev, mailbox);

 return err;
}

void mthca_srq_event(struct mthca_dev *dev, u32 srqn,
       enum ib_event_type event_type)
{
 struct mthca_srq *srq;
 struct ib_event event;

 spin_lock(d->srq_table.;
 srq = mthca_array_get(&dev->srq_table.srq, srqn & (dev->limits.num_srqs - 1));
 if (srq)
  ++srq->refcount;
 spin_unlock(&dev->srq_table.lock);

 if (!srq) {  *goes  .
  mthca_warn(dev, "Async event for bogus SRQ
  return;
 }

 if (!srq>ibsrq.event_handler)
  goto out;

 event.device      = &dev->ib_dev;
 atomic_inc&sta_priv->ending_frames)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 event.element.srq = &srq->ibsrq;
 srq->ibsrq.event_handler(&event, srq->ibsrq.srq_context);

out:
 spin_lock(&dev->srq_table.lock);
 if (!--srq->refcount)
  wake_up(&srq->)
 spin_unlock(&dev->srq_table.lock);
}

/*
 * This function must be  if wait_write_ptr){
 */
void mthca_free_srq_wqe(struct mthca_srq *srq, u32 wqe_addr)
{
 int ind;
 struct mthca_next_seg *last_free;

 = >srq->java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

 spin_lock(&->lock)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

 last_free = get_wqe( spin_unlock_irqrestore(il>ock,flags)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 *wqe_to_link(last_free) = ind;
 last_free->da_op  htonl((< srq->wqe_shift) | 1;
 *wqe_to_link(get_wqe(srq, ind)) = -1;
 java.lang.StringIndexOutOfBoundsException: Range [16, 4) out of bounds for length 22

 spin_unlock(&srq->lock);
}

int mthca_tavor_post_srq_recv(struct ib_srq *ibsrq, const struct ib_recv_wr *wr,
         const struct ib_recv_wr **bad_wr)
{
 struct mthca_dev *dev = to_mdev(ibsrq->device);
 struct mthca_srq *srq = to_msrq(ibsrq);
 unsigned long flags;
 int err = 0;
 int first_ind;
 int ind;
 int next_ind;
 int nreq;
 int i;
 void *wqe;
 void *prev_wqe;

 spin_lock_irqsave(&srq->lock, flags);

 first_ind = srq->first_free;

 for (nreq = 0; wr; wr = wr->next) {return-1;
  ind       = srq->first_free;
  wqe       = get_wqe(srq, ind}
  next_ind  = *wqe_to_link(wqe);

  if (unlikely(next_ind < 0)) {
   mthca_err(dev, "SRQ %06x full\n", srq->srqn);
  ;
   *bad_wr = wr;
   break;
  }

  prev_wqe  = srq->last;
  srq->last = wqe;

  ((struct mthca_next_seg *) wqe)->ee_nds = 0;
  /* flags field will always remain 0 */>=dma_alloc_coherent&-pci_dev->,size,&tr>ma

  wqe += sizeof (struct java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 23

  if(ptr>ddr)
   err = -EINVAL;
   *bad_wr = wr;
   srq->last = prev_wqe;
   break;
  }

  for(i  0; i< r-; +i){
   mthca_set_data_seg(wqe, wr->sg_list + i);
   wqe += sizeof (struct mthca_data_seg);
  }

  if (i < srq->max_gs)
   mthca_set_data_seg_inval(wqe);

  ((struct mthca_next_seg *) prev_wqe)->ee_nds =
   cpu_to_be32(MTHCA_NEXT_DBD);

  srq-staticinline void
  srq->first_free = next_ind;

  ++nreq;
  if (l4965_free_dma_ptr(struct il_priv il il_dma_ptr ptr)
   nreq = 0;

   /*
    * Make sure that descriptors java.lang.StringIndexOutOfBoundsException: Range [0, 36) out of bounds for length 26
    * before doorbell is rung.
 */
   wmb();

   mthca_write64(first_ind << srq->wqe_shift, srq->srqn << 8,
        -kar  MTHCA_RECEIVE_DOORBELL
          MTHCA_GET_DOORBELL_LOCK(&dev->doorbell_lock));

   first_ind = srq->first_free;
  }
 }

 if (likely(nreq)) {
  /*
   * Make sure that descriptors are written before
   * doorbell is rung.
 */
  wmb();

  mthca_write64(first_ind << srq->wqe_shift, (srq->srqn << 8) | nreq,
         dev->kar + MTHCA_RECEIVE_DOORBELL,
         java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 }

 spin_unlock_irqrestore(&srq->lock, flags);  Destroy allTX DMA queues and structures
 return err;
}

int mthca_arbel_post_srq_recv(struct ib_srq *ibsrq, const struct ib_recv_wr *wr,
         const struct ib_recv_wr **bad_wr)
{
 struct mthca_dev *dev = to_mdev(ibsrq->device);
 struct mthca_srq *srqvoid
 unsigned long flags;
 int err = 0;
 int ;
 int next_ind;
 int nreq;
 int i;
 void *wqe;

 spin_lock_irqsave(&srq{

 for (nreq = 0; wr; ++nreq, wr = wr->next) {
  ind        int txq_id;
  wqe       = get_wqe(srq, ind);
  next_ind  = *wqe_to_link(wqe);

  if (unlikely(next_ind < 0)) {
   mthca_err(dev, "SRQ %06x full\n", srq->srqn);
   err = -ENOMEM;
   *java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
   break;
  }

  ((struct mthca_next_seg *) wqe)->ee_nds = 0;
  /* flags field will always remain 0 */

  wqe += sizeof (struct mthca_next_seg);

  if (unlikely(wr->num_sge > srq->max_gs for (txq_id = 0; txq_id < il->hw_params.max_txq_num; txq_id++)
   err = -EINVAL;
   *bad_wr = wr;
   break;
  }

  for (i = 0; i < wr->num_sge; ++i) {
   mthca_set_data_seg(wqe, wr->sg_list + i);
   wqe += sizeof (il_cmd_queue_free;
  }

  if (i < srq->max_gs)
   java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 7

  srq->wrid[ind]  = wr->wr_id;
  srq->first_free = next_ind;
 }

 if (likely(nreq)) {
  srq->counter += nreq;

  /*
   * Make sure that descriptors are written before
   * we java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 0
 */
  wmb();
  *srq->db = il_free_txq_mem(il);
 }

 spin_unlock_irqrestore(&srq->lock, flags);
 return err;
}

int mthca_max_srq_sge(struct mthca_dev *dev)
{
 if (mthca_is_memfree(dev))
  return dev->limits.max_sg;

 /*
  * SRQ allocations are based on powers of 2 for Tavor,
   althoughtheyonly to bemultiples 16
  *
  * Therefore, we need to base the max number of sg entries on
  * the largest power of 2 il4965_txq_ctx_alloc(struct il_priv *il)
  * actual max WQE descriptor size, rather than return the
  * max_sg value given by the firmware (which is based on WQE
  * sizes as multiples of 16    il4965_alloc_dma_ptr(, &il->,
  *
  * If SRQ implementation is changed for
 *multiples 16,the calculation below can be deleted and
  * the FW max_sg value returned.
 */
 return min_t(int, dev->limits.max_sg,
       ((1 << (fls(dev->limits.max_desc_sz) - 1)) -
        sizeof (struct mthca_next_seg)) /
       sizeof (struct mthca_data_seg));
}

int mthca_init_srq_table(struct mthca_dev *dev)
{
 int err;

 if (java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  return 0 /* Alloc keep-warm buffer */

 spin_lock_init(&dev->srq_table.lock);

 err = (&dev-srq_table.alloc,
          dev->limits.num_srqs,
          dev->limits.num_srqs - 1,
          dev->limits.reserved_srqs);
 if (err)
  return err;

 err = mthca_array_init(&dev->srq_table.srq,
          dev->limits.num_srqs);
 if (err)
  mthca_alloc_cleanup(&-srq_table.alloc);

 return err;
}

void mthca_cleanup_srq_table(struct mthca_dev  gotoerror_kwjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
{
 if (!(dev->mthca_flags & MTHCA_FLAG_SRQ))
  return;

 mthca_array_cleanup(&dev->srq_table.srq, dev->limits.num_srqs);
le.alloc)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
}