resource.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
    3  *
    4  * Copyright (c) 2009-2013 Chelsio, Inc. All rights reserved.
    5  *
    6  * This software is available to you under a choice of one of two
    7  * licenses.  You may choose to be licensed under the terms of the GNU
    8  * General Public License (GPL) Version 2, available from the file
    9  * COPYING in the main directory of this source tree, or the
   10  * OpenIB.org BSD license below:
   11  *
   12  *     Redistribution and use in source and binary forms, with or
   13  *     without modification, are permitted provided that the following
   14  *     conditions are met:
   15  *
   16  *      - Redistributions of source code must retain the above
   17  *        copyright notice, this list of conditions and the following
   18  *        disclaimer.
   19  *
   20  *      - Redistributions in binary form must reproduce the above
   21  *        copyright notice, this list of conditions and the following
   22  *        disclaimer in the documentation and/or other materials
   23  *        provided with the distribution.
   24  *
   25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
   26  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   27  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
   28  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
   29  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
   30  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
   31  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
   32  * SOFTWARE.
   33  */
   34 /* Crude resource management */
   35 #include <sys/cdefs.h>
   36 __FBSDID("$FreeBSD$");
   37 
   38 #include "opt_inet.h"
   39 
   40 #ifdef TCP_OFFLOAD
   41 #include <linux/spinlock.h>
   42 #include "iw_cxgbe.h"
   43 
   44 static int c4iw_init_qid_table(struct c4iw_rdev *rdev)
   45 {
   46         u32 i;
   47 
   48         if (c4iw_id_table_alloc(&rdev->resource.qid_table,
   49                                 rdev->adap->vres.qp.start,
   50                                 rdev->adap->vres.qp.size,
   51                                 rdev->adap->vres.qp.size, 0)) {
   52                 printf("%s: return ENOMEM\n", __func__);
   53                 return -ENOMEM;
   54         }
   55 
   56         for (i = rdev->adap->vres.qp.start;
   57                 i < rdev->adap->vres.qp.start + rdev->adap->vres.qp.size; i++)
   58                 if (!(i & rdev->qpmask))
   59                         c4iw_id_free(&rdev->resource.qid_table, i);
   60         return 0;
   61 }
   62 
   63 /* nr_* must be power of 2 */
   64 int c4iw_init_resource(struct c4iw_rdev *rdev, u32 nr_tpt, u32 nr_pdid)
   65 {
   66         int err = 0;
   67         err = c4iw_id_table_alloc(&rdev->resource.tpt_table, 0, nr_tpt, 1,
   68                                         C4IW_ID_TABLE_F_RANDOM);
   69         if (err)
   70                 goto tpt_err;
   71         err = c4iw_init_qid_table(rdev);
   72         if (err)
   73                 goto qid_err;
   74         err = c4iw_id_table_alloc(&rdev->resource.pdid_table, 0,
   75                                         nr_pdid, 1, 0);
   76         if (err)
   77                 goto pdid_err;
   78         return 0;
   79  pdid_err:
   80         c4iw_id_table_free(&rdev->resource.qid_table);
   81  qid_err:
   82         c4iw_id_table_free(&rdev->resource.tpt_table);
   83  tpt_err:
   84         return -ENOMEM;
   85 }
   86 
   87 /*
   88  * returns 0 if no resource available
   89  */
   90 u32 c4iw_get_resource(struct c4iw_id_table *id_table)
   91 {
   92         u32 entry;
   93         entry = c4iw_id_alloc(id_table);
   94         if (entry == (u32)(-1)) {
   95                 return 0;
   96         }
   97         return entry;
   98 }
   99 
  100 void c4iw_put_resource(struct c4iw_id_table *id_table, u32 entry)
  101 {
  102         CTR2(KTR_IW_CXGBE, "%s entry 0x%x", __func__, entry);
  103         c4iw_id_free(id_table, entry);
  104 }
  105 
  106 u32 c4iw_get_cqid(struct c4iw_rdev *rdev, struct c4iw_dev_ucontext *uctx)
  107 {
  108         struct c4iw_qid_list *entry;
  109         u32 qid;
  110         int i;
  111 
  112         mutex_lock(&uctx->lock);
  113         if (!list_empty(&uctx->cqids)) {
  114                 entry = list_entry(uctx->cqids.next, struct c4iw_qid_list,
  115                                    entry);
  116                 list_del(&entry->entry);
  117                 qid = entry->qid;
  118                 kfree(entry);
  119         } else {
  120                 qid = c4iw_get_resource(&rdev->resource.qid_table);
  121                 if (!qid)
  122                         goto out;
  123                 mutex_lock(&rdev->stats.lock);
  124                 rdev->stats.qid.cur += rdev->qpmask + 1;
  125                 mutex_unlock(&rdev->stats.lock);
  126                 for (i = qid+1; i & rdev->qpmask; i++) {
  127                         entry = kmalloc(sizeof *entry, GFP_KERNEL);
  128                         if (!entry)
  129                                 goto out;
  130                         entry->qid = i;
  131                         list_add_tail(&entry->entry, &uctx->cqids);
  132                 }
  133 
  134                 /*
  135                  * now put the same ids on the qp list since they all
  136                  * map to the same db/gts page.
  137                  */
  138                 entry = kmalloc(sizeof *entry, GFP_KERNEL);
  139                 if (!entry)
  140                         goto out;
  141                 entry->qid = qid;
  142                 list_add_tail(&entry->entry, &uctx->qpids);
  143                 for (i = qid+1; i & rdev->qpmask; i++) {
  144                         entry = kmalloc(sizeof *entry, GFP_KERNEL);
  145                         if (!entry)
  146                                 goto out;
  147                         entry->qid = i;
  148                         list_add_tail(&entry->entry, &uctx->qpids);
  149                 }
  150         }
  151 out:
  152         mutex_unlock(&uctx->lock);
  153         CTR2(KTR_IW_CXGBE, "%s: qid 0x%x", __func__, qid);
  154         mutex_lock(&rdev->stats.lock);
  155         if (rdev->stats.qid.cur > rdev->stats.qid.max)
  156                 rdev->stats.qid.max = rdev->stats.qid.cur;
  157         mutex_unlock(&rdev->stats.lock);
  158         return qid;
  159 }
  160 
  161 void c4iw_put_cqid(struct c4iw_rdev *rdev, u32 qid,
  162                    struct c4iw_dev_ucontext *uctx)
  163 {
  164         struct c4iw_qid_list *entry;
  165 
  166         entry = kmalloc(sizeof *entry, GFP_KERNEL);
  167         if (!entry)
  168                 return;
  169         CTR2(KTR_IW_CXGBE, "%s qid 0x%x", __func__, qid);
  170         entry->qid = qid;
  171         mutex_lock(&uctx->lock);
  172         list_add_tail(&entry->entry, &uctx->cqids);
  173         mutex_unlock(&uctx->lock);
  174 }
  175 
  176 u32 c4iw_get_qpid(struct c4iw_rdev *rdev, struct c4iw_dev_ucontext *uctx)
  177 {
  178         struct c4iw_qid_list *entry;
  179         u32 qid;
  180         int i;
  181 
  182         mutex_lock(&uctx->lock);
  183         if (!list_empty(&uctx->qpids)) {
  184                 entry = list_entry(uctx->qpids.next, struct c4iw_qid_list,
  185                                    entry);
  186                 list_del(&entry->entry);
  187                 qid = entry->qid;
  188                 kfree(entry);
  189         } else {
  190                 qid = c4iw_get_resource(&rdev->resource.qid_table);
  191                 if (!qid)
  192                         goto out;
  193                 mutex_lock(&rdev->stats.lock);
  194                 rdev->stats.qid.cur += rdev->qpmask + 1;
  195                 mutex_unlock(&rdev->stats.lock);
  196                 for (i = qid+1; i & rdev->qpmask; i++) {
  197                         entry = kmalloc(sizeof *entry, GFP_KERNEL);
  198                         if (!entry)
  199                                 goto out;
  200                         entry->qid = i;
  201                         list_add_tail(&entry->entry, &uctx->qpids);
  202                 }
  203 
  204                 /*
  205                  * now put the same ids on the cq list since they all
  206                  * map to the same db/gts page.
  207                  */
  208                 entry = kmalloc(sizeof *entry, GFP_KERNEL);
  209                 if (!entry)
  210                         goto out;
  211                 entry->qid = qid;
  212                 list_add_tail(&entry->entry, &uctx->cqids);
  213                 for (i = qid; i & rdev->qpmask; i++) {
  214                         entry = kmalloc(sizeof *entry, GFP_KERNEL);
  215                         if (!entry)
  216                                 goto out;
  217                         entry->qid = i;
  218                         list_add_tail(&entry->entry, &uctx->cqids);
  219                 }
  220         }
  221 out:
  222         mutex_unlock(&uctx->lock);
  223         CTR2(KTR_IW_CXGBE, "%s qid 0x%x", __func__, qid);
  224         mutex_lock(&rdev->stats.lock);
  225         if (rdev->stats.qid.cur > rdev->stats.qid.max)
  226                 rdev->stats.qid.max = rdev->stats.qid.cur;
  227         mutex_unlock(&rdev->stats.lock);
  228         return qid;
  229 }
  230 
  231 void c4iw_put_qpid(struct c4iw_rdev *rdev, u32 qid,
  232                    struct c4iw_dev_ucontext *uctx)
  233 {
  234         struct c4iw_qid_list *entry;
  235 
  236         entry = kmalloc(sizeof *entry, GFP_KERNEL);
  237         if (!entry)
  238                 return;
  239         CTR2(KTR_IW_CXGBE, "%s qid 0x%x", __func__, qid);
  240         entry->qid = qid;
  241         mutex_lock(&uctx->lock);
  242         list_add_tail(&entry->entry, &uctx->qpids);
  243         mutex_unlock(&uctx->lock);
  244 }
  245 
  246 void c4iw_destroy_resource(struct c4iw_resource *rscp)
  247 {
  248         c4iw_id_table_free(&rscp->tpt_table);
  249         c4iw_id_table_free(&rscp->qid_table);
  250         c4iw_id_table_free(&rscp->pdid_table);
  251 }
  252 
  253 /* PBL Memory Manager. */
  254 
  255 #define MIN_PBL_SHIFT 5                 /* 32B == min PBL size (4 entries) */
  256 
  257 u32 c4iw_pblpool_alloc(struct c4iw_rdev *rdev, int size)
  258 {
  259         unsigned long addr;
  260 
  261         vmem_xalloc(rdev->pbl_arena, roundup(size, (1 << MIN_PBL_SHIFT)),
  262                         4, 0, 0, VMEM_ADDR_MIN, VMEM_ADDR_MAX,
  263                         M_FIRSTFIT|M_NOWAIT, &addr);
  264         CTR3(KTR_IW_CXGBE, "%s addr 0x%x size %d", __func__, (u32)addr, size);
  265         mutex_lock(&rdev->stats.lock);
  266         if (addr) {
  267                 rdev->stats.pbl.cur += roundup(size, 1 << MIN_PBL_SHIFT);
  268                 if (rdev->stats.pbl.cur > rdev->stats.pbl.max)
  269                         rdev->stats.pbl.max = rdev->stats.pbl.cur;
  270         } else
  271                 rdev->stats.pbl.fail++;
  272         mutex_unlock(&rdev->stats.lock);
  273         return (u32)addr;
  274 }
  275 
  276 void c4iw_pblpool_free(struct c4iw_rdev *rdev, u32 addr, int size)
  277 {
  278         CTR3(KTR_IW_CXGBE, "%s addr 0x%x size %d", __func__, addr, size);
  279         mutex_lock(&rdev->stats.lock);
  280         rdev->stats.pbl.cur -= roundup(size, 1 << MIN_PBL_SHIFT);
  281         mutex_unlock(&rdev->stats.lock);
  282         vmem_xfree(rdev->pbl_arena, addr, roundup(size,(1 << MIN_PBL_SHIFT)));
  283 }
  284 
  285 int c4iw_pblpool_create(struct c4iw_rdev *rdev)
  286 {
  287         rdev->pbl_arena = vmem_create("PBL_MEM_POOL",
  288                                         rdev->adap->vres.pbl.start,
  289                                         rdev->adap->vres.pbl.size,
  290                                         1, 0, M_FIRSTFIT| M_NOWAIT);
  291         if (!rdev->pbl_arena)
  292                 return -ENOMEM;
  293 
  294         return 0;
  295 }
  296 
  297 void c4iw_pblpool_destroy(struct c4iw_rdev *rdev)
  298 {
  299         vmem_destroy(rdev->pbl_arena);
  300 }
  301 
  302 /* RQT Memory Manager. */
  303 
  304 #define MIN_RQT_SHIFT 10        /* 1KB == min RQT size (16 entries) */
  305 
  306 u32 c4iw_rqtpool_alloc(struct c4iw_rdev *rdev, int size)
  307 {
  308         unsigned long addr;
  309 
  310         vmem_xalloc(rdev->rqt_arena,
  311                         roundup((size << 6),(1 << MIN_RQT_SHIFT)),
  312                         4, 0, 0, VMEM_ADDR_MIN, VMEM_ADDR_MAX,
  313                         M_FIRSTFIT|M_NOWAIT, &addr);
  314         CTR3(KTR_IW_CXGBE, "%s addr 0x%x size %d", __func__, (u32)addr,
  315             size << 6);
  316         if (!addr)
  317                 printf("%s: Out of RQT memory\n",
  318                        device_get_nameunit(rdev->adap->dev));
  319         mutex_lock(&rdev->stats.lock);
  320         if (addr) {
  321                 rdev->stats.rqt.cur += roundup(size << 6, 1 << MIN_RQT_SHIFT);
  322                 if (rdev->stats.rqt.cur > rdev->stats.rqt.max)
  323                         rdev->stats.rqt.max = rdev->stats.rqt.cur;
  324         } else
  325                 rdev->stats.rqt.fail++;
  326         mutex_unlock(&rdev->stats.lock);
  327         return (u32)addr;
  328 }
  329 
  330 void c4iw_rqtpool_free(struct c4iw_rdev *rdev, u32 addr, int size)
  331 {
  332         CTR3(KTR_IW_CXGBE, "%s addr 0x%x size %d", __func__, addr, size << 6);
  333         mutex_lock(&rdev->stats.lock);
  334         rdev->stats.rqt.cur -= roundup(size << 6, 1 << MIN_RQT_SHIFT);
  335         mutex_unlock(&rdev->stats.lock);
  336         vmem_xfree(rdev->rqt_arena, addr,
  337                        roundup((size << 6),(1 << MIN_RQT_SHIFT)));
  338 }
  339 
  340 int c4iw_rqtpool_create(struct c4iw_rdev *rdev)
  341 {
  342         rdev->rqt_arena = vmem_create("RQT_MEM_POOL",
  343                                         rdev->adap->vres.rq.start,
  344                                         rdev->adap->vres.rq.size,
  345                                         1, 0, M_FIRSTFIT| M_NOWAIT);
  346         if (!rdev->rqt_arena)
  347                 return -ENOMEM;
  348 
  349         return 0;
  350 }
  351 
  352 void c4iw_rqtpool_destroy(struct c4iw_rdev *rdev)
  353 {
  354         vmem_destroy(rdev->rqt_arena);
  355 }
  356 #endif
Cache object: ea67eda38d84613ee417f6d90538d8b1
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/dev/cxgbe/iw_cxgbe/resource.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/cxgbe/iw_cxgbe/resource.c
